Add opt-in native Modern UI foundation and first desktop flow (by Codex)
This commit is contained in:
1 parent
a4a37f1cb2
commit
11a6356c1e
42 files changed
+5333
-9
No files matched your search
@@ -0,0 +1,859 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
#include "modern/ui/view.hpp"
|
||||
#include "content/package.hpp"
|
||||
#include "launch/game_data.hpp"
|
||||
#include "launch/process.hpp"
|
||||
#include "launch/rml_path.hpp"
|
||||
#include "launch/rml_video.hpp"
|
||||
#include "modern/ui/desktop.hpp"
|
||||
#include "modern/ui/gui_assets.hpp"
|
||||
#include "modern/ui/model.hpp"
|
||||
#include "modern/ui/ticket_popover.hpp"
|
||||
#include "version.hpp"
|
||||
#include <RmlUi/Core.h>
|
||||
#include <RmlUi/Core/Elements/ElementFormControl.h>
|
||||
#include <RmlUi_Platform_SDL.h>
|
||||
#include <SDL.h>
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <fstream>
|
||||
#include <functional>
|
||||
#include <iomanip>
|
||||
#include <nfd.hpp>
|
||||
#include <sstream>
|
||||
|
||||
namespace bmh::modern_ui {
|
||||
namespace {
|
||||
std::string esc(std::string_view value) { return editor::escaped(value); }
|
||||
std::string scalar(double n) {
|
||||
std::ostringstream s;
|
||||
s.imbue(std::locale::classic());
|
||||
s << n;
|
||||
return s.str();
|
||||
}
|
||||
std::string rect(double x, double y, double w, double h) {
|
||||
return "left:" + scalar(x) + "dp;top:" + scalar(y) + "dp;width:" + scalar(w) +
|
||||
"dp;height:" + scalar(h) + "dp;";
|
||||
}
|
||||
std::string btn(const std::string &action, const std::string &label,
|
||||
const std::string &css = {}, const std::string &attrs = {}) {
|
||||
return "<button data-action=\"" + esc(action) + "\" class=\"" + css + "\" " +
|
||||
attrs + ">" + label + "</button>";
|
||||
}
|
||||
const std::array<std::string, 31> routes = {
|
||||
"tables", "league", "strengths", "lineup", "achievements",
|
||||
"other", "friendlies", "postpone", "calendar", "indoor",
|
||||
"load", "save", "kickoff", "toto", "bank",
|
||||
"camp", "training", "transfer", "tactics", "settings",
|
||||
"scorers", "advertising", "stadium", "statistics", "environment",
|
||||
"fairplay", "highscore", "contracts", "balance", "newplayer",
|
||||
"news"};
|
||||
const std::array<std::string, 31> titles = {"Tabellen",
|
||||
"Ligaspiele",
|
||||
"Stärken",
|
||||
"Aufstellung",
|
||||
"Erfolge",
|
||||
"Übrige Spiele",
|
||||
"Freundschaftsspiele",
|
||||
"Verlegen",
|
||||
"Kalender",
|
||||
"Hallentabellen",
|
||||
"Laden",
|
||||
"Speichern",
|
||||
"Anstoß",
|
||||
"TOTO",
|
||||
"Bank",
|
||||
"Trainingslager",
|
||||
"Training",
|
||||
"Transfermarkt",
|
||||
"Taktik",
|
||||
"Einstellungen",
|
||||
"Spielerstatistiken",
|
||||
"Werbung",
|
||||
"Stadion",
|
||||
"Statistiken",
|
||||
"Umfeld",
|
||||
"Fairplay",
|
||||
"Highscore",
|
||||
"Verträge",
|
||||
"Bilanz",
|
||||
"Neuer Spieler",
|
||||
"Nachrichten"};
|
||||
std::string title(const std::string &route) {
|
||||
const auto i = std::find(routes.begin(), routes.end(), route);
|
||||
if (i != routes.end())
|
||||
return titles[size_t(i - routes.begin())];
|
||||
if (route == "newgame")
|
||||
return "Neues Spiel";
|
||||
if (route == "mods")
|
||||
return "Mod";
|
||||
if (route == "opening")
|
||||
return "Saisonvorbereitung";
|
||||
return "OpenBMH";
|
||||
}
|
||||
struct Picture {
|
||||
std::string token;
|
||||
int width = 1, height = 1;
|
||||
};
|
||||
class Renderer final : public rml::Renderer {
|
||||
GuiAssets &gui_;
|
||||
fs::path assets_;
|
||||
std::shared_ptr<const Catalog> world_;
|
||||
struct Entry {
|
||||
std::string key;
|
||||
bool world;
|
||||
int pixels;
|
||||
editor::images::Raster raster;
|
||||
};
|
||||
std::map<std::string, Entry> entries_;
|
||||
std::map<std::string, std::string> keys_;
|
||||
size_t serial_ = 0;
|
||||
|
||||
public:
|
||||
Renderer(rml::Video &video, GuiAssets &gui, fs::path assets)
|
||||
: rml::Renderer(video), gui_(gui), assets_(std::move(assets)) {}
|
||||
Picture local_image(const fs::path &file, int pixels) {
|
||||
const auto identity =
|
||||
editor::utf8(file) + ":" +
|
||||
std::to_string(fs::last_write_time(file).time_since_epoch().count());
|
||||
if (!keys_.contains(identity)) {
|
||||
auto raster = editor::images::decode(
|
||||
editor::read_file(file), editor::utf8(file.extension()), pixels);
|
||||
const auto token = "modern-image-" + std::to_string(serial_++) + ".png";
|
||||
entries_[token] = {identity, false, pixels, std::move(raster)};
|
||||
keys_[identity] = token;
|
||||
}
|
||||
const auto token = keys_.at(identity);
|
||||
const auto &r = entries_.at(token).raster;
|
||||
return {token, r.width, r.height};
|
||||
}
|
||||
void world(std::shared_ptr<const Catalog> value) {
|
||||
Rml::ReleaseTextures(this);
|
||||
entries_.clear();
|
||||
keys_.clear();
|
||||
world_ = std::move(value);
|
||||
}
|
||||
Picture image(const std::string &key, bool world = false, int pixels = 512) {
|
||||
const auto identity =
|
||||
(world ? "world:" : "gui:") + key + ":" + std::to_string(pixels);
|
||||
auto found = keys_.find(identity);
|
||||
if (found == keys_.end()) {
|
||||
auto token = "modern-image-" + std::to_string(serial_++) + ".png";
|
||||
editor::images::Raster raster;
|
||||
if (world) {
|
||||
if (!world_)
|
||||
return {};
|
||||
const auto bytes = world_->asset(key, pixels);
|
||||
if (bytes.first.empty())
|
||||
return {};
|
||||
raster = editor::images::decode(bytes.first, bytes.second, pixels);
|
||||
} else if (key.starts_with("icon.")) {
|
||||
const auto name = key.substr(5);
|
||||
if (name.empty() ||
|
||||
name.find_first_not_of("abcdefghijklmnopqrstuvwxyz-") != name.npos)
|
||||
return {};
|
||||
raster = editor::images::decode(
|
||||
editor::read_file(assets_ / "icons" / (name + ".svg")), ".svg",
|
||||
pixels);
|
||||
} else if (gui_.contains(key))
|
||||
raster = gui_.decode(key, pixels);
|
||||
else if (key == "background")
|
||||
raster = editor::images::decode(
|
||||
editor::read_file(assets_.parent_path() / "launcher" /
|
||||
"stadium.tga"),
|
||||
".tga", pixels);
|
||||
else
|
||||
return {};
|
||||
// Decode at source fidelity, then bound GPU storage to the requested
|
||||
// display detail.
|
||||
const auto largest = std::max(raster.width, raster.height);
|
||||
if (largest > pixels) {
|
||||
const double scale = double(pixels) / largest;
|
||||
editor::images::Raster small{
|
||||
std::max(1, int(std::round(raster.width * scale))),
|
||||
std::max(1, int(std::round(raster.height * scale))),
|
||||
{}};
|
||||
small.pixels.resize(size_t(small.width) * small.height * 4);
|
||||
SDL_Surface *source = SDL_CreateRGBSurfaceWithFormatFrom(
|
||||
raster.pixels.data(), raster.width, raster.height, 32,
|
||||
raster.width * 4, SDL_PIXELFORMAT_RGBA32);
|
||||
SDL_Surface *destination = SDL_CreateRGBSurfaceWithFormatFrom(
|
||||
small.pixels.data(), small.width, small.height, 32, small.width * 4,
|
||||
SDL_PIXELFORMAT_RGBA32);
|
||||
if (!source || !destination) {
|
||||
if (source)
|
||||
SDL_FreeSurface(source);
|
||||
if (destination)
|
||||
SDL_FreeSurface(destination);
|
||||
throw std::runtime_error(SDL_GetError());
|
||||
}
|
||||
SDL_SetSurfaceBlendMode(source, SDL_BLENDMODE_NONE);
|
||||
SDL_BlitScaled(source, nullptr, destination, nullptr);
|
||||
SDL_FreeSurface(source);
|
||||
SDL_FreeSurface(destination);
|
||||
raster = std::move(small);
|
||||
}
|
||||
entries_[token] = {key, world, pixels, std::move(raster)};
|
||||
keys_[identity] = token;
|
||||
found = keys_.find(identity);
|
||||
}
|
||||
const auto &r = entries_.at(found->second).raster;
|
||||
return {found->second, r.width, r.height};
|
||||
}
|
||||
Rml::TextureHandle LoadTexture(Rml::Vector2i &dimensions,
|
||||
const Rml::String &source) override {
|
||||
const auto token = editor::utf8(editor::path(source).filename());
|
||||
auto found = entries_.find(token);
|
||||
if (found == entries_.end())
|
||||
return rml::Renderer::LoadTexture(dimensions, source);
|
||||
auto pixels = found->second.raster.pixels;
|
||||
for (size_t i = 0; i < pixels.size(); i += 4)
|
||||
for (int c = 0; c < 3; ++c)
|
||||
pixels[i + c] =
|
||||
uint8_t((unsigned(pixels[i + c]) * pixels[i + 3] + 127) / 255);
|
||||
dimensions = {found->second.raster.width, found->second.raster.height};
|
||||
return GenerateTexture(pixels, dimensions);
|
||||
}
|
||||
};
|
||||
struct Mod {
|
||||
std::string name, type, error;
|
||||
fs::path file;
|
||||
Json manifest;
|
||||
};
|
||||
class App final : public Rml::EventListener {
|
||||
fs::path executable_, root_, assets_, gui_root_;
|
||||
launch::SaveMigrator migrate_;
|
||||
Config config_;
|
||||
GuiAssets gui_;
|
||||
rml::Video video_;
|
||||
rml::AssetFiles files_;
|
||||
SystemInterface_SDL system_;
|
||||
Renderer renderer_;
|
||||
TextInputMethodEditor_SDL ime_;
|
||||
Rml::Context *context_ = nullptr;
|
||||
Rml::ElementDocument *doc_ = nullptr;
|
||||
bool initialized_ = false, closed_ = false, dirty_ = true,
|
||||
needs_render_ = true;
|
||||
double scale_ = 1, canvas_left_ = 0, canvas_top_ = 0;
|
||||
std::string scene_ = "main", menu_, theme_ = "midnight", active_mod_,
|
||||
selected_mod_, notice_, country_ = "nation:de", league_,
|
||||
selected_club_;
|
||||
std::vector<Mod> mods_;
|
||||
std::shared_ptr<const Catalog> world_;
|
||||
std::unique_ptr<DemoSource> source_;
|
||||
std::unique_ptr<TicketPopover> ticket_;
|
||||
bool focus_ticket_ = false;
|
||||
float device_ratio_ = 1.f;
|
||||
Json desktop_ = Json::object(), saved_desktop_ = Json::object(),
|
||||
options_ = Json::object();
|
||||
Json managers_draft_ = Json::array(),
|
||||
start_options_ = {{"duration", 5}, {"difficulty", 3}, {"players", 1},
|
||||
{"mode", 3}, {"league", true}, {"world", true}};
|
||||
int manager_index_ = 0;
|
||||
bool manager_picker_ = false, adding_manager_ = false;
|
||||
struct Drag {
|
||||
bool active = false, moved = false;
|
||||
std::string id;
|
||||
float x = 0, y = 0;
|
||||
double left = 0, top = 0;
|
||||
};
|
||||
Drag drag_;
|
||||
bool suppress_click_ = false;
|
||||
std::vector<Json> undo_;
|
||||
std::function<void()> confirm_;
|
||||
std::string popup_, rendered_popup_;
|
||||
bool rendered_confirm_ = false;
|
||||
std::string popup_input_, popup_extra_, popup_accept_ = "Bestätigen";
|
||||
bool popup_has_input_ = false, quit_after_save_ = false;
|
||||
std::function<void(const std::string &)> text_accept_;
|
||||
bool context_open_ = false, context_dirty_ = false;
|
||||
std::string context_id_;
|
||||
int context_x_ = 0, context_y_ = 0;
|
||||
int opening_page_ = 0, draw_revealed_ = 0;
|
||||
bool draw_playing_ = true;
|
||||
uint64_t draw_at_ = 0;
|
||||
std::string settings_category_ = "display";
|
||||
Json draft_preferences_;
|
||||
std::map<std::string, std::string> selections_;
|
||||
Rml::Element *element(const std::string &id) const {
|
||||
return doc_->GetElementById(id);
|
||||
}
|
||||
std::string field(const std::string &id) const {
|
||||
auto *p = dynamic_cast<Rml::ElementFormControl *>(element(id));
|
||||
return p ? p->GetValue() : "";
|
||||
}
|
||||
Snapshot snap() const { return source_->snapshot(); }
|
||||
const Json &manager(const Snapshot &s) const {
|
||||
return s.state.at("managers").at(0);
|
||||
}
|
||||
const Json *club(const Snapshot &s) const {
|
||||
return s.world->find("clubs", manager(s).value("club", ""));
|
||||
}
|
||||
std::string cash(int64_t value) const {
|
||||
return money(value,
|
||||
world_ ? world_->manifest().value("currency", Json::object())
|
||||
: Json::object());
|
||||
}
|
||||
fs::path user_dir() const {
|
||||
const auto id = world_ ? world_->manifest().value("id", std::string("none"))
|
||||
: std::string("none");
|
||||
return root_ / "userdata" / "ui-demo" / content::sha256(id);
|
||||
}
|
||||
std::string img(const std::string &key, double w, double h,
|
||||
bool world = false, bool cover = false, int pixels = 512) {
|
||||
const auto p = renderer_.image(key, world, pixels);
|
||||
if (p.token.empty())
|
||||
return "<div style=\"width:" + scalar(w) + "dp;height:" + scalar(h) +
|
||||
"dp;\"></div>";
|
||||
double iw = w, ih = h;
|
||||
std::string crop;
|
||||
if (cover) {
|
||||
const auto a = double(p.width) / p.height, b = w / h;
|
||||
double x = 0, y = 0, sw = p.width, sh = p.height;
|
||||
if (a > b) {
|
||||
sw = sh * b;
|
||||
x = (p.width - sw) / 2;
|
||||
} else {
|
||||
sh = sw / b;
|
||||
y = (p.height - sh) / 2;
|
||||
}
|
||||
crop = " rect=\"" + scalar(x) + " " + scalar(y) + " " + scalar(sw) + " " +
|
||||
scalar(sh) + "\"";
|
||||
} else {
|
||||
const auto factor = std::min(w / p.width, h / p.height);
|
||||
iw = p.width * factor;
|
||||
ih = p.height * factor;
|
||||
}
|
||||
return "<div class=\"image-frame\" style=\"width:" + scalar(w) +
|
||||
"dp;height:" + scalar(h) + "dp;\"><img src=\"" + p.token + "\"" +
|
||||
crop + " style=\"width:" + scalar(iw) + "dp;height:" + scalar(ih) +
|
||||
"dp;\"/></div>";
|
||||
}
|
||||
std::string crest(const Json *c, double size) {
|
||||
return c ? img(c->value("crest", ""), size, size, true) : "";
|
||||
}
|
||||
std::string glyph(const std::string &name, double size) {
|
||||
return img("icon." + name, size, size, false, false, int(size));
|
||||
}
|
||||
std::string label(const Json *c, double size = 40) {
|
||||
return c ? "<span class=\"club-label\">" + crest(c, size) + "<span>" +
|
||||
esc(world_->name(*c)) + "</span></span>"
|
||||
: "";
|
||||
}
|
||||
std::string window(const std::string &heading, const std::string &content,
|
||||
bool close = true) {
|
||||
return "<div class=\"window\"><div class=\"titlebar\">" +
|
||||
(close ? btn("close", "<span>×</span>", "close")
|
||||
: "<span style=\"width:76dp;\"></span>") +
|
||||
"<h1>" + esc(heading) + "</h1></div><div class=\"content\">" +
|
||||
content + "</div></div>";
|
||||
}
|
||||
std::string
|
||||
select(const std::string &id,
|
||||
const std::vector<std::pair<std::string, std::string>> &rows,
|
||||
const std::string &value, const std::string &action = {}) {
|
||||
std::string out =
|
||||
"<select id=\"" + id + "\" data-change=\"" + action + "\">";
|
||||
for (const auto &[key, name] : rows)
|
||||
out += "<option value=\"" + esc(key) + "\" " +
|
||||
(key == value ? "selected" : "") + ">" + esc(name) + "</option>";
|
||||
return out + "</select>";
|
||||
}
|
||||
bool apply(const std::string &kind, const Json &value) {
|
||||
const auto r = source_->apply({source_->snapshot().revision, kind, value});
|
||||
if (!r.ok) {
|
||||
message("Die Eingabe konnte nicht übernommen werden: " + r.error);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void reset_popup() {
|
||||
popup_has_input_ = false;
|
||||
popup_input_.clear();
|
||||
popup_extra_.clear();
|
||||
popup_accept_ = "Bestätigen";
|
||||
text_accept_ = {};
|
||||
rendered_popup_.clear();
|
||||
}
|
||||
void message(const std::string &text) {
|
||||
reset_popup();
|
||||
popup_ = text;
|
||||
confirm_ = {};
|
||||
dirty_ = true;
|
||||
}
|
||||
void confirmation(const std::string &text, std::function<void()> accepted) {
|
||||
reset_popup();
|
||||
popup_ = text;
|
||||
confirm_ = std::move(accepted);
|
||||
dirty_ = true;
|
||||
}
|
||||
void text_dialog(const std::string &text, const std::string &initial,
|
||||
std::function<void(const std::string &)> accepted) {
|
||||
confirmation(text, {});
|
||||
popup_has_input_ = true;
|
||||
popup_input_ = initial;
|
||||
text_accept_ = std::move(accepted);
|
||||
dirty_ = true;
|
||||
}
|
||||
void refresh() {
|
||||
needs_render_ = true;
|
||||
dirty_ = true;
|
||||
}
|
||||
void collect_mods() {
|
||||
mods_.clear();
|
||||
const auto folder = root_ / "mods";
|
||||
if (!fs::exists(folder))
|
||||
return;
|
||||
for (const auto &entry : fs::directory_iterator(folder)) {
|
||||
if (!entry.is_directory() || entry.is_symlink() ||
|
||||
editor::utf8(entry.path().filename()).starts_with('.'))
|
||||
continue;
|
||||
Mod m{editor::utf8(entry.path().filename()),
|
||||
"",
|
||||
{},
|
||||
entry.path() / "content.obw",
|
||||
{}};
|
||||
try {
|
||||
auto store = editor::ArchiveStore::open(m.file);
|
||||
m.manifest = Json::parse(store->read("manifest.json"));
|
||||
m.type = Catalog::modern_manifest(m.manifest) ? "Modern" : "Classic";
|
||||
} catch (const std::exception &e) {
|
||||
m.error = e.what();
|
||||
m.type = "Unbekannt";
|
||||
}
|
||||
mods_.push_back(std::move(m));
|
||||
}
|
||||
std::sort(mods_.begin(), mods_.end(),
|
||||
[](const auto &a, const auto &b) { return a.name < b.name; });
|
||||
}
|
||||
Mod *mod(const std::string &name) {
|
||||
for (auto &m : mods_)
|
||||
if (m.name == name)
|
||||
return &m;
|
||||
return nullptr;
|
||||
}
|
||||
void load_world(const fs::path &file) {
|
||||
auto next = Catalog::open(file);
|
||||
auto demo = std::make_unique<DemoSource>(next);
|
||||
ticket_.reset();
|
||||
renderer_.world(next);
|
||||
world_ = std::move(next);
|
||||
source_ = std::move(demo);
|
||||
desktop_ = Json::object();
|
||||
ticket_ =
|
||||
std::make_unique<TicketPopover>(*context_, *doc_, *source_, [this] {
|
||||
focus_ticket_ = true;
|
||||
refresh();
|
||||
});
|
||||
league_ = world_->leagues("nation:de").empty()
|
||||
? ""
|
||||
: world_->leagues("nation:de").front()->value("id", "");
|
||||
selected_club_ = manager(snap()).value("club", "");
|
||||
}
|
||||
std::string main_menu() {
|
||||
const auto *m = mod(active_mod_);
|
||||
std::string out =
|
||||
"<div class=\"fill front-shade\"></div><div "
|
||||
"class=\"brand\"><p>FUSSBALLMANAGER</p><h1>Open<span>BMH</span></h1></"
|
||||
"div><div class=\"main-options\">";
|
||||
const std::array<std::pair<std::string, std::string>, 6> actions = {
|
||||
{{"new", "Neues Spiel"},
|
||||
{"load", "Spiel laden"},
|
||||
{"network", "Netzwerk"},
|
||||
{"mods", "Mod"},
|
||||
{"settings", "Einstellungen"},
|
||||
{"exit", "Beenden"}}};
|
||||
for (const auto &[key, name] : actions)
|
||||
out += btn(
|
||||
key, esc(name) + (key == "network" ? "<small>Demnächst</small>" : ""),
|
||||
{},
|
||||
key == "network" || (key == "new" && !m && !world_) ? "disabled"
|
||||
: "");
|
||||
out +=
|
||||
"</div><div class=\"front-footer\"><div><small>Aktive Mod</small><p>" +
|
||||
esc(m ? m->name
|
||||
: world_ ? world_->title()
|
||||
: "Keine Mod aktiviert") +
|
||||
"</p></div><small>v" + std::string(kOpenBmhVersion) +
|
||||
(m && m->type == "Classic" ? "" : " · Modern UI Demo") +
|
||||
"</small></div>";
|
||||
return out;
|
||||
}
|
||||
std::string mods_page() {
|
||||
if (selected_mod_.empty() && !mods_.empty())
|
||||
selected_mod_ = mods_.front().name;
|
||||
std::string left = "<h3 style=\"padding:28dp;\">Installierte Mods</h3><div "
|
||||
"class=\"list\" style=\"height:1310dp;\">";
|
||||
for (const auto &m : mods_)
|
||||
left += btn(
|
||||
"mod-select",
|
||||
"<span class=\"grow\">" + esc(m.name) + "</span><span>" +
|
||||
esc(m.type) + "</span>",
|
||||
std::string("row choice ") +
|
||||
(m.name == selected_mod_ ? "selected" : ""),
|
||||
"data-id=\"" + esc(m.name) +
|
||||
"\" style=\"width:100%;margin-bottom:12dp;min-height:120dp;\"");
|
||||
left += "</div>";
|
||||
std::string right;
|
||||
if (auto *m = mod(selected_mod_))
|
||||
right =
|
||||
"<div class=\"column\" style=\"padding:38dp;\">" +
|
||||
img("background", 1300, 400, false, true, 1600) + "<h2>" +
|
||||
esc(m->name) + "</h2><p class=\"muted\">" + esc(m->type) +
|
||||
(m->type == "Modern" ? " · Oberfläche bis zum Anstoß" : "") +
|
||||
"</p><p>" + esc(m->error) + "</p>" +
|
||||
btn("mod-activate", m->name == active_mod_ ? "Aktiv" : "Aktivieren",
|
||||
"primary", m->name == active_mod_ ? "disabled" : "") +
|
||||
"</div>";
|
||||
return window(
|
||||
"Mod",
|
||||
"<div class=\"row\" style=\"height:1560dp;align-items:stretch;\"><div "
|
||||
"class=\"panel\" style=\"width:1120dp;\">" +
|
||||
left + "</div><div class=\"panel grow\">" + right +
|
||||
"</div></div><div class=\"bottom-controls\">" +
|
||||
btn("import-modern", "OBW-Paket hinzufügen") +
|
||||
btn("import-classic", "BMH / Football Limited") +
|
||||
btn("mod-rename", "Umbenennen") + btn("mod-remove", "Löschen") +
|
||||
"</div>");
|
||||
}
|
||||
std::string render_desktop();
|
||||
void init_desktop();
|
||||
std::string widget(const std::string &, const Json &);
|
||||
std::string render_table(bool strengths = false, bool indoor = false);
|
||||
std::string render_camp();
|
||||
std::string render_settings();
|
||||
std::string render_save(bool save);
|
||||
std::string render_desktop_tools(const std::string &);
|
||||
void render_context();
|
||||
void context_menu(const std::string &id, int x, int y);
|
||||
void drag_event(Rml::Event &);
|
||||
std::string render_newgame();
|
||||
std::string render_manager();
|
||||
std::string render_opening();
|
||||
std::string render_menu(const std::string &);
|
||||
void dispatch(const std::string &, Rml::Element *);
|
||||
void change(Rml::Element *);
|
||||
void input(Rml::Element *);
|
||||
void resize() {
|
||||
int w, h, pw, ph;
|
||||
SDL_GetWindowSize(video_.window, &w, &h);
|
||||
video_.drawable_size(pw, ph);
|
||||
if (w <= 0 || h <= 0 || pw <= 0 || ph <= 0)
|
||||
return;
|
||||
scale_ = std::min(double(pw) / 3840, double(ph) / 2160);
|
||||
canvas_left_ = (pw - 3840 * scale_) / 2;
|
||||
canvas_top_ = (ph - 2160 * scale_) / 2;
|
||||
device_ratio_ = float(pw) / w;
|
||||
renderer_.SetViewport(pw, ph);
|
||||
context_->SetDimensions({pw, ph});
|
||||
context_->SetDensityIndependentPixelRatio(float(scale_));
|
||||
element("canvas")->SetProperty("left", scalar(canvas_left_) + "px");
|
||||
element("canvas")->SetProperty("top", scalar(canvas_top_) + "px");
|
||||
if (ticket_)
|
||||
ticket_->resize(device_ratio_);
|
||||
dirty_ = true;
|
||||
}
|
||||
void render() {
|
||||
if (ticket_)
|
||||
ticket_->close(false);
|
||||
context_open_ = false;
|
||||
context_dirty_ = true;
|
||||
doc_->SetClassNames(theme_);
|
||||
std::string markup;
|
||||
if (scene_ == "main")
|
||||
markup = main_menu();
|
||||
else if (scene_ == "mods")
|
||||
markup = mods_page();
|
||||
else if (scene_ == "newgame")
|
||||
markup = render_newgame();
|
||||
else if (scene_ == "manager")
|
||||
markup = render_manager();
|
||||
else if (scene_ == "opening")
|
||||
markup = render_opening();
|
||||
else if (source_)
|
||||
markup = render_desktop();
|
||||
if (!menu_.empty())
|
||||
markup += render_menu(menu_);
|
||||
element("canvas")->SetInnerRML(markup);
|
||||
const auto size = context_->GetDimensions();
|
||||
const auto background =
|
||||
img("background", size.x / scale_, size.y / scale_, false, true, 2048);
|
||||
element("background")->SetInnerRML(background);
|
||||
element("background")
|
||||
->SetProperty("filter", scene_ == "main" ? "none"
|
||||
: theme_ == "silver"
|
||||
? "saturate(0.2) brightness(0.9)"
|
||||
: theme_ == "matchday"
|
||||
? "saturate(0.13) brightness(0.56)"
|
||||
: "saturate(0.34) brightness(0.70)");
|
||||
needs_render_ = false;
|
||||
dirty_ = true;
|
||||
if (focus_ticket_) {
|
||||
if (auto *n = element("desktop-ticket"))
|
||||
n->Focus();
|
||||
focus_ticket_ = false;
|
||||
}
|
||||
}
|
||||
void render_popup() {
|
||||
if (popup_.empty()) {
|
||||
element("popup")->SetClass("visible", false);
|
||||
rendered_popup_.clear();
|
||||
return;
|
||||
}
|
||||
element("popup")->SetClass("visible", true);
|
||||
if (popup_ == rendered_popup_ && bool(confirm_) == rendered_confirm_)
|
||||
return;
|
||||
element("popup")->SetInnerRML(
|
||||
"<div class=\"fill popup-backdrop\"></div><div "
|
||||
"class=\"popup-box\"><h2>OpenBMH</h2><p>" +
|
||||
esc(popup_) + "</p>" +
|
||||
(popup_has_input_
|
||||
? "<input id=\"popup-text\" value=\"" + esc(popup_input_) +
|
||||
"\" style=\"width:100%;margin-bottom:38dp;\"/>"
|
||||
: "") +
|
||||
"<footer>" +
|
||||
btn("popup-close",
|
||||
confirm_ || text_accept_ ? "Abbrechen" : "Verstanden") +
|
||||
popup_extra_ +
|
||||
((confirm_ || text_accept_)
|
||||
? btn("popup-confirm", popup_accept_, "primary")
|
||||
: "") +
|
||||
"</footer></div>");
|
||||
rendered_popup_ = popup_;
|
||||
rendered_confirm_ = bool(confirm_);
|
||||
if (auto *button = element("popup")->QuerySelector("button"))
|
||||
button->Focus();
|
||||
}
|
||||
void frame() {
|
||||
if (ticket_)
|
||||
ticket_->update();
|
||||
if (needs_render_)
|
||||
render();
|
||||
render_popup();
|
||||
render_context();
|
||||
context_->Update();
|
||||
renderer_.Clear();
|
||||
renderer_.BeginFrame();
|
||||
context_->Render();
|
||||
renderer_.EndFrame();
|
||||
video_.present();
|
||||
dirty_ = false;
|
||||
}
|
||||
void screenshot(const fs::path &file) {
|
||||
frame();
|
||||
int w, h;
|
||||
auto bytes = video_.capture(w, h);
|
||||
fs::create_directories(file.parent_path());
|
||||
editor::write_atomic(file,
|
||||
editor::images::encode_png({w, h, std::move(bytes)}));
|
||||
}
|
||||
void load_fonts() {
|
||||
bool regular = false, bold = false;
|
||||
#ifdef _WIN32
|
||||
const char *base = std::getenv("WINDIR");
|
||||
if (base) {
|
||||
const auto folder = fs::path(base) / "Fonts";
|
||||
regular = Rml::LoadFontFace(rml::asset_path(folder / "segoeui.ttf"),
|
||||
"Modern", Rml::Style::FontStyle::Normal,
|
||||
Rml::Style::FontWeight::Normal);
|
||||
bold = Rml::LoadFontFace(rml::asset_path(folder / "segoeuib.ttf"),
|
||||
"Modern", Rml::Style::FontStyle::Normal,
|
||||
Rml::Style::FontWeight::Bold);
|
||||
}
|
||||
#elif defined(__APPLE__)
|
||||
const fs::path system = "/System/Library/Fonts/SFNS.ttf";
|
||||
if (fs::exists(system)) {
|
||||
regular = Rml::LoadFontFace(rml::asset_path(system), "Modern",
|
||||
Rml::Style::FontStyle::Normal,
|
||||
Rml::Style::FontWeight::Normal);
|
||||
bold = Rml::LoadFontFace(rml::asset_path(system), "Modern",
|
||||
Rml::Style::FontStyle::Normal,
|
||||
Rml::Style::FontWeight::Bold);
|
||||
}
|
||||
#else
|
||||
const fs::path fonts = fs::exists("/usr/share/fonts/truetype/liberation2")
|
||||
? "/usr/share/fonts/truetype/liberation2"
|
||||
: "/usr/share/fonts/truetype/liberation";
|
||||
if (fs::exists(fonts)) {
|
||||
regular = Rml::LoadFontFace(
|
||||
rml::asset_path(fonts / "LiberationSans-Regular.ttf"), "Modern",
|
||||
Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Normal);
|
||||
bold = Rml::LoadFontFace(
|
||||
rml::asset_path(fonts / "LiberationSans-Bold.ttf"), "Modern",
|
||||
Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Bold);
|
||||
}
|
||||
#endif
|
||||
if (!regular)
|
||||
regular = Rml::LoadFontFace(
|
||||
rml::asset_path(assets_ / "LatoLatin-Regular.ttf"), "Modern",
|
||||
Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Normal);
|
||||
if (!bold)
|
||||
bold = Rml::LoadFontFace(rml::asset_path(assets_ / "LatoLatin-Bold.ttf"),
|
||||
"Modern", Rml::Style::FontStyle::Normal,
|
||||
Rml::Style::FontWeight::Bold);
|
||||
if (!regular || !bold)
|
||||
throw std::runtime_error(
|
||||
"GUI-Schriften fehlen. Bitte das vollständige Paket entpacken.");
|
||||
}
|
||||
void script();
|
||||
|
||||
public:
|
||||
App(fs::path executable, launch::SaveMigrator migrate, Config config)
|
||||
: executable_(std::move(executable)), root_(executable_.parent_path()),
|
||||
assets_(root_ / "assets" / "modern"),
|
||||
gui_root_(config.gui_assets.empty() ? assets_ / "gui"
|
||||
: config.gui_assets),
|
||||
migrate_(std::move(migrate)), config_(std::move(config)),
|
||||
gui_(gui_root_),
|
||||
video_("OpenBMH", config_.width, config_.height, 960, 540),
|
||||
system_(video_.window), renderer_(video_, gui_, assets_) {
|
||||
try {
|
||||
Rml::SetSystemInterface(&system_);
|
||||
Rml::SetFileInterface(&files_);
|
||||
Rml::SetRenderInterface(&renderer_);
|
||||
Rml::SetTextInputHandler(&ime_);
|
||||
initialized_ = Rml::Initialise();
|
||||
if (!initialized_)
|
||||
throw std::runtime_error("RmlUI initialization failed");
|
||||
load_fonts();
|
||||
context_ =
|
||||
Rml::CreateContext("modern-ui", {config_.width, config_.height});
|
||||
if (!context_)
|
||||
throw std::runtime_error("Modern UI context failed");
|
||||
doc_ = context_->LoadDocument(rml::asset_path(assets_ / "modern.rml"));
|
||||
if (!doc_)
|
||||
throw std::runtime_error("Modern UI layout missing");
|
||||
for (const char *event :
|
||||
{"click", "dblclick", "change", "input", "keydown", "mousedown",
|
||||
"mouseup", "mousemove", "contextmenu"})
|
||||
doc_->AddEventListener(event, this);
|
||||
if(!config_.theme.empty())theme_ = config_.theme;
|
||||
if(theme_!="midnight"&&theme_!="silver"&&theme_!="matchday")throw editor::Error("Unbekanntes Modern-Theme.");
|
||||
collect_mods();
|
||||
if (!mods_.empty())
|
||||
active_mod_ = mods_.front().name;
|
||||
if (!config_.world.empty()) {
|
||||
load_world(config_.world);
|
||||
scene_ = config_.scene;
|
||||
if (scene_ != "main" && scene_ != "newgame" && scene_ != "manager" &&
|
||||
scene_ != "opening" && scene_ != "desktop") {
|
||||
menu_ = scene_;
|
||||
scene_ = "desktop";
|
||||
}
|
||||
}
|
||||
if (!config_.state.empty() && source_) {
|
||||
desktop_ = source_->load(config_.state);
|
||||
saved_desktop_ = desktop_;
|
||||
if(config_.theme.empty())theme_ = snap().state.at("preferences").value("theme", theme_);
|
||||
}
|
||||
if(source_&&!config_.theme.empty()){
|
||||
auto preferences=snap().state.at("preferences");preferences["theme"]=theme_;apply("preferences",preferences);
|
||||
}
|
||||
if (scene_ == "manager" && selections_["manager-name"].empty())
|
||||
selections_["manager-name"] = "Alex Berger";
|
||||
doc_->Show();
|
||||
resize();
|
||||
render();
|
||||
SDL_ShowWindow(video_.window);
|
||||
frame();
|
||||
} catch (...) {
|
||||
shutdown();
|
||||
throw;
|
||||
}
|
||||
}
|
||||
void shutdown() {
|
||||
ticket_.reset();
|
||||
if (doc_) {
|
||||
doc_->Close();
|
||||
doc_ = nullptr;
|
||||
}
|
||||
if (context_) {
|
||||
const auto name = context_->GetName();
|
||||
context_ = nullptr;
|
||||
Rml::RemoveContext(name);
|
||||
}
|
||||
if (initialized_) {
|
||||
Rml::Shutdown();
|
||||
initialized_ = false;
|
||||
}
|
||||
}
|
||||
~App() { shutdown(); }
|
||||
void ProcessEvent(Rml::Event &event) override;
|
||||
int run() {
|
||||
if (!config_.commands.empty())
|
||||
script();
|
||||
if (!config_.screenshot.empty()) {
|
||||
screenshot(config_.screenshot);
|
||||
return 0;
|
||||
}
|
||||
while (!closed_) {
|
||||
if (scene_ == "opening" && opening_page_ == 3 && draw_revealed_ < 64 &&
|
||||
draw_playing_ && SDL_GetTicks64() >= draw_at_ &&
|
||||
(SDL_GetWindowFlags(video_.window) & SDL_WINDOW_INPUT_FOCUS)) {
|
||||
++draw_revealed_;
|
||||
draw_at_ = SDL_GetTicks64() + 900;
|
||||
if (draw_revealed_ == 64)
|
||||
opening_page_ = 4;
|
||||
refresh();
|
||||
}
|
||||
if (needs_render_ || dirty_)
|
||||
frame();
|
||||
SDL_Event event;
|
||||
const auto timeout =
|
||||
int(std::clamp(context_->GetNextUpdateDelay(), 0.0, .2) * 1000);
|
||||
bool got = SDL_WaitEventTimeout(&event, timeout) != 0;
|
||||
while (got) {
|
||||
if (event.type == SDL_QUIT) {
|
||||
if (source_ && scene_ != "main") {
|
||||
dispatch("context-quit", nullptr);
|
||||
} else
|
||||
closed_ = true;
|
||||
} else {
|
||||
if (event.type == SDL_WINDOWEVENT)
|
||||
resize();
|
||||
int w, h, pw, ph;
|
||||
SDL_GetWindowSize(video_.window, &w, &h);
|
||||
video_.drawable_size(pw, ph);
|
||||
if (w > 0 && h > 0) {
|
||||
if (event.type == SDL_MOUSEMOTION) {
|
||||
event.motion.x = int(double(event.motion.x) * pw / w);
|
||||
event.motion.y = int(double(event.motion.y) * ph / h);
|
||||
}
|
||||
if (event.type == SDL_MOUSEBUTTONDOWN ||
|
||||
event.type == SDL_MOUSEBUTTONUP) {
|
||||
event.button.x = int(double(event.button.x) * pw / w);
|
||||
event.button.y = int(double(event.button.y) * ph / h);
|
||||
context_->ProcessMouseMove(event.button.x, event.button.y,
|
||||
RmlSDL::GetKeyModifierState());
|
||||
}
|
||||
}
|
||||
RmlSDL::InputEventHandler(context_, video_.window, event);
|
||||
dirty_ = true;
|
||||
}
|
||||
got = SDL_PollEvent(&event) != 0;
|
||||
}
|
||||
if (context_->GetNextUpdateDelay() <= 0)
|
||||
dirty_ = true;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
#include "modern/ui/controls.inc"
|
||||
#include "modern/ui/desktop_screens.inc"
|
||||
#include "modern/ui/screens.inc"
|
||||
} // namespace
|
||||
bool is_modern_world(const fs::path &file) {
|
||||
try {
|
||||
auto store = editor::ArchiveStore::open(file);
|
||||
return Catalog::modern_manifest(Json::parse(store->read("manifest.json")));
|
||||
} catch (const std::exception &) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
int run(const fs::path &executable, const launch::SaveMigrator &migrate,
|
||||
const Config &config) {
|
||||
App app(executable, migrate, config);
|
||||
return app.run();
|
||||
}
|
||||
} // namespace bmh::modern_ui
|
||||
Reference in new issue
Block a user