PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

refactor: add GUI instance reference to UI nodes

Browse Source
This commit is contained in:
MihailRis 2025-03-07 18:19:56 +03:00
parent 74a94f869c
commit 4c48afbb90
70 changed files with 1133 additions and 832 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/assets/AssetsLoader.cpp
View File

@ -19,13 +19,14 @@
#include "items/ItemDef.hpp"
#include "Assets.hpp"
#include "assetload_funcs.hpp"
#include "engine/Engine.hpp"
namespace fs = std::filesystem;
static debug::Logger logger("assets-loader");
AssetsLoader::AssetsLoader(Assets* assets, const ResPaths* paths)
: assets(assets), paths(paths) {
AssetsLoader::AssetsLoader(Engine& engine, Assets& assets, const ResPaths* paths)
: engine(engine), assets(assets), paths(paths) {
addLoader(AssetType::SHADER, assetload::shader);
addLoader(AssetType::TEXTURE, assetload::texture);
addLoader(AssetType::FONT, assetload::font);
@ -73,7 +74,7 @@ void AssetsLoader::loadNext() {
aloader_func loader = getLoader(entry.tag);
auto postfunc =
loader(this, paths, entry.filename, entry.alias, entry.config);
postfunc(assets);
postfunc(&assets);
entries.pop();
} catch (std::runtime_error& err) {
logger.error() << err.what();
@ -101,7 +102,7 @@ static void add_layouts(
AssetType::LAYOUT,
file.string(),
name,
std::make_shared<LayoutCfg>(env)
std::make_shared<LayoutCfg>(&loader.getEngine().getGUI(), env)
);
}
}
@ -296,6 +297,10 @@ bool AssetsLoader::loadExternalTexture(
return false;
}
Engine& AssetsLoader::getEngine() {
return engine;
}
const ResPaths* AssetsLoader::getPaths() const {
return paths;
}
@ -324,7 +329,7 @@ std::shared_ptr<Task> AssetsLoader::startTask(runnable onDone) {
std::make_shared<util::ThreadPool<aloader_entry, assetload::postfunc>>(
"assets-loader-pool",
[=]() { return std::make_shared<LoaderWorker>(this); },
[=](const assetload::postfunc& func) { func(assets); }
[this](const assetload::postfunc& func) { func(&assets); }
);
pool->setOnComplete(std::move(onDone));
while (!entries.empty()) {

15
src/assets/AssetsLoader.hpp
View File

@ -18,6 +18,11 @@
class ResPaths;
class AssetsLoader;
class Content;
class Engine;
namespace gui {
class GUI;
}
struct AssetCfg {
virtual ~AssetCfg() {
@ -25,9 +30,10 @@ struct AssetCfg {
};
struct LayoutCfg : AssetCfg {
gui::GUI* gui;
scriptenv env;
LayoutCfg(scriptenv env) : env(std::move(env)) {
LayoutCfg(gui::GUI* gui, scriptenv env) : gui(gui), env(std::move(env)) {
}
};
@ -61,7 +67,8 @@ struct aloader_entry {
};
class AssetsLoader {
Assets* assets;
Engine& engine;
Assets& assets;
std::map<AssetType, aloader_func> loaders;
std::queue<aloader_entry> entries;
std::set<std::pair<AssetType, std::string>> enqueued;
@ -76,7 +83,7 @@ class AssetsLoader {
void processPreloadConfig(const io::path& file);
void processPreloadConfigs(const Content* content);
public:
AssetsLoader(Assets* assets, const ResPaths* paths);
AssetsLoader(Engine& engine, Assets& assets, const ResPaths* paths);
void addLoader(AssetType tag, aloader_func func);
/// @brief Enqueue asset load
@ -111,4 +118,6 @@ public:
const std::string& name,
const std::vector<io::path>& alternatives
);
Engine& getEngine();
};

1
src/assets/assetload_funcs.cpp
View File

@ -189,6 +189,7 @@ assetload::postfunc assetload::layout(
auto prefix = name.substr(0, pos);
assets->store(
UiDocument::read(
*cfg->gui,
cfg->env,
name,
file,

43
src/engine/Engine.cpp
View File

@ -50,8 +50,6 @@
static debug::Logger logger("engine");
namespace fs = std::filesystem;
static std::unique_ptr<ImageData> load_icon() {
try {
auto file = "res:textures/misc/icon.png";
@ -65,20 +63,21 @@ static std::unique_ptr<ImageData> load_icon() {
}
Engine::Engine() = default;
Engine::~Engine() = default;
static std::unique_ptr<Engine> engine;
static std::unique_ptr<Engine> instance = nullptr;
Engine& Engine::getInstance() {
if (!engine) {
engine = std::make_unique<Engine>();
if (!instance) {
instance = std::make_unique<Engine>();
}
return *engine;
return *instance;
}
void Engine::initialize(CoreParameters coreParameters) {
params = std::move(coreParameters);
settingsHandler = std::make_unique<SettingsHandler>(settings);
interpreter = std::make_unique<cmd::CommandsInterpreter>();
cmd = std::make_unique<cmd::CommandsInterpreter>();
network = network::Network::create(settings.network);
logger.info() << "engine version: " << ENGINE_VERSION_STRING;
@ -97,7 +96,7 @@ void Engine::initialize(CoreParameters coreParameters) {
controller = std::make_unique<EngineController>(*this);
if (!params.headless) {
if (Window::initialize(&settings.display)){
if (!(input = Window::initialize(&settings.display))){
throw initialize_error("could not initialize window");
}
time.set(Window::time());
@ -107,9 +106,9 @@ void Engine::initialize(CoreParameters coreParameters) {
}
loadControls();
gui = std::make_unique<gui::GUI>();
gui = std::make_unique<gui::GUI>(*this);
if (ENGINE_DEBUG_BUILD) {
menus::create_version_label(*this);
menus::create_version_label(*gui);
}
}
audio::initialize(!params.headless, settings.audio);
@ -209,7 +208,7 @@ void Engine::nextFrame() {
: settings.display.framerate.get()
);
Window::swapBuffers();
Events::pollEvents();
input->pollEvents();
}
void Engine::renderFrame() {
@ -229,7 +228,7 @@ void Engine::saveSettings() {
}
}
Engine::~Engine() {
void Engine::close() {
saveSettings();
logger.info() << "shutting down";
if (screen) {
@ -238,7 +237,7 @@ Engine::~Engine() {
}
content.reset();
assets.reset();
interpreter.reset();
cmd.reset();
if (gui) {
gui.reset();
logger.info() << "gui finished";
@ -256,17 +255,14 @@ Engine::~Engine() {
}
void Engine::terminate() {
engine.reset();
instance->close();
instance.reset();
}
EngineController* Engine::getController() {
return controller.get();
}
cmd::CommandsInterpreter* Engine::getCommandsInterpreter() {
return interpreter.get();
}
PacksManager Engine::createPacksManager(const io::path& worldFolder) {
PacksManager manager;
manager.setSources({
@ -286,7 +282,7 @@ void Engine::loadAssets() {
Shader::preprocessor->setPaths(resPaths.get());
auto new_assets = std::make_unique<Assets>();
AssetsLoader loader(new_assets.get(), resPaths.get());
AssetsLoader loader(*this, *new_assets, resPaths.get());
AssetsLoader::addDefaults(loader, content.get());
// no need
@ -376,7 +372,6 @@ void Engine::loadContent() {
load_configs(pack.folder);
}
content = contentBuilder.build();
interpreter->reset();
scripting::on_content_load(content.get());
ContentLoader::loadScripts(*content);
@ -468,10 +463,6 @@ bool Engine::isQuitSignal() const {
return quitSignal;
}
gui::GUI* Engine::getGUI() {
return gui.get();
}
EngineSettings& Engine::getSettings() {
return settings;
}
@ -518,10 +509,6 @@ SettingsHandler& Engine::getSettingsHandler() {
return *settingsHandler;
}
network::Network& Engine::getNetwork() {
return *network;
}
Time& Engine::getTime() {
return time;
}

27
src/engine/Engine.hpp
View File

@ -26,6 +26,7 @@ class ResPaths;
class EngineController;
class SettingsHandler;
struct EngineSettings;
class Input;
namespace gui {
class GUI;
@ -66,8 +67,9 @@ class Engine : public util::ObjectsKeeper {
std::unique_ptr<Content> content;
std::unique_ptr<ResPaths> resPaths;
std::unique_ptr<EngineController> controller;
std::unique_ptr<cmd::CommandsInterpreter> interpreter;
std::unique_ptr<cmd::CommandsInterpreter> cmd;
std::unique_ptr<network::Network> network;
std::unique_ptr<Input> input;
std::vector<std::string> basePacks;
std::unique_ptr<gui::GUI> gui;
PostRunnables postRunnables;
@ -87,6 +89,7 @@ public:
static Engine& getInstance();
void initialize(CoreParameters coreParameters);
void close();
static void terminate();
@ -128,9 +131,6 @@ public:
/// @brief Get active assets storage instance
Assets* getAssets();
/// @brief Get main UI controller
gui::GUI* getGUI();
/// @brief Get writeable engine settings structure instance
EngineSettings& getSettings();
@ -171,7 +171,6 @@ public:
void saveScreenshot();
EngineController* getController();
cmd::CommandsInterpreter* getCommandsInterpreter();
PacksManager createPacksManager(const io::path& worldFolder);
@ -179,11 +178,25 @@ public:
SettingsHandler& getSettingsHandler();
network::Network& getNetwork();
Time& getTime();
const CoreParameters& getCoreParameters() const;
bool isHeadless() const;
gui::GUI& getGUI() {
return *gui;
}
Input& getInput() {
return *input;
}
network::Network& getNetwork() {
return *network;
}
cmd::CommandsInterpreter& getCmd() {
return *cmd;
}
};

8
src/frontend/UiDocument.cpp
View File

@ -54,6 +54,7 @@ scriptenv UiDocument::getEnvironment() const {
}
std::unique_ptr<UiDocument> UiDocument::read(
gui::GUI& gui,
const scriptenv& penv,
const std::string& name,
const io::path& file,
@ -66,7 +67,7 @@ std::unique_ptr<UiDocument> UiDocument::read(
? scripting::create_doc_environment(scripting::get_root_environment(), name)
: scripting::create_doc_environment(penv, name);
gui::UiXmlReader reader(env);
gui::UiXmlReader reader(gui, env);
auto view = reader.readXML(file.string(), *xmldoc->getRoot());
view->setId("root");
uidocscript script {};
@ -80,8 +81,7 @@ std::unique_ptr<UiDocument> UiDocument::read(
}
std::shared_ptr<gui::UINode> UiDocument::readElement(
const io::path& file, const std::string& fileName
gui::GUI& gui, const io::path& file, const std::string& fileName
) {
auto document = read(nullptr, file.name(), file, fileName);
return document->getRoot();
return read(gui, nullptr, file.name(), file, fileName)->getRoot();
}

4
src/frontend/UiDocument.hpp
View File

@ -9,6 +9,7 @@
#include "io/fwd.hpp"
namespace gui {
class GUI;
class UINode;
}
@ -45,12 +46,13 @@ public:
scriptenv getEnvironment() const;
static std::unique_ptr<UiDocument> read(
gui::GUI&,
const scriptenv& parent_env,
const std::string& name,
const io::path& file,
const std::string& fileName
);
static std::shared_ptr<gui::UINode> readElement(
const io::path& file, const std::string& fileName
gui::GUI&, const io::path& file, const std::string& fileName
);
};

59
src/frontend/debug_panel.cpp
View File

@ -35,8 +35,8 @@
using namespace gui;
static std::shared_ptr<Label> create_label(wstringsupplier supplier) {
auto label = std::make_shared<Label>(L"-");
static std::shared_ptr<Label> create_label(GUI& gui, wstringsupplier supplier) {
auto label = std::make_shared<Label>(gui, L"-");
label->textSupplier(std::move(supplier));
return label;
}
@ -50,7 +50,10 @@ std::shared_ptr<UINode> create_debug_panel(
Player& player,
bool allowDebugCheats
) {
auto panel = std::make_shared<Panel>(glm::vec2(300, 200), glm::vec4(5.0f), 2.0f);
auto& gui = engine.getGUI();
auto panel = std::make_shared<Panel>(
gui, glm::vec2(300, 200), glm::vec4(5.0f), 2.0f
);
panel->setId("hud.debug-panel");
panel->setPos(glm::vec2(10, 10));
@ -87,48 +90,48 @@ std::shared_ptr<UINode> create_debug_panel(
lastTotalUpload = totalUpload;
});
panel->add(create_label([]() { return L"fps: "+fpsString;}));
panel->add(create_label(gui, []() { return L"fps: "+fpsString;}));
panel->add(create_label([]() {
panel->add(create_label(gui, []() {
return L"meshes: " + std::to_wstring(Mesh::meshesCount);
}));
panel->add(create_label([]() {
panel->add(create_label(gui, []() {
int drawCalls = Mesh::drawCalls;
Mesh::drawCalls = 0;
return L"draw-calls: " + std::to_wstring(drawCalls);
}));
panel->add(create_label([]() {
panel->add(create_label(gui, []() {
return L"speakers: " + std::to_wstring(audio::count_speakers())+
L" streams: " + std::to_wstring(audio::count_streams());
}));
panel->add(create_label([]() {
panel->add(create_label(gui, []() {
return L"lua-stack: " + std::to_wstring(scripting::get_values_on_stack());
}));
panel->add(create_label([]() { return netSpeedString; }));
panel->add(create_label([&engine]() {
panel->add(create_label(gui, []() { return netSpeedString; }));
panel->add(create_label(gui, [&engine]() {
auto& settings = engine.getSettings();
bool culling = settings.graphics.frustumCulling.get();
return L"frustum-culling: "+std::wstring(culling ? L"on" : L"off");
}));
panel->add(create_label([=]() {
panel->add(create_label(gui, [=]() {
return L"particles: " +
std::to_wstring(ParticlesRenderer::visibleParticles) +
L" emitters: " +
std::to_wstring(ParticlesRenderer::aliveEmitters);
}));
panel->add(create_label([&]() {
panel->add(create_label(gui, [&]() {
return L"chunks: "+std::to_wstring(level.chunks->size())+
L" visible: "+std::to_wstring(ChunksRenderer::visibleChunks);
}));
panel->add(create_label([&]() {
panel->add(create_label(gui, [&]() {
return L"entities: "+std::to_wstring(level.entities->size())+L" next: "+
std::to_wstring(level.entities->peekNextID());
}));
panel->add(create_label([&]() {
panel->add(create_label(gui, [&]() {
return L"players: "+std::to_wstring(level.players->size())+L" local: "+
std::to_wstring(player.getId());
}));
panel->add(create_label([&]() -> std::wstring {
panel->add(create_label(gui, [&]() -> std::wstring {
const auto& vox = player.selection.vox;
std::wstringstream stream;
stream << "r:" << vox.state.rotation << " s:"
@ -141,7 +144,7 @@ std::shared_ptr<UINode> create_debug_panel(
L" "+stream.str();
}
}));
panel->add(create_label([&]() -> std::wstring {
panel->add(create_label(gui, [&]() -> std::wstring {
const auto& selection = player.selection;
const auto& vox = selection.vox;
if (vox.id == BLOCK_VOID) {
@ -151,7 +154,7 @@ std::shared_ptr<UINode> create_debug_panel(
L" y: " + std::to_wstring(selection.actualPosition.y) +
L" z: " + std::to_wstring(selection.actualPosition.z);
}));
panel->add(create_label([&]() {
panel->add(create_label(gui, [&]() {
auto eid = player.getSelectedEntity();
if (eid == ENTITY_NONE) {
return std::wstring {L"entity: -"};
@ -162,7 +165,7 @@ std::shared_ptr<UINode> create_debug_panel(
return std::wstring {L"entity: error (invalid UID)"};
}
}));
panel->add(create_label([&](){
panel->add(create_label(gui, [&](){
auto indices = level.content.getIndices();
if (auto def = indices->blocks.get(player.selection.vox.id)) {
return L"name: " + util::str2wstr_utf8(def->name);
@ -170,23 +173,23 @@ std::shared_ptr<UINode> create_debug_panel(
return std::wstring {L"name: void"};
}
}));
panel->add(create_label([&](){
panel->add(create_label(gui, [&](){
return L"seed: "+std::to_wstring(level.getWorld()->getSeed());
}));
for (int ax = 0; ax < 3; ax++) {
auto sub = std::make_shared<Container>(glm::vec2(250, 27));
auto sub = std::make_shared<Container>(gui, glm::vec2(250, 27));
std::wstring str = L"x: ";
str[0] += ax;
auto label = std::make_shared<Label>(str);
auto label = std::make_shared<Label>(gui, str);
label->setMargin(glm::vec4(2, 3, 2, 3));
label->setSize(glm::vec2(20, 27));
sub->add(label);
sub->setColor(glm::vec4(0.0f));
// Coord input
auto box = std::make_shared<TextBox>(L"");
auto box = std::make_shared<TextBox>(gui, L"");
auto boxRef = box.get();
box->setTextSupplier([&player, ax]() {
return util::to_wstring(player.getPosition()[ax], 2);
@ -212,7 +215,7 @@ std::shared_ptr<UINode> create_debug_panel(
panel->add(sub);
}
auto& worldInfo = level.getWorld()->getInfo();
panel->add(create_label([&](){
panel->add(create_label(gui, [&](){
int hour, minute, second;
timeutil::from_value(worldInfo.daytime, hour, minute, second);
@ -222,20 +225,20 @@ std::shared_ptr<UINode> create_debug_panel(
return L"time: "+timeString;
}));
if (allowDebugCheats) {
auto bar = std::make_shared<TrackBar>(0.0f, 1.0f, 1.0f, 0.005f, 8);
auto bar = std::make_shared<TrackBar>(gui, 0.0f, 1.0f, 1.0f, 0.005f, 8);
bar->setSupplier([&]() {return worldInfo.daytime;});
bar->setConsumer([&](double val) {worldInfo.daytime = val;});
panel->add(bar);
}
if (allowDebugCheats) {
auto bar = std::make_shared<TrackBar>(0.0f, 1.0f, 0.0f, 0.005f, 8);
auto bar = std::make_shared<TrackBar>(gui, 0.0f, 1.0f, 0.0f, 0.005f, 8);
bar->setSupplier([&]() {return worldInfo.fog;});
bar->setConsumer([&](double val) {worldInfo.fog = val;});
panel->add(bar);
}
{
auto checkbox = std::make_shared<FullCheckBox>(
L"Show Chunk Borders", glm::vec2(400, 24)
gui, L"Show Chunk Borders", glm::vec2(400, 24)
);
checkbox->setSupplier([=]() {
return WorldRenderer::showChunkBorders;
@ -247,7 +250,7 @@ std::shared_ptr<UINode> create_debug_panel(
}
{
auto checkbox = std::make_shared<FullCheckBox>(
L"Show Hitboxes", glm::vec2(400, 24)
gui, L"Show Hitboxes", glm::vec2(400, 24)
);
checkbox->setSupplier([=]() {
return WorldRenderer::showEntitiesDebug;
@ -259,7 +262,7 @@ std::shared_ptr<UINode> create_debug_panel(
}
{
auto checkbox = std::make_shared<FullCheckBox>(
L"Show Generator Minimap", glm::vec2(400, 24)
gui, L"Show Generator Minimap", glm::vec2(400, 24)
);
checkbox->setSupplier([=]() {
return Hud::showGeneratorMinimap;

60
src/frontend/hud.cpp
View File

@ -126,7 +126,7 @@ std::shared_ptr<InventoryView> Hud::createContentAccess() {
inventory->getSlot(player.getChosenSlot()).set(item);
});
InventoryBuilder builder;
InventoryBuilder builder(gui);
builder.addGrid(8, itemsCount-1, glm::vec2(), glm::vec4(8, 8, 12, 8), true, slotLayout);
auto view = builder.build();
view->bind(accessInventory, &content);
@ -139,7 +139,7 @@ std::shared_ptr<InventoryView> Hud::createHotbar() {
auto& content = frontend.getLevel().content;
SlotLayout slotLayout(-1, glm::vec2(), false, false, nullptr, nullptr, nullptr);
InventoryBuilder builder;
InventoryBuilder builder(gui);
builder.addGrid(10, 10, glm::vec2(), glm::vec4(4), true, slotLayout);
auto view = builder.build();
view->setId("hud.hotbar");
@ -153,8 +153,10 @@ static constexpr uint WORLDGEN_IMG_SIZE = 128U;
Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
: engine(engine),
input(engine.getInput()),
assets(*engine.getAssets()),
gui(*engine.getGUI()),
gui(engine.getGUI()),
menu(*engine.getGUI().getMenu()),
frontend(frontend),
player(player),
debugImgWorldGen(std::make_unique<ImageData>(
@ -163,7 +165,7 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
contentAccess = createContentAccess();
contentAccess->setId("hud.content-access");
contentAccessPanel = std::make_shared<Panel>(
contentAccess->getSize(), glm::vec4(0.0f), 0.0f
gui, contentAccess->getSize(), glm::vec4(0.0f), 0.0f
);
contentAccessPanel->setColor(glm::vec4());
contentAccessPanel->add(contentAccess);
@ -172,6 +174,7 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
hotbarView = createHotbar();
darkOverlay = guiutil::create(
gui,
"<container size='4000' color='#00000080' z-index='-1' visible='false'/>"
);
@ -183,13 +186,13 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
engine, frontend.getLevel(), player, allowDebugCheats
);
debugPanel->setZIndex(2);
gui.add(debugPanel);
gui.add(darkOverlay);
gui.add(hotbarView);
gui.add(contentAccessPanel);
auto dplotter = std::make_shared<Plotter>(350, 250, 2000, 16);
auto dplotter = std::make_shared<Plotter>(gui, 350, 250, 2000, 16);
dplotter->setGravity(Gravity::bottom_right);
dplotter->setInteractive(false);
add(HudElement(HudElementMode::PERMANENT, nullptr, dplotter, true));
@ -197,9 +200,10 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
assets.store(Texture::from(debugImgWorldGen.get()), DEBUG_WORLDGEN_IMAGE);
debugMinimap = guiutil::create(
"<image src='"+DEBUG_WORLDGEN_IMAGE+
gui,
"<image src='" + DEBUG_WORLDGEN_IMAGE +
"' pos='0' size='256' gravity='top-right' margin='0,20,0,0'/>"
);
);
add(HudElement(HudElementMode::PERMANENT, nullptr, debugMinimap, true));
}
@ -223,11 +227,11 @@ void Hud::cleanup() {
}
void Hud::processInput(bool visible) {
auto menu = gui.getMenu();
if (!Window::isFocused() && !menu->hasOpenPage() && !isInventoryOpen()) {
if (!Window::isFocused() && !menu.hasOpenPage() && !isInventoryOpen()) {
setPause(true);
}
if (!pause && visible && Events::jactive(BIND_HUD_INVENTORY)) {
const auto& bindings = input.getBindings();
if (!pause && visible && bindings.jactive(BIND_HUD_INVENTORY)) {
if (inventoryOpen) {
closeInventory();
} else {
@ -240,9 +244,10 @@ void Hud::processInput(bool visible) {
}
void Hud::updateHotbarControl() {
if (!inventoryOpen && Events::scroll) {
int scroll = input.getScroll();
if (!inventoryOpen && scroll) {
int slot = player.getChosenSlot();
slot = (slot - Events::scroll) % 10;
slot = (slot - scroll) % 10;
if (slot < 0) {
slot += 10;
}
@ -253,11 +258,11 @@ void Hud::updateHotbarControl() {
i <= static_cast<int>(keycode::NUM_9);
i++
) {
if (Events::jpressed(static_cast<keycode>(i))) {
if (input.jpressed(static_cast<keycode>(i))) {
player.setChosenSlot(i - static_cast<int>(keycode::NUM_1));
}
}
if (Events::jpressed(keycode::NUM_0)) {
if (input.jpressed(keycode::NUM_0)) {
player.setChosenSlot(9);
}
}
@ -311,7 +316,6 @@ void Hud::updateWorldGenDebug() {
void Hud::update(bool visible) {
const auto& chunks = *player.chunks;
const auto& menu = gui.getMenu();
debugPanel->setVisible(
debug && visible && !(inventoryOpen && inventoryView == nullptr)
@ -320,13 +324,13 @@ void Hud::update(bool visible) {
if (!visible && inventoryOpen) {
closeInventory();
}
if (pause && !menu->hasOpenPage()) {
if (pause && !menu.hasOpenPage()) {
setPause(false);
}
if (!gui.isFocusCaught()) {
processInput(visible);
}
if ((menu->hasOpenPage() || inventoryOpen) == Events::isCursorLocked()) {
if ((menu.hasOpenPage() || inventoryOpen) == input.getCursor().locked) {
Events::toggleCursor();
}
@ -447,6 +451,7 @@ void Hud::showExchangeSlot() {
auto& content = level.content;
exchangeSlotInv = level.inventories->createVirtual(1);
exchangeSlot = std::make_shared<SlotView>(
gui,
SlotLayout(-1, glm::vec2(), false, false, nullptr, nullptr, nullptr)
);
exchangeSlot->bind(exchangeSlotInv->getId(), exchangeSlotInv->getSlot(0), &content);
@ -590,11 +595,10 @@ void Hud::draw(const DrawContext& ctx){
const Viewport& viewport = ctx.getViewport();
const uint width = viewport.getWidth();
const uint height = viewport.getHeight();
auto menu = gui.getMenu();
bool is_menu_open = menu->hasOpenPage();
bool is_menu_open = menu.hasOpenPage();
darkOverlay->setVisible(is_menu_open);
menu->setVisible(is_menu_open);
menu.setVisible(is_menu_open);
updateElementsPosition(viewport);
@ -663,7 +667,7 @@ void Hud::updateElementsPosition(const Viewport& viewport) {
}
}
if (exchangeSlot != nullptr) {
exchangeSlot->setPos(glm::vec2(Events::cursor));
exchangeSlot->setPos(input.getCursor().pos);
}
hotbarView->setPos(glm::vec2(width/2, height-65));
hotbarView->setSelected(player.getChosenSlot());
@ -689,12 +693,11 @@ void Hud::setPause(bool pause) {
closeInventory();
}
const auto& menu = gui.getMenu();
if (!pause && menu->hasOpenPage()) {
menu->reset();
if (!pause && menu.hasOpenPage()) {
menu.reset();
}
if (pause && !menu->hasOpenPage()) {
menu->setPage("pause");
if (pause && !menu.hasOpenPage()) {
menu.setPage("pause");
}
}
@ -730,9 +733,8 @@ void Hud::setDebugCheats(bool flag) {
void Hud::setAllowPause(bool flag) {
if (pause) {
auto menu = gui.getMenu();
setPause(false);
menu->setPage("pause", true);
menu.setPage("pause", true);
}
allowPause = flag;
}

6
src/frontend/hud.hpp
View File

@ -20,9 +20,11 @@ class UiDocument;
class DrawContext;
class Viewport;
class ImageData;
class Input;
namespace gui {
class GUI;
class Menu;
class UINode;
class Panel;
class Container;
@ -71,9 +73,11 @@ public:
class Hud : public util::ObjectsKeeper {
Engine& engine;
Input& input;
Assets& assets;
std::unique_ptr<Camera> uicamera;
gui::GUI& gui;
gui::Menu& menu;
std::unique_ptr<Camera> uicamera;
LevelFrontend& frontend;
Player& player;

97
src/frontend/menu.cpp
View File

@ -1,35 +1,35 @@
#include "menu.hpp"
#include "locale.hpp"
#include "UiDocument.hpp"
#include "screens/MenuScreen.hpp"
#include "delegates.hpp"
#include "engine/Engine.hpp"
#include "data/dv.hpp"
#include "interfaces/Task.hpp"
#include "io/engine_paths.hpp"
#include "graphics/ui/elements/Menu.hpp"
#include "graphics/ui/gui_util.hpp"
#include "graphics/ui/GUI.hpp"
#include "logic/scripting/scripting.hpp"
#include "settings.hpp"
#include "coders/commons.hpp"
#include "util/stringutil.hpp"
#include <filesystem>
#include <glm/glm.hpp>
#include "UiDocument.hpp"
#include "coders/commons.hpp"
#include "data/dv.hpp"
#include "delegates.hpp"
#include "engine/Engine.hpp"
#include "graphics/ui/GUI.hpp"
#include "graphics/ui/elements/Menu.hpp"
#include "graphics/ui/gui_util.hpp"
#include "interfaces/Task.hpp"
#include "io/engine_paths.hpp"
#include "locale.hpp"
#include "logic/scripting/scripting.hpp"
#include "screens/MenuScreen.hpp"
#include "settings.hpp"
#include "util/stringutil.hpp"
namespace fs = std::filesystem;
using namespace gui;
void menus::create_version_label(Engine& engine) {
auto gui = engine.getGUI();
auto text = ENGINE_VERSION_STRING+" debug build";
gui->add(guiutil::create(
"<label z-index='1000' color='#FFFFFF80' gravity='top-right' margin='4'>"
+text+
"</label>"
void menus::create_version_label(gui::GUI& gui) {
auto text = ENGINE_VERSION_STRING + " debug build";
gui.add(guiutil::create(
gui,
"<label z-index='1000' color='#FFFFFF80' gravity='top-right' "
"margin='4'>" +
text + "</label>"
));
}
@ -44,14 +44,16 @@ bool menus::call(Engine& engine, runnable func) {
engine.setScreen(std::make_shared<MenuScreen>(engine));
// could not to find or read pack
guiutil::alert(
engine, langs::get(L"error.pack-not-found")+L": "+
util::str2wstr_utf8(error.getPackId())
engine,
langs::get(L"error.pack-not-found") + L": " +
util::str2wstr_utf8(error.getPackId())
);
return false;
} catch (const assetload::error& error) {
engine.setScreen(std::make_shared<MenuScreen>(engine));
guiutil::alert(
engine, langs::get(L"Assets Load Error", L"menu")+L":\n"+
engine,
langs::get(L"Assets Load Error", L"menu") + L":\n" +
util::str2wstr_utf8(error.what())
);
return false;
@ -62,20 +64,27 @@ bool menus::call(Engine& engine, runnable func) {
} catch (const std::runtime_error& error) {
engine.setScreen(std::make_shared<MenuScreen>(engine));
guiutil::alert(
engine, langs::get(L"Content Error", L"menu")+L":\n"+
engine,
langs::get(L"Content Error", L"menu") + L":\n" +
util::str2wstr_utf8(error.what())
);
return false;
}
}
UiDocument* menus::show(Engine& engine, const std::string& name, std::vector<dv::value> args) {
auto menu = engine.getGUI()->getMenu();
auto file = engine.getResPaths()->find("layouts/"+name+".xml");
auto fullname = "core:layouts/"+name;
UiDocument* menus::show(
Engine& engine, const std::string& name, std::vector<dv::value> args
) {
auto menu = engine.getGUI().getMenu();
auto file = engine.getResPaths()->find("layouts/" + name + ".xml");
auto fullname = "core:layouts/" + name;
auto documentPtr = UiDocument::read(
scripting::get_root_environment(), fullname, file, "core:layouts/"+name
engine.getGUI(),
scripting::get_root_environment(),
fullname,
file,
"core:layouts/" + name
);
auto document = documentPtr.get();
engine.getAssets()->store(std::move(documentPtr), fullname);
@ -85,18 +94,20 @@ UiDocument* menus::show(Engine& engine, const std::string& name, std::vector<dv:
return document;
}
void menus::show_process_panel(Engine& engine, const std::shared_ptr<Task>& task, const std::wstring& text) {
void menus::show_process_panel(
Engine& engine, const std::shared_ptr<Task>& task, const std::wstring& text
) {
uint initialWork = task->getWorkTotal();
auto menu = engine.getGUI()->getMenu();
auto menu = engine.getGUI().getMenu();
menu->reset();
auto doc = menus::show(engine, "process", {
util::wstr2str_utf8(langs::get(text))
});
std::dynamic_pointer_cast<Container>(doc->getRoot())->listenInterval(0.01f, [=]() {
task->update();
auto doc =
menus::show(engine, "process", {util::wstr2str_utf8(langs::get(text))});
std::dynamic_pointer_cast<Container>(doc->getRoot())
->listenInterval(0.01f, [=]() {
task->update();
uint tasksDone = task->getWorkDone();
scripting::on_ui_progress(doc, tasksDone, initialWork);
});
uint tasksDone = task->getWorkDone();
scripting::on_ui_progress(doc, tasksDone, initialWork);
});
}

2
src/frontend/menu.hpp
View File

@ -14,7 +14,7 @@ class UiDocument;
namespace menus {
/// @brief Create development version label at the top-right screen corner
void create_version_label(Engine& engine);
void create_version_label(gui::GUI& gui);
UiDocument* show(
Engine& engine,

40
src/frontend/screens/LevelScreen.cpp
View File

@ -6,7 +6,7 @@
#include "core_defs.hpp"
#include "debug/Logger.hpp"
#include "engine/Engine.hpp"
#include "io/io.hpp"
#include "frontend/ContentGfxCache.hpp"
#include "frontend/LevelFrontend.hpp"
#include "frontend/hud.hpp"
#include "graphics/core/DrawContext.hpp"
@ -17,8 +17,7 @@
#include "graphics/render/WorldRenderer.hpp"
#include "graphics/ui/GUI.hpp"
#include "graphics/ui/elements/Menu.hpp"
#include "graphics/ui/GUI.hpp"
#include "frontend/ContentGfxCache.hpp"
#include "io/io.hpp"
#include "logic/LevelController.hpp"
#include "logic/PlayerController.hpp"
#include "logic/scripting/scripting.hpp"
@ -43,24 +42,23 @@ LevelScreen::LevelScreen(
)
: Screen(engine),
world(*levelPtr->getWorld()),
postProcessing(std::make_unique<PostProcessing>()) {
postProcessing(std::make_unique<PostProcessing>()),
gui(engine.getGUI()),
input(engine.getInput()) {
Level* level = levelPtr.get();
auto& settings = engine.getSettings();
auto& assets = *engine.getAssets();
auto menu = engine.getGUI()->getMenu();
auto menu = engine.getGUI().getMenu();
menu->reset();
auto player = level->players->get(localPlayer);
assert(player != nullptr);
controller =
std::make_unique<LevelController>(&engine, std::move(levelPtr), player);
playerController = std::make_unique<PlayerController>(
settings,
*level,
*player,
*controller->getBlocksController()
settings, *level, *player, *controller->getBlocksController()
);
frontend = std::make_unique<LevelFrontend>(
@ -87,7 +85,7 @@ LevelScreen::LevelScreen(
keepAlive(settings.camera.fov.observe([=](double value) {
player->fpCamera->setFov(glm::radians(value));
}));
keepAlive(Events::getBinding(BIND_CHUNKS_RELOAD).onactived.add([=](){
keepAlive(input.addCallback(BIND_CHUNKS_RELOAD, [=]() {
player->chunks->saveAndClear();
renderer->clear();
return false;
@ -178,13 +176,14 @@ void LevelScreen::saveWorldPreview() {
void LevelScreen::updateHotkeys() {
auto& settings = engine.getSettings();
if (Events::jpressed(keycode::O)) {
if (input.jpressed(keycode::O)) {
settings.graphics.frustumCulling.toggle();
}
if (Events::jpressed(keycode::F1)) {
if (input.jpressed(keycode::F1)) {
hudVisible = !hudVisible;
}
if (Events::jpressed(keycode::F3)) {
if (input.jpressed(keycode::F3)) {
debug = !debug;
hud->setDebug(debug);
renderer->setDebug(debug);
@ -199,19 +198,16 @@ void LevelScreen::updateAudio() {
audio::get_channel("regular")->setPaused(paused);
audio::get_channel("ambient")->setPaused(paused);
glm::vec3 velocity {};
if (auto hitbox = player->getHitbox()) {
if (auto hitbox = player->getHitbox()) {
velocity = hitbox->velocity;
}
audio::set_listener(
camera->position,
velocity,
camera->dir,
glm::vec3(0, 1, 0)
camera->position, velocity, camera->dir, glm::vec3(0, 1, 0)
);
}
void LevelScreen::update(float delta) {
auto& gui = *engine.getGUI();
auto& gui = engine.getGUI();
if (!gui.isFocusCaught()) {
updateHotkeys();
@ -225,10 +221,10 @@ void LevelScreen::update(float delta) {
if (!paused) {
world.updateTimers(delta);
animator->update(delta);
playerController->update(delta, !inputLocked);
playerController->update(delta, inputLocked ? nullptr : &engine.getInput());
}
controller->update(glm::min(delta, 0.2f), paused);
playerController->postUpdate(delta, !inputLocked, paused);
playerController->postUpdate(delta, inputLocked ? nullptr : &engine.getInput(), paused);
hud->update(hudVisible);

7
src/frontend/screens/LevelScreen.hpp
View File

@ -16,6 +16,11 @@ class ContentPackRuntime;
class Decorator;
class Level;
class World;
class Input;
namespace gui {
class GUI;
}
class LevelScreen : public Screen {
World& world;
@ -27,6 +32,8 @@ class LevelScreen : public Screen {
std::unique_ptr<PostProcessing> postProcessing;
std::unique_ptr<Decorator> decorator;
std::unique_ptr<Hud> hud;
gui::GUI& gui;
Input& input;
void saveWorldPreview();

5
src/frontend/screens/MenuScreen.cpp
View File

@ -13,7 +13,7 @@
MenuScreen::MenuScreen(Engine& engine) : Screen(engine) {
engine.resetContent();
auto menu = engine.getGUI()->getMenu();
auto menu = engine.getGUI().getMenu();
menu->reset();
menu->setPage("main");
@ -22,8 +22,7 @@ MenuScreen::MenuScreen(Engine& engine) : Screen(engine) {
uicamera->flipped = true;
}
MenuScreen::~MenuScreen() {
}
MenuScreen::~MenuScreen() = default;
void MenuScreen::update(float delta) {
}

104
src/graphics/ui/GUI.cpp
View File

@ -1,13 +1,15 @@
#include "GUI.hpp"
#include "gui_util.hpp"
#include <algorithm>
#include <iostream>
#include <utility>
#include "elements/UINode.hpp"
#include "assets/Assets.hpp"
#include "elements/Label.hpp"
#include "elements/Menu.hpp"
#include "elements/Panel.hpp"
#include "assets/Assets.hpp"
#include "elements/UINode.hpp"
#include "engine/Engine.hpp"
#include "frontend/UiDocument.hpp"
#include "frontend/locale.hpp"
#include "graphics/core/Batch2D.hpp"
@ -15,31 +17,36 @@
#include "graphics/core/Shader.hpp"
#include "graphics/core/Font.hpp"
#include "graphics/core/DrawContext.hpp"
#include "graphics/core/Shader.hpp"
#include "gui_util.hpp"
#include "window/Camera.hpp"
#include "window/Events.hpp"
#include "window/Window.hpp"
#include "window/input.hpp"
#include "window/Camera.hpp"
#include <algorithm>
#include <utility>
using namespace gui;
GUI::GUI()
: batch2D(std::make_unique<Batch2D>(1024)),
container(std::make_shared<Container>(glm::vec2(1000))) {
GUI::GUI(Engine& engine)
: engine(engine),
input(engine.getInput()),
batch2D(std::make_unique<Batch2D>(1024)),
container(std::make_shared<Container>(*this, glm::vec2(1000))) {
container->setId("root");
uicamera = std::make_unique<Camera>(glm::vec3(), Window::height);
uicamera->perspective = false;
uicamera->flipped = true;
menu = std::make_shared<Menu>();
menu = std::make_shared<Menu>(*this);
menu->setId("menu");
menu->setZIndex(10);
container->add(menu);
container->setScrollable(false);
tooltip = guiutil::create(
*this,
"<container color='#000000A0' interactive='false' z-index='999'>"
"<label id='tooltip.label' pos='2' autoresize='true' multiline='true' text-wrap='false'></label>"
"</container>"
@ -65,12 +72,15 @@ std::shared_ptr<Menu> GUI::getMenu() {
}
void GUI::onAssetsLoad(Assets* assets) {
assets->store(std::make_unique<UiDocument>(
"core:root",
uidocscript {},
std::dynamic_pointer_cast<gui::UINode>(container),
nullptr
), "core:root");
assets->store(
std::make_unique<UiDocument>(
"core:root",
uidocscript {},
std::dynamic_pointer_cast<gui::UINode>(container),
nullptr
),
"core:root"
);
}
void GUI::resetTooltip() {
@ -79,11 +89,13 @@ void GUI::resetTooltip() {
}
void GUI::updateTooltip(float delta) {
if (hover == nullptr || !hover->isInside(Events::cursor)) {
const auto& cursor = input.getCursor();
if (hover == nullptr || !hover->isInside(cursor.pos)) {
return resetTooltip();
}
if (tooltipTimer + delta >= hover->getTooltipDelay()) {
auto label = std::dynamic_pointer_cast<gui::Label>(get("tooltip.label"));
auto label =
std::dynamic_pointer_cast<gui::Label>(get("tooltip.label"));
const auto& text = hover->getTooltip();
if (text.empty() && tooltip->isVisible()) {
return resetTooltip();
@ -91,11 +103,11 @@ void GUI::updateTooltip(float delta) {
if (label && !text.empty()) {
tooltip->setVisible(true);
label->setText(langs::get(text));
auto size = label->getSize()+glm::vec2(4.0f);
auto pos = Events::cursor+glm::vec2(10.0f);
auto size = label->getSize() + glm::vec2(4.0f);
auto pos = cursor.pos + glm::vec2(10.0f);
auto rootSize = container->getSize();
pos.x = glm::min(pos.x, rootSize.x-size.x);
pos.y = glm::min(pos.y, rootSize.y-size.y);
pos.x = glm::min(pos.x, rootSize.x - size.x);
pos.y = glm::min(pos.y, rootSize.y - size.y);
tooltip->setSize(size);
tooltip->setPos(pos);
}
@ -103,9 +115,9 @@ void GUI::updateTooltip(float delta) {
tooltipTimer += delta;
}
/// @brief Mouse related input and logic handling
void GUI::actMouse(float delta) {
float mouseDelta = glm::length(Events::delta);
/// @brief Mouse related input and logic handling
void GUI::actMouse(float delta, const CursorState& cursor) {
float mouseDelta = glm::length(cursor.delta);
doubleClicked = false;
doubleClickTimer += delta + mouseDelta * 0.1f;
@ -116,21 +128,21 @@ void GUI::actMouse(float delta) {
if (hover) {
hover->setHover(true);
int scroll = Events::getScroll();
int scroll = input.getScroll();
if (scroll) {
hover->scrolled(scroll);
}
}
this->hover = hover;
if (Events::jclicked(mousecode::BUTTON_1)) {
if (input.jclicked(mousecode::BUTTON_1)) {
if (pressed == nullptr && this->hover) {
pressed = hover;
if (doubleClickTimer < doubleClickDelay) {
pressed->doubleClick(this, Events::cursor.x, Events::cursor.y);
pressed->doubleClick(cursor.pos.x, cursor.pos.y);
doubleClicked = true;
} else {
pressed->click(this, Events::cursor.x, Events::cursor.y);
pressed->click(cursor.pos.x, cursor.pos.y);
}
doubleClickTimer = 0.0f;
if (focus && focus != pressed) {
@ -138,7 +150,7 @@ void GUI::actMouse(float delta) {
}
if (focus != pressed) {
focus = pressed;
focus->onFocus(this);
focus->onFocus();
return;
}
}
@ -146,22 +158,22 @@ void GUI::actMouse(float delta) {
focus->defocus();
focus = nullptr;
}
} else if (!Events::clicked(mousecode::BUTTON_1) && pressed) {
pressed->mouseRelease(this, Events::cursor.x, Events::cursor.y);
} else if (!input.clicked(mousecode::BUTTON_1) && pressed) {
pressed->mouseRelease(cursor.pos.x, cursor.pos.y);
pressed = nullptr;
}
if (hover) {
for (mousecode code : MOUSECODES_ALL) {
if (Events::jclicked(code)) {
hover->clicked(this, code);
if (input.jclicked(code)) {
hover->clicked(code);
}
}
}
}
}
void GUI::actFocused() {
if (Events::jpressed(keycode::ESCAPE)) {
if (input.jpressed(keycode::ESCAPE)) {
focus->defocus();
focus = nullptr;
return;
@ -173,12 +185,13 @@ void GUI::actFocused() {
focus->keyPressed(key);
}
if (!Events::isCursorLocked()) {
if (Events::clicked(mousecode::BUTTON_1) &&
(Events::jclicked(mousecode::BUTTON_1) || Events::delta.x || Events::delta.y))
{
const auto& cursor = input.getCursor();
if (!cursor.locked) {
if (input.clicked(mousecode::BUTTON_1) &&
(input.jclicked(mousecode::BUTTON_1) || cursor.delta.x ||
cursor.delta.y)) {
if (!doubleClicked) {
focus->mouseMove(this, Events::cursor.x, Events::cursor.y);
focus->mouseMove(cursor.pos.x, cursor.pos.y);
}
}
}
@ -190,15 +203,16 @@ void GUI::act(float delta, const Viewport& vp) {
auto prevfocus = focus;
updateTooltip(delta);
const auto& cursor = input.getCursor();
if (!Events::isCursorLocked()) {
actMouse(delta);
actMouse(delta, cursor);
} else {
if (hover) {
hover->setHover(false);
hover = nullptr;
}
}
if (focus) {
actFocused();
}
@ -316,7 +330,7 @@ void GUI::setFocus(std::shared_ptr<UINode> node) {
}
focus = std::move(node);
if (focus) {
focus->onFocus(this);
focus->onFocus();
}
}
@ -339,3 +353,7 @@ float GUI::getDoubleClickDelay() const {
void GUI::toggleDebug() {
debug = !debug;
}
const Input& GUI::getInput() const {
return engine.getInput();
}

11
src/graphics/ui/GUI.hpp
View File

@ -14,7 +14,9 @@ class DrawContext;
class Assets;
class Camera;
class Batch2D;
class LineBatch;
struct CursorState;
class Engine;
class Input;
/*
Some info about padding and margin.
@ -56,6 +58,8 @@ namespace gui {
/// @brief The main UI controller
class GUI {
Engine& engine;
Input& input;
std::unique_ptr<Batch2D> batch2D;
std::shared_ptr<Container> container;
std::shared_ptr<UINode> hover;
@ -76,12 +80,12 @@ namespace gui {
bool doubleClicked = false;
bool debug = false;
void actMouse(float delta);
void actMouse(float delta, const CursorState& cursor);
void actFocused();
void updateTooltip(float delta);
void resetTooltip();
public:
GUI();
GUI(Engine& engine);
~GUI();
void setPageLoader(PageLoaderFunc pageLoader);
@ -152,5 +156,6 @@ namespace gui {
float getDoubleClickDelay() const;
void toggleDebug();
const Input& getInput() const;
};
}

3
src/graphics/ui/elements/BasePanel.hpp
View File

@ -26,12 +26,13 @@ namespace gui {
}
protected:
BasePanel(
GUI& gui,
glm::vec2 size,
glm::vec4 padding = glm::vec4(0.0f),
float interval = 2.0f,
Orientation orientation = Orientation::vertical
)
: Container(std::move(size)),
: Container(gui, std::move(size)),
padding(std::move(padding)),
interval(interval) {
}

37
src/graphics/ui/elements/Button.cpp
View File

@ -3,17 +3,23 @@
#include <utility>
#include "Label.hpp"
#include "graphics/core/DrawContext.hpp"
#include "graphics/core/Batch2D.hpp"
#include "graphics/core/DrawContext.hpp"
using namespace gui;
Button::Button(const std::shared_ptr<UINode>& content, glm::vec4 padding)
: Panel(glm::vec2(), padding, 0) {
Button::Button(
GUI& gui, const std::shared_ptr<UINode>& content, glm::vec4 padding
)
: Panel(gui, glm::vec2(), padding, 0) {
glm::vec4 margin = getMargin();
setSize(content->getSize()+
glm::vec2(padding[0]+padding[2]+margin[0]+margin[2],
padding[1]+padding[3]+margin[1]+margin[3]));
setSize(
content->getSize() +
glm::vec2(
padding[0] + padding[2] + margin[0] + margin[2],
padding[1] + padding[3] + margin[1] + margin[3]
)
);
add(content);
setScrollable(false);
setHoverColor(glm::vec4(0.05f, 0.1f, 0.15f, 0.75f));
@ -22,15 +28,16 @@ Button::Button(const std::shared_ptr<UINode>& content, glm::vec4 padding)
}
Button::Button(
GUI& gui,
const std::wstring& text,
glm::vec4 padding,
glm::vec4 padding,
const onaction& action,
glm::vec2 size
) : Panel(size, padding, 0)
{
)
: Panel(gui, size, padding, 0) {
if (size.y < 0.0f) {
size = glm::vec2(
glm::max(padding.x + padding.z + text.length()*8, size.x),
glm::max(padding.x + padding.z + text.length() * 8, size.x),
glm::max(padding.y + padding.w + 16, size.y)
);
}
@ -41,9 +48,11 @@ Button::Button(
}
setScrollable(false);
label = std::make_shared<Label>(text);
label = std::make_shared<Label>(gui, text);
label->setAlign(Align::center);
label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
label->setSize(
size - glm::vec2(padding.z + padding.x, padding.w + padding.y)
);
label->setInteractive(false);
add(label);
setHoverColor(glm::vec4(0.05f, 0.1f, 0.15f, 0.75f));
@ -73,7 +82,9 @@ Button* Button::textSupplier(wstringsupplier supplier) {
void Button::refresh() {
Panel::refresh();
if (label) {
label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
label->setSize(
size - glm::vec2(padding.z + padding.x, padding.w + padding.y)
);
}
}

20
src/graphics/ui/elements/Button.hpp
View File

@ -9,13 +9,19 @@ namespace gui {
protected:
std::shared_ptr<Label> label;
public:
Button(const std::shared_ptr<UINode>& content,
glm::vec4 padding=glm::vec4(2.0f));
Button(const std::wstring& text,
glm::vec4 padding,
const onaction& action,
glm::vec2 size=glm::vec2(-1));
Button(
GUI& gui,
const std::shared_ptr<UINode>& content,
glm::vec4 padding = glm::vec4(2.0f)
);
Button(
GUI& gui,
const std::wstring& text,
glm::vec4 padding,
const onaction& action,
glm::vec2 size = glm::vec2(-1)
);
virtual void drawBackground(
const DrawContext& pctx, const Assets& assets

3
src/graphics/ui/elements/Canvas.cpp
View File

@ -4,7 +4,8 @@
#include "graphics/core/DrawContext.hpp"
#include "graphics/core/Texture.hpp"
gui::Canvas::Canvas(ImageFormat inFormat, glm::uvec2 inSize) : UINode(inSize) {
gui::Canvas::Canvas(GUI& gui, ImageFormat inFormat, glm::uvec2 inSize)
: UINode(gui, inSize) {
auto data = std::make_shared<ImageData>(inFormat, inSize.x, inSize.y);
mTexture = Texture::from(data.get());
mData = std::move(data);

2
src/graphics/ui/elements/Canvas.hpp
View File

@ -9,7 +9,7 @@ class Texture;
namespace gui {
class Canvas final : public UINode {
public:
explicit Canvas(ImageFormat inFormat, glm::uvec2 inSize);
explicit Canvas(GUI& gui, ImageFormat inFormat, glm::uvec2 inSize);
~Canvas() override = default;

21
src/graphics/ui/elements/CheckBox.cpp
View File

@ -2,13 +2,14 @@
#include <utility>
#include "graphics/core/DrawContext.hpp"
#include "graphics/core/Batch2D.hpp"
#include "Label.hpp"
#include "graphics/core/Batch2D.hpp"
#include "graphics/core/DrawContext.hpp"
using namespace gui;
CheckBox::CheckBox(bool checked) : UINode(glm::vec2(32.0f)), checked(checked) {
CheckBox::CheckBox(GUI& gui, bool checked)
: UINode(gui, glm::vec2(32.0f)), checked(checked) {
setColor({0.0f, 0.0f, 0.0f, 0.5f});
setHoverColor({0.05f, 0.1f, 0.2f, 0.75f});
}
@ -24,7 +25,7 @@ void CheckBox::draw(const DrawContext& pctx, const Assets&) {
batch->rect(pos.x, pos.y, size.x, size.y);
}
void CheckBox::mouseRelease(GUI*, int, int) {
void CheckBox::mouseRelease(int, int) {
checked = !checked;
if (consumer) {
consumer(checked);
@ -44,15 +45,17 @@ CheckBox* CheckBox::setChecked(bool flag) {
return this;
}
FullCheckBox::FullCheckBox(const std::wstring& text, glm::vec2 size, bool checked)
: Panel(size),
checkbox(std::make_shared<CheckBox>(checked)),
label(std::make_shared<Label>(text)) {
FullCheckBox::FullCheckBox(
GUI& gui, const std::wstring& text, glm::vec2 size, bool checked
)
: Panel(gui, size),
checkbox(std::make_shared<CheckBox>(gui, checked)),
label(std::make_shared<Label>(gui, text)) {
setColor(glm::vec4(0.0f));
setOrientation(Orientation::horizontal);
add(checkbox);
label->setMargin(glm::vec4(5.f, 5.f, 0.f, 0.f));
add(label);
}

19
src/graphics/ui/elements/CheckBox.hpp
View File

@ -2,8 +2,8 @@
#include <utility>
#include "Panel.hpp"
#include "Label.hpp"
#include "Panel.hpp"
namespace gui {
class CheckBox : public UINode {
@ -13,11 +13,12 @@ namespace gui {
boolconsumer consumer = nullptr;
bool checked = false;
public:
CheckBox(bool checked=false);
explicit CheckBox(GUI& gui, bool checked = false);
virtual void draw(const DrawContext& pctx, const Assets& assets) override;
virtual void draw(const DrawContext& pctx, const Assets& assets)
override;
virtual void mouseRelease(GUI*, int x, int y) override;
virtual void mouseRelease(int x, int y) override;
virtual void setSupplier(boolsupplier supplier);
virtual void setConsumer(boolconsumer consumer);
@ -25,8 +26,7 @@ namespace gui {
virtual CheckBox* setChecked(bool flag);
virtual bool isChecked() const {
if (supplier)
return supplier();
if (supplier) return supplier();
return checked;
}
};
@ -36,7 +36,12 @@ namespace gui {
std::shared_ptr<CheckBox> checkbox;
std::shared_ptr<Label> label;
public:
FullCheckBox(const std::wstring& text, glm::vec2 size, bool checked=false);
explicit FullCheckBox(
GUI& gui,
const std::wstring& text,
glm::vec2 size,
bool checked = false
);
virtual void setSupplier(boolsupplier supplier) {
checkbox->setSupplier(std::move(supplier));

10
src/graphics/ui/elements/Container.cpp
View File

@ -8,7 +8,7 @@
using namespace gui;
Container::Container(glm::vec2 size) : UINode(size) {
Container::Container(GUI& gui, glm::vec2 size) : UINode(gui, size) {
actualLength = size.y;
setColor(glm::vec4());
}
@ -41,8 +41,8 @@ std::shared_ptr<UINode> Container::getAt(const glm::vec2& pos) {
return UINode::getAt(pos);
}
void Container::mouseMove(GUI* gui, int x, int y) {
UINode::mouseMove(gui, x, y);
void Container::mouseMove(int x, int y) {
UINode::mouseMove(x, y);
if (!scrollable) {
return;
}
@ -65,8 +65,8 @@ void Container::mouseMove(GUI* gui, int x, int y) {
prevScrollY = y;
}
void Container::mouseRelease(GUI* gui, int x, int y) {
UINode::mouseRelease(gui, x, y);
void Container::mouseRelease(int x, int y) {
UINode::mouseRelease(x, y);
prevScrollY = -1;
}

8
src/graphics/ui/elements/Container.hpp
View File

@ -7,7 +7,7 @@
#include <vector>
namespace gui {
class Container : public UINode, public util::ObjectsKeeper {
class Container : public UINode, public ::util::ObjectsKeeper {
int prevScrollY = -1;
protected:
std::vector<std::shared_ptr<UINode>> nodes;
@ -22,7 +22,7 @@ namespace gui {
return prevScrollY != -1;
}
public:
Container(glm::vec2 size);
Container(GUI& gui, glm::vec2 size);
virtual ~Container();
virtual void act(float delta) override;
@ -44,8 +44,8 @@ namespace gui {
virtual void refresh() override;
void setScroll(int scroll);
virtual void mouseMove(GUI*, int x, int y) override;
virtual void mouseRelease(GUI*, int x, int y) override;
virtual void mouseMove(int x, int y) override;
virtual void mouseRelease(int x, int y) override;
const std::vector<std::shared_ptr<UINode>>& getNodes() const;
};

34
src/graphics/ui/elements/Image.cpp
View File

@ -2,23 +2,24 @@
#include <utility>
#include "graphics/core/DrawContext.hpp"
#include "graphics/core/Batch2D.hpp"
#include "graphics/core/Texture.hpp"
#include "graphics/core/Atlas.hpp"
#include "assets/Assets.hpp"
#include "graphics/core/Atlas.hpp"
#include "graphics/core/Batch2D.hpp"
#include "graphics/core/DrawContext.hpp"
#include "graphics/core/Texture.hpp"
#include "maths/UVRegion.hpp"
using namespace gui;
Image::Image(std::string texture, glm::vec2 size) : UINode(size), texture(std::move(texture)) {
Image::Image(GUI& gui, std::string texture, glm::vec2 size)
: UINode(gui, size), texture(std::move(texture)) {
setInteractive(false);
}
void Image::draw(const DrawContext& pctx, const Assets& assets) {
glm::vec2 pos = calcPos();
auto batch = pctx.getBatch2D();
Texture* texture = nullptr;
auto separator = this->texture.find(':');
if (separator == std::string::npos) {
@ -30,14 +31,16 @@ void Image::draw(const DrawContext& pctx, const Assets& assets) {
} else {
auto atlasName = this->texture.substr(0, separator);
if (auto atlas = assets.get<Atlas>(atlasName)) {
if (auto region = atlas->getIf(this->texture.substr(separator+1))) {
if (auto region =
atlas->getIf(this->texture.substr(separator + 1))) {
texture = atlas->getTexture();
batch->texture(atlas->getTexture());
batch->setRegion(*region);
if (autoresize) {
setSize(glm::vec2(
texture->getWidth()*region->getWidth(),
texture->getHeight()*region->getHeight()));
texture->getWidth() * region->getWidth(),
texture->getHeight() * region->getHeight()
));
}
} else {
batch->texture(nullptr);
@ -45,8 +48,17 @@ void Image::draw(const DrawContext& pctx, const Assets& assets) {
}
}
batch->rect(
pos.x, pos.y, size.x, size.y,
0, 0, 0, UVRegion(), false, true, calcColor()
pos.x,
pos.y,
size.x,
size.y,
0,
0,
0,
UVRegion(),
false,
true,
calcColor()
);
}

2
src/graphics/ui/elements/Image.hpp
View File

@ -8,7 +8,7 @@ namespace gui {
std::string texture;
bool autoresize = false;
public:
Image(std::string texture, glm::vec2 size=glm::vec2(32,32));
Image(GUI& gui, std::string texture, glm::vec2 size=glm::vec2(32,32));
virtual void draw(const DrawContext& pctx, const Assets& assets) override;

8
src/graphics/ui/elements/InputBindBox.cpp
View File

@ -7,10 +7,10 @@
using namespace gui;
InputBindBox::InputBindBox(Binding& binding, glm::vec4 padding)
: Panel(glm::vec2(100,32), padding, 0),
InputBindBox::InputBindBox(GUI& gui, Binding& binding, glm::vec4 padding)
: Panel(gui, glm::vec2(100,32), padding, 0),
binding(binding),
label(std::make_shared<Label>(L"")) {
label(std::make_shared<Label>(gui, L"")) {
add(label);
setScrollable(false);
hoverColor = glm::vec4(0.05f, 0.1f, 0.2f, 0.75f);
@ -25,7 +25,7 @@ void InputBindBox::drawBackground(const DrawContext& pctx, const Assets&) {
label->setText(util::str2wstr_utf8(binding.text()));
}
void InputBindBox::clicked(GUI*, mousecode button) {
void InputBindBox::clicked(mousecode button) {
if (isFocused()) {
binding.reset(button);
defocus();

14
src/graphics/ui/elements/InputBindBox.hpp
View File

@ -4,21 +4,25 @@
namespace gui {
class Label;
class InputBindBox : public Panel {
protected:
Binding& binding;
glm::vec4 focusedColor {0.1f, 0.15f, 0.35f, 0.75f};
std::shared_ptr<Label> label;
public:
InputBindBox(Binding& binding, glm::vec4 padding=glm::vec4(6.0f));
explicit InputBindBox(
GUI& gui, Binding& binding, glm::vec4 padding = glm::vec4(6.0f)
);
virtual void drawBackground(
const DrawContext& pctx, const Assets& assets
) override;
virtual void clicked(GUI*, mousecode button) override;
virtual void clicked(mousecode button) override;
virtual void keyPressed(keycode key) override;
virtual bool isFocuskeeper() const override {return true;}
virtual bool isFocuskeeper() const override {
return true;
}
};
}

23
src/graphics/ui/elements/InventoryView.cpp
View File

@ -46,8 +46,8 @@ SlotLayout::SlotLayout(
shareFunc(std::move(shareFunc)),
rightClick(std::move(rightClick)) {}
InventoryBuilder::InventoryBuilder() {
view = std::make_shared<InventoryView>();
InventoryBuilder::InventoryBuilder(GUI& gui) : gui(gui) {
view = std::make_shared<InventoryView>(gui);
}
void InventoryBuilder::addGrid(
@ -75,7 +75,8 @@ void InventoryBuilder::addGrid(
view->setSize(vsize);
if (addpanel) {
auto panel = std::make_shared<gui::Container>(glm::vec2(width, height));
auto panel =
std::make_shared<gui::Container>(gui, glm::vec2(width, height));
view->setColor(glm::vec4(0.122f, 0.122f, 0.122f, 0.878f));
view->add(panel, pos);
}
@ -106,8 +107,8 @@ std::shared_ptr<InventoryView> InventoryBuilder::build() {
}
SlotView::SlotView(
SlotLayout layout
) : UINode(glm::vec2(InventoryView::SLOT_SIZE)),
GUI& gui, SlotLayout layout
) : UINode(gui, glm::vec2(InventoryView::SLOT_SIZE)),
layout(std::move(layout))
{
setColor(glm::vec4(0, 0, 0, 0.2f));
@ -347,11 +348,11 @@ void SlotView::performRightClick(ItemStack& stack, ItemStack& grabbed) {
}
}
void SlotView::clicked(gui::GUI* gui, mousecode button) {
void SlotView::clicked(mousecode button) {
if (bound == nullptr)
return;
auto exchangeSlot =
std::dynamic_pointer_cast<SlotView>(gui->get(EXCHANGE_SLOT_NAME));
std::dynamic_pointer_cast<SlotView>(gui.get(EXCHANGE_SLOT_NAME));
if (exchangeSlot == nullptr) {
return;
}
@ -368,8 +369,8 @@ void SlotView::clicked(gui::GUI* gui, mousecode button) {
}
}
void SlotView::onFocus(gui::GUI* gui) {
clicked(gui, mousecode::BUTTON_1);
void SlotView::onFocus() {
clicked(mousecode::BUTTON_1);
}
const std::wstring& SlotView::getTooltip() const {
@ -398,7 +399,7 @@ ItemStack& SlotView::getStack() {
return *bound;
}
InventoryView::InventoryView() : Container(glm::vec2()) {
InventoryView::InventoryView(GUI& gui) : Container(gui, glm::vec2()) {
setColor(glm::vec4(0, 0, 0, 0.0f));
}
@ -419,7 +420,7 @@ std::shared_ptr<SlotView> InventoryView::addSlot(const SlotLayout& layout) {
}
setSize(vsize);
auto slot = std::make_shared<SlotView>(layout);
auto slot = std::make_shared<SlotView>(gui, layout);
if (!layout.background) {
slot->setColor(glm::vec4());
}

11
src/graphics/ui/elements/InventoryView.hpp
View File

@ -86,15 +86,15 @@ namespace gui {
void refreshTooltip(const ItemStack& stack, const ItemDef& item);
public:
SlotView(SlotLayout layout);
SlotView(GUI& gui, SlotLayout layout);
virtual void draw(const DrawContext& pctx, const Assets& assets) override;
void setHighlighted(bool flag);
bool isHighlighted() const;
virtual void clicked(gui::GUI*, mousecode) override;
virtual void onFocus(gui::GUI*) override;
virtual void clicked(mousecode) override;
virtual void onFocus() override;
virtual const std::wstring& getTooltip() const override;
void bind(
@ -117,7 +117,7 @@ namespace gui {
std::vector<SlotView*> slots;
glm::vec2 origin {};
public:
InventoryView();
InventoryView(GUI& gui);
virtual ~InventoryView();
virtual void setPos(glm::vec2 pos) override;
@ -145,9 +145,10 @@ namespace gui {
};
class InventoryBuilder {
GUI& gui;
std::shared_ptr<InventoryView> view;
public:
InventoryBuilder();
InventoryBuilder(GUI& gui);
/// @brief Add slots grid to inventory view
/// @param cols grid columns

8
src/graphics/ui/elements/Label.cpp
View File

@ -83,8 +83,8 @@ void LabelCache::update(std::wstring_view text, bool multiline, bool wrap) {
}
}
Label::Label(const std::string& text, std::string fontName)
: UINode(glm::vec2(text.length() * 8, 16)),
Label::Label(GUI& gui, const std::string& text, std::string fontName)
: UINode(gui, glm::vec2(text.length() * 8, 16)),
text(util::str2wstr_utf8(text)),
fontName(std::move(fontName))
{
@ -93,8 +93,8 @@ Label::Label(const std::string& text, std::string fontName)
}
Label::Label(const std::wstring& text, std::string fontName)
: UINode(glm::vec2(text.length() * 8, 16)),
Label::Label(GUI& gui, const std::wstring& text, std::string fontName)
: UINode(gui, glm::vec2(text.length() * 8, 16)),
text(text),
fontName(std::move(fontName))
{

4
src/graphics/ui/elements/Label.hpp
View File

@ -63,8 +63,8 @@ namespace gui {
std::unique_ptr<FontStylesScheme> styles;
public:
Label(const std::string& text, std::string fontName=FONT_DEFAULT);
Label(const std::wstring& text, std::string fontName=FONT_DEFAULT);
Label(GUI& gui, const std::string& text, std::string fontName="normal");
Label(GUI& gui, const std::wstring& text, std::string fontName="normal");
virtual ~Label();

2
src/graphics/ui/elements/Menu.cpp
View File

@ -5,7 +5,7 @@
using namespace gui;
Menu::Menu() : Container(glm::vec2(1)){
Menu::Menu(GUI& gui) : Container(gui, glm::vec2(1)){
}
bool Menu::has(const std::string& name) {

2
src/graphics/ui/elements/Menu.hpp
View File

@ -21,7 +21,7 @@ namespace gui {
std::unordered_map<std::string, supplier<std::shared_ptr<UINode>>> pageSuppliers;
PageLoaderFunc pagesLoader = nullptr;
public:
Menu();
explicit Menu(GUI& gui);
/// @brief Check menu have page or page supplier
/// @param name page name

24
src/graphics/ui/elements/Panel.cpp
View File

@ -4,14 +4,12 @@
using namespace gui;
Panel::Panel(glm::vec2 size, glm::vec4 padding, float interval)
: BasePanel(size, padding, interval, Orientation::vertical)
{
Panel::Panel(GUI& gui, glm::vec2 size, glm::vec4 padding, float interval)
: BasePanel(gui, size, padding, interval) {
setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.75f));
}
Panel::~Panel() {
}
Panel::~Panel() = default;
void Panel::setMaxLength(int value) {
maxLength = value;
@ -46,7 +44,7 @@ void Panel::fullRefresh() {
Container::fullRefresh();
}
void Panel::add(const std::shared_ptr<UINode> &node) {
void Panel::add(const std::shared_ptr<UINode>& node) {
node->setResizing(true);
Container::add(node);
fullRefresh();
@ -68,10 +66,10 @@ void Panel::refresh() {
for (auto& node : nodes) {
const glm::vec4 margin = node->getMargin();
y += margin.y;
float ex = x + margin.x;
node->setPos(glm::vec2(ex, y));
float width = size.x - padding.x - padding.z - margin.x - margin.z;
if (node->isResizing()) {
node->setMaxSize({width, node->getMaxSize().y});
@ -80,7 +78,7 @@ void Panel::refresh() {
node->refresh();
glm::vec2 nodeSize = node->getSize();
y += nodeSize.y + margin.w + interval;
maxw = fmax(maxw, ex+nodeSize.x+margin.z+padding.z);
maxw = fmax(maxw, ex + nodeSize.x + margin.z + padding.z);
}
actualLength = y + padding.w;
} else {
@ -89,11 +87,13 @@ void Panel::refresh() {
glm::vec2 nodesize = node->getSize();
const glm::vec4 margin = node->getMargin();
x += margin.x;
node->setPos(glm::vec2(x, y+margin.y));
node->setPos(glm::vec2(x, y + margin.y));
x += nodesize.x + margin.z + interval;
node->refresh();
maxh = fmax(maxh, y+margin.y+node->getSize().y+margin.w+padding.w);
maxh = fmax(
maxh, y + margin.y + node->getSize().y + margin.w + padding.w
);
}
actualLength = size.y;
}

9
src/graphics/ui/elements/Panel.hpp
View File

@ -1,15 +1,16 @@
#pragma once
#include "commons.hpp"
#include "BasePanel.hpp"
#include "commons.hpp"
namespace gui {
class Panel : public BasePanel {
public:
Panel(
glm::vec2 size,
glm::vec4 padding=glm::vec4(0.0f),
float interval=2.0f
GUI& gui,
glm::vec2 size,
glm::vec4 padding = glm::vec4(2.0f),
float interval = 2.0f
);
virtual ~Panel();

26
src/graphics/ui/elements/Plotter.hpp
View File

@ -1,15 +1,16 @@
#pragma once
#include <glm/glm.hpp>
#include <memory>
#include "UINode.hpp"
#include "typedefs.hpp"
#include <memory>
class Assets;
class DrawContext;
namespace gui {
class Plotter : public gui::UINode {
class Plotter : public UINode {
std::unique_ptr<int[]> points;
float multiplier;
int index = 0;
@ -17,13 +18,18 @@ namespace gui {
int dmheight;
int labelsInterval;
public:
Plotter(uint width, uint height, float multiplier, int labelsInterval)
: gui::UINode(glm::vec2(width, height)),
multiplier(multiplier),
dmwidth(width-50),
dmheight(height),
labelsInterval(labelsInterval)
{
Plotter(
GUI& gui,
uint width,
uint height,
float multiplier,
int labelsInterval
)
: UINode(gui, glm::vec2(width, height)),
multiplier(multiplier),
dmwidth(width - 50),
dmheight(height),
labelsInterval(labelsInterval) {
points = std::make_unique<int[]>(dmwidth);
}

8
src/graphics/ui/elements/SplitBox.cpp
View File

@ -2,15 +2,15 @@
using namespace gui;
SplitBox::SplitBox(const glm::vec2& size, float splitPos, Orientation orientation)
: BasePanel(size, glm::vec4(), 4.0f, orientation), splitPos(splitPos) {
SplitBox::SplitBox(GUI& gui, const glm::vec2& size, float splitPos, Orientation orientation)
: BasePanel(gui, size, glm::vec4(), 4.0f, orientation), splitPos(splitPos) {
setCursor(
orientation == Orientation::vertical ? CursorShape::NS_RESIZE
: CursorShape::EW_RESIZE
);
}
void SplitBox::mouseMove(GUI*, int x, int y) {
void SplitBox::mouseMove(int x, int y) {
auto pos = calcPos();
auto size = getSize();
@ -59,7 +59,7 @@ void SplitBox::refresh() {
}
}
void SplitBox::doubleClick(GUI*, int x, int y) {
void SplitBox::doubleClick(int x, int y) {
if (nodes.size() < 2) {
return;
}

6
src/graphics/ui/elements/SplitBox.hpp
View File

@ -5,12 +5,12 @@
namespace gui {
class SplitBox : public BasePanel {
public:
SplitBox(const glm::vec2& size, float splitPos, Orientation orientation);
SplitBox(GUI& gui, const glm::vec2& size, float splitPos, Orientation orientation);
virtual void mouseMove(GUI*, int x, int y) override;
virtual void mouseMove(int x, int y) override;
virtual void refresh() override;
virtual void fullRefresh() override;
virtual void doubleClick(GUI*, int x, int y) override;
virtual void doubleClick(int x, int y) override;
private:
float splitPos;
};

156
src/graphics/ui/elements/TextBox.cpp
View File

@ -4,9 +4,12 @@
#include <sstream>
#include <utility>
#include "../GUI.hpp"
#include "../markdown.hpp"
#include "Label.hpp"
#include "assets/Assets.hpp"
#include "devtools/syntax_highlighting.hpp"
#include "engine/Engine.hpp"
#include "graphics/core/Batch2D.hpp"
#include "graphics/core/DrawContext.hpp"
#include "graphics/core/Font.hpp"
@ -186,8 +189,9 @@ namespace gui {
};
}
TextBox::TextBox(std::wstring placeholder, glm::vec4 padding)
: Container(glm::vec2(200, 32)),
TextBox::TextBox(GUI& gui, std::wstring placeholder, glm::vec4 padding)
: Container(gui, glm::vec2(200, 32)),
inputEvents(gui.getInput()),
history(std::make_shared<ActionsHistory>()),
historian(std::make_unique<TextBoxHistorian>(*this, *history)),
padding(padding),
@ -197,19 +201,24 @@ TextBox::TextBox(std::wstring placeholder, glm::vec4 padding)
setOnUpPressed(nullptr);
setOnDownPressed(nullptr);
setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.75f));
label = std::make_shared<Label>(L"");
label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
label = std::make_shared<Label>(gui, L"");
label->setSize(
size - glm::vec2(padding.z + padding.x, padding.w + padding.y)
);
label->setPos(glm::vec2(
padding.x + LINE_NUMBERS_PANE_WIDTH * showLineNumbers, padding.y
));
add(label);
lineNumbersLabel = std::make_shared<Label>(L"");
lineNumbersLabel = std::make_shared<Label>(gui, L"");
lineNumbersLabel->setMultiline(true);
lineNumbersLabel->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
lineNumbersLabel->setSize(
size - glm::vec2(padding.z + padding.x, padding.w + padding.y)
);
lineNumbersLabel->setVerticalAlign(Align::top);
add(lineNumbersLabel);
setHoverColor(glm::vec4(0.05f, 0.1f, 0.2f, 0.75f));
textInitX = label->getPos().x;
@ -342,7 +351,7 @@ void TextBox::drawBackground(const DrawContext& pctx, const Assets&) {
batch->texture(nullptr);
auto subctx = pctx.sub();
subctx.setScissors(glm::vec4(pos.x, pos.y-0.5, size.x, size.y+1));
subctx.setScissors(glm::vec4(pos.x, pos.y - 0.5, size.x, size.y + 1));
if (valid) {
if (isFocused() && !multiline) {
@ -371,7 +380,8 @@ void TextBox::refreshLabel() {
const auto& displayText = input.empty() && !hint.empty() ? hint : getText();
if (markup == "md") {
auto [processedText, styles] = markdown::process(displayText, !focused || !editable);
auto [processedText, styles] =
markdown::process(displayText, !focused || !editable);
label->setText(std::move(processedText));
label->setStyles(std::move(styles));
} else {
@ -380,13 +390,13 @@ void TextBox::refreshLabel() {
label->setStyles(nullptr);
}
}
if (showLineNumbers) {
if (lineNumbersLabel->getLinesNumber() != label->getLinesNumber()) {
std::wstringstream ss;
int n = 1;
for (int i = 1; i <= label->getLinesNumber(); i++) {
if (!label->isFakeLine(i-1)) {
if (!label->isFakeLine(i - 1)) {
ss << n;
n++;
}
@ -402,11 +412,12 @@ void TextBox::refreshLabel() {
if (autoresize && font) {
auto size = getSize();
int newy = glm::min(static_cast<int>(parent->getSize().y),
static_cast<int>(
label->getLinesNumber() *
label->getLineInterval() *
font->getLineHeight()) + 1
int newy = glm::min(
static_cast<int>(parent->getSize().y),
static_cast<int>(
label->getLinesNumber() * label->getLineInterval() *
font->getLineHeight()
) + 1
);
if (newy != static_cast<int>(size.y)) {
size.y = newy;
@ -475,7 +486,7 @@ bool TextBox::eraseSelected() {
input.substr(selectionStart, selectionEnd - selectionStart),
true
);
erase(selectionStart, selectionEnd-selectionStart);
erase(selectionStart, selectionEnd - selectionStart);
resetSelection();
onInput();
return true;
@ -495,7 +506,7 @@ void TextBox::extendSelection(int index) {
size_t TextBox::getLineLength(uint line) const {
size_t position = label->getTextLineOffset(line);
size_t lineLength = label->getTextLineOffset(line+1)-position;
size_t lineLength = label->getTextLineOffset(line + 1) - position;
if (lineLength == 0) {
lineLength = label->getText().length() - position + 1;
}
@ -547,7 +558,7 @@ void TextBox::setMultiline(bool multiline) {
bool TextBox::isMultiline() const {
return multiline;
}
void TextBox::setTextWrapping(bool flag) {
label->setTextWrapping(flag);
}
@ -593,9 +604,9 @@ bool TextBox::isAutoResize() const {
return autoresize;
}
void TextBox::onFocus(GUI* gui) {
Container::onFocus(gui);
if (onEditStart){
void TextBox::onFocus() {
Container::onFocus();
if (onEditStart) {
setCaret(input.size());
onEditStart();
resetSelection();
@ -609,7 +620,9 @@ void TextBox::reposition() {
void TextBox::refresh() {
Container::refresh();
label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
label->setSize(
size - glm::vec2(padding.z + padding.x, padding.w + padding.y)
);
label->setPos(glm::vec2(
padding.x + LINE_NUMBERS_PANE_WIDTH * showLineNumbers + textInitX -
static_cast<int>(textOffset),
@ -629,24 +642,27 @@ size_t TextBox::normalizeIndex(int index) {
/// @param y screen Y position
/// @return non-normalized character index
int TextBox::calcIndexAt(int x, int y) const {
if (font == nullptr)
return 0;
if (font == nullptr) return 0;
const auto& labelText = label->getText();
glm::vec2 lcoord = label->calcPos();
uint line = label->getLineByYOffset(y-lcoord.y);
line = std::min(line, label->getLinesNumber()-1);
uint line = label->getLineByYOffset(y - lcoord.y);
line = std::min(line, label->getLinesNumber() - 1);
size_t lineLength = getLineLength(line);
uint offset = 0;
while (lcoord.x + font->calcWidth(labelText, offset) < x && offset < lineLength-1) {
while (lcoord.x + font->calcWidth(labelText, offset) < x &&
offset < lineLength - 1) {
offset++;
}
return std::min(offset+label->getTextLineOffset(line), labelText.length());
return std::min(
offset + label->getTextLineOffset(line), labelText.length()
);
}
static inline std::wstring get_alphabet(wchar_t c) {
std::wstring alphabet {c};
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_') {
return L"abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
return L"abcdefghijklmnopqrstuvwxyz_"
L"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
} else if (c >= '0' && c <= '9') {
return L"0123456789";
}
@ -660,7 +676,7 @@ void TextBox::tokenSelectAt(int index) {
}
int left = index;
int right = index;
std::wstring alphabet = get_alphabet(actualText.at(index));
while (left >= 0) {
if (alphabet.find(actualText.at(left)) == std::wstring::npos) {
@ -674,23 +690,23 @@ void TextBox::tokenSelectAt(int index) {
}
right++;
}
select(left+1, right);
select(left + 1, right);
}
void TextBox::doubleClick(GUI* gui, int x, int y) {
UINode::doubleClick(gui, x, y);
tokenSelectAt(normalizeIndex(calcIndexAt(x, y)-1));
void TextBox::doubleClick(int x, int y) {
UINode::doubleClick(x, y);
tokenSelectAt(normalizeIndex(calcIndexAt(x, y) - 1));
}
void TextBox::click(GUI*, int x, int y) {
void TextBox::click(int x, int y) {
int index = normalizeIndex(calcIndexAt(x, y));
selectionStart = index;
selectionEnd = index;
selectionOrigin = index;
}
void TextBox::mouseMove(GUI* gui, int x, int y) {
Container::mouseMove(gui, x, y);
void TextBox::mouseMove(int x, int y) {
Container::mouseMove(x, y);
if (isScrolling()) {
return;
}
@ -701,7 +717,8 @@ void TextBox::mouseMove(GUI* gui, int x, int y) {
}
void TextBox::resetMaxLocalCaret() {
maxLocalCaret = caret - label->getTextLineOffset(label->getLineByTextIndex(caret));
maxLocalCaret =
caret - label->getTextLineOffset(label->getLineByTextIndex(caret));
}
void TextBox::stepLeft(bool shiftPressed, bool breakSelection) {
@ -709,9 +726,9 @@ void TextBox::stepLeft(bool shiftPressed, bool breakSelection) {
size_t caret = breakSelection ? selectionStart : this->caret;
if (caret > 0) {
if (caret > input.length()) {
setCaret(input.length()-1);
setCaret(input.length() - 1);
} else {
setCaret(caret-1);
setCaret(caret - 1);
}
if (shiftPressed) {
if (selectionStart == selectionEnd) {
@ -732,7 +749,7 @@ void TextBox::stepRight(bool shiftPressed, bool breakSelection) {
uint previousCaret = this->caret;
size_t caret = breakSelection ? selectionEnd : this->caret;
if (caret < input.length()) {
setCaret(caret+1);
setCaret(caret + 1);
caretLastMove = Window::time();
if (shiftPressed) {
if (selectionStart == selectionEnd) {
@ -753,9 +770,10 @@ void TextBox::stepDefaultDown(bool shiftPressed, bool breakSelection) {
uint previousCaret = this->caret;
uint caret = breakSelection ? selectionEnd : this->caret;
uint caretLine = label->getLineByTextIndex(caret);
if (caretLine < label->getLinesNumber()-1) {
uint offset = std::min(size_t(maxLocalCaret), getLineLength(caretLine+1)-1);
setCaret(label->getTextLineOffset(caretLine+1) + offset);
if (caretLine < label->getLinesNumber() - 1) {
uint offset =
std::min(size_t(maxLocalCaret), getLineLength(caretLine + 1) - 1);
setCaret(label->getTextLineOffset(caretLine + 1) + offset);
} else {
setCaret(input.length());
}
@ -774,8 +792,9 @@ void TextBox::stepDefaultUp(bool shiftPressed, bool breakSelection) {
uint caret = breakSelection ? selectionStart : this->caret;
uint caretLine = label->getLineByTextIndex(caret);
if (caretLine > 0) {
uint offset = std::min(size_t(maxLocalCaret), getLineLength(caretLine-1)-1);
setCaret(label->getTextLineOffset(caretLine-1) + offset);
uint offset =
std::min(size_t(maxLocalCaret), getLineLength(caretLine - 1) - 1);
setCaret(label->getTextLineOffset(caretLine - 1) + offset);
} else {
setCaret(static_cast<size_t>(0));
}
@ -805,7 +824,7 @@ void TextBox::onInput() {
}
void TextBox::performEditingKeyboardEvents(keycode key) {
bool shiftPressed = Events::pressed(keycode::LEFT_SHIFT);
bool shiftPressed = gui.getInput().pressed(keycode::LEFT_SHIFT);
bool breakSelection = getSelectionLength() != 0 && !shiftPressed;
if (key == keycode::BACKSPACE) {
if (!eraseSelected() && caret > 0 && input.length() > 0) {
@ -813,8 +832,8 @@ void TextBox::performEditingKeyboardEvents(keycode key) {
caret = input.length();
}
historian->onErase(caret - 1, input.substr(caret - 1, 1));
input = input.substr(0, caret-1) + input.substr(caret);
setCaret(caret-1);
input = input.substr(0, caret - 1) + input.substr(caret);
setCaret(caret - 1);
if (validate()) {
onInput();
}
@ -850,10 +869,11 @@ void TextBox::performEditingKeyboardEvents(keycode key) {
}
void TextBox::keyPressed(keycode key) {
const auto& inputEvents = gui.getInput();
if (editable) {
performEditingKeyboardEvents(key);
}
if (Events::pressed(keycode::LEFT_CONTROL) && key != keycode::LEFT_CONTROL) {
if (inputEvents.pressed(keycode::LEFT_CONTROL) && key != keycode::LEFT_CONTROL) {
if (controlCombinationsHandler) {
if (controlCombinationsHandler(static_cast<int>(key))) {
return;
@ -871,7 +891,7 @@ void TextBox::keyPressed(keycode key) {
}
// Paste text from clipboard
if (key == keycode::V && editable) {
const char* text = Window::getClipboardText();
const char* text = inputEvents.getClipboardText();
if (text) {
historian->sync(); // flush buffer before combination
// Combine deleting selected text and pasing a clipboard content
@ -924,14 +944,14 @@ std::shared_ptr<UINode> TextBox::getAt(const glm::vec2& pos) {
return UINode::getAt(pos);
}
void TextBox::setOnUpPressed(const runnable &callback) {
void TextBox::setOnUpPressed(const runnable& callback) {
if (callback == nullptr) {
onUpPressed = [this]() {
if (Events::pressed(keycode::LEFT_CONTROL)) {
if (inputEvents.pressed(keycode::LEFT_CONTROL)) {
scrolled(1);
return;
}
bool shiftPressed = Events::pressed(keycode::LEFT_SHIFT);
bool shiftPressed = inputEvents.pressed(keycode::LEFT_SHIFT);
bool breakSelection = getSelectionLength() != 0 && !shiftPressed;
stepDefaultUp(shiftPressed, breakSelection);
};
@ -940,14 +960,14 @@ void TextBox::setOnUpPressed(const runnable &callback) {
}
}
void TextBox::setOnDownPressed(const runnable &callback) {
void TextBox::setOnDownPressed(const runnable& callback) {
if (callback == nullptr) {
onDownPressed = [this]() {
if (Events::pressed(keycode::LEFT_CONTROL)) {
if (inputEvents.pressed(keycode::LEFT_CONTROL)) {
scrolled(-1);
return;
}
bool shiftPressed = Events::pressed(keycode::LEFT_SHIFT);
bool shiftPressed = inputEvents.pressed(keycode::LEFT_SHIFT);
bool breakSelection = getSelectionLength() != 0 && !shiftPressed;
stepDefaultDown(shiftPressed, breakSelection);
};
@ -984,7 +1004,6 @@ glm::vec4 TextBox::getFocusedColor() const {
return focusedColor;
}
void TextBox::setTextColor(glm::vec4 color) {
this->textColor = color;
}
@ -1002,8 +1021,7 @@ glm::vec4 TextBox::getErrorColor() const {
}
const std::wstring& TextBox::getText() const {
if (input.empty())
return placeholder;
if (input.empty()) return placeholder;
return input;
}
@ -1024,7 +1042,6 @@ void TextBox::setPlaceholder(const std::wstring& placeholder) {
this->placeholder = placeholder;
}
const std::wstring& TextBox::getHint() const {
return hint;
}
@ -1035,7 +1052,7 @@ void TextBox::setHint(const std::wstring& text) {
std::wstring TextBox::getSelection() const {
const auto& text = label->getText();
return text.substr(selectionStart, selectionEnd-selectionStart);
return text.substr(selectionStart, selectionEnd - selectionStart);
}
size_t TextBox::getCaret() const {
@ -1057,24 +1074,25 @@ void TextBox::setCaret(size_t position) {
uint line = rawTextCache.getLineByTextIndex(caret);
int offset = label->getLineYOffset(line) + getContentOffset().y;
uint lineHeight = font->getLineHeight()*label->getLineInterval();
uint lineHeight = font->getLineHeight() * label->getLineInterval();
if (scrollStep == 0) {
scrollStep = lineHeight;
}
if (offset < 0) {
scrolled(-glm::floor(offset / static_cast<double>(scrollStep)+0.5f));
scrolled(-glm::floor(offset / static_cast<double>(scrollStep) + 0.5f));
} else if (offset >= getSize().y) {
offset -= getSize().y;
scrolled(-glm::ceil(offset / static_cast<double>(scrollStep)+0.5f));
scrolled(-glm::ceil(offset / static_cast<double>(scrollStep) + 0.5f));
}
int lcaret = caret - rawTextCache.getTextLineOffset(line);
int realoffset =
font->calcWidth(labelText, lcaret) - static_cast<int>(textOffset) + 2;
if (realoffset-width > 0) {
setTextOffset(textOffset + realoffset-width);
if (realoffset - width > 0) {
setTextOffset(textOffset + realoffset - width);
} else if (realoffset < 0) {
setTextOffset(std::max(textOffset + realoffset, static_cast<size_t>(0)));
setTextOffset(std::max(textOffset + realoffset, static_cast<size_t>(0))
);
}
}

12
src/graphics/ui/elements/TextBox.hpp
View File

@ -9,6 +9,7 @@ class ActionsHistory;
namespace gui {
class TextBoxHistorian;
class TextBox : public Container {
const Input& inputEvents;
LabelCache rawTextCache;
std::shared_ptr<ActionsHistory> history;
std::unique_ptr<TextBoxHistorian> historian;
@ -94,7 +95,8 @@ namespace gui {
void refreshSyntax();
public:
TextBox(
explicit TextBox(
GUI& gui,
std::wstring placeholder,
glm::vec4 padding=glm::vec4(4.0f)
);
@ -227,11 +229,11 @@ namespace gui {
virtual bool isShowLineNumbers() const;
virtual void reposition() override;
virtual void onFocus(GUI*) override;
virtual void onFocus() override;
virtual void refresh() override;
virtual void doubleClick(GUI*, int x, int y) override;
virtual void click(GUI*, int, int) override;
virtual void mouseMove(GUI*, int x, int y) override;
virtual void doubleClick(int x, int y) override;
virtual void click(int, int) override;
virtual void mouseMove(int x, int y) override;
virtual bool isFocuskeeper() const override {return true;}
virtual void draw(const DrawContext& pctx, const Assets& assets) override;
virtual void drawBackground(const DrawContext& pctx, const Assets& assets) override;

9
src/graphics/ui/elements/TrackBar.cpp
View File

@ -9,12 +9,13 @@
using namespace gui;
TrackBar::TrackBar(
GUI& gui,
double min,
double max,
double value,
double step,
int trackWidth
) : UINode(glm::vec2(26)),
) : UINode(gui, glm::vec2(26)),
min(min),
max(max),
value(value),
@ -54,7 +55,7 @@ void TrackBar::setSubConsumer(doubleconsumer consumer) {
this->subconsumer = std::move(consumer);
}
void TrackBar::mouseMove(GUI*, int x, int) {
void TrackBar::mouseMove(int x, int) {
glm::vec2 pos = calcPos();
value = x - trackWidth/2;
value -= pos.x;
@ -62,7 +63,7 @@ void TrackBar::mouseMove(GUI*, int x, int) {
value += min;
value = (value > max) ? max : value;
value = (value < min) ? min : value;
value = (int64_t)round(value / step) * step;
value = static_cast<int64_t>(std::round(value / step)) * step;
if (consumer && !changeOnRelease) {
consumer(value);
@ -72,7 +73,7 @@ void TrackBar::mouseMove(GUI*, int x, int) {
}
}
void TrackBar::mouseRelease(GUI*, int, int) {
void TrackBar::mouseRelease(int, int) {
if (consumer && changeOnRelease) {
consumer(value);
}

17
src/graphics/ui/elements/TrackBar.hpp
View File

@ -16,19 +16,22 @@ namespace gui {
int trackWidth;
bool changeOnRelease = false;
public:
TrackBar(double min,
double max,
double value,
double step=1.0,
int trackWidth=12);
TrackBar(
GUI& gui,
double min,
double max,
double value,
double step = 1.0,
int trackWidth = 12
);
virtual void draw(const DrawContext& pctx, const Assets& assets) override;
virtual void setSupplier(doublesupplier);
virtual void setConsumer(doubleconsumer);
virtual void setSubConsumer(doubleconsumer);
virtual void mouseMove(GUI*, int x, int y) override;
virtual void mouseRelease(GUI*, int x, int y) override;
virtual void mouseMove(int x, int y) override;
virtual void mouseRelease(int x, int y) override;
virtual double getValue() const;
virtual double getMin() const;

8
src/graphics/ui/elements/UINode.cpp
View File

@ -8,7 +8,7 @@
using gui::UINode;
using gui::Align;
UINode::UINode(glm::vec2 size) : size(size) {
UINode::UINode(GUI& gui, glm::vec2 size) : gui(gui), size(size) {
}
UINode::~UINode() {
@ -74,18 +74,18 @@ UINode* UINode::listenDoubleClick(const onaction& action) {
return this;
}
void UINode::click(GUI*, int, int) {
void UINode::click(int, int) {
pressed = true;
}
void UINode::doubleClick(GUI* gui, int x, int y) {
void UINode::doubleClick(int x, int y) {
pressed = true;
if (isInside(glm::vec2(x, y))) {
doubleClickCallbacks.notify(gui);
}
}
void UINode::mouseRelease(GUI* gui, int x, int y) {
void UINode::mouseRelease(int x, int y) {
pressed = false;
if (isInside(glm::vec2(x, y))) {
actions.notify(gui);

23
src/graphics/ui/elements/UINode.hpp
View File

@ -19,8 +19,8 @@ namespace gui {
class GUI;
class Container;
using onaction = std::function<void(GUI*)>;
using onnumberchange = std::function<void(GUI*, double)>;
using onaction = std::function<void(GUI&)>;
using onnumberchange = std::function<void(GUI&, double)>;
class ActionsSet {
std::unique_ptr<std::vector<onaction>> callbacks;
@ -32,7 +32,7 @@ namespace gui {
callbacks->push_back(callback);
}
void notify(GUI* gui) {
void notify(GUI& gui) {
if (callbacks) {
for (auto& callback : *callbacks) {
callback(gui);
@ -64,6 +64,9 @@ namespace gui {
/// @brief Base abstract class for all UI elements
class UINode : public std::enable_shared_from_this<UINode> {
protected:
GUI& gui;
private:
/// @brief element identifier used for direct access in UiDocument
std::string id = "";
/// @brief element enabled state
@ -118,7 +121,7 @@ namespace gui {
/// @brief cursor shape when mouse is over the element
CursorShape cursor = CursorShape::ARROW;
UINode(glm::vec2 size);
UINode(GUI& gui, glm::vec2 size);
public:
virtual ~UINode();
@ -169,12 +172,12 @@ namespace gui {
virtual UINode* listenAction(const onaction &action);
virtual UINode* listenDoubleClick(const onaction &action);
virtual void onFocus(GUI*) {focused = true;}
virtual void doubleClick(GUI*, int x, int y);
virtual void click(GUI*, int x, int y);
virtual void clicked(GUI*, mousecode button) {}
virtual void mouseMove(GUI*, int x, int y) {};
virtual void mouseRelease(GUI*, int x, int y);
virtual void onFocus() {focused = true;}
virtual void doubleClick(int x, int y);
virtual void click(int x, int y);
virtual void clicked(mousecode button) {}
virtual void mouseMove(int x, int y) {};
virtual void mouseRelease(int x, int y);
virtual void scrolled(int value);
bool isPressed() const;

117
src/graphics/ui/gui_util.cpp
View File

@ -1,37 +1,36 @@
#include "gui_util.hpp"
#include "elements/Label.hpp"
#include "elements/Menu.hpp"
#include "elements/Button.hpp"
#include "elements/TextBox.hpp"
#include "gui_xml.hpp"
#include "logic/scripting/scripting.hpp"
#include "frontend/locale.hpp"
#include "util/stringutil.hpp"
#include "delegates.hpp"
#include "window/Events.hpp"
#include "engine/Engine.hpp"
#include <glm/glm.hpp>
#include "delegates.hpp"
#include "elements/Button.hpp"
#include "elements/Label.hpp"
#include "elements/Menu.hpp"
#include "elements/TextBox.hpp"
#include "engine/Engine.hpp"
#include "frontend/locale.hpp"
#include "gui_xml.hpp"
#include "logic/scripting/scripting.hpp"
#include "util/stringutil.hpp"
using namespace gui;
std::shared_ptr<gui::UINode> guiutil::create(const std::string& source, scriptenv env) {
std::shared_ptr<gui::UINode> guiutil::create(
GUI& gui, const std::string& source, scriptenv env
) {
if (env == nullptr) {
env = scripting::get_root_environment();
}
UiXmlReader reader(env);
UiXmlReader reader(gui, env);
return reader.readXML("[string]", source);
}
void guiutil::alert(
Engine& engine,
const std::wstring& text,
const runnable& on_hidden
Engine& engine, const std::wstring& text, const runnable& on_hidden
) {
GUI& gui = engine.getGUI();
auto panel = std::make_shared<Panel>(
gui,
glm::vec2(
glm::min(
static_cast<size_t>(650),
@ -44,7 +43,7 @@ void guiutil::alert(
);
panel->setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.5f));
auto menuPtr = engine.getGUI()->getMenu();
auto menuPtr = gui.getMenu();
auto& menu = *menuPtr;
runnable on_hidden_final = [on_hidden, &menu]() {
menu.removePage("<alert>");
@ -54,25 +53,26 @@ void guiutil::alert(
menu.reset();
}
};
auto label = std::make_shared<Label>(text);
auto label = std::make_shared<Label>(gui, text);
label->setMultiline(true);
label->setSize(glm::vec2(1, 24));
label->setAutoResize(true);
panel->add(label);
panel->add(std::make_shared<Button>(
langs::get(L"Ok"), glm::vec4(10.f),
[on_hidden_final](GUI*) {
on_hidden_final();
}
gui,
langs::get(L"Ok"),
glm::vec4(10.f),
[on_hidden_final](GUI&) { on_hidden_final(); }
));
panel->refresh();
panel->keepAlive(Events::addKeyCallback(keycode::ENTER, [on_hidden_final](){
auto& input = engine.getInput();
panel->keepAlive(input.addKeyCallback(keycode::ENTER, [on_hidden_final]() {
on_hidden_final();
return true;
}));
panel->keepAlive(Events::addKeyCallback(keycode::ESCAPE, [on_hidden_final](){
panel->keepAlive(input.addKeyCallback(keycode::ESCAPE, [on_hidden_final]() {
on_hidden_final();
return true;
}));
@ -91,17 +91,25 @@ void guiutil::confirm(
if (yestext.empty()) yestext = langs::get(L"Yes");
if (notext.empty()) notext = langs::get(L"No");
auto container = std::make_shared<Container>(glm::vec2(5000, 5000));
auto& gui = engine.getGUI();
auto& input = engine.getInput();
auto container = std::make_shared<Container>(gui, glm::vec2(5000, 5000));
container->setColor(glm::vec4(0.05f, 0.05f, 0.05f, 0.7f));
auto panel = std::make_shared<Panel>(glm::vec2(600, 200), glm::vec4(8.0f), 8.0f);
auto panel = std::make_shared<Panel>(
gui, glm::vec2(600, 200), glm::vec4(8.0f), 8.0f
);
panel->setGravity(Gravity::center_center);
container->add(panel);
panel->setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.5f));
panel->add(std::make_shared<Label>(text));
auto subpanel = std::make_shared<Panel>(glm::vec2(600, 53));
panel->add(std::make_shared<Label>(gui, text));
auto subpanel = std::make_shared<Panel>(gui, glm::vec2(600, 53));
subpanel->setColor(glm::vec4(0));
auto menu = engine.getGUI()->getMenu();
auto menu = gui.getMenu();
runnable on_confirm_final = [on_confirm, menu]() {
menu->removePage("<confirm>");
@ -121,20 +129,20 @@ void guiutil::confirm(
}
};
subpanel->add(std::make_shared<Button>(yestext, glm::vec4(8.f), [=](GUI*){
subpanel->add(std::make_shared<Button>(gui, yestext, glm::vec4(8.f), [=](GUI&) {
on_confirm_final();
}));
subpanel->add(std::make_shared<Button>(notext, glm::vec4(8.f), [=](GUI*){
subpanel->add(std::make_shared<Button>(gui, notext, glm::vec4(8.f), [=](GUI&) {
on_deny_final();
}));
panel->add(subpanel);
panel->keepAlive(Events::addKeyCallback(keycode::ENTER, [=](){
panel->keepAlive(input.addKeyCallback(keycode::ENTER, [=]() {
on_confirm_final();
return true;
}));
panel->keepAlive(Events::addKeyCallback(keycode::ESCAPE, [=](){
panel->keepAlive(input.addKeyCallback(keycode::ESCAPE, [=]() {
on_deny_final();
return true;
}));
@ -145,21 +153,25 @@ void guiutil::confirm(
}
void guiutil::confirm_with_memo(
const std::shared_ptr<gui::Menu>& menu,
const std::wstring& text,
const std::wstring& memo,
const runnable& on_confirm,
std::wstring yestext,
std::wstring notext) {
Engine& engine,
const std::wstring& text,
const std::wstring& memo,
const runnable& on_confirm,
std::wstring yestext,
std::wstring notext
) {
auto& gui = engine.getGUI();
auto menu = gui.getMenu();
if (yestext.empty()) yestext = langs::get(L"Yes");
if (notext.empty()) notext = langs::get(L"No");
auto panel = std::make_shared<Panel>(glm::vec2(600, 500), glm::vec4(8.0f), 8.0f);
auto panel = std::make_shared<Panel>(
gui, glm::vec2(600, 500), glm::vec4(8.0f), 8.0f
);
panel->setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.5f));
panel->add(std::make_shared<Label>(text));
auto textbox = std::make_shared<TextBox>(L"");
panel->add(std::make_shared<Label>(gui, text));
auto textbox = std::make_shared<TextBox>(gui, L"");
textbox->setMultiline(true);
textbox->setTextWrapping(true);
textbox->setSize(glm::vec2(600, 300));
@ -167,16 +179,15 @@ void guiutil::confirm_with_memo(
textbox->setEditable(false);
panel->add(textbox);
auto subpanel = std::make_shared<Panel>(glm::vec2(600, 53));
auto subpanel = std::make_shared<Panel>(gui, glm::vec2(600, 53));
subpanel->setColor(glm::vec4(0));
subpanel->add(std::make_shared<Button>(yestext, glm::vec4(8.f), [=](GUI*){
if (on_confirm)
on_confirm();
subpanel->add(std::make_shared<Button>(gui, yestext, glm::vec4(8.f), [=](GUI&) {
if (on_confirm) on_confirm();
menu->back();
}));
subpanel->add(std::make_shared<Button>(notext, glm::vec4(8.f), [=](GUI*){
subpanel->add(std::make_shared<Button>(gui, notext, glm::vec4(8.f), [=](GUI&) {
menu->back();
}));

38
src/graphics/ui/gui_util.hpp
View File

@ -1,38 +1,42 @@
#pragma once
#include "GUI.hpp"
#include "typedefs.hpp"
#include "delegates.hpp"
#include <memory>
#include <string>
#include "GUI.hpp"
#include "delegates.hpp"
#include "typedefs.hpp"
class Engine;
namespace guiutil {
/// @brief Create element from XML
/// @param source XML
std::shared_ptr<gui::UINode> create(const std::string& source, scriptenv env=0);
std::shared_ptr<gui::UINode> create(
gui::GUI& gui, const std::string& source, scriptenv env = 0
);
void alert(
Engine& engine,
const std::wstring& text,
const runnable& on_hidden=nullptr
const std::wstring& text,
const runnable& on_hidden = nullptr
);
void confirm(
Engine& engine,
const std::wstring& text,
const runnable& on_confirm=nullptr,
const runnable& on_deny=nullptr,
std::wstring yestext=L"",
std::wstring notext=L"");
const std::wstring& text,
const runnable& on_confirm = nullptr,
const runnable& on_deny = nullptr,
std::wstring yestext = L"",
std::wstring notext = L""
);
void confirm_with_memo(
const std::shared_ptr<gui::Menu>& menu,
const std::wstring& text,
Engine& engine,
const std::wstring& text,
const std::wstring& memo,
const runnable& on_confirm=nullptr,
std::wstring yestext=L"",
std::wstring notext=L"");
const runnable& on_confirm = nullptr,
std::wstring yestext = L"",
std::wstring notext = L""
);
}

184
src/graphics/ui/gui_xml.cpp
View File

@ -1,30 +1,31 @@
#include "gui_xml.hpp"
#include "elements/Panel.hpp"
#include "elements/Image.hpp"
#include "elements/Menu.hpp"
#include <stdexcept>
#include <utility>
#include "GUI.hpp"
#include "elements/Button.hpp"
#include "elements/Canvas.hpp"
#include "elements/CheckBox.hpp"
#include "elements/TextBox.hpp"
#include "elements/SplitBox.hpp"
#include "elements/TrackBar.hpp"
#include "elements/Image.hpp"
#include "elements/InputBindBox.hpp"
#include "elements/InventoryView.hpp"
#include "GUI.hpp"
#include "elements/Menu.hpp"
#include "elements/Panel.hpp"
#include "elements/TextBox.hpp"
#include "elements/TrackBar.hpp"
#include "engine/Engine.hpp"
#include "frontend/menu.hpp"
#include "frontend/locale.hpp"
#include "frontend/menu.hpp"
#include "items/Inventory.hpp"
#include "logic/scripting/scripting.hpp"
#include "maths/voxmaths.hpp"
#include "util/stringutil.hpp"
#include "window/Events.hpp"
#include <stdexcept>
#include <utility>
using namespace gui;
static Align align_from_string(const std::string& str, Align def) {
@ -56,7 +57,7 @@ static Gravity gravity_from_string(const std::string& str) {
}
static runnable create_runnable(
const UiXmlReader& reader,
const UiXmlReader& reader,
const xml::xmlelement& element,
const std::string& name
) {
@ -80,7 +81,7 @@ static onaction create_action(
if (callback == nullptr) {
return nullptr;
}
return [callback](GUI*) {callback();};
return [callback](GUI&) { callback(); };
}
/// @brief Read basic UINode properties
@ -152,9 +153,7 @@ static void read_uinode(
node.setAlign(align_from_string(alignName, node.getAlign()));
if (element.has("gravity")) {
node.setGravity(gravity_from_string(
element.attr("gravity").getText()
));
node.setGravity(gravity_from_string(element.attr("gravity").getText()));
}
if (element.has("tooltip")) {
@ -184,7 +183,9 @@ static void read_uinode(
}
}
static void read_container_impl(UiXmlReader& reader, const xml::xmlelement& element, Container& container) {
static void read_container_impl(
UiXmlReader& reader, const xml::xmlelement& element, Container& container
) {
read_uinode(reader, element, container);
if (element.has("scrollable")) {
@ -194,8 +195,7 @@ static void read_container_impl(UiXmlReader& reader, const xml::xmlelement& elem
container.setScrollStep(element.attr("scroll-step").asInt());
}
for (auto& sub : element.getElements()) {
if (sub->isText())
continue;
if (sub->isText()) continue;
auto subnode = reader.readUINode(*sub);
if (subnode) {
container.add(subnode);
@ -203,7 +203,9 @@ static void read_container_impl(UiXmlReader& reader, const xml::xmlelement& elem
}
}
void UiXmlReader::readUINode(UiXmlReader& reader, const xml::xmlelement& element, Container& container) {
void UiXmlReader::readUINode(
UiXmlReader& reader, const xml::xmlelement& element, Container& container
) {
read_container_impl(reader, element, container);
}
@ -225,8 +227,7 @@ static void read_base_panel_impl(
panel.setPadding(padding);
glm::vec2 size = panel.getSize();
panel.setSize(glm::vec2(
size.x + padding.x + padding.z,
size.y + padding.y + padding.w
size.x + padding.x + padding.z, size.y + padding.y + padding.w
));
}
if (element.has("orientation")) {
@ -254,10 +255,15 @@ static void read_panel_impl(
if (element.has("min-length")) {
panel.setMinLength(element.attr("min-length").asInt());
}
if (element.has("orientation")) {
auto& oname = element.attr("orientation").getText();
if (oname == "horizontal") {
panel.setOrientation(Orientation::horizontal);
}
}
if (subnodes) {
for (auto& sub : element.getElements()) {
if (sub->isText())
continue;
if (sub->isText()) continue;
auto subnode = reader.readUINode(*sub);
if (subnode) {
panel.add(subnode);
@ -273,7 +279,7 @@ static std::wstring parse_inner_text(
if (element.size() == 1) {
std::string source = element.sub(0).attr("#").getText();
util::trim(source);
text = util::str2wstr_utf8(source);
text = util::str2wstr_utf8(source);
if (text[0] == '@') {
if (context.empty()) {
text = langs::get(text.substr(1));
@ -289,12 +295,12 @@ static std::shared_ptr<UINode> readLabel(
const UiXmlReader& reader, const xml::xmlelement& element
) {
std::wstring text = parse_inner_text(element, reader.getContext());
auto label = std::make_shared<Label>(text);
auto label = std::make_shared<Label>(reader.getGUI(), text);
read_uinode(reader, element, *label);
if (element.has("valign")) {
label->setVerticalAlign(
align_from_string(element.attr("valign").getText(), label->getVerticalAlign())
);
label->setVerticalAlign(align_from_string(
element.attr("valign").getText(), label->getVerticalAlign()
));
}
if (element.has("supplier")) {
label->textSupplier(scripting::create_wstring_supplier(
@ -324,7 +330,7 @@ static std::shared_ptr<UINode> readLabel(
static std::shared_ptr<UINode> read_container(
UiXmlReader& reader, const xml::xmlelement& element
) {
auto container = std::make_shared<Container>(glm::vec2());
auto container = std::make_shared<Container>(reader.getGUI(), glm::vec2());
read_container_impl(reader, element, *container);
return container;
}
@ -337,8 +343,9 @@ static std::shared_ptr<UINode> read_split_box(
element.attr("orientation", "vertical").getText() == "horizontal"
? Orientation::horizontal
: Orientation::vertical;
auto splitBox =
std::make_shared<SplitBox>(glm::vec2(), splitPos, orientation);
auto splitBox = std::make_shared<SplitBox>(
reader.getGUI(), glm::vec2(), splitPos, orientation
);
read_base_panel_impl(reader, element, *splitBox);
for (auto& sub : element.getElements()) {
if (sub->isText())
@ -355,7 +362,9 @@ static std::shared_ptr<UINode> read_panel(
UiXmlReader& reader, const xml::xmlelement& element
) {
float interval = element.attr("interval", "2").asFloat();
auto panel = std::make_shared<Panel>(glm::vec2(), glm::vec4(), interval);
auto panel = std::make_shared<Panel>(
reader.getGUI(), glm::vec2(), glm::vec4(), interval
);
read_panel_impl(reader, element, *panel);
return panel;
}
@ -363,6 +372,7 @@ static std::shared_ptr<UINode> read_panel(
static std::shared_ptr<UINode> read_button(
UiXmlReader& reader, const xml::xmlelement& element
) {
auto& gui = reader.getGUI();
glm::vec4 padding = element.attr("padding", "10").asVec4();
std::shared_ptr<Button> button;
@ -370,14 +380,14 @@ static std::shared_ptr<UINode> read_button(
if (!elements.empty() && elements[0]->getTag() != "#") {
auto inner = reader.readUINode(*elements.at(0));
if (inner != nullptr) {
button = std::make_shared<Button>(inner, padding);
button = std::make_shared<Button>(gui, inner, padding);
} else {
button = std::make_shared<Button>(L"", padding, nullptr);
button = std::make_shared<Button>(gui, L"", padding, nullptr);
}
read_panel_impl(reader, element, *button, false);
} else {
std::wstring text = parse_inner_text(element, reader.getContext());
button = std::make_shared<Button>(text, padding, nullptr);
button = std::make_shared<Button>(gui, text, padding, nullptr);
read_panel_impl(reader, element, *button, true);
}
if (element.has("text-align")) {
@ -393,7 +403,9 @@ static std::shared_ptr<UINode> read_check_box(
) {
auto text = parse_inner_text(element, reader.getContext());
bool checked = element.attr("checked", "false").asBool();
auto checkbox = std::make_shared<FullCheckBox>(text, glm::vec2(32), checked);
auto checkbox = std::make_shared<FullCheckBox>(
reader.getGUI(), text, glm::vec2(32), checked
);
read_panel_impl(reader, element, *checkbox);
if (element.has("consumer")) {
@ -417,20 +429,22 @@ static std::shared_ptr<UINode> read_check_box(
static std::shared_ptr<UINode> read_text_box(
UiXmlReader& reader, const xml::xmlelement& element
) {
auto placeholder = util::str2wstr_utf8(element.attr("placeholder", "").getText());
auto placeholder =
util::str2wstr_utf8(element.attr("placeholder", "").getText());
auto hint = util::str2wstr_utf8(element.attr("hint", "").getText());
auto text = parse_inner_text(element, reader.getContext());
auto textbox = std::make_shared<TextBox>(placeholder, glm::vec4(0.0f));
auto textbox = std::make_shared<TextBox>(
reader.getGUI(), placeholder, glm::vec4(0.0f)
);
textbox->setHint(hint);
read_container_impl(reader, element, *textbox);
if (element.has("padding")) {
glm::vec4 padding = element.attr("padding").asVec4();
textbox->setPadding(padding);
glm::vec2 size = textbox->getSize();
textbox->setSize(glm::vec2(
size.x + padding.x + padding.z,
size.y + padding.y + padding.w
size.x + padding.x + padding.z, size.y + padding.y + padding.w
));
}
textbox->setText(text);
@ -513,7 +527,7 @@ static std::shared_ptr<UINode> read_image(
const UiXmlReader& reader, const xml::xmlelement& element
) {
std::string src = element.attr("src", "").getText();
auto image = std::make_shared<Image>(src);
auto image = std::make_shared<Image>(reader.getGUI(), src);
read_uinode(reader, element, *image);
return image;
}
@ -521,11 +535,12 @@ static std::shared_ptr<UINode> read_image(
static std::shared_ptr<UINode> read_canvas(
const UiXmlReader& reader, const xml::xmlelement& element
) {
auto size = glm::uvec2{32, 32};
auto size = glm::uvec2 {32, 32};
if (element.has("size")) {
size = element.attr("size").asVec2();
}
auto image = std::make_shared<Canvas>(ImageFormat::rgba8888, size);
auto image =
std::make_shared<Canvas>(reader.getGUI(), ImageFormat::rgba8888, size);
read_uinode(reader, element, *image);
return image;
}
@ -540,19 +555,24 @@ static std::shared_ptr<UINode> read_track_bar(
float def = element.attr("value", "0.0").asFloat();
float step = element.attr("step", "1.0").asFloat();
int trackWidth = element.attr("track-width", "12").asInt();
auto bar = std::make_shared<TrackBar>(minv, maxv, def, step, trackWidth);
auto bar = std::make_shared<TrackBar>(
reader.getGUI(), minv, maxv, def, step, trackWidth
);
read_uinode(reader, element, *bar);
if (element.has("consumer")) {
bar->setConsumer(scripting::create_number_consumer(
env, element.attr("consumer").getText(), file));
env, element.attr("consumer").getText(), file
));
}
if (element.has("sub-consumer")) {
bar->setSubConsumer(scripting::create_number_consumer(
env, element.attr("sub-consumer").getText(), file));
env, element.attr("sub-consumer").getText(), file
));
}
if (element.has("supplier")) {
bar->setSupplier(scripting::create_number_supplier(
env, element.attr("supplier").getText(), file));
env, element.attr("supplier").getText(), file
));
}
if (element.has("track-color")) {
bar->setTrackColor(element.attr("track-color").asColor());
@ -567,14 +587,11 @@ static std::shared_ptr<UINode> read_input_bind_box(
UiXmlReader& reader, const xml::xmlelement& element
) {
auto bindname = element.attr("binding").getText();
auto found = Events::bindings.find(bindname);
if (found == Events::bindings.end()) {
throw std::runtime_error("binding does not exists "+util::quote(bindname));
}
auto& found = Events::requireBinding(bindname);
glm::vec4 padding = element.attr("padding", "6").asVec4();
auto bindbox = std::make_shared<InputBindBox>(found->second, padding);
auto bindbox =
std::make_shared<InputBindBox>(reader.getGUI(), found, padding);
read_panel_impl(reader, element, *bindbox);
return bindbox;
}
@ -585,11 +602,12 @@ static slotcallback read_slot_func(
const std::string& attr
) {
auto consumer = scripting::create_int_array_consumer(
reader.getEnvironment(),
element.attr(attr).getText()
reader.getEnvironment(), element.attr(attr).getText()
);
return [=](uint slot, ItemStack&) {
int args[] {int(view->getInventory()->getId()), int(slot)};
int args[] {
static_cast<int>(view->getInventory()->getId()),
static_cast<int>(slot)};
consumer(args, 2);
};
}
@ -601,7 +619,9 @@ static void readSlot(
bool itemSource = element.attr("item-source", "false").asBool();
bool taking = element.attr("taking", "true").asBool();
bool placing = element.attr("placing", "true").asBool();
SlotLayout layout(index, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr);
SlotLayout layout(
index, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr
);
if (element.has("pos")) {
layout.position = element.attr("pos").asVec2();
}
@ -612,7 +632,8 @@ static void readSlot(
layout.shareFunc = read_slot_func(view, reader, element, "sharefunc");
}
if (element.has("onrightclick")) {
layout.rightClick = read_slot_func(view, reader, element, "onrightclick");
layout.rightClick =
read_slot_func(view, reader, element, "onrightclick");
}
layout.taking = taking;
layout.placing = placing;
@ -622,7 +643,9 @@ static void readSlot(
}
static void readSlotsGrid(
InventoryView* view, const UiXmlReader& reader, const xml::xmlelement& element
InventoryView* view,
const UiXmlReader& reader,
const xml::xmlelement& element
) {
int startIndex = element.attr("start-index", "0").asInt();
int rows = element.attr("rows", "0").asInt();
@ -647,7 +670,9 @@ static void readSlotsGrid(
count = rows * cols;
}
bool itemSource = element.attr("item-source", "false").asBool();
SlotLayout layout(-1, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr);
SlotLayout layout(
-1, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr
);
if (element.has("pos")) {
layout.position = element.attr("pos").asVec2();
}
@ -658,7 +683,8 @@ static void readSlotsGrid(
layout.shareFunc = read_slot_func(view, reader, element, "sharefunc");
}
if (element.has("onrightclick")) {
layout.rightClick = read_slot_func(view, reader, element, "onrightclick");
layout.rightClick =
read_slot_func(view, reader, element, "onrightclick");
}
layout.padding = padding;
layout.taking = taking;
@ -674,7 +700,7 @@ static void readSlotsGrid(
slotLayout.index = startIndex + idx;
slotLayout.position += glm::vec2(
padding + col * (slotSize + interval),
padding + (rows-row-1) * (slotSize + interval)
padding + (rows - row - 1) * (slotSize + interval)
);
auto slot = view->addSlot(slotLayout);
view->add(slot, slotLayout.position);
@ -685,8 +711,8 @@ static void readSlotsGrid(
static std::shared_ptr<UINode> read_inventory(
UiXmlReader& reader, const xml::xmlelement& element
) {
auto view = std::make_shared<InventoryView>();
view->setColor(glm::vec4(0.122f, 0.122f, 0.122f, 0.878f)); // todo: fixme
auto view = std::make_shared<InventoryView>(reader.getGUI());
view->setColor(glm::vec4(0.122f, 0.122f, 0.122f, 0.878f)); // TODO: fixme
reader.addIgnore("slot");
reader.addIgnore("slots-grid");
reader.readUINode(reader, element, *view);
@ -704,16 +730,15 @@ static std::shared_ptr<UINode> read_inventory(
static std::shared_ptr<UINode> read_page_box(
UiXmlReader& reader, const xml::xmlelement& element
) {
auto menu = std::make_shared<Menu>();
menu->setPageLoader(
Engine::getInstance().getGUI()->getMenu()->getPageLoader()
);
auto& gui = reader.getGUI();
auto menu = std::make_shared<Menu>(gui);
menu->setPageLoader(gui.getMenu()->getPageLoader());
read_container_impl(reader, element, *menu);
return menu;
}
UiXmlReader::UiXmlReader(const scriptenv& env) : env(env) {
UiXmlReader::UiXmlReader(gui::GUI& gui, const scriptenv& env) : gui(gui), env(env) {
contextStack.emplace("");
add("image", read_image);
add("canvas", read_canvas);
@ -742,16 +767,15 @@ void UiXmlReader::addIgnore(const std::string& tag) {
ignored.insert(tag);
}
std::shared_ptr<UINode> UiXmlReader::readUINode(const xml::xmlelement& element) {
std::shared_ptr<UINode> UiXmlReader::readUINode(const xml::xmlelement& element
) {
if (element.has("if")) {
const auto& cond = element.attr("if").getText();
if (cond.empty() || cond == "false" || cond == "nil")
return nullptr;
if (cond.empty() || cond == "false" || cond == "nil") return nullptr;
}
if (element.has("ifnot")) {
const auto& cond = element.attr("ifnot").getText();
if (!(cond.empty() || cond == "false" || cond == "nil"))
return nullptr;
if (!(cond.empty() || cond == "false" || cond == "nil")) return nullptr;
}
const std::string& tag = element.getTag();
@ -760,7 +784,7 @@ std::shared_ptr<UINode> UiXmlReader::readUINode(const xml::xmlelement& element)
if (ignored.find(tag) != ignored.end()) {
return nullptr;
}
throw std::runtime_error("unsupported element '"+tag+"'");
throw std::runtime_error("unsupported element '" + tag + "'");
}
bool hascontext = element.has("context");
@ -775,8 +799,7 @@ std::shared_ptr<UINode> UiXmlReader::readUINode(const xml::xmlelement& element)
}
std::shared_ptr<UINode> UiXmlReader::readXML(
const std::string& filename,
const std::string& source
const std::string& filename, const std::string& source
) {
this->filename = filename;
auto document = xml::parse(filename, source);
@ -784,8 +807,7 @@ std::shared_ptr<UINode> UiXmlReader::readXML(
}
std::shared_ptr<UINode> UiXmlReader::readXML(
const std::string& filename,
const xml::xmlelement& root
const std::string& filename, const xml::xmlelement& root
) {
this->filename = filename;
return readUINode(root);
@ -802,3 +824,7 @@ const std::string& UiXmlReader::getFilename() const {
const scriptenv& UiXmlReader::getEnvironment() const {
return env;
}
gui::GUI& UiXmlReader::getGUI() const {
return gui;
}

4
src/graphics/ui/gui_xml.hpp
View File

@ -15,13 +15,14 @@ namespace gui {
std::shared_ptr<UINode>(UiXmlReader&, const xml::xmlelement&)>;
class UiXmlReader {
gui::GUI& gui;
std::unordered_map<std::string, uinode_reader> readers;
std::unordered_set<std::string> ignored;
std::stack<std::string> contextStack;
std::string filename;
const scriptenv& env;
public:
UiXmlReader(const scriptenv& env);
UiXmlReader(gui::GUI& gui, const scriptenv& env);
void add(const std::string& tag, uinode_reader reader);
bool hasReader(const std::string& tag) const;
@ -54,5 +55,6 @@ namespace gui {
const std::string& getContext() const;
const scriptenv& getEnvironment() const;
const std::string& getFilename() const;
gui::GUI& getGUI() const;
};
}

4
src/logic/EngineController.cpp
View File

@ -38,7 +38,7 @@ void EngineController::deleteWorld(const std::string& name) {
logger.info() << "deleting " << folder.string();
io::remove_all(folder);
if (!engine.isHeadless()) {
engine.getGUI()->getMenu()->back();
engine.getGUI().getMenu()->back();
}
};
@ -109,7 +109,7 @@ static void show_convert_request(
text += util::str2wstr_utf8(line) + L"\n";
}
guiutil::confirm_with_memo(
engine.getGUI()->getMenu(),
engine,
langs::get(message),
text,
on_confirm,

118
src/logic/PlayerController.cpp
View File

@ -4,9 +4,10 @@
#include <algorithm>
#include <cmath>
#include "BlocksController.hpp"
#include "content/Content.hpp"
#include "core_defs.hpp"
#include "settings.hpp"
#include "engine/Engine.hpp"
#include "items/Inventory.hpp"
#include "items/ItemDef.hpp"
#include "items/ItemStack.hpp"
@ -16,17 +17,15 @@
#include "objects/Players.hpp"
#include "physics/Hitbox.hpp"
#include "physics/PhysicsSolver.hpp"
#include "scripting/scripting.hpp"
#include "settings.hpp"
#include "voxels/Block.hpp"
#include "voxels/Chunks.hpp"
#include "voxels/voxel.hpp"
#include "window/Camera.hpp"
#include "window/Events.hpp"
#include "window/Window.hpp"
#include "window/input.hpp"
#include "world/Level.hpp"
#include "BlocksController.hpp"
#include "scripting/scripting.hpp"
const float INTERACTION_RELOAD = 0.160f;
const float STEPS_SPEED = 2.2f;
@ -40,9 +39,7 @@ const float RUN_ZOOM = 1.1f;
const float C_ZOOM = 0.1f;
const float CROUCH_SHIFT_Y = -0.2f;
CameraControl::CameraControl(
Player& player, const CameraSettings& settings
)
CameraControl::CameraControl(Player& player, const CameraSettings& settings)
: player(player),
camera(player.fpCamera),
settings(settings),
@ -70,7 +67,9 @@ void CameraControl::updateMouse(PlayerInput& input) {
(input.zoom ? settings.sensitivity.get() / 4.f
: settings.sensitivity.get());
auto d = glm::degrees(Events::delta / (float)Window::height * sensitivity);
auto d = glm::degrees(
input.delta / static_cast<float>(Window::height) * sensitivity
);
rotation.x -= d.x;
rotation.y -= d.y;
@ -147,15 +146,16 @@ void CameraControl::updateFovEffects(
// more extensible but uglier
void CameraControl::switchCamera() {
const std::vector<std::shared_ptr<Camera>> playerCameras {
camera, player.tpCamera, player.spCamera
};
camera, player.tpCamera, player.spCamera};
auto index = std::distance(
playerCameras.begin(),
std::find_if(
playerCameras.begin(),
playerCameras.end(),
[this](auto& ptr) { return ptr.get() == player.currentCamera.get(); }
[this](auto& ptr) {
return ptr.get() == player.currentCamera.get();
}
)
);
if (static_cast<size_t>(index) != playerCameras.size()) {
@ -205,8 +205,8 @@ void CameraControl::update(
tpCamera->front = camera->front;
tpCamera->right = camera->right;
}
if (player.currentCamera == spCamera ||
player.currentCamera == tpCamera || player.currentCamera == camera) {
if (player.currentCamera == spCamera || player.currentCamera == tpCamera ||
player.currentCamera == camera) {
player.currentCamera->setFov(glm::radians(settings.fov.get()));
}
}
@ -239,10 +239,7 @@ void PlayerController::onFootstep(const Hitbox& hitbox) {
continue;
}
blocksController.onBlockInteraction(
&player,
glm::ivec3(x, y, z),
def,
BlockInteraction::step
&player, glm::ivec3(x, y, z), def, BlockInteraction::step
);
return;
}
@ -265,9 +262,9 @@ void PlayerController::updateFootsteps(float delta) {
}
}
void PlayerController::update(float delta, bool input) {
if (input) {
updateKeyboard();
void PlayerController::update(float delta, const Input* inputEvents) {
if (inputEvents) {
updateKeyboard(*inputEvents);
player.updateSelectedEntity();
} else {
resetKeyboard();
@ -275,7 +272,7 @@ void PlayerController::update(float delta, bool input) {
updatePlayer(delta);
}
void PlayerController::postUpdate(float delta, bool input, bool pause) {
void PlayerController::postUpdate(float delta, const Input* input, bool pause) {
if (!pause) {
updateFootsteps(delta);
}
@ -287,23 +284,25 @@ void PlayerController::postUpdate(float delta, bool input, bool pause) {
player.postUpdate();
camControl.update(this->input, pause ? 0.0f : delta, *player.chunks);
if (input) {
updateInteraction(delta);
updateInteraction(*input, delta);
} else {
player.selection = {};
}
}
void PlayerController::updateKeyboard() {
input.moveForward = Events::active(BIND_MOVE_FORWARD);
input.moveBack = Events::active(BIND_MOVE_BACK);
input.moveLeft = Events::active(BIND_MOVE_LEFT);
input.moveRight = Events::active(BIND_MOVE_RIGHT);
input.sprint = Events::active(BIND_MOVE_SPRINT);
input.shift = Events::active(BIND_MOVE_CROUCH);
input.cheat = Events::active(BIND_MOVE_CHEAT);
input.jump = Events::active(BIND_MOVE_JUMP);
input.zoom = Events::active(BIND_CAM_ZOOM);
input.cameraMode = Events::jactive(BIND_CAM_MODE);
void PlayerController::updateKeyboard(const Input& inputEvents) {
const auto& bindings = inputEvents.getBindings();
input.moveForward = bindings.active(BIND_MOVE_FORWARD);
input.moveBack = bindings.active(BIND_MOVE_BACK);
input.moveLeft = bindings.active(BIND_MOVE_LEFT);
input.moveRight = bindings.active(BIND_MOVE_RIGHT);
input.sprint = bindings.active(BIND_MOVE_SPRINT);
input.shift = bindings.active(BIND_MOVE_CROUCH);
input.cheat = bindings.active(BIND_MOVE_CHEAT);
input.jump = bindings.active(BIND_MOVE_JUMP);
input.zoom = bindings.active(BIND_CAM_ZOOM);
input.cameraMode = bindings.jactive(BIND_CAM_MODE);
input.delta = inputEvents.getCursor().delta;
}
void PlayerController::resetKeyboard() {
@ -316,6 +315,7 @@ void PlayerController::resetKeyboard() {
input.shift = false;
input.cheat = false;
input.jump = false;
input.delta = {};
}
void PlayerController::updatePlayer(float delta) {
@ -328,18 +328,12 @@ static int determine_rotation(
if (def && def->rotatable) {
const std::string& name = def->rotations.name;
if (name == "pipe") {
if (norm.x < 0.0f)
return BLOCK_DIR_WEST;
if (norm.x > 0.0f)
return BLOCK_DIR_EAST;
if (norm.y > 0.0f)
return BLOCK_DIR_UP;
if (norm.y < 0.0f)
return BLOCK_DIR_DOWN;
if (norm.z > 0.0f)
return BLOCK_DIR_NORTH;
if (norm.z < 0.0f)
return BLOCK_DIR_SOUTH;
if (norm.x < 0.0f) return BLOCK_DIR_WEST;
if (norm.x > 0.0f) return BLOCK_DIR_EAST;
if (norm.y > 0.0f) return BLOCK_DIR_UP;
if (norm.y < 0.0f) return BLOCK_DIR_DOWN;
if (norm.z > 0.0f) return BLOCK_DIR_NORTH;
if (norm.z < 0.0f) return BLOCK_DIR_SOUTH;
} else if (name == "pane") {
if (abs(camDir.x) > abs(camDir.z)) {
if (camDir.x > 0.0f) return BLOCK_DIR_EAST;
@ -417,7 +411,9 @@ voxel* PlayerController::updateSelection(float maxDistance) {
return vox;
}
void PlayerController::processRightClick(const Block& def, const Block& target) {
void PlayerController::processRightClick(
const Block& def, const Block& target
) {
const auto& selection = player.selection;
auto& chunks = *player.chunks;
auto camera = player.fpCamera.get();
@ -427,8 +423,8 @@ void PlayerController::processRightClick(const Block& def, const Block& target)
if (!input.shift && target.rt.funcsset.oninteract) {
if (scripting::on_block_interact(
&player, target, selection.actualPosition
)) {
&player, target, selection.actualPosition
)) {
return;
}
}
@ -443,7 +439,8 @@ void PlayerController::processRightClick(const Block& def, const Block& target)
if (def.obstacle) {
const auto& hitboxes = def.rt.hitboxes[state.rotation];
for (const AABB& blockAABB : hitboxes) {
if (level.entities->hasBlockingInside(blockAABB.translated(coord))) {
if (level.entities->hasBlockingInside(blockAABB.translated(coord)
)) {
return;
}
}
@ -466,7 +463,7 @@ void PlayerController::processRightClick(const Block& def, const Block& target)
if (chosenBlock != vox->id && chosenBlock) {
if (!player.isInfiniteItems()) {
auto& slot = player.getInventory()->getSlot(player.getChosenSlot());
slot.setCount(slot.getCount()-1);
slot.setCount(slot.getCount() - 1);
}
blocksController.placeBlock(
&player, def, state, coord.x, coord.y, coord.z
@ -490,21 +487,22 @@ void PlayerController::updateEntityInteraction(
}
}
void PlayerController::updateInteraction(float delta) {
void PlayerController::updateInteraction(const Input& inputEvents, float delta) {
auto indices = level.content.getIndices();
const auto& selection = player.selection;
if (interactionTimer > 0.0f) {
interactionTimer -= delta;
}
bool xkey = Events::active(BIND_PLAYER_FAST_INTERACTOIN);
const auto& bindings = inputEvents.getBindings();
bool xkey = bindings.active(BIND_PLAYER_FAST_INTERACTOIN);
float maxDistance = xkey ? 200.0f : 10.0f;
bool longInteraction = interactionTimer <= 0 || xkey;
bool lclick = Events::jactive(BIND_PLAYER_DESTROY) ||
(longInteraction && Events::active(BIND_PLAYER_DESTROY));
bool lattack = Events::jactive(BIND_PLAYER_ATTACK);
bool rclick = Events::jactive(BIND_PLAYER_BUILD) ||
(longInteraction && Events::active(BIND_PLAYER_BUILD));
bool lclick = bindings.jactive(BIND_PLAYER_DESTROY) ||
(longInteraction && bindings.active(BIND_PLAYER_DESTROY));
bool lattack = bindings.jactive(BIND_PLAYER_ATTACK);
bool rclick = bindings.jactive(BIND_PLAYER_BUILD) ||
(longInteraction && bindings.active(BIND_PLAYER_BUILD));
if (lclick || rclick) {
interactionTimer = INTERACTION_RELOAD;
}
@ -527,8 +525,8 @@ void PlayerController::updateInteraction(float delta) {
auto iend = selection.position;
if (lclick && !input.shift && item.rt.funcsset.on_block_break_by) {
if (scripting::on_item_break_block(
&player, item, iend.x, iend.y, iend.z
)) {
&player, item, iend.x, iend.y, iend.z
)) {
return;
}
}

13
src/logic/PlayerController.hpp
View File

@ -7,6 +7,7 @@
#include "objects/Player.hpp"
#include "util/Clock.hpp"
class Input;
class Engine;
class Camera;
class Level;
@ -54,11 +55,11 @@ class PlayerController {
BlocksController& blocksController;
float interactionTimer = 0.0f;
void updateKeyboard();
void updateKeyboard(const Input& inputEvents);
void resetKeyboard();
void updatePlayer(float delta);
void updateEntityInteraction(entityid_t eid, bool lclick, bool rclick);
void updateInteraction(float delta);
void updateInteraction(const Input& inputEvents, float delta);
float stepsTimer = 0.0f;
void onFootstep(const Hitbox& hitbox);
@ -76,13 +77,13 @@ public:
/// @brief Called after blocks update if not paused
/// @param delta delta time
/// @param input process user input
void update(float delta, bool input);
/// @param inputEvents nullable window inputs
void update(float delta, const Input* inputEvents);
/// @brief Called after whole level update
/// @param delta delta time
/// @param input process user input
/// @param inputEvents nullable window inputs
/// @param pause is game paused
void postUpdate(float delta, bool input, bool pause);
void postUpdate(float delta, const Input* inputEvents, bool pause);
Player* getPlayer();
};

14
src/logic/scripting/lua/libs/libconsole.cpp
View File

@ -14,7 +14,7 @@ static int l_add_command(lua::State* L) {
lua::pushvalue(L, 3);
auto func = lua::create_lambda(L);
try {
engine->getCommandsInterpreter()->getRepository()->add(
engine->getCmd().getRepository()->add(
scheme,
description,
[func](auto, auto args, auto kwargs) {
@ -32,7 +32,7 @@ static int l_add_command(lua::State* L) {
static int l_execute(lua::State* L) {
auto prompt = lua::require_string(L, 1);
try {
auto result = engine->getCommandsInterpreter()->execute(prompt);
auto result = engine->getCmd().execute(prompt);
lua::pushvalue(L, result);
return 1;
} catch (const parsing_error& err) {
@ -45,19 +45,18 @@ static int l_execute(lua::State* L) {
static int l_get(lua::State* L) {
auto name = lua::require_string(L, 1);
return lua::pushvalue(L, (*engine->getCommandsInterpreter())[name]);
return lua::pushvalue(L, engine->getCmd()[name]);
}
static int l_set(lua::State* L) {
auto name = lua::require_string(L, 1);
auto value = lua::tovalue(L, 2);
(*engine->getCommandsInterpreter())[name] = value;
engine->getCmd()[name] = value;
return 0;
}
static int l_get_commands_list(lua::State* L) {
auto interpreter = engine->getCommandsInterpreter();
auto repo = interpreter->getRepository();
auto repo = engine->getCmd().getRepository();
const auto& commands = repo->getCommands();
lua::createtable(L, commands.size(), 0);
@ -71,8 +70,7 @@ static int l_get_commands_list(lua::State* L) {
static int l_get_command_info(lua::State* L) {
auto name = lua::require_string(L, 1);
auto interpreter = engine->getCommandsInterpreter();
auto repo = interpreter->getRepository();
auto repo = engine->getCmd().getRepository();
auto command = repo->get(name);
if (command == nullptr) {
return 0;

1
src/logic/scripting/lua/libs/libcore.cpp
View File

@ -17,7 +17,6 @@
#include "logic/LevelController.hpp"
#include "util/listutil.hpp"
#include "util/platform.hpp"
#include "window/Events.hpp"
#include "world/Level.hpp"
#include "world/generator/WorldGenerator.hpp"

12
src/logic/scripting/lua/libs/libgui.cpp
View File

@ -80,8 +80,9 @@ static int l_container_add(lua::State* L) {
}
auto xmlsrc = lua::require_string(L, 2);
try {
auto subnode =
guiutil::create(xmlsrc, docnode.document->getEnvironment());
auto subnode = guiutil::create(
engine->getGUI(), xmlsrc, docnode.document->getEnvironment()
);
node->add(subnode);
UINode::getIndices(subnode, docnode.document->getMapWriteable());
} catch (const std::exception& err) {
@ -93,7 +94,7 @@ static int l_container_add(lua::State* L) {
static int l_node_destruct(lua::State* L) {
auto docnode = get_document_node(L);
auto node = docnode.node;
engine->getGUI()->postRunnable([node]() {
engine->getGUI().postRunnable([node]() {
auto parent = node->getParent();
if (auto container = dynamic_cast<Container*>(parent)) {
container->remove(node.get());
@ -651,7 +652,7 @@ static void p_set_focused(
const std::shared_ptr<UINode>& node, lua::State* L, int idx
) {
if (lua::toboolean(L, idx) && !node->isFocused()) {
engine->getGUI()->setFocus(node);
engine->getGUI().setFocus(node);
} else if (node->isFocused()) {
node->defocus();
}
@ -782,7 +783,7 @@ static int l_gui_get_locales_info(lua::State* L) {
}
static int l_gui_getviewport(lua::State* L) {
return lua::pushvec2(L, engine->getGUI()->getContainer()->getSize());
return lua::pushvec2(L, engine->getGUI().getContainer()->getSize());
}
static int l_gui_clear_markup(lua::State* L) {
@ -845,6 +846,7 @@ static int l_gui_load_document(lua::State* L) {
auto args = lua::tovalue(L, 3);
auto documentPtr = UiDocument::read(
engine->getGUI(),
scripting::get_root_environment(),
alias,
filename,

65
src/logic/scripting/lua/libs/libinput.cpp
View File

@ -1,15 +1,15 @@
#include <filesystem>
#include "engine/Engine.hpp"
#include "io/io.hpp"
#include "frontend/hud.hpp"
#include "frontend/screens/Screen.hpp"
#include "graphics/ui/GUI.hpp"
#include "graphics/ui/elements/Container.hpp"
#include "io/io.hpp"
#include "libgui.hpp"
#include "util/stringutil.hpp"
#include "window/Events.hpp"
#include "window/input.hpp"
#include "libgui.hpp"
namespace scripting {
extern Hud* hud;
@ -37,26 +37,26 @@ static int l_add_callback(lua::State* L) {
lua::pushvalue(L, 2);
auto actual_callback = lua::create_simple_handler(L);
observer_handler handler;
auto& gui = engine->getGUI();
auto& input = engine->getInput();
if (pos != std::string::npos) {
std::string prefix = bindname.substr(0, pos);
if (prefix == "key") {
auto key = input_util::keycode_from(bindname.substr(pos + 1));
handler = Events::addKeyCallback(key, actual_callback);
handler = input.addKeyCallback(key, actual_callback);
}
}
auto callback = [=]() -> bool {
if (!scripting::engine->getGUI()->isFocusCaught()) {
auto callback = [&gui, actual_callback]() -> bool {
if (!gui.isFocusCaught()) {
return actual_callback();
}
return false;
};
if (handler == nullptr) {
const auto& bind = Events::bindings.find(bindname);
if (bind == Events::bindings.end()) {
throw std::runtime_error("unknown binding " + util::quote(bindname));
}
handler = bind->second.onactived.add(callback);
auto& bind = input.requireBinding(bindname);
handler = bind.onactived.add(callback);
}
if (hud) {
@ -64,7 +64,8 @@ static int l_add_callback(lua::State* L) {
return 0;
} else if (lua::gettop(L) >= 3) {
auto node = get_document_node(L, 3);
if (auto container = std::dynamic_pointer_cast<gui::Container>(node.node)) {
if (auto container =
std::dynamic_pointer_cast<gui::Container>(node.node)) {
container->keepAlive(handler);
return 0;
}
@ -74,11 +75,11 @@ static int l_add_callback(lua::State* L) {
}
static int l_get_mouse_pos(lua::State* L) {
return lua::pushvec2(L, Events::cursor);
return lua::pushvec2(L, engine->getInput().getCursor().pos);
}
static int l_get_bindings(lua::State* L) {
auto& bindings = Events::bindings;
const auto& bindings = engine->getInput().getBindings().getAll();
lua::createtable(L, bindings.size(), 0);
int i = 0;
@ -92,25 +93,14 @@ static int l_get_bindings(lua::State* L) {
static int l_get_binding_text(lua::State* L) {
auto bindname = lua::require_string(L, 1);
auto index = Events::bindings.find(bindname);
if (index == Events::bindings.end()) {
throw std::runtime_error("unknown binding " + util::quote(bindname));
lua::pushstring(L, "");
} else {
lua::pushstring(L, index->second.text());
}
return 1;
const auto& bind = engine->getInput().requireBinding(bindname);
return lua::pushstring(L, bind.text());
}
static int l_is_active(lua::State* L) {
auto bindname = lua::require_string(L, 1);
const auto& bind = Events::bindings.find(bindname);
if (bind == Events::bindings.end()) {
throw std::runtime_error("unknown binding " + util::quote(bindname));
}
return lua::pushboolean(L, bind->second.active());
auto& bind = engine->getInput().requireBinding(bindname);
return lua::pushboolean(L, bind.active());
}
static int l_is_pressed(lua::State* L) {
@ -123,12 +113,11 @@ static int l_is_pressed(lua::State* L) {
auto name = code.substr(sep + 1);
if (prefix == "key") {
return lua::pushboolean(
L, Events::pressed(static_cast<int>(input_util::keycode_from(name)))
L, engine->getInput().pressed(input_util::keycode_from(name))
);
} else if (prefix == "mouse") {
return lua::pushboolean(
L,
Events::clicked(static_cast<int>(input_util::mousecode_from(name)))
L, engine->getInput().clicked(input_util::mousecode_from(name))
);
} else {
throw std::runtime_error("unknown input type " + util::quote(code));
@ -140,9 +129,7 @@ static void reset_pack_bindings(const io::path& packFolder) {
auto bindsFile = configFolder / "bindings.toml";
if (io::is_regular_file(bindsFile)) {
Events::loadBindings(
bindsFile.string(),
io::read_string(bindsFile),
BindType::REBIND
bindsFile.string(), io::read_string(bindsFile), BindType::REBIND
);
}
}
@ -157,12 +144,8 @@ static int l_reset_bindings(lua::State*) {
static int l_set_enabled(lua::State* L) {
std::string bindname = lua::require_string(L, 1);
bool enable = lua::toboolean(L, 2);
const auto& bind = Events::bindings.find(bindname);
if (bind == Events::bindings.end()) {
throw std::runtime_error("unknown binding " + util::quote(bindname));
}
Events::bindings[bindname].enable = enable;
bool enabled = lua::toboolean(L, 2);
engine->getInput().requireBinding(bindname).enabled = enabled;
return 0;
}

116
src/logic/scripting/lua/libs/libnetwork.cpp
View File

@ -6,13 +6,13 @@
using namespace scripting;
static int l_get(lua::State* L) {
static int l_get(lua::State* L, network::Network& network) {
std::string url(lua::require_lstring(L, 1));
lua::pushvalue(L, 2);
auto onResponse = lua::create_lambda_nothrow(L);
engine->getNetwork().get(url, [onResponse](std::vector<char> bytes) {
network.get(url, [onResponse](std::vector<char> bytes) {
engine->postRunnable([=]() {
onResponse({std::string(bytes.data(), bytes.size())});
});
@ -20,13 +20,13 @@ static int l_get(lua::State* L) {
return 0;
}
static int l_get_binary(lua::State* L) {
static int l_get_binary(lua::State* L, network::Network& network) {
std::string url(lua::require_lstring(L, 1));
lua::pushvalue(L, 2);
auto onResponse = lua::create_lambda_nothrow(L);
engine->getNetwork().get(url, [onResponse](std::vector<char> bytes) {
network.get(url, [onResponse](std::vector<char> bytes) {
auto buffer = std::make_shared<util::Buffer<ubyte>>(
reinterpret_cast<const ubyte*>(bytes.data()), bytes.size()
);
@ -37,7 +37,7 @@ static int l_get_binary(lua::State* L) {
return 0;
}
static int l_post(lua::State* L) {
static int l_post(lua::State* L, network::Network& network) {
std::string url(lua::require_lstring(L, 1));
auto data = lua::tovalue(L, 2);
@ -61,12 +61,12 @@ static int l_post(lua::State* L) {
return 0;
}
static int l_connect(lua::State* L) {
static int l_connect(lua::State* L, network::Network& network) {
std::string address = lua::require_string(L, 1);
int port = lua::tointeger(L, 2);
lua::pushvalue(L, 3);
auto callback = lua::create_lambda_nothrow(L);
u64id_t id = engine->getNetwork().connect(address, port, [callback](u64id_t id) {
u64id_t id = network.connect(address, port, [callback](u64id_t id) {
engine->postRunnable([=]() {
callback({id});
});
@ -75,25 +75,25 @@ static int l_connect(lua::State* L) {
}
static int l_close(lua::State* L) {
static int l_close(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto connection = engine->getNetwork().getConnection(id)) {
if (auto connection = network.getConnection(id)) {
connection->close(true);
}
return 0;
}
static int l_closeserver(lua::State* L) {
static int l_closeserver(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto server = engine->getNetwork().getServer(id)) {
if (auto server = network.getServer(id)) {
server->close();
}
return 0;
}
static int l_send(lua::State* L) {
static int l_send(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
auto connection = engine->getNetwork().getConnection(id);
auto connection = network.getConnection(id);
if (connection == nullptr ||
connection->getState() == network::ConnectionState::CLOSED) {
return 0;
@ -120,7 +120,7 @@ static int l_send(lua::State* L) {
return 0;
}
static int l_recv(lua::State* L) {
static int l_recv(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
int length = lua::tointeger(L, 2);
auto connection = engine->getNetwork().getConnection(id);
@ -149,19 +149,19 @@ static int l_recv(lua::State* L) {
return 1;
}
static int l_available(lua::State* L) {
static int l_available(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto connection = engine->getNetwork().getConnection(id)) {
if (auto connection = network.getConnection(id)) {
return lua::pushinteger(L, connection->available());
}
return 0;
}
static int l_open(lua::State* L) {
static int l_open(lua::State* L, network::Network& network) {
int port = lua::tointeger(L, 1);
lua::pushvalue(L, 2);
auto callback = lua::create_lambda_nothrow(L);
u64id_t id = engine->getNetwork().openServer(port, [callback](u64id_t id) {
u64id_t id = network.openServer(port, [callback](u64id_t id) {
engine->postRunnable([=]() {
callback({id});
});
@ -169,9 +169,9 @@ static int l_open(lua::State* L) {
return lua::pushinteger(L, id);
}
static int l_is_alive(lua::State* L) {
static int l_is_alive(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto connection = engine->getNetwork().getConnection(id)) {
if (auto connection = network.getConnection(id)) {
return lua::pushboolean(
L,
connection->getState() != network::ConnectionState::CLOSED ||
@ -181,9 +181,9 @@ static int l_is_alive(lua::State* L) {
return lua::pushboolean(L, false);
}
static int l_is_connected(lua::State* L) {
static int l_is_connected(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto connection = engine->getNetwork().getConnection(id)) {
if (auto connection = network.getConnection(id)) {
return lua::pushboolean(
L, connection->getState() == network::ConnectionState::CONNECTED
);
@ -191,9 +191,9 @@ static int l_is_connected(lua::State* L) {
return lua::pushboolean(L, false);
}
static int l_get_address(lua::State* L) {
static int l_get_address(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto connection = engine->getNetwork().getConnection(id)) {
if (auto connection = network.getConnection(id)) {
lua::pushstring(L, connection->getAddress());
lua::pushinteger(L, connection->getPort());
return 2;
@ -201,47 +201,65 @@ static int l_get_address(lua::State* L) {
return 0;
}
static int l_is_serveropen(lua::State* L) {
static int l_is_serveropen(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto server = engine->getNetwork().getServer(id)) {
if (auto server = network.getServer(id)) {
return lua::pushboolean(L, server->isOpen());
}
return lua::pushboolean(L, false);
}
static int l_get_serverport(lua::State* L) {
static int l_get_serverport(lua::State* L, network::Network& network) {
u64id_t id = lua::tointeger(L, 1);
if (auto server = engine->getNetwork().getServer(id)) {
if (auto server = network.getServer(id)) {
return lua::pushinteger(L, server->getPort());
}
return 0;
}
static int l_get_total_upload(lua::State* L) {
return lua::pushinteger(L, engine->getNetwork().getTotalUpload());
static int l_get_total_upload(lua::State* L, network::Network& network) {
return lua::pushinteger(L, network.getTotalUpload());
}
static int l_get_total_download(lua::State* L) {
return lua::pushinteger(L, engine->getNetwork().getTotalDownload());
static int l_get_total_download(lua::State* L, network::Network& network) {
return lua::pushinteger(L, network.getTotalDownload());
}
template <int(*func)(lua::State*, network::Network&)>
int wrap(lua_State* L) {
int result = 0;
try {
result = func(L, engine->getNetwork());
}
// transform exception with description into lua_error
catch (std::exception& e) {
luaL_error(L, e.what());
}
// Rethrow any other exception (lua error for example)
catch (...) {
throw;
}
return result;
}
const luaL_Reg networklib[] = {
{"get", lua::wrap<l_get>},
{"get_binary", lua::wrap<l_get_binary>},
{"post", lua::wrap<l_post>},
{"get_total_upload", lua::wrap<l_get_total_upload>},
{"get_total_download", lua::wrap<l_get_total_download>},
{"__open", lua::wrap<l_open>},
{"__closeserver", lua::wrap<l_closeserver>},
{"__connect", lua::wrap<l_connect>},
{"__close", lua::wrap<l_close>},
{"__send", lua::wrap<l_send>},
{"__recv", lua::wrap<l_recv>},
{"__available", lua::wrap<l_available>},
{"__is_alive", lua::wrap<l_is_alive>},
{"__is_connected", lua::wrap<l_is_connected>},
{"__get_address", lua::wrap<l_get_address>},
{"__is_serveropen", lua::wrap<l_is_serveropen>},
{"__get_serverport", lua::wrap<l_get_serverport>},
{"get", wrap<l_get>},
{"get_binary", wrap<l_get_binary>},
{"post", wrap<l_post>},
{"get_total_upload", wrap<l_get_total_upload>},
{"get_total_download", wrap<l_get_total_download>},
{"__open", wrap<l_open>},
{"__closeserver", wrap<l_closeserver>},
{"__connect", wrap<l_connect>},
{"__close", wrap<l_close>},
{"__send", wrap<l_send>},
{"__recv", wrap<l_recv>},
{"__available", wrap<l_available>},
{"__is_alive", wrap<l_is_alive>},
{"__is_connected", wrap<l_is_connected>},
{"__get_address", wrap<l_get_address>},
{"__is_serveropen", wrap<l_is_serveropen>},
{"__get_serverport", wrap<l_get_serverport>},
{NULL, NULL}
};

2
src/logic/scripting/lua/libs/libpack.cpp
View File

@ -259,7 +259,7 @@ static int l_pack_request_writeable(lua::State* L) {
util::replaceAll(str, L"%{0}", util::str2wstr_utf8(packid));
guiutil::confirm(*engine, str, [packid, handler]() {
handler({engine->getPaths().createWriteablePackDevice(packid)});
engine->getGUI()->getMenu()->reset();
engine->getGUI().getMenu()->reset();
});
return 0;
}

10
src/logic/scripting/scripting.cpp
View File

@ -268,21 +268,21 @@ void scripting::on_world_load(LevelController* controller) {
lua::call_nothrow(L, 0, 0);
}
for (auto& pack : scripting::engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::emit_event(L, pack.id + ":.worldopen");
}
}
void scripting::on_world_tick() {
auto L = lua::get_main_state();
for (auto& pack : scripting::engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::emit_event(L, pack.id + ":.worldtick");
}
}
void scripting::on_world_save() {
auto L = lua::get_main_state();
for (auto& pack : scripting::engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::emit_event(L, pack.id + ":.worldsave");
}
if (lua::getglobal(L, "__vc_on_world_save")) {
@ -292,7 +292,7 @@ void scripting::on_world_save() {
void scripting::on_world_quit() {
auto L = lua::get_main_state();
for (auto& pack : scripting::engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::emit_event(L, pack.id + ":.worldquit");
}
if (lua::getglobal(L, "__vc_on_world_quit")) {
@ -308,7 +308,7 @@ void scripting::on_world_quit() {
void scripting::cleanup() {
auto L = lua::get_main_state();
lua::requireglobal(L, "pack");
for (auto& pack : scripting::engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::requirefield(L, "unload");
lua::pushstring(L, pack.id);
lua::call_nothrow(L, 1);

8
src/logic/scripting/scripting_hud.cpp
View File

@ -44,7 +44,7 @@ void scripting::on_frontend_init(Hud* hud, WorldRenderer* renderer) {
lua::call_nothrow(L, 0, 0);
}
for (auto& pack : engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::emit_event(
lua::get_main_state(),
pack.id + ":.hudopen",
@ -56,7 +56,7 @@ void scripting::on_frontend_init(Hud* hud, WorldRenderer* renderer) {
}
void scripting::on_frontend_render() {
for (auto& pack : engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::emit_event(
lua::get_main_state(),
pack.id + ":.hudrender",
@ -67,7 +67,7 @@ void scripting::on_frontend_render() {
void scripting::on_frontend_close() {
auto L = lua::get_main_state();
for (auto& pack : engine->getAllContentPacks()) {
for (auto& pack : Engine::getInstance().getAllContentPacks()) {
lua::emit_event(
L,
pack.id + ":.hudclose",
@ -109,7 +109,7 @@ gui::PageLoaderFunc scripting::create_page_loader() {
auto func = lua::create_lambda(L);
return [func](const std::string& name) -> std::shared_ptr<gui::UINode> {
auto docname = func({name}).asString();
return engine->getAssets()->require<UiDocument>(docname).getRoot();
return Engine::getInstance().getAssets()->require<UiDocument>(docname).getRoot();
};
}
return nullptr;

2
src/logic/scripting/scripting_world_generation.cpp
View File

@ -260,7 +260,7 @@ std::unique_ptr<GeneratorScript> scripting::load_generator(
const io::path& file,
const std::string& dirPath
) {
auto L = create_state(engine->getPaths(), StateType::GENERATOR);
auto L = create_state(Engine::getInstance().getPaths(), StateType::GENERATOR);
return std::make_unique<LuaGeneratorScript>(L, def, file, dirPath);
}

23
src/objects/Player.hpp
View File

@ -18,16 +18,19 @@ struct Hitbox;
struct EngineSettings;
struct PlayerInput {
bool zoom : 1;
bool cameraMode : 1;
bool moveForward : 1;
bool moveBack : 1;
bool moveRight : 1;
bool moveLeft : 1;
bool sprint : 1;
bool shift : 1;
bool cheat : 1;
bool jump : 1;
struct {
bool zoom : 1;
bool cameraMode : 1;
bool moveForward : 1;
bool moveBack : 1;
bool moveRight : 1;
bool moveLeft : 1;
bool sprint : 1;
bool shift : 1;
bool cheat : 1;
bool jump : 1;
};
glm::vec2 delta;
};
struct CursorSelection {

1
src/window/Camera.cpp
View File

@ -28,7 +28,6 @@ void Camera::rotate(float x, float y, float z) {
}
glm::mat4 Camera::getProjection() const {
constexpr float epsilon = 1e-6f;
if (perspective) {
return glm::perspective(fov * zoom, ar, near, far);
} else if (flipped) {

46
src/window/Events.cpp
View File

@ -28,7 +28,7 @@ glm::vec2 Events::cursor = {};
std::vector<uint> Events::codepoints;
std::vector<keycode> Events::pressedKeys;
std::unordered_map<std::string, Binding> Events::bindings;
Bindings Events::bindings {};
int Events::getScroll() {
return scroll;
@ -86,9 +86,9 @@ void Events::pollEvents() {
pressedKeys.clear();
glfwPollEvents();
for (auto& entry : bindings) {
for (auto& entry : bindings.getAll()) {
auto& binding = entry.second;
if (!binding.enable) {
if (!binding.enabled) {
binding.state = false;
continue;
}
@ -119,12 +119,15 @@ void Events::pollEvents() {
}
}
Binding& Events::getBinding(const std::string& name) {
const auto found = bindings.find(name);
if (found == bindings.end()) {
throw std::runtime_error("binding '" + name + "' does not exist");
Binding* Events::getBinding(const std::string& name) {
return bindings.get(name);
}
Binding& Events::requireBinding(const std::string& name) {
if (const auto found = getBinding(name)) {
return *found;
}
return found->second;
throw std::runtime_error("binding '" + name + "' does not exist");
}
void Events::bind(const std::string& name, inputtype type, keycode code) {
@ -136,31 +139,19 @@ void Events::bind(const std::string& name, inputtype type, mousecode code) {
}
void Events::bind(const std::string& name, inputtype type, int code) {
bindings.try_emplace(name, Binding(type, code));
bindings.bind(name, type, code);
}
void Events::rebind(const std::string& name, inputtype type, int code) {
const auto& found = bindings.find(name);
if (found == bindings.end()) {
throw std::runtime_error("binding '" + name + "' does not exist");
}
bindings[name] = Binding(type, code);
requireBinding(name) = Binding(type, code);
}
bool Events::active(const std::string& name) {
const auto& found = bindings.find(name);
if (found == bindings.end()) {
return false;
}
return found->second.active();
return bindings.active(name);
}
bool Events::jactive(const std::string& name) {
const auto& found = bindings.find(name);
if (found == bindings.end()) {
return false;
}
return found->second.jactive();
return bindings.jactive(name);
}
void Events::setKey(int key, bool b) {
@ -198,7 +189,7 @@ observer_handler Events::addKeyCallback(keycode key, KeyCallback callback) {
std::string Events::writeBindings() {
auto obj = dv::object();
for (auto& entry : Events::bindings) {
for (auto& entry : bindings.getAll()) {
const auto& binding = entry.second;
std::string value;
switch (binding.type) {
@ -253,9 +244,8 @@ void Events::loadBindings(
}
void Events::enableBindings() {
for (auto& entry : bindings) {
auto& binding = entry.second;
binding.enable = true;
for (auto& entry : bindings.getAll()) {
entry.second.enabled = true;
}
}

5
src/window/Events.hpp
View File

@ -21,7 +21,7 @@ namespace Events {
extern glm::vec2 cursor;
extern std::vector<uint> codepoints;
extern std::vector<keycode> pressedKeys;
extern std::unordered_map<std::string, Binding> bindings;
extern Bindings bindings;
void pollEvents();
@ -39,7 +39,8 @@ namespace Events {
void toggleCursor();
Binding& getBinding(const std::string& name);
Binding* getBinding(const std::string& name);
Binding& requireBinding(const std::string& name);
void bind(const std::string& name, inputtype type, keycode code);
void bind(const std::string& name, inputtype type, mousecode code);
void bind(const std::string& name, inputtype type, int code);

68
src/window/Window.cpp
View File

@ -175,7 +175,61 @@ static void glfw_error_callback(int error, const char* description) {
static GLFWcursor* standard_cursors[static_cast<int>(CursorShape::LAST) + 1] = {};
int Window::initialize(DisplaySettings* settings) {
class GLFWInput : public Input {
public:
void pollEvents() override {
Events::pollEvents();
}
const char* getClipboardText() const override {
return glfwGetClipboardString(::window);
}
int getScroll() override {
return Events::getScroll();
}
Binding& requireBinding(const std::string& name) override {
return Events::requireBinding(name);
}
bool pressed(keycode keycode) const override {
return Events::pressed(keycode);
}
bool jpressed(keycode keycode) const override {
return Events::jpressed(keycode);
}
bool clicked(mousecode mousecode) const override {
return Events::clicked(mousecode);
}
bool jclicked(mousecode mousecode) const override {
return Events::jclicked(mousecode);
}
CursorState getCursor() const override {
return {
Events::isCursorLocked(),
Events::cursor,
Events::delta
};
}
Bindings& getBindings() override {
return Events::bindings;
}
const Bindings& getBindings() const override {
return Events::bindings;
}
observer_handler addKeyCallback(keycode key, KeyCallback callback) override {
return Events::addKeyCallback(key, std::move(callback));
}
};
static_assert(!std::is_abstract<GLFWInput>());
std::unique_ptr<Input> Window::initialize(DisplaySettings* settings) {
::settings = settings;
Window::width = settings->width.get();
Window::height = settings->height.get();
@ -190,7 +244,7 @@ int Window::initialize(DisplaySettings* settings) {
glfwSetErrorCallback(glfw_error_callback);
if (glfwInit() == GLFW_FALSE) {
logger.error() << "failed to initialize GLFW";
return -1;
return nullptr;
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
@ -209,7 +263,7 @@ int Window::initialize(DisplaySettings* settings) {
if (window == nullptr) {
logger.error() << "failed to create GLFW window";
glfwTerminate();
return -1;
return nullptr;
}
glfwMakeContextCurrent(window);
@ -224,7 +278,7 @@ int Window::initialize(DisplaySettings* settings) {
} else {
logger.error() << "failed to initialize GLEW:\n"
<< glewGetErrorString(glewErr);
return -1;
return nullptr;
}
}
@ -283,7 +337,7 @@ int Window::initialize(DisplaySettings* settings) {
}
standard_cursors[i] = glfwCreateStandardCursor(cursor);
}
return 0;
return std::make_unique<GLFWInput>();
}
void Window::clear() {
@ -467,10 +521,6 @@ std::unique_ptr<ImageData> Window::takeScreenshot() {
);
}
const char* Window::getClipboardText() {
return glfwGetClipboardString(window);
}
void Window::setClipboardText(const char* text) {
glfwSetClipboardString(window, text);
}

4
src/window/Window.hpp
View File

@ -9,13 +9,14 @@
#include "typedefs.hpp"
class ImageData;
class Input;
struct DisplaySettings;
namespace Window {
extern uint width;
extern uint height;
int initialize(DisplaySettings* settings);
std::unique_ptr<Input> initialize(DisplaySettings* settings);
void terminate();
void viewport(int x, int y, int width, int height);
@ -41,7 +42,6 @@ namespace Window {
void setBgColor(glm::vec3 color);
void setBgColor(glm::vec4 color);
double time();
const char* getClipboardText();
void setClipboardText(const char* text);
DisplaySettings* getSettings();
void setIcon(const ImageData* image);

77
src/window/input.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include <string>
#include <glm/vec2.hpp>
#include "util/HandlersList.hpp"
@ -143,7 +144,7 @@ struct Binding {
int code;
bool state = false;
bool justChange = false;
bool enable = true;
bool enabled = true;
Binding() = default;
Binding(inputtype type, int code) : type(type), code(code) {
@ -173,3 +174,77 @@ struct Binding {
return "<unknown input type>";
}
};
class Bindings {
std::unordered_map<std::string, Binding> bindings;
public:
bool active(const std::string& name) const {
const auto& found = bindings.find(name);
if (found == bindings.end()) {
return false;
}
return found->second.active();
}
bool jactive(const std::string& name) const {
const auto& found = bindings.find(name);
if (found == bindings.end()) {
return false;
}
return found->second.jactive();
}
Binding* get(const std::string& name) {
const auto found = bindings.find(name);
if (found == bindings.end()) {
return nullptr;
}
return &found->second;
}
void bind(const std::string& name, inputtype type, int code) {
bindings.try_emplace(name, Binding(type, code));
}
auto& getAll() {
return bindings;
}
};
struct CursorState {
bool locked = false;
glm::vec2 pos {};
glm::vec2 delta {};
};
class Input {
public:
virtual ~Input() = default;
virtual void pollEvents() = 0;
virtual const char* getClipboardText() const = 0;
virtual int getScroll() = 0;
virtual Binding& requireBinding(const std::string& name) = 0;
virtual bool pressed(keycode keycode) const = 0;
virtual bool jpressed(keycode keycode) const = 0;
virtual bool clicked(mousecode mousecode) const = 0;
virtual bool jclicked(mousecode mousecode) const = 0;
virtual CursorState getCursor() const = 0;
virtual Bindings& getBindings() = 0;
virtual const Bindings& getBindings() const = 0;
virtual observer_handler addKeyCallback(keycode key, KeyCallback callback) = 0;
observer_handler addCallback(const std::string& name, KeyCallback callback) {
return requireBinding(name).onactived.add(callback);
}
};