// main app message handler
static InReaction MainInputHandler(const SDL_Event_* ev)
{
switch(ev->ev.type)
{
case SDL_WINDOWEVENT:
switch(ev->ev.window.event)
{
case SDL_WINDOWEVENT_ENTER:
RenderCursor(true);
break;
case SDL_WINDOWEVENT_LEAVE:
RenderCursor(false);
break;
case SDL_WINDOWEVENT_RESIZED:
g_ResizedW = ev->ev.window.data1;
g_ResizedH = ev->ev.window.data2;
break;
case SDL_WINDOWEVENT_MOVED:
g_VideoMode.UpdatePosition(ev->ev.window.data1, ev->ev.window.data2);
}
break;
case SDL_QUIT:
kill_mainloop();
break;
case SDL_HOTKEYDOWN:
std::string hotkey = static_cast<const char*>(ev->ev.user.data1);
if (hotkey == "exit")
{
kill_mainloop();
return IN_HANDLED;
}
else if (hotkey == "screenshot")
{
WriteScreenshot(L".png");
return IN_HANDLED;
}
else if (hotkey == "bigscreenshot")
{
WriteBigScreenshot(L".bmp", 10);
return IN_HANDLED;
}
else if (hotkey == "togglefullscreen")
{
g_VideoMode.ToggleFullscreen();
return IN_HANDLED;
}
else if (hotkey == "profile2.toggle")
{
g_Profiler2.Toggle();
return IN_HANDLED;
}
break;
}
return IN_PASS;
}
void CHud::OnRender()
{
if(!m_pClient->m_Snap.m_pGameInfoObj)
return;
m_Width = 300.0f*Graphics()->ScreenAspect();
m_Height = 300.0f;
Graphics()->MapScreen(0.0f, 0.0f, m_Width, m_Height);
if(g_Config.m_ClShowhud)
{
//if(m_pClient->m_Snap.m_pLocalCharacter && !(m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER))
// RenderHealthAndAmmo(m_pClient->m_Snap.m_pLocalCharacter);
//else if(m_pClient->m_Snap.m_SpecInfo.m_Active)
//{
// if(m_pClient->m_Snap.m_SpecInfo.m_SpectatorID != SPEC_FREEVIEW)
// RenderHealthAndAmmo(&m_pClient->m_Snap.m_aCharacters[m_pClient->m_Snap.m_SpecInfo.m_SpectatorID].m_Cur);
// RenderSpectatorHud();
//}
RenderNeuron();
//RenderGameTimer();
//RenderPauseNotification();
//RenderSuddenDeath();
//RenderScoreHud();
//RenderWarmupTimer();
//RenderFps();
if(Client()->State() != IClient::STATE_DEMOPLAYBACK)
RenderConnectionWarning();
//RenderTeambalanceWarning();
//RenderVoting();
}
RenderCursor();
}
void CHud::OnRender()
{
if(!m_pClient->m_Snap.m_pGameobj)
return;
m_Width = 300*Graphics()->ScreenAspect();
bool Spectate = false;
if(m_pClient->m_Snap.m_pLocalInfo && m_pClient->m_Snap.m_pLocalInfo->m_Team == TEAM_SPECTATORS)
Spectate = true;
if(m_pClient->m_Snap.m_pLocalCharacter && !Spectate && !(m_pClient->m_Snap.m_pGameobj && m_pClient->m_Snap.m_pGameobj->m_GameOver))
RenderHealthAndAmmo();
RenderGameTimer();
RenderSuddenDeath();
RenderScoreHud();
RenderWarmupTimer();
RenderFps();
if(Client()->State() != IClient::STATE_DEMOPLAYBACK)
RenderConnectionWarning();
RenderTeambalanceWarning();
RenderVoting();
RenderCursor();
}
//-----------------------------------------------------------------------------------------------
void DeveloperConsole::Render()
{
OpenGLRenderer::PushMatrix();
RenderConsoleBackground();
RenderCommandPromptBorder();
RenderCursor();
RenderText();
OpenGLRenderer::PopMatrix();
}
block_t *screen_Capture( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
screen_data_t *p_data = p_sys->p_data;
if( !p_data->i_fragment )
{
if( !( p_data->p_block = CaptureBlockNew( p_demux ) ) )
{
msg_Warn( p_demux, "cannot get block" );
return NULL;
}
}
if( p_sys->b_follow_mouse )
{
POINT pos;
GetCursorPos( &pos );
FollowMouse( p_sys, pos.x, pos.y );
}
if( !BitBlt( p_data->hdc_dst, 0,
p_data->i_fragment * p_data->i_fragment_size,
p_sys->fmt.video.i_width, p_data->i_fragment_size,
p_data->hdc_src, p_sys->i_left, p_sys->i_top +
p_data->i_fragment * p_data->i_fragment_size,
SRCCOPY | CAPTUREBLT ) )
{
msg_Err( p_demux, "error during BitBlt()" );
return NULL;
}
p_data->i_fragment++;
if( !( p_data->i_fragment %
(p_sys->fmt.video.i_height/p_data->i_fragment_size) ) )
{
block_t *p_block = p_data->p_block;
p_data->i_fragment = 0;
p_data->p_block = 0;
if( p_sys->p_mouse )
{
POINT pos;
GetCursorPos( &pos );
RenderCursor( p_demux, pos.x, pos.y,
p_block->p_buffer );
}
return p_block;
}
return NULL;
}
void CHud::OnRender()
{
if(!m_pClient->m_Snap.m_pGameData)
return;
// dont render hud if the menu is active
if(m_pClient->m_pMenus->IsActive())
return;
m_Width = 300.0f*Graphics()->ScreenAspect();
m_Height = 300.0f;
Graphics()->MapScreen(0.0f, 0.0f, m_Width, m_Height);
if(g_Config.m_ClShowhud)
{
if(m_pClient->m_Snap.m_pLocalCharacter && !(m_pClient->m_Snap.m_pGameData->m_GameStateFlags&(GAMESTATEFLAG_ROUNDOVER|GAMESTATEFLAG_GAMEOVER)))
RenderHealthAndAmmo(m_pClient->m_Snap.m_pLocalCharacter);
else if(m_pClient->m_Snap.m_SpecInfo.m_Active)
{
if(m_pClient->m_Snap.m_SpecInfo.m_SpectatorID != -1)
RenderHealthAndAmmo(&m_pClient->m_Snap.m_aCharacters[m_pClient->m_Snap.m_SpecInfo.m_SpectatorID].m_Cur);
RenderSpectatorHud();
RenderSpectatorNotification();
}
RenderGameTimer();
RenderPauseTimer();
RenderStartCountdown();
RenderDeadNotification();
RenderSuddenDeath();
RenderScoreHud();
RenderWarmupTimer();
RenderFps();
if(Client()->State() != IClient::STATE_DEMOPLAYBACK)
RenderConnectionWarning();
RenderTeambalanceWarning();
RenderVoting();
}
RenderCursor();
}
bool UIInputText::Update(float dt)
{
if (textChanged)
{
UpdateTextTexture();
textChanged = false;
}
if (App->gui->GetFocus() == this)
{
//Deactivate default text
if (defaultText)
{
if (defaultText->active = true)
{
defaultText->active = false;
defaultOn = false;
}
}
ManageInput();
RenderCursor();
}
if (!defaultOn)
{
//Rendering input text
int x, y;
x = GetWorldRect().x + offsetX - App->render->camera.x - textDisplacement;
y = GetWorldRect().y + offsetY - App->render->camera.y;
if (text_texture)
App->render->Blit(text_texture, x, y, &textRect);
}
return true;
}
HumanClientApp::HumanClientApp(int width, int height, bool calculate_fps, const std::string& name,
int x, int y, bool fullscreen, bool fake_mode_change) :
ClientApp(),
SDLGUI(width, height, calculate_fps, name, x, y, fullscreen, fake_mode_change),
m_fsm(0),
m_single_player_game(true),
m_game_started(false),
m_connected(false),
m_auto_turns(0),
m_have_window_focus(true)
{
#ifdef ENABLE_CRASH_BACKTRACE
signal(SIGSEGV, SigHandler);
#endif
#ifdef FREEORION_MACOSX
SDL_SetHint(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, "1");
#endif
m_fsm = new HumanClientFSM(*this);
const std::string HUMAN_CLIENT_LOG_FILENAME((GetUserDir() / "freeorion.log").string());
InitLogger(HUMAN_CLIENT_LOG_FILENAME, "Client");
try {
DebugLogger() << "GL Version String: " << GetGLVersionString();
} catch (...) {
ErrorLogger() << "Unable to get GL Version String?";
}
LogDependencyVersions();
boost::shared_ptr<GG::StyleFactory> style(new CUIStyle());
SetStyleFactory(style);
SetMinDragTime(0);
m_ui = boost::shared_ptr<ClientUI>(new ClientUI());
if ((GetOptionsDB().Get<bool>("UI.sound.music-enabled")))
Sound::GetSound().PlayMusic(GetOptionsDB().Get<std::string>("UI.sound.bg-music"), -1);
Sound::GetSound().SetMusicVolume(GetOptionsDB().Get<int>("UI.sound.music-volume"));
Sound::GetSound().SetUISoundsVolume(GetOptionsDB().Get<int>("UI.sound.volume"));
EnableFPS();
UpdateFPSLimit();
GG::Connect(GetOptionsDB().OptionChangedSignal("show-fps"), &HumanClientApp::UpdateFPSLimit, this);
boost::shared_ptr<GG::BrowseInfoWnd> default_browse_info_wnd(
new GG::TextBoxBrowseInfoWnd(GG::X(400), ClientUI::GetFont(),
GG::Clr(0, 0, 0, 200), ClientUI::WndOuterBorderColor(), ClientUI::TextColor(),
GG::FORMAT_LEFT | GG::FORMAT_WORDBREAK, 1));
GG::Wnd::SetDefaultBrowseInfoWnd(default_browse_info_wnd);
boost::shared_ptr<GG::Texture> cursor_texture = m_ui->GetTexture(ClientUI::ArtDir() / "cursors" / "default_cursor.png");
SetCursor(boost::shared_ptr<GG::TextureCursor>(new GG::TextureCursor(cursor_texture, GG::Pt(GG::X(6), GG::Y(3)))));
RenderCursor(true);
EnableKeyPressRepeat(GetOptionsDB().Get<int>("UI.keypress-repeat-delay"),
GetOptionsDB().Get<int>("UI.keypress-repeat-interval"));
EnableMouseButtonDownRepeat(GetOptionsDB().Get<int>("UI.mouse-click-repeat-delay"),
GetOptionsDB().Get<int>("UI.mouse-click-repeat-interval"));
GG::Connect(WindowResizedSignal, &HumanClientApp::HandleWindowResize, this);
GG::Connect(FocusChangedSignal, &HumanClientApp::HandleFocusChange, this);
GG::Connect(WindowMovedSignal, &HumanClientApp::HandleWindowMove, this);
/* TODO: Wire these signals if theyare needed
GG::Connect(WindowClosingSignal, &HumanClientApp::HandleWindowClosing, this);
GG::Connect(WindowClosedSignal, &HumanClientApp::HandleWindowClose, this);
*/
SetStringtableDependentOptionDefaults();
SetGLVersionDependentOptionDefaults();
this->SetMouseLRSwapped(GetOptionsDB().Get<bool>("UI.swap-mouse-lr"));
std::map<std::string, std::map<int, int> > named_key_maps;
parse::keymaps(GetResourceDir() / "keymaps.txt", named_key_maps);
if (GetOptionsDB().Get<bool>("verbose-logging")) {
DebugLogger() << "Keymaps:";
for (std::map<std::string, std::map<int, int> >::const_iterator km_it = named_key_maps.begin();
km_it != named_key_maps.end(); ++km_it)
{
DebugLogger() << "Keymap name = \"" << km_it->first << "\"";
const std::map<int, int>& key_map = km_it->second;
for (std::map<int, int>::const_iterator keys_it = key_map.begin(); keys_it != key_map.end(); ++keys_it)
DebugLogger() << " " << char(keys_it->first) << " : " << char(keys_it->second);
}
}
std::map<std::string, std::map<int, int> >::const_iterator km_it = named_key_maps.find("TEST");
if (km_it != named_key_maps.end()) {
const std::map<int, int> int_key_map = km_it->second;
std::map<GG::Key, GG::Key> key_map;
for (std::map<int, int>::const_iterator key_int_it = int_key_map.begin();
key_int_it != int_key_map.end(); ++key_int_it)
{ key_map[GG::Key(key_int_it->first)] = GG::Key(key_int_it->second); }
this->SetKeyMap(key_map);
}
ConnectKeyboardAcceleratorSignals();
InitAutoTurns(GetOptionsDB().Get<int>("auto-advance-n-turns"));
if (fake_mode_change && !FramebuffersAvailable()) {
ErrorLogger() << "Requested fake mode changes, but the framebuffer opengl extension is not available. Ignoring.";
}
m_fsm->initiate();
}
// main app message handler
static InReaction MainInputHandler(const SDL_Event_* ev)
{
switch(ev->ev.type)
{
#if SDL_VERSION_ATLEAST(2, 0, 0)
case SDL_WINDOWEVENT:
switch(ev->ev.window.event)
{
case SDL_WINDOWEVENT_ENTER:
RenderCursor(true);
break;
case SDL_WINDOWEVENT_LEAVE:
RenderCursor(false);
break;
case SDL_WINDOWEVENT_RESIZED:
g_ResizedW = ev->ev.window.data1;
g_ResizedH = ev->ev.window.data2;
break;
}
break;
#else
case SDL_ACTIVEEVENT:
if (ev->ev.active.state & SDL_APPMOUSEFOCUS)
{
// Tell renderer not to render cursor if mouse focus is lost
// this restores system cursor, until/if focus is regained
if (!ev->ev.active.gain)
RenderCursor(false);
else
RenderCursor(true);
}
break;
case SDL_VIDEORESIZE:
g_ResizedW = ev->ev.resize.w;
g_ResizedH = ev->ev.resize.h;
break;
#endif
case SDL_QUIT:
kill_mainloop();
break;
case SDL_HOTKEYDOWN:
std::string hotkey = static_cast<const char*>(ev->ev.user.data1);
if (hotkey == "exit")
{
kill_mainloop();
return IN_HANDLED;
}
else if (hotkey == "screenshot")
{
WriteScreenshot(L".png");
return IN_HANDLED;
}
else if (hotkey == "bigscreenshot")
{
WriteBigScreenshot(L".bmp", 10);
return IN_HANDLED;
}
else if (hotkey == "togglefullscreen")
{
#if !OS_MACOSX
// TODO: Fix fullscreen toggling on OS X, see http://trac.wildfiregames.com/ticket/741
g_VideoMode.ToggleFullscreen();
#else
LOGWARNING(L"Toggling fullscreen and resizing are disabled on OS X due to a known bug. Please use the config file to change display settings.");
#endif
return IN_HANDLED;
}
else if (hotkey == "profile2.enable")
{
g_Profiler2.EnableGPU();
g_Profiler2.EnableHTTP();
return IN_HANDLED;
}
break;
}
return IN_PASS;
}
// main app message handler
static InReaction MainInputHandler(const SDL_Event_* ev)
{
switch(ev->ev.type)
{
#if SDL_VERSION_ATLEAST(2, 0, 0)
case SDL_WINDOWEVENT:
switch(ev->ev.window.event)
{
case SDL_WINDOWEVENT_ENTER:
RenderCursor(true);
break;
case SDL_WINDOWEVENT_LEAVE:
RenderCursor(false);
break;
case SDL_WINDOWEVENT_RESIZED:
g_ResizedW = ev->ev.window.data1;
g_ResizedH = ev->ev.window.data2;
break;
case SDL_WINDOWEVENT_MOVED:
g_VideoMode.UpdatePosition(ev->ev.window.data1, ev->ev.window.data2);
}
break;
#else
case SDL_ACTIVEEVENT:
if (ev->ev.active.state & SDL_APPMOUSEFOCUS)
{
// Tell renderer not to render cursor if mouse focus is lost
// this restores system cursor, until/if focus is regained
if (!ev->ev.active.gain)
RenderCursor(false);
else
RenderCursor(true);
}
break;
case SDL_VIDEORESIZE:
g_ResizedW = ev->ev.resize.w;
g_ResizedH = ev->ev.resize.h;
break;
#endif
case SDL_QUIT:
kill_mainloop();
break;
case SDL_HOTKEYDOWN:
std::string hotkey = static_cast<const char*>(ev->ev.user.data1);
if (hotkey == "exit")
{
kill_mainloop();
return IN_HANDLED;
}
else if (hotkey == "screenshot")
{
WriteScreenshot(L".png");
return IN_HANDLED;
}
else if (hotkey == "bigscreenshot")
{
WriteBigScreenshot(L".bmp", 10);
return IN_HANDLED;
}
else if (hotkey == "togglefullscreen")
{
g_VideoMode.ToggleFullscreen();
return IN_HANDLED;
}
else if (hotkey == "profile2.toggle")
{
g_Profiler2.Toggle();
return IN_HANDLED;
}
break;
}
return IN_PASS;
}
void RadarCanvas::Render(wxPaintEvent &evt) {
int w, h;
if (!IsShown() || !m_pi->m_initialized) {
return;
}
GetClientSize(&w, &h);
wxPaintDC(this); // only to be used in paint events. use wxClientDC to paint
// outside the paint event
if (!m_pi->m_opengl_mode) {
LOG_DIALOG(wxT("BR24radar_pi: %s cannot render non-OpenGL mode"), m_ri->m_name.c_str());
return;
}
if (!m_pi->m_opencpn_gl_context && !m_pi->m_opencpn_gl_context_broken) {
LOG_DIALOG(wxT("BR24radar_pi: %s skip render as no context known yet"), m_ri->m_name.c_str());
return;
}
LOG_DIALOG(wxT("BR24radar_pi: %s render OpenGL canvas %d by %d "), m_ri->m_name.c_str(), w, h);
SetCurrent(*m_context);
glPushMatrix();
glPushAttrib(GL_ALL_ATTRIB_BITS);
wxFont font = GetOCPNGUIScaledFont_PlugIn(_T("StatusBar"));
m_FontNormal.Build(font);
wxFont bigFont = GetOCPNGUIScaledFont_PlugIn(_T("Dialog"));
bigFont.SetPointSize(bigFont.GetPointSize() + 2);
bigFont.SetWeight(wxFONTWEIGHT_BOLD);
m_FontBig.Build(bigFont);
bigFont.SetPointSize(bigFont.GetPointSize() + 2);
bigFont.SetWeight(wxFONTWEIGHT_NORMAL);
m_FontMenu.Build(bigFont);
bigFont.SetPointSize(bigFont.GetPointSize() + 10);
bigFont.SetWeight(wxFONTWEIGHT_BOLD);
m_FontMenuBold.Build(bigFont);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Black Background
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the canvas
glEnable(GL_TEXTURE_2D); // Enable textures
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_BLEND);
// glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack
glLoadIdentity(); // Reset projection matrix stack
glOrtho(0, w, h, 0, -1, 1);
glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW
RenderRangeRingsAndHeading(w, h);
Render_EBL_VRM(w, h);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack
glLoadIdentity(); // Reset projection matrix stack
if (w >= h) {
glScaled(1.0, (float)-w / h, 1.0);
} else {
glScaled((float)h / w, -1.0, 1.0);
}
glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW
m_ri->RenderRadarImage(wxPoint(0, 0), 1.0, 0.0, false);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack
glLoadIdentity(); // Reset projection matrix stack
glOrtho(0, w, h, 0, -1, 1);
glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW
glEnable(GL_TEXTURE_2D);
RenderTexts(w, h);
RenderCursor(w, h);
#ifdef NEVER
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack
glLoadIdentity(); // Reset projection matrix stack
glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW
#endif
glPopAttrib();
glPopMatrix();
glFlush();
glFinish();
SwapBuffers();
if (m_pi->m_opencpn_gl_context) {
SetCurrent(*m_pi->m_opencpn_gl_context);
} else {
SetCurrent(*m_zero_context); // Make sure OpenCPN -at least- doesn't overwrite our context info
}
}
