363 lines
9.7 KiB
C++
363 lines
9.7 KiB
C++
/*
|
|
Copyright (c) 2013 yvt
|
|
|
|
This file is part of OpenSpades.
|
|
|
|
OpenSpades is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
OpenSpades is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenSpades. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
#include "MainScreen.h"
|
|
#include "MainScreenHelper.h"
|
|
#include <Client/Client.h>
|
|
#include <Client/Fonts.h>
|
|
#include <Core/Exception.h>
|
|
#include <Core/Strings.h>
|
|
#include <ScriptBindings/Config.h>
|
|
#include <ScriptBindings/ScriptFunction.h>
|
|
|
|
namespace spades {
|
|
namespace gui {
|
|
MainScreen::MainScreen(client::IRenderer *r, client::IAudioDevice *a,
|
|
client::FontManager *fontManager)
|
|
: renderer(r), audioDevice(a), fontManager(fontManager) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (r == NULL)
|
|
SPInvalidArgument("r");
|
|
if (a == NULL)
|
|
SPInvalidArgument("a");
|
|
|
|
helper = new MainScreenHelper(this);
|
|
|
|
// first call to RunFrame tends to have larger dt value.
|
|
// so this value is set in the first call.
|
|
timeToStartInitialization = 1000.f;
|
|
}
|
|
|
|
MainScreen::~MainScreen() {
|
|
SPADES_MARK_FUNCTION();
|
|
helper->MainScreenDestroyed();
|
|
}
|
|
|
|
// Restores renderer's state (game map, fog color)
|
|
// after returning from the game client.
|
|
void MainScreen::RestoreRenderer() {
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void SetupRenderer()");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
bool MainScreen::NeedsAbsoluteMouseCoordinate() {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
return subview->NeedsAbsoluteMouseCoordinate();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void MainScreen::MouseEvent(float x, float y) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
subview->MouseEvent(x, y);
|
|
return;
|
|
}
|
|
if (!ui) {
|
|
return;
|
|
}
|
|
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void MouseEvent(float, float)");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c->SetArgFloat(0, x);
|
|
c->SetArgFloat(1, y);
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
void MainScreen::WheelEvent(float x, float y) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
subview->WheelEvent(x, y);
|
|
return;
|
|
}
|
|
if (!ui) {
|
|
return;
|
|
}
|
|
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void WheelEvent(float, float)");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c->SetArgFloat(0, x);
|
|
c->SetArgFloat(1, y);
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
void MainScreen::KeyEvent(const std::string &key, bool down) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
subview->KeyEvent(key, down);
|
|
return;
|
|
}
|
|
if (!ui) {
|
|
return;
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void KeyEvent(string, bool)");
|
|
ScriptContextHandle c = func.Prepare();
|
|
std::string k = key;
|
|
c->SetObject(&*ui);
|
|
c->SetArgObject(0, reinterpret_cast<void *>(&k));
|
|
c->SetArgByte(1, down ? 1 : 0);
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
void MainScreen::TextInputEvent(const std::string &ch) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
subview->TextInputEvent(ch);
|
|
return;
|
|
}
|
|
if (!ui) {
|
|
return;
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void TextInputEvent(string)");
|
|
ScriptContextHandle c = func.Prepare();
|
|
std::string k = ch;
|
|
c->SetObject(&*ui);
|
|
c->SetArgObject(0, reinterpret_cast<void *>(&k));
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
void MainScreen::TextEditingEvent(const std::string &ch, int start, int len) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
subview->TextEditingEvent(ch, start, len);
|
|
return;
|
|
}
|
|
if (!ui) {
|
|
return;
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void TextEditingEvent(string, int, int)");
|
|
ScriptContextHandle c = func.Prepare();
|
|
std::string k = ch;
|
|
c->SetObject(&*ui);
|
|
c->SetArgObject(0, reinterpret_cast<void *>(&k));
|
|
c->SetArgDWord(1, static_cast<asDWORD>(start));
|
|
c->SetArgDWord(2, static_cast<asDWORD>(len));
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
bool MainScreen::AcceptsTextInput() {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
return subview->AcceptsTextInput();
|
|
}
|
|
if (!ui) {
|
|
return false;
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "bool AcceptsTextInput()");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c.ExecuteChecked();
|
|
return c->GetReturnByte() != 0;
|
|
}
|
|
|
|
AABB2 MainScreen::GetTextInputRect() {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
return subview->GetTextInputRect();
|
|
}
|
|
if (!ui) {
|
|
return AABB2();
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "AABB2 GetTextInputRect()");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c.ExecuteChecked();
|
|
return *reinterpret_cast<AABB2 *>(c->GetReturnObject());
|
|
}
|
|
|
|
bool MainScreen::WantsToBeClosed() {
|
|
SPADES_MARK_FUNCTION();
|
|
if (!ui) {
|
|
return false;
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "bool WantsToBeClosed()");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c.ExecuteChecked();
|
|
return c->GetReturnByte() != 0;
|
|
}
|
|
|
|
void MainScreen::DrawStartupScreen() {
|
|
SPADES_MARK_FUNCTION();
|
|
Handle<client::IImage> img;
|
|
Vector2 scrSize = {renderer->ScreenWidth(), renderer->ScreenHeight()};
|
|
|
|
renderer->SetColorAlphaPremultiplied(MakeVector4(0, 0, 0, 1.));
|
|
img = renderer->RegisterImage("Gfx/White.tga");
|
|
renderer->DrawImage(img, AABB2(0, 0, scrSize.x, scrSize.y));
|
|
|
|
std::string str = _Tr("MainScreen", "NOW LOADING");
|
|
client::IFont *font = fontManager->GetGuiFont();
|
|
Vector2 size = font->Measure(str);
|
|
Vector2 pos = MakeVector2(scrSize.x - 16.f, scrSize.y - 16.f);
|
|
pos -= size;
|
|
font->DrawShadow(str, pos, 1.f, MakeVector4(1, 1, 1, 1), MakeVector4(0, 0, 0, 0.5));
|
|
|
|
renderer->FrameDone();
|
|
renderer->Flip();
|
|
}
|
|
|
|
void MainScreen::RunFrame(float dt) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
try {
|
|
subview->RunFrame(dt);
|
|
return;
|
|
} catch (const std::exception &ex) {
|
|
SPLog("[!] Error while running a game client: %s", ex.what());
|
|
subview->Closing();
|
|
subview = NULL;
|
|
RestoreRenderer();
|
|
helper->errorMessage = ex.what();
|
|
}
|
|
}
|
|
if (timeToStartInitialization > 100.f) {
|
|
timeToStartInitialization = 0.2f;
|
|
}
|
|
if (timeToStartInitialization > 0.f) {
|
|
DrawStartupScreen();
|
|
timeToStartInitialization -= dt;
|
|
if (timeToStartInitialization <= 0.f) {
|
|
// do init
|
|
DoInit();
|
|
}
|
|
return;
|
|
}
|
|
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void RunFrame(float)");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c->SetArgFloat(0, dt);
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
void MainScreen::RunFrameLate(float dt) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
try {
|
|
subview->RunFrameLate(dt);
|
|
if (subview->WantsToBeClosed()) {
|
|
subview->Closing();
|
|
subview = NULL;
|
|
RestoreRenderer();
|
|
} else {
|
|
return;
|
|
}
|
|
} catch (const std::exception &ex) {
|
|
SPLog("[!] Error while running a game client: %s", ex.what());
|
|
subview->Closing();
|
|
subview = NULL;
|
|
RestoreRenderer();
|
|
helper->errorMessage = ex.what();
|
|
}
|
|
}
|
|
|
|
if (!ui) {
|
|
return;
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void RunFrameLate(float)");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c->SetArgFloat(0, dt);
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
void MainScreen::DoInit() {
|
|
SPADES_MARK_FUNCTION();
|
|
renderer->Init();
|
|
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction uiFactory("MainScreenUI@ CreateMainScreenUI(Renderer@, "
|
|
"AudioDevice@, FontManager@, MainScreenHelper@)");
|
|
{
|
|
ScriptContextHandle ctx = uiFactory.Prepare();
|
|
ctx->SetArgObject(0, renderer);
|
|
ctx->SetArgObject(1, audioDevice);
|
|
ctx->SetArgObject(2, fontManager);
|
|
ctx->SetArgObject(3, &*helper);
|
|
|
|
ctx.ExecuteChecked();
|
|
ui = reinterpret_cast<asIScriptObject *>(ctx->GetReturnObject());
|
|
}
|
|
}
|
|
|
|
void MainScreen::Closing() {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
subview->Closing();
|
|
subview = NULL;
|
|
}
|
|
|
|
if (!ui) {
|
|
return;
|
|
}
|
|
ScopedPrivilegeEscalation privilege;
|
|
static ScriptFunction func("MainScreenUI", "void Closing()");
|
|
ScriptContextHandle c = func.Prepare();
|
|
c->SetObject(&*ui);
|
|
c.ExecuteChecked();
|
|
}
|
|
|
|
bool MainScreen::ExecCommand(const Handle<ConsoleCommand> &cmd) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
return subview->ExecCommand(cmd);
|
|
}
|
|
return View::ExecCommand(cmd);
|
|
}
|
|
|
|
Handle<ConsoleCommandCandidateIterator>
|
|
MainScreen::AutocompleteCommandName(const std::string &name) {
|
|
SPADES_MARK_FUNCTION();
|
|
if (subview) {
|
|
return subview->AutocompleteCommandName(name);
|
|
}
|
|
return View::AutocompleteCommandName(name);
|
|
}
|
|
|
|
std::string MainScreen::Connect(const ServerAddress &host) {
|
|
try {
|
|
subview.Set(new client::Client(&*renderer, &*audioDevice, host, fontManager),
|
|
false);
|
|
} catch (const std::exception &ex) {
|
|
SPLog("[!] Error while initializing a game client: %s", ex.what());
|
|
return ex.what();
|
|
}
|
|
return "";
|
|
}
|
|
} // namespace gui
|
|
} // namespace spades
|