1057 lines
36 KiB
C++
1057 lines
36 KiB
C++
/**
|
|
* This file is part of RenderD7
|
|
* Copyright (C) 2021-2024 NPI-D7, tobid7
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <ctime>
|
|
#include <renderd7/Color.hpp>
|
|
#include <renderd7/DrawV2.hpp>
|
|
#include <renderd7/Hid.hpp>
|
|
#include <renderd7/Message.hpp>
|
|
#include <renderd7/Overlays.hpp>
|
|
#include <renderd7/UI7.hpp>
|
|
#include <renderd7/internal_db.hpp>
|
|
#include <unordered_map>
|
|
|
|
template <typename T>
|
|
inline T d7max(T a, T b) {
|
|
return a > b ? a : b;
|
|
}
|
|
|
|
template <typename T>
|
|
inline T d7min(T a, T b) {
|
|
return a < b ? a : b;
|
|
}
|
|
|
|
// As the 3ds doesn't support std::chrono
|
|
#ifdef __3DS__
|
|
/// @brief 3ds System Ticks per milli second
|
|
/// Already defined in FTrace ik but
|
|
/// I Want to make UI7 and Draw2 more
|
|
/// Independent of the main RenderD7 api
|
|
#define TICKS_PER_MSEC 268111.856
|
|
#include <3ds.h>
|
|
#define __get_time() (float)svcGetSystemTick() / (float)TICKS_PER_MSEC
|
|
#else
|
|
#include <chrono>
|
|
#define __get_time() \
|
|
std::chrono::duration_cast<std::chrono::milliseconds>( \
|
|
std::chrono::system_clock().now().time_since_epoch()) \
|
|
.count()
|
|
#endif
|
|
|
|
// Basement structs enums etc
|
|
struct UI7ID {
|
|
UI7ID(const std::string &id) {
|
|
real_id = id;
|
|
title = id;
|
|
if (id.substr(0, 2) == "##") {
|
|
title = "";
|
|
has_title = false;
|
|
}
|
|
// Ensure the id is lowercase
|
|
std::transform(real_id.begin(), real_id.end(), real_id.begin(),
|
|
[](unsigned char c) { return std::tolower(c); });
|
|
}
|
|
UI7ID() {
|
|
title = "";
|
|
real_id = "";
|
|
has_title = false;
|
|
}
|
|
|
|
std::string Title() { return title; }
|
|
|
|
std::string ID() { return real_id; }
|
|
|
|
bool operator==(const UI7ID &in) { return (real_id == in.real_id); }
|
|
|
|
bool operator!=(const UI7ID &in) { return !(*this == in); }
|
|
|
|
std::string title;
|
|
std::string real_id;
|
|
bool has_title;
|
|
};
|
|
|
|
using DrawCmdType = int;
|
|
enum DrawCmdType_ {
|
|
DrawCmdType_Skip,
|
|
DrawCmdType_Rect,
|
|
DrawCmdType_Triangle,
|
|
DrawCmdType_Text,
|
|
DrawCmdType_Debug,
|
|
};
|
|
|
|
struct DrawCmd;
|
|
void UI7CtxPushDebugCmd(std::shared_ptr<DrawCmd> ref);
|
|
|
|
struct DrawCmd {
|
|
DrawCmd(R7Vec4 r, RD7Color c) : rect(r), clr(c), type(DrawCmdType_Rect) {}
|
|
DrawCmd(R7Vec4 r, unsigned int c)
|
|
: rect(r), ovr_clr(c), type(DrawCmdType_Rect) {
|
|
clr = -1;
|
|
}
|
|
DrawCmd(R7Vec4 r, R7Vec2 a, RD7Color c)
|
|
: rect(r), add_coords(a), clr(c), type(DrawCmdType_Triangle) {}
|
|
DrawCmd(R7Vec4 r, R7Vec2 a, unsigned int c)
|
|
: rect(r), add_coords(a), ovr_clr(c), type(DrawCmdType_Triangle) {
|
|
clr = -1;
|
|
}
|
|
DrawCmd(R7Vec2 p, const std::string &t, RD7Color c, RD7TextFlags f = 0)
|
|
: rect(p, R7Vec2()),
|
|
text(t),
|
|
clr(c),
|
|
text_flags(f),
|
|
type(DrawCmdType_Text) {}
|
|
DrawCmd(R7Vec2 p, const std::string &t, unsigned int c, RD7TextFlags f = 0)
|
|
: rect(p, R7Vec2()),
|
|
text(t),
|
|
ovr_clr(c),
|
|
text_flags(f),
|
|
type(DrawCmdType_Text) {
|
|
clr = -1;
|
|
}
|
|
// Empty Command
|
|
DrawCmd() {}
|
|
// For Debug API
|
|
DrawCmd(DrawCmd &thiz) {
|
|
auto cmd = DrawCmd::New();
|
|
cmd->add_coords = thiz.add_coords;
|
|
cmd->clr = thiz.clr;
|
|
cmd->ovr_clr = thiz.ovr_clr;
|
|
cmd->rect = thiz.rect;
|
|
cmd->stype = thiz.type;
|
|
cmd->text = thiz.text;
|
|
cmd->text_box = thiz.text_box;
|
|
cmd->text_flags = thiz.text_flags;
|
|
cmd->type = DrawCmdType_Debug;
|
|
cmd->screen = rd7i_current_screen;
|
|
UI7CtxPushDebugCmd(cmd);
|
|
}
|
|
R7Vec4 rect; // Position / Size
|
|
R7Vec2 add_coords; // Additional Coords
|
|
RD7Color clr; // Color
|
|
std::string text; // Text
|
|
DrawCmdType type; // DrawCmd Type
|
|
DrawCmdType stype; // Second Type
|
|
unsigned int ovr_clr; // Override Color (if not clr)
|
|
RD7TextFlags text_flags; // Flags for Text Rendering
|
|
R7Vec2 text_box; // Maximum text Box
|
|
bool screen;
|
|
|
|
// Process the Command
|
|
void Process() {
|
|
DrawCmd(*this);
|
|
if (type == DrawCmdType_Skip) {
|
|
return;
|
|
}
|
|
auto color = (clr == -1 ? ovr_clr : RenderD7::ThemeActive()->Get(clr));
|
|
if (type == DrawCmdType_Rect) {
|
|
RenderD7::Draw2::RFS(R7Vec2(rect.x, rect.y), R7Vec2(rect.z, rect.w),
|
|
color);
|
|
} else if (type == DrawCmdType_Triangle) {
|
|
RenderD7::Draw2::TriangleSolid(R7Vec2(rect.x, rect.y),
|
|
R7Vec2(rect.z, rect.w), add_coords, color);
|
|
} else if (type == DrawCmdType_Text) {
|
|
if (text_box.x || text_box.y) {
|
|
RenderD7::TextMaxBox(text_box);
|
|
}
|
|
RenderD7::Draw2::TextClr(R7Vec2(rect.x, rect.y), text, color, text_flags);
|
|
if (text_box.x || text_box.y) {
|
|
RenderD7::TextDefaultBox();
|
|
}
|
|
} else if (type == DrawCmdType_Debug) {
|
|
Debug();
|
|
}
|
|
}
|
|
void Debug() {
|
|
RenderD7::OnScreen(screen ? Top : Bottom);
|
|
if (stype == DrawCmdType_Skip && type != DrawCmdType_Debug) return;
|
|
// auto color = (clr == -1 ? ovr_clr : RenderD7::ThemeActive()->Get(clr));
|
|
if (stype == DrawCmdType_Rect) {
|
|
RenderD7::Draw2::TriangleLined(
|
|
R7Vec2(rect.x, rect.y), R7Vec2(rect.x + rect.z, rect.y),
|
|
R7Vec2(rect.x, rect.y + rect.w), 0xff0000ff);
|
|
RenderD7::Draw2::TriangleLined(R7Vec2(rect.x + rect.z, rect.y + rect.w),
|
|
R7Vec2(rect.x + rect.z, rect.y),
|
|
R7Vec2(rect.x, rect.y + rect.w),
|
|
0xff0000ff);
|
|
} else if (stype == DrawCmdType_Text) {
|
|
auto szs = RenderD7::GetTextDimensions(text);
|
|
if (text_flags & RD7TextFlags_AlignRight) {
|
|
rect.x -= szs.x;
|
|
}
|
|
RenderD7::Draw2::TriangleLined(
|
|
R7Vec2(rect.x, rect.y), R7Vec2(rect.x + szs.x, rect.y),
|
|
R7Vec2(rect.x, rect.y + szs.y), 0xff00ffff);
|
|
RenderD7::Draw2::TriangleLined(R7Vec2(rect.x + szs.x, rect.y + szs.y),
|
|
R7Vec2(rect.x + szs.x, rect.y),
|
|
R7Vec2(rect.x, rect.y + szs.y),
|
|
0xff00ffff);
|
|
}
|
|
}
|
|
// For Smart Pointer
|
|
using Ref = std::shared_ptr<DrawCmd>;
|
|
template <typename... args>
|
|
static Ref New(args &&...cargs) {
|
|
return std::make_shared<DrawCmd>(std::forward<args>(cargs)...);
|
|
}
|
|
};
|
|
|
|
struct UI7Menu {
|
|
UI7Menu() {}
|
|
UI7ID menuid; // menu ID
|
|
R7Vec2 cursor; // cursor
|
|
R7Vec2 cb; // backup cursor
|
|
R7Vec2 slc; // sameline cursor
|
|
float scrolling_offset = 0.f; // MenuScrolling Pos
|
|
bool enable_scrolling = false; // Menu Scrolling
|
|
float scrolling_mod = 0.f; // For Menu Scrolling effect
|
|
float tbh; // TabBar Height
|
|
bool show_scroolbar = true; // Show Scrollbar
|
|
bool has_touch = false; // To Disable touch on Top Screen
|
|
|
|
// SubMenu
|
|
std::string submenu;
|
|
|
|
// DrawLists
|
|
std::vector<DrawCmd::Ref> background;
|
|
std::vector<DrawCmd::Ref> main;
|
|
std::vector<DrawCmd::Ref> front;
|
|
|
|
R7Vec2 ms; // Max Size
|
|
R7Vec2 msr; // Max Size Real (Slider)
|
|
R7Vec2 mdp; // Mouse/Touch Initial pos
|
|
// For Smart Pointer
|
|
using Ref = std::shared_ptr<UI7Menu>;
|
|
static Ref New() { return std::make_shared<UI7Menu>(); }
|
|
};
|
|
|
|
struct UI7_Ctx {
|
|
UI7_Ctx() {
|
|
delta = 0.0f;
|
|
time = 0.0f;
|
|
is_activated = false;
|
|
_last = 0;
|
|
in_menu = false;
|
|
debugging = false;
|
|
}
|
|
float delta;
|
|
float time;
|
|
bool is_activated;
|
|
float _last;
|
|
bool in_menu;
|
|
bool debugging;
|
|
std::map<std::string, UI7Menu::Ref> menus;
|
|
std::vector<DrawCmd::Ref> debug_calls;
|
|
UI7Menu::Ref cm;
|
|
};
|
|
|
|
UI7_Ctx *ui7_ctx;
|
|
|
|
void UI7CtxPushDebugCmd(DrawCmd::Ref ref) {
|
|
ui7_ctx->debug_calls.push_back(ref);
|
|
}
|
|
|
|
bool UI7CtxValidate() {
|
|
if (ui7_ctx == nullptr) return false;
|
|
if (!ui7_ctx->is_activated) return false;
|
|
return true;
|
|
}
|
|
|
|
bool UI7CtxInMenu() {
|
|
if (!UI7CtxValidate()) return false;
|
|
return ui7_ctx->in_menu;
|
|
}
|
|
|
|
bool UI7CtxBeginMenu(const std::string &lb) {
|
|
if (!UI7CtxValidate()) return false;
|
|
auto id = UI7ID(lb);
|
|
if (ui7_ctx->menus.find(id.ID()) == ui7_ctx->menus.end())
|
|
ui7_ctx->menus.insert(std::make_pair(id.ID(), UI7Menu::New()));
|
|
ui7_ctx->cm = ui7_ctx->menus[id.ID()];
|
|
ui7_ctx->cm->menuid = id;
|
|
ui7_ctx->cm->cursor = R7Vec2(0, 0);
|
|
ui7_ctx->cm->has_touch = !rd7i_current_screen;
|
|
ui7_ctx->in_menu = true;
|
|
return true;
|
|
}
|
|
|
|
void UI7CtxEndMenu() {
|
|
if (!UI7CtxValidate()) return;
|
|
if (!UI7CtxInMenu()) return;
|
|
RenderD7::Ftrace::ScopedTrace tr("ui7", "EndMenu");
|
|
// Draw Scrollbar
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
int sw = (rd7i_current_screen ? 400 : 320);
|
|
int tsp = 5 + ui7_ctx->cm->tbh;
|
|
int szs = 240 - tsp - 5;
|
|
int lszs = 20; // Lowest Slider size
|
|
float slider_h = (szs - 4) * (static_cast<float>(szs - 4) /
|
|
static_cast<float>(ui7_ctx->cm->msr.y));
|
|
int slider_rh = d7min(d7max(slider_h, (float)lszs), (float)(szs - 4));
|
|
int slider_pos = d7min(
|
|
static_cast<float>(tsp + szs - slider_rh - 4),
|
|
d7max(
|
|
static_cast<float>(tsp),
|
|
static_cast<float>(tsp) +
|
|
static_cast<float>(
|
|
(szs) * (static_cast<float>(ui7_ctx->cm->scrolling_offset) /
|
|
static_cast<float>(ui7_ctx->cm->msr.y)))));
|
|
int slider_w = 4;
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(R7Vec2(sw - 12, tsp), R7Vec2(slider_w * 2, szs)),
|
|
RD7Color_List0));
|
|
ui7_ctx->cm->front.push_back(DrawCmd::New(
|
|
R7Vec4(R7Vec2(sw - 10, slider_pos + 2), R7Vec2(slider_w, slider_rh)),
|
|
RD7Color_Selector));
|
|
}
|
|
// Proccess DrawLists
|
|
for (auto &it : ui7_ctx->cm->background) it->Process();
|
|
for (auto &it : ui7_ctx->cm->main) it->Process();
|
|
for (auto &it : ui7_ctx->cm->front) it->Process();
|
|
ui7_ctx->cm->background.clear();
|
|
ui7_ctx->cm->main.clear();
|
|
ui7_ctx->cm->front.clear();
|
|
ui7_ctx->cm = nullptr;
|
|
ui7_ctx->in_menu = false;
|
|
}
|
|
|
|
void UI7CtxCursorMove(R7Vec2 size) {
|
|
if (!UI7CtxValidate()) return;
|
|
if (!UI7CtxInMenu()) return;
|
|
ui7_ctx->cm->slc = ui7_ctx->cm->cursor + R7Vec2(size.x + 5, 0);
|
|
ui7_ctx->cm->cursor.x = 5;
|
|
ui7_ctx->cm->cursor += R7Vec2(0, size.y + 5);
|
|
ui7_ctx->cm->ms = R7Vec2(ui7_ctx->cm->slc.x, ui7_ctx->cm->cursor.y);
|
|
// TODO: Correct that calculation
|
|
ui7_ctx->cm->msr = R7Vec2(ui7_ctx->cm->slc.x, ui7_ctx->cm->slc.y - 10);
|
|
}
|
|
|
|
namespace UI7 {
|
|
bool InBox(R7Vec2 inpos, R7Vec2 boxpos, R7Vec2 boxsize) {
|
|
if ((inpos.x > boxpos.x) && (inpos.y > boxpos.y) &&
|
|
(inpos.x < boxpos.x + boxsize.x) && (inpos.y < boxpos.y + boxsize.y))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void Init() {
|
|
// If Context is valid it makes no sense to reinit lol
|
|
if (UI7CtxValidate()) return;
|
|
ui7_ctx = new UI7_Ctx;
|
|
ui7_ctx->delta = 0.0f;
|
|
ui7_ctx->time = 0.0f;
|
|
ui7_ctx->_last = __get_time();
|
|
ui7_ctx->is_activated = true;
|
|
}
|
|
|
|
void Deinit() {
|
|
// Dont deinit something not initialized
|
|
// Please dont count how often init... was
|
|
// written wrong by me :(
|
|
if (!UI7CtxValidate()) return;
|
|
ui7_ctx->is_activated = false;
|
|
ui7_ctx->menus.clear();
|
|
delete ui7_ctx;
|
|
}
|
|
|
|
void Update() {
|
|
// Dont do anithing without ctx;
|
|
if (!UI7CtxValidate()) return;
|
|
ui7_ctx->debug_calls.clear();
|
|
float current = __get_time();
|
|
ui7_ctx->delta = (current - ui7_ctx->_last) / 1000.f;
|
|
ui7_ctx->_last = current;
|
|
ui7_ctx->time += ui7_ctx->delta;
|
|
}
|
|
|
|
float GetTime() {
|
|
if (!UI7CtxValidate()) return 0;
|
|
return ui7_ctx->time;
|
|
}
|
|
|
|
float GetDeltaTime() {
|
|
if (!UI7CtxValidate()) return 0;
|
|
return ui7_ctx->delta;
|
|
}
|
|
|
|
bool Button(const std::string &label, R7Vec2 size) {
|
|
bool ret = false;
|
|
if (!UI7CtxValidate()) return ret;
|
|
R7Vec2 textdim = RenderD7::GetTextDimensions(label);
|
|
if (size.x == 0) {
|
|
size.x = textdim.x + 8;
|
|
}
|
|
if (size.y == 0) {
|
|
size.y = textdim.y + 4;
|
|
}
|
|
RD7Color btn = RD7Color_Button;
|
|
R7Vec2 pos = GetCursorPos();
|
|
|
|
UI7CtxCursorMove(size);
|
|
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
R7Vec2 pb = pos;
|
|
pos -= R7Vec2(0, ui7_ctx->cm->scrolling_offset);
|
|
if (pos.y > 240 ||
|
|
(pos.y + size.y < ui7_ctx->cm->tbh - 5 && pb.y > ui7_ctx->cm->tbh))
|
|
return false;
|
|
}
|
|
|
|
if (ui7_ctx->cm->has_touch) {
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
|
|
InBox(RenderD7::Hid::GetLastTouchPosition(), pos, size)) {
|
|
btn = RD7Color_ButtonActive;
|
|
ret = true;
|
|
} else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held) &&
|
|
InBox(RenderD7::Hid::GetTouchPosition(), pos, size)) {
|
|
btn = RD7Color_ButtonHovered;
|
|
}
|
|
}
|
|
|
|
ui7_ctx->cm->main.push_back(DrawCmd::New(R7Vec4(pos, size), btn));
|
|
pos = R7Vec2(pos.x + size.x * 0.5f - textdim.x * 0.5,
|
|
pos.y + size.y * 0.5f - textdim.y * 0.5);
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(pos, label, RenderD7::ThemeActive()->AutoText(btn)));
|
|
return ret;
|
|
}
|
|
|
|
void Checkbox(const std::string &label, bool &c) {
|
|
if (!UI7CtxValidate()) return;
|
|
float sv = (RenderD7::TextGetSize() * 40) * 0.9;
|
|
R7Vec2 cbs = R7Vec2(sv, sv);
|
|
R7Vec2 txtdim = RenderD7::GetTextDimensions(label);
|
|
R7Vec2 inp = cbs + R7Vec2(txtdim.x + 5, 0);
|
|
RD7Color bg = RD7Color_FrameBg;
|
|
|
|
R7Vec2 pos = GetCursorPos();
|
|
|
|
UI7CtxCursorMove(inp);
|
|
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
R7Vec2 pb = pos;
|
|
pos -= R7Vec2(0, ui7_ctx->cm->scrolling_offset);
|
|
if (pos.y > 240 ||
|
|
(pos.y + cbs.y < ui7_ctx->cm->tbh - 5 && pb.y > ui7_ctx->cm->tbh))
|
|
return;
|
|
}
|
|
|
|
if (ui7_ctx->cm->has_touch) {
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
|
|
InBox(RenderD7::Hid::GetLastTouchPosition(), pos, inp)) {
|
|
bg = RD7Color_FrameBgHovered;
|
|
c = !c;
|
|
} else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held) &&
|
|
InBox(RenderD7::Hid::GetTouchPosition(), pos, inp)) {
|
|
bg = RD7Color_FrameBgHovered;
|
|
}
|
|
}
|
|
|
|
ui7_ctx->cm->main.push_back(DrawCmd::New(R7Vec4(pos, cbs), bg));
|
|
if (c == true) {
|
|
ui7_ctx->cm->main.push_back(DrawCmd::New(
|
|
R7Vec4(pos + R7Vec2(2, 2), cbs - R7Vec2(4, 4)), RD7Color_Checkmark));
|
|
}
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(pos + R7Vec2(cbs.x + 5, 1), label,
|
|
RenderD7::ThemeActive()->AutoText(RD7Color_Background)));
|
|
}
|
|
|
|
void Label(const std::string &label, RD7TextFlags flags) {
|
|
if (!UI7CtxValidate()) return;
|
|
R7Vec2 textdim = RenderD7::GetTextDimensions(label);
|
|
R7Vec2 pos = GetCursorPos();
|
|
auto upos = pos;
|
|
// Remove some y offset cause texts have some offset
|
|
UI7CtxCursorMove(textdim - R7Vec2(0, 4));
|
|
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
R7Vec2 pb = pos;
|
|
pos -= R7Vec2(0, ui7_ctx->cm->scrolling_offset);
|
|
if (pos.y > 240 ||
|
|
(pos.y + textdim.y < ui7_ctx->cm->tbh - 5 && pb.y > ui7_ctx->cm->tbh))
|
|
return;
|
|
}
|
|
|
|
float tbh = RenderD7::TextGetSize() * 40;
|
|
auto &list =
|
|
(upos.y + textdim.y < tbh) ? ui7_ctx->cm->front : ui7_ctx->cm->main;
|
|
|
|
list.push_back(DrawCmd::New(
|
|
pos, label,
|
|
RenderD7::ThemeActive()->AutoText(
|
|
(upos.y + textdim.y < tbh ? RD7Color_Header : RD7Color_Background)),
|
|
flags));
|
|
}
|
|
|
|
void Progressbar(float value) {
|
|
if (!UI7CtxValidate()) return;
|
|
R7Vec2 pos = GetCursorPos();
|
|
R7Vec2 size = R7Vec2((rd7i_current_screen ? 400 : 320) - (pos.x * 2), 20);
|
|
if (ui7_ctx->cm->show_scroolbar && ui7_ctx->cm->enable_scrolling)
|
|
size.x -= 16;
|
|
UI7CtxCursorMove(size);
|
|
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
R7Vec2 pb = pos;
|
|
pos -= R7Vec2(0, ui7_ctx->cm->scrolling_offset);
|
|
if (pos.y > 240 ||
|
|
(pos.y + size.y < ui7_ctx->cm->tbh - 5 && pb.y > ui7_ctx->cm->tbh))
|
|
return;
|
|
}
|
|
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(R7Vec4(pos, size), RD7Color_FrameBg));
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(R7Vec4(pos + R7Vec2(2, 2), size - R7Vec2(4, 4)),
|
|
RD7Color_FrameBgHovered));
|
|
if (!(value != value) && !(value < 0.0) && !(value > 1.0)) {
|
|
ui7_ctx->cm->main.push_back(DrawCmd::New(
|
|
R7Vec4(pos + R7Vec2(2, 2), R7Vec2((size.x - 4) * value, size.y - 4)),
|
|
RD7Color_Progressbar));
|
|
}
|
|
}
|
|
|
|
void Image(RenderD7::Image *img) {
|
|
if (!UI7CtxValidate()) return;
|
|
R7Vec2 pos = GetCursorPos();
|
|
UI7CtxCursorMove(R7Vec2(img->get_size().x, img->get_size().y));
|
|
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
R7Vec2 pb = pos;
|
|
pos -= R7Vec2(0, ui7_ctx->cm->scrolling_offset);
|
|
if (pos.y > 240 || (pos.y + img->get_size().y < ui7_ctx->cm->tbh - 5 &&
|
|
pb.y > ui7_ctx->cm->tbh))
|
|
return;
|
|
}
|
|
|
|
RenderD7::Draw2::Image(img, pos);
|
|
}
|
|
|
|
void BrowserList(const std::vector<std::string> &entrys, int &selection,
|
|
RD7TextFlags txtflags, R7Vec2 size, int max_entrys) {
|
|
if (!UI7CtxValidate()) return;
|
|
if (selection < 0) return;
|
|
float tmp_txt = RenderD7::TextGetSize();
|
|
RenderD7::TextDefaultSize();
|
|
R7Vec2 pos = GetCursorPos();
|
|
if (pos.y + 15 * max_entrys > 230) max_entrys = (int)((230 - pos.y) / 15);
|
|
if (size.x == 0) size.x = (rd7i_current_screen ? 400 : 320) - (pos.x * 2);
|
|
if (size.y == 0) size.y = (max_entrys * 15);
|
|
UI7CtxCursorMove(size);
|
|
int selindex = (selection < max_entrys ? selection : (max_entrys - 1));
|
|
|
|
for (int i = 0; i < max_entrys; i++) {
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(R7Vec4(pos + R7Vec2(0, 15 * i), R7Vec2(size.x, 15)),
|
|
(i % 2 == 0 ? RD7Color_List0 : RD7Color_List1)));
|
|
}
|
|
for (size_t i = 0;
|
|
i < ((entrys.size() < (size_t)max_entrys) ? entrys.size()
|
|
: (size_t)max_entrys);
|
|
i++) {
|
|
int list_index =
|
|
(selection < max_entrys ? i : (i + selection - (max_entrys - 1)));
|
|
if (i == (size_t)selindex) {
|
|
ui7_ctx->cm->main.push_back(DrawCmd::New(
|
|
R7Vec4(pos + R7Vec2(0, 15 * i), R7Vec2(size.x, 15)),
|
|
(unsigned int)RenderD7::Color::RGBA(RD7Color_Selector)
|
|
.fade_to(RD7Color_SelectorFade, std::sin(RenderD7::GetTime()))
|
|
.toRGBA()));
|
|
}
|
|
auto cmd =
|
|
DrawCmd::New(pos + R7Vec2(5, 15 * i), entrys[list_index],
|
|
RenderD7::ThemeActive()->AutoText(
|
|
selindex == (int)i
|
|
? RD7Color_Selector
|
|
: (i % 2 == 0 ? RD7Color_List0 : RD7Color_List1)),
|
|
txtflags | RD7TextFlags_Short);
|
|
cmd->text_box = R7Vec2(size.x, 15);
|
|
ui7_ctx->cm->main.push_back(cmd);
|
|
}
|
|
RenderD7::CustomTextSize(tmp_txt);
|
|
}
|
|
|
|
void InputText(const std::string &label, std::string &text,
|
|
const std::string &hint) {
|
|
if (!UI7CtxValidate()) return;
|
|
float sv = (RenderD7::TextGetSize() * 40) * 0.9;
|
|
R7Vec2 cbs = R7Vec2(144, sv);
|
|
R7Vec2 txtdim = RenderD7::GetTextDimensions(label);
|
|
R7Vec2 inp = cbs + R7Vec2(txtdim.x + 5, 0);
|
|
RD7Color bg = RD7Color_FrameBg;
|
|
auto id = UI7ID(label);
|
|
RD7KeyboardState kbd_state; // tmp (goes out of scope)
|
|
|
|
R7Vec2 pos = GetCursorPos();
|
|
UI7CtxCursorMove(inp);
|
|
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
R7Vec2 pb = pos;
|
|
pos -= R7Vec2(0, ui7_ctx->cm->scrolling_offset);
|
|
if (pos.y > 240 ||
|
|
(pos.y + cbs.y < ui7_ctx->cm->tbh - 5 && pb.y > ui7_ctx->cm->tbh))
|
|
return;
|
|
}
|
|
|
|
if (ui7_ctx->cm->has_touch) {
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
|
|
InBox(RenderD7::Hid::GetLastTouchPosition(), pos, inp)) {
|
|
bg = RD7Color_FrameBgHovered;
|
|
RenderD7::AddOvl(
|
|
std::make_unique<RenderD7::Ovl_Keyboard>(text, kbd_state, hint));
|
|
} else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held) &&
|
|
InBox(RenderD7::Hid::GetTouchPosition(), pos, inp)) {
|
|
bg = RD7Color_FrameBgHovered;
|
|
}
|
|
}
|
|
|
|
ui7_ctx->cm->main.push_back(DrawCmd::New(R7Vec4(pos, cbs), bg));
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(pos + R7Vec2(5, 1), (text != "" ? text : hint),
|
|
RenderD7::ThemeActive()->AutoText(bg)));
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(pos + R7Vec2(cbs.x + 5, 1), id.Title(),
|
|
RenderD7::ThemeActive()->AutoText(RD7Color_Background)));
|
|
}
|
|
|
|
bool BeginMenu(const std::string &title, R7Vec2 size, UI7MenuFlags flags) {
|
|
if (!UI7CtxValidate()) return false;
|
|
if (UI7CtxInMenu()) return false;
|
|
auto id = UI7ID(title);
|
|
auto ret = UI7CtxBeginMenu(title);
|
|
if (!ret) return ret;
|
|
bool titlebar = true;
|
|
if (size.x == 0) {
|
|
size.x = rd7i_current_screen ? 400 : 320;
|
|
}
|
|
if (size.y == 0) {
|
|
size.y = 240;
|
|
}
|
|
RD7TextFlags txtflags = 0;
|
|
float tbh = RenderD7::TextGetSize() * 40;
|
|
ui7_ctx->cm->tbh = tbh;
|
|
|
|
if (flags & UI7MenuFlags_NoTitlebar) {
|
|
titlebar = false;
|
|
ui7_ctx->cm->tbh = 0.f;
|
|
}
|
|
if (flags & UI7MenuFlags_TitleMid) txtflags = RD7TextFlags_AlignMid;
|
|
ui7_ctx->cm->enable_scrolling = (flags & UI7MenuFlags_Scrolling);
|
|
if (ui7_ctx->cm->enable_scrolling && !rd7i_current_screen) {
|
|
// Patch that sets scrolling to 0 if max pos is not out of screen
|
|
if (ui7_ctx->cm->scrolling_offset != 0.f && ui7_ctx->cm->ms.y < 235) {
|
|
ui7_ctx->cm->scrolling_offset = 0.f;
|
|
}
|
|
// Auto scroll back if last object is on screen
|
|
if (ui7_ctx->cm->scrolling_offset > ui7_ctx->cm->ms.y - 240 &&
|
|
ui7_ctx->cm->ms.y != 0 && ui7_ctx->cm->ms.y >= 235) {
|
|
ui7_ctx->cm->scrolling_offset -= 3;
|
|
// Patch to Scroll to perfect pos
|
|
if (ui7_ctx->cm->scrolling_offset < ui7_ctx->cm->ms.y - 240) {
|
|
ui7_ctx->cm->scrolling_offset = ui7_ctx->cm->ms.y - 240;
|
|
}
|
|
}
|
|
// Auto Scroll back if offset gets below 0
|
|
if (ui7_ctx->cm->scrolling_offset < 0) {
|
|
ui7_ctx->cm->scrolling_offset += 3;
|
|
if (ui7_ctx->cm->scrolling_offset > 0) ui7_ctx->cm->scrolling_offset = 0;
|
|
}
|
|
|
|
// Zero out scrolling_mod if it goeas < -40
|
|
// or > 40 over the max size
|
|
if (ui7_ctx->cm->scrolling_offset < -40 ||
|
|
ui7_ctx->cm->scrolling_offset > ui7_ctx->cm->ms.y - 200) {
|
|
ui7_ctx->cm->scrolling_mod = 0.f;
|
|
}
|
|
if (ui7_ctx->cm->has_touch) {
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Down)) {
|
|
// Set the mdp Value as Start Pos
|
|
ui7_ctx->cm->mdp = RenderD7::Hid::GetTouchPosition();
|
|
} else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up)) {
|
|
// 0 out the start pos
|
|
ui7_ctx->cm->mdp = R7Vec2();
|
|
}
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held)) {
|
|
// Set modifier
|
|
auto np = RenderD7::Hid::GetTouchPosition();
|
|
// Check if and do nothing if the scrolling ofset goes out of screen
|
|
if (ui7_ctx->cm->scrolling_offset < ui7_ctx->cm->ms.y - 200 &&
|
|
ui7_ctx->cm->scrolling_offset > -40) {
|
|
float cursor_mod = (ui7_ctx->cm->mdp.y - np.y);
|
|
if (ui7_ctx->cm->scrolling_mod <= 4.f &&
|
|
ui7_ctx->cm->scrolling_mod >= -4 && cursor_mod != 0.0f) {
|
|
if (cursor_mod > 0) {
|
|
ui7_ctx->cm->scrolling_mod = cursor_mod;
|
|
} else {
|
|
ui7_ctx->cm->scrolling_mod = cursor_mod;
|
|
}
|
|
}
|
|
}
|
|
// Update Start pos
|
|
ui7_ctx->cm->mdp = np;
|
|
}
|
|
}
|
|
// New Scrolling efect
|
|
if (ui7_ctx->cm->scrolling_mod != 0)
|
|
ui7_ctx->cm->scrolling_offset += ui7_ctx->cm->scrolling_mod;
|
|
// Slow out the effect
|
|
if (ui7_ctx->cm->scrolling_mod < 0.f) {
|
|
ui7_ctx->cm->scrolling_mod += 0.4f;
|
|
if (ui7_ctx->cm->scrolling_mod > 0.f) {
|
|
ui7_ctx->cm->scrolling_mod = 0.f;
|
|
}
|
|
} else if (ui7_ctx->cm->scrolling_mod > 0.f) {
|
|
ui7_ctx->cm->scrolling_mod -= 0.4f;
|
|
if (ui7_ctx->cm->scrolling_mod < 0.f) {
|
|
ui7_ctx->cm->scrolling_mod = 0.f;
|
|
}
|
|
}
|
|
} else {
|
|
// Set scrollingoffset and mod to 0 if not scrolling enabled
|
|
ui7_ctx->cm->scrolling_offset = 0.f;
|
|
ui7_ctx->cm->scrolling_mod = 0.f;
|
|
}
|
|
|
|
ui7_ctx->cm->background.push_back(
|
|
DrawCmd::New(R7Vec4(R7Vec2(), size), RD7Color_Background));
|
|
if (titlebar) {
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(R7Vec2(), R7Vec2(size.x, tbh)), RD7Color_Header));
|
|
ui7_ctx->cm->front.push_back(DrawCmd::New(
|
|
R7Vec2(5, 2), id.Title(),
|
|
RenderD7::ThemeActive()->AutoText(RD7Color_Header), txtflags));
|
|
}
|
|
|
|
SetCursorPos(R7Vec2(5, ui7_ctx->cm->tbh + 5));
|
|
|
|
return ret;
|
|
}
|
|
|
|
void EndMenu() { UI7CtxEndMenu(); }
|
|
|
|
void Grid(const std::string &name, const R7Vec2 &size, const R7Vec2 &entry_size,
|
|
void (*display_func)(void *, R7Vec2), void **data_array,
|
|
size_t num_entrys) {
|
|
if (!UI7CtxValidate()) return;
|
|
if (num_entrys <= 0) return;
|
|
if (data_array == nullptr) return;
|
|
R7Vec2 pos = GetCursorPos();
|
|
R7Vec2 cpos(pos);
|
|
|
|
int neh = std::floor(size.x / (entry_size.x + 4));
|
|
int nev = std::floor(size.y / (entry_size.y + 4));
|
|
|
|
// Inside Grid Offset
|
|
R7Vec2 igoff = R7Vec2();
|
|
if (neh >= 2 && nev >= 2) {
|
|
igoff = R7Vec2(
|
|
((size.x) / 2 - (((neh - 1) * (entry_size.x + 4)) + entry_size.x) / 2),
|
|
((size.y) / 2 - ((nev - 1) * ((entry_size.y + 4)) + entry_size.y) / 2));
|
|
}
|
|
// Y-Offset
|
|
int yoff = 0;
|
|
|
|
pos += igoff;
|
|
for (size_t i = 0; i < num_entrys; i++) {
|
|
display_func(data_array[i], pos);
|
|
if (ui7_ctx->debugging)
|
|
RenderD7::Draw2::Text(pos + R7Vec2(4, 4), std::to_string(i));
|
|
if (pos.x + (entry_size.x * 2) > (cpos.x + size.x) &&
|
|
pos.y + (entry_size.y * 2) > cpos.y + size.y) {
|
|
break;
|
|
} else if (pos.x + (entry_size.x * 2) > (cpos.x + size.x)) {
|
|
pos = R7Vec2(5 + igoff.x, pos.y + entry_size.y + 4);
|
|
yoff++;
|
|
} else {
|
|
pos += R7Vec2(entry_size.x + 4, 0);
|
|
}
|
|
}
|
|
|
|
UI7CtxCursorMove(size);
|
|
}
|
|
|
|
void ColorSelector(const std::string &label, unsigned int &color) {
|
|
if (!UI7CtxValidate()) return;
|
|
float sv = (RenderD7::TextGetSize() * 40) * 0.9;
|
|
R7Vec2 cbs = R7Vec2(sv, sv);
|
|
R7Vec2 txtdim = RenderD7::GetTextDimensions(label);
|
|
R7Vec2 inp = cbs + R7Vec2(txtdim.x + 5, 0);
|
|
auto outline =
|
|
RenderD7::Color::RGBA(color).is_light() ? 0xff000000 : 0xffffffff;
|
|
auto id = UI7ID(label);
|
|
|
|
R7Vec2 pos = GetCursorPos();
|
|
UI7CtxCursorMove(inp);
|
|
|
|
if (ui7_ctx->cm->enable_scrolling) {
|
|
R7Vec2 pb = pos;
|
|
pos -= R7Vec2(0, ui7_ctx->cm->scrolling_offset);
|
|
if (pos.y > 240 ||
|
|
(pos.y + cbs.y < ui7_ctx->cm->tbh - 5 && pb.y > ui7_ctx->cm->tbh))
|
|
return;
|
|
}
|
|
|
|
if (ui7_ctx->cm->has_touch) {
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
|
|
InBox(RenderD7::Hid::GetLastTouchPosition(), pos, inp)) {
|
|
ui7_ctx->cm->submenu = id.ID();
|
|
// Nullify scrolling mod to fix freeze
|
|
ui7_ctx->cm->scrolling_mod = 0.0f;
|
|
RenderD7::Hid::Lock();
|
|
RenderD7::Hid::Clear();
|
|
}
|
|
}
|
|
|
|
if (ui7_ctx->cm->submenu == id.ID()) {
|
|
// Base
|
|
auto clr = RenderD7::Color::RGBA(color);
|
|
// Keyboard logic
|
|
static bool inkbd;
|
|
static std::string kbd_txt;
|
|
static RD7KeyboardState kbd_state;
|
|
static int kbd_rgba = 0;
|
|
if (kbd_state == RD7KeyboardState_Confirm) {
|
|
int num = std::atoi(kbd_txt.c_str());
|
|
if (num < 0 || num > 255) {
|
|
RenderD7::PushMessage("UI7", "Error: Value must\nbe 0 - 255!");
|
|
} else {
|
|
if (kbd_rgba == 1) {
|
|
clr.m_r = num;
|
|
} else if (kbd_rgba == 2) {
|
|
clr.m_g = num;
|
|
} else if (kbd_rgba == 3) {
|
|
clr.m_b = num;
|
|
} else if (kbd_rgba == 4) {
|
|
clr.m_a = num;
|
|
}
|
|
}
|
|
}
|
|
if (kbd_state) {
|
|
inkbd = false;
|
|
kbd_state = RD7KeyboardState_None;
|
|
kbd_txt = "";
|
|
kbd_rgba = 0;
|
|
}
|
|
|
|
if (!inkbd) RenderD7::Hid::Unlock();
|
|
bool isunlock = false;
|
|
R7Vec2 npos = pos;
|
|
if (npos.y < ui7_ctx->cm->tbh + 2) npos.y = ui7_ctx->cm->tbh;
|
|
if (npos.y + 97 > 235) npos.y = 137;
|
|
// Input
|
|
if (ui7_ctx->cm->has_touch) {
|
|
auto ltp = RenderD7::Hid::GetLastTouchPosition();
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
|
|
(InBox(ltp, npos + R7Vec2(2, 2), cbs) ||
|
|
!InBox(ltp, npos, R7Vec2(107, 97)))) {
|
|
ui7_ctx->cm->submenu = "";
|
|
isunlock = true;
|
|
} else if (RenderD7::Hid::IsEvent("cancel", RenderD7::Hid::Down)) {
|
|
ui7_ctx->cm->submenu = "";
|
|
isunlock = true;
|
|
RenderD7::Hid::Clear();
|
|
}
|
|
if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up)) {
|
|
if (InBox(ltp, npos + R7Vec2(2, cbs.y * 3 + 4), R7Vec2(50, cbs.y))) {
|
|
inkbd = true;
|
|
kbd_txt = std::to_string(clr.m_r);
|
|
kbd_rgba = 1;
|
|
RenderD7::AddOvl(std::make_unique<RenderD7::Ovl_Keyboard>(
|
|
kbd_txt, kbd_state, "", RD7Keyboard_Numpad));
|
|
} else if (InBox(ltp, npos + R7Vec2(54, cbs.y * 3 + 4),
|
|
R7Vec2(50, cbs.y))) {
|
|
inkbd = true;
|
|
kbd_txt = std::to_string(clr.m_g);
|
|
kbd_rgba = 2;
|
|
RenderD7::AddOvl(std::make_unique<RenderD7::Ovl_Keyboard>(
|
|
kbd_txt, kbd_state, "", RD7Keyboard_Numpad));
|
|
} else if (InBox(ltp, npos + R7Vec2(2, cbs.y * 4 + 4),
|
|
R7Vec2(50, cbs.y))) {
|
|
inkbd = true;
|
|
kbd_txt = std::to_string(clr.m_b);
|
|
kbd_rgba = 3;
|
|
RenderD7::AddOvl(std::make_unique<RenderD7::Ovl_Keyboard>(
|
|
kbd_txt, kbd_state, "", RD7Keyboard_Numpad));
|
|
} else if (InBox(ltp, npos + R7Vec2(54, cbs.y * 4 + 4),
|
|
R7Vec2(50, cbs.y))) {
|
|
inkbd = true;
|
|
kbd_txt = std::to_string(clr.m_a);
|
|
kbd_rgba = 4;
|
|
RenderD7::AddOvl(std::make_unique<RenderD7::Ovl_Keyboard>(
|
|
kbd_txt, kbd_state, "", RD7Keyboard_Numpad));
|
|
}
|
|
}
|
|
color = clr.toRGBA();
|
|
}
|
|
if (!isunlock && !inkbd) RenderD7::Hid::Lock();
|
|
// Draw Frame
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(npos.x, npos.y, 107, 97), RD7Color_FrameBg));
|
|
// Draw Color Button
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(npos + R7Vec2(2, 2), cbs), outline));
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(npos + R7Vec2(4, 4), cbs - R7Vec2(4, 4)), color));
|
|
// Setup TextCommand with Short flag
|
|
auto cmd =
|
|
DrawCmd::New(npos + R7Vec2(cbs.x + 7, 1), label,
|
|
RenderD7::ThemeActive()->AutoText(RD7Color_FrameBg));
|
|
cmd->text_box = R7Vec2(93 - cbs.x - 5, 0);
|
|
cmd->text_flags |= RD7TextFlags_Short;
|
|
ui7_ctx->cm->front.push_back(cmd);
|
|
// Add luminance text
|
|
ui7_ctx->cm->front.push_back(DrawCmd::New(
|
|
npos + R7Vec2(2, cbs.y + 4), "lum: " + std::to_string(clr.luminance()),
|
|
RenderD7::ThemeActive()->AutoText(RD7Color_FrameBg)));
|
|
// Add Hex value
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(npos + R7Vec2(2, cbs.y * 2 + 4),
|
|
"hex: " + RenderD7::Color::RGBA2Hex(color),
|
|
RenderD7::ThemeActive()->AutoText(RD7Color_FrameBg)));
|
|
// Red
|
|
{
|
|
ui7_ctx->cm->front.push_back(DrawCmd::New(
|
|
R7Vec4(npos + R7Vec2(2, cbs.y * 3 + 4), R7Vec2(50, cbs.y)),
|
|
RD7Color_FrameBgHovered));
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(npos + R7Vec2(2, cbs.y * 3 + 4),
|
|
R7Vec2(50 * ((float)clr.m_r / 255.f), cbs.y)),
|
|
0xff0000ff));
|
|
|
|
auto ncmd = DrawCmd::New(npos + R7Vec2(2, cbs.y * 3 + 4),
|
|
"R: " + std::to_string(clr.m_r), RD7Color_Text);
|
|
ncmd->text_flags |= RD7TextFlags_AlignMid;
|
|
ncmd->text_box = R7Vec2(50, 0);
|
|
ui7_ctx->cm->front.push_back(ncmd);
|
|
}
|
|
// Green
|
|
{
|
|
ui7_ctx->cm->front.push_back(DrawCmd::New(
|
|
R7Vec4(npos + R7Vec2(54, cbs.y * 3 + 4), R7Vec2(50, cbs.y)),
|
|
RD7Color_FrameBgHovered));
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(npos + R7Vec2(54, cbs.y * 3 + 4),
|
|
R7Vec2(50 * ((float)clr.m_g / 255.f), cbs.y)),
|
|
0xff00ff00));
|
|
auto ncmd = DrawCmd::New(npos + R7Vec2(54, cbs.y * 3 + 4),
|
|
"G: " + std::to_string(clr.m_g), RD7Color_Text);
|
|
ncmd->text_flags |= RD7TextFlags_AlignMid;
|
|
ncmd->text_box = R7Vec2(50, 0);
|
|
ui7_ctx->cm->front.push_back(ncmd);
|
|
}
|
|
// Blue
|
|
{
|
|
ui7_ctx->cm->front.push_back(DrawCmd::New(
|
|
R7Vec4(npos + R7Vec2(2, cbs.y * 4 + 4), R7Vec2(50, cbs.y)),
|
|
RD7Color_FrameBgHovered));
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(npos + R7Vec2(2, cbs.y * 4 + 4),
|
|
R7Vec2(50 * ((float)clr.m_b / 255.f), cbs.y)),
|
|
0xffff0000));
|
|
|
|
auto ncmd = DrawCmd::New(npos + R7Vec2(2, cbs.y * 4 + 4),
|
|
"B: " + std::to_string(clr.m_b), RD7Color_Text);
|
|
ncmd->text_flags |= RD7TextFlags_AlignMid;
|
|
ncmd->text_box = R7Vec2(50, 0);
|
|
ui7_ctx->cm->front.push_back(ncmd);
|
|
}
|
|
// Alpha
|
|
{
|
|
ui7_ctx->cm->front.push_back(DrawCmd::New(
|
|
R7Vec4(npos + R7Vec2(54, cbs.y * 4 + 4), R7Vec2(50, cbs.y)),
|
|
RD7Color_FrameBgHovered));
|
|
ui7_ctx->cm->front.push_back(
|
|
DrawCmd::New(R7Vec4(npos + R7Vec2(54, cbs.y * 4 + 4),
|
|
R7Vec2(50 * ((float)clr.m_a / 255.f), cbs.y)),
|
|
0xffffffff));
|
|
|
|
auto ncmd = DrawCmd::New(npos + R7Vec2(54, cbs.y * 4 + 4),
|
|
"A: " + std::to_string(clr.m_a), RD7Color_Text);
|
|
ncmd->text_flags |= RD7TextFlags_AlignMid;
|
|
ncmd->text_box = R7Vec2(50, 0);
|
|
ui7_ctx->cm->front.push_back(ncmd);
|
|
}
|
|
}
|
|
|
|
ui7_ctx->cm->main.push_back(DrawCmd::New(R7Vec4(pos, cbs), outline));
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(R7Vec4(pos + R7Vec2(2, 2), cbs - R7Vec2(4, 4)), color));
|
|
ui7_ctx->cm->main.push_back(
|
|
DrawCmd::New(pos + R7Vec2(cbs.x + 5, 1), label,
|
|
RenderD7::ThemeActive()->AutoText(RD7Color_Background)));
|
|
}
|
|
|
|
bool BeginTree(const std::string &text) {
|
|
// TODO
|
|
return false;
|
|
}
|
|
|
|
void EndTree() {
|
|
// TODO
|
|
}
|
|
|
|
R7Vec2 GetCursorPos() {
|
|
if (!UI7CtxValidate()) return R7Vec2();
|
|
if (!UI7CtxInMenu()) return R7Vec2();
|
|
return ui7_ctx->cm->cursor;
|
|
}
|
|
|
|
void SetCursorPos(R7Vec2 cp) {
|
|
if (!UI7CtxValidate()) return;
|
|
if (!UI7CtxInMenu()) return;
|
|
ui7_ctx->cm->cb = ui7_ctx->cm->cursor;
|
|
ui7_ctx->cm->cursor = cp;
|
|
}
|
|
|
|
void RestoreCursor() {
|
|
if (!UI7CtxValidate()) return;
|
|
if (!UI7CtxInMenu()) return;
|
|
ui7_ctx->cm->cursor = ui7_ctx->cm->cb;
|
|
}
|
|
|
|
void SameLine() {
|
|
if (!UI7CtxValidate()) return;
|
|
if (!UI7CtxInMenu()) return;
|
|
ui7_ctx->cm->cursor = ui7_ctx->cm->slc;
|
|
}
|
|
|
|
void Debug() {
|
|
if (!UI7CtxValidate()) return;
|
|
if (ui7_ctx->debugging) {
|
|
for (auto &it : ui7_ctx->debug_calls) {
|
|
it->Process();
|
|
}
|
|
}
|
|
}
|
|
|
|
float GetScrollingOffset() {
|
|
if (!UI7CtxValidate()) return 0.f;
|
|
if (!UI7CtxInMenu()) return 0.f;
|
|
return ui7_ctx->cm->scrolling_offset;
|
|
}
|
|
|
|
bool &IsDebugging() {
|
|
if (!UI7CtxValidate()) {
|
|
// Return a Default Val
|
|
static bool t = false;
|
|
return t;
|
|
}
|
|
return ui7_ctx->debugging;
|
|
}
|
|
|
|
} // namespace UI7
|