tobid7/palladium
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects Releases Wiki Activity

# Stage 2.2

Browse Source 
- Move Timer to core
- Use Timer for app_time
- Fix Deltatime Bug in App
- Add HwInfo to lib3ds (stolen from hbloader 2 pd-rewrite port)
- Add GetSystemLanguage to lib3ds
- Add Net Header for pd-net (still need to find a way to make this working)
- Add base Decoder and Player Headers for pd-sound
- Add Mp3 Decoder (useless and untested yet)
- Add GetDataDirectory to App
- Add InitFLag to App for HwInfo
- Actually write the Timer class
- Rework the UI7 Theme API to use SmartCtor
- UI7::Menu::JoinAlign: Use a loop to determinate max width for centering a group
- Add some Doctumentation around UI7::Menu
This commit is contained in:
tobid7
2025-02-28 19:49:24 +01:00
parent f9a1d8aefb
commit debedf59c6
27 changed files with 840 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/pd.hpp
View File

@ -29,6 +29,7 @@ SOFTWARE.
#include <pd/core/io.hpp>
#include <pd/core/strings.hpp>
#include <pd/core/sys.hpp>
#include <pd/core/timer.hpp>
#include <pd/core/timetrace.hpp>
// Graphics
#include <pd/lithium/renderer.hpp>
@ -49,12 +50,15 @@ SOFTWARE.
#include <pd/overlays/settings.hpp>
// UI7
#include <pd/ui7/ui7.hpp>
// Lib3ds
#include <pd/lib3ds/hwinfo.hpp>
#include <pd/lib3ds/memory.hpp>
#include <pd/lib3ds/os.hpp>
#include <pd/lib3ds/result_decoder.hpp>
// App
#include <pd/app/app.hpp>
#include <pd/app/error.hpp>
#include <pd/app/lang.hpp>
#include <pd/app/timer.hpp>
/// Setup these as non Namespaced access by default
#ifndef PD_MATH_NAMESPACED

18
include/pd/app/app.hpp
View File

@ -24,6 +24,7 @@ SOFTWARE.
*/
#include <pd/core/common.hpp>
#include <pd/core/timer.hpp>
#include <pd/core/timetrace.hpp>
#include <pd/lib3ds/drv_hid.hpp>
#include <pd/lithium/renderer.hpp>
@ -46,15 +47,16 @@ class App {
};
using AppInitFlags = u32;
enum AppInitFlags_ {
AppInitFlags_None = 0,
AppInitFlags_MountRomfs = 1 << 0,
AppInitFlags_InitGraphics = 1 << 1,
AppInitFlags_New3dsMode = 1 << 2,
AppInitFlags_InitGraphicsNoC3D = 1 << 3,
AppInitFlags_InitLithium = 1 << 4,
AppInitFlags_None = 0, /// Do nothing (probably a useles ability)
AppInitFlags_MountRomfs = 1 << 0, /// Mount Romfs on PreInit
AppInitFlags_InitGraphics = 1 << 1, /// Default Init Graphics for GPU use
AppInitFlags_New3dsMode = 1 << 2, /// Enable New3DS Speedup
AppInitFlags_InitGraphicsNoC3D = 1 << 3, /// Init GFX for Buf Modification
AppInitFlags_InitLithium = 1 << 4, /// Init 2D Rendering Engine
/// I dont have a name for this one yet
/// It Inits Internal Directory structure
AppInitFlags_UnnamedOption1 = 1 << 5,
AppInitFlags_InitHwInfo = 1 << 6, /// Init HwInfo from lib3ds
AppInitFlags_Default = AppInitFlags_MountRomfs | AppInitFlags_InitGraphics |
AppInitFlags_New3dsMode | AppInitFlags_InitLithium,
};
@ -95,6 +97,8 @@ class App {
void FeatureDisable(AppFlags flags) { runtimeflags &= ~flags; }
AppFlags& GetFeatureSet() { return runtimeflags; }
std::string GetDataDirectory();
protected:
Screen::Ref Top;
Screen::Ref Bottom;
@ -110,8 +114,8 @@ class App {
MessageMgr::Ref msg_mgr;
OverlayMgr::Ref overlay_mgr;
Hid::Ref input_mgr;
Timer::Ref app_time;
u64 last_time;
float app_time;
float fps;
std::string name;

21
include/pd/app/timer.hpp → include/pd/core/timer.hpp
View File

@ -27,18 +27,21 @@ SOFTWARE.
#include <pd/core/sys.hpp>
namespace PD {
class Timer {
class Timer : public SmartCtor<Timer> {
public:
Timer() {}
Timer(bool auto_start = true);
~Timer() {}
void Start() {}
void Pause() {}
void Update() {}
void Reset() { start_ = Sys::GetTime(); }
u64 Get() {}
void Rseume();
void Pause();
void Update();
void Reset();
bool IsRunning() const;
u64 Get();
double GetSeconds();
private:
u64 start_;
u64 now_;
u64 start;
u64 now;
bool is_running = false;
};
} // namespace PD

36
include/pd/lib3ds/hwinfo.hpp Normal file
View File

@ -0,0 +1,36 @@
#pragma once
/*
MIT License
Copyright (c) 2024 - 2025 René Amthor (tobid7)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <pd/core/common.hpp>
namespace PD {
namespace HwInfo {
void Init();
void Deinit();
bool IsCharging();
int GetBatteryPercentage();
int GetWifiLevel();
} // namespace HwInfo
} // namespace PD

32
include/pd/lib3ds/os.hpp Normal file
View File

@ -0,0 +1,32 @@
#pragma once
/*
MIT License
Copyright (c) 2024 - 2025 René Amthor (tobid7)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <pd/core/common.hpp>
namespace PD {
namespace Ctr {
std::string GetSystemLanguage();
} // namespace Ctr
} // namespace PD

72
include/pd/net/net.hpp Normal file
View File

@ -0,0 +1,72 @@
#pragma once
/*
MIT License
Copyright (c) 2024 - 2025 René Amthor (tobid7)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <pd/core/common.hpp>
#include <pd/external/json.hpp>
namespace PD {
class DownloadManager : public SmartCtor<DownloadManager> {
public:
using Error = u64;
enum Error_ {
Error_None, // Function Executed Successfully
Error_Memory, // Memory Allocation Error
Error_Write, // Unable to Write File
Error_StatusCode, // Error with Status Code
Error_Git, // Git Error
Error_CtrStatus, // 3ds Result Code
Error_Curl, // Curl Error
Error_Busy, // Another Download Taskl is already running
Error_Invalid, // Invalid Json struct
Error_NoWifi, // Console not connected to wifi
};
DownloadManager() {}
~DownloadManager() {}
static Error_ GetErrorCode(Error err) {
return (Error_)u32(err & 0xffffffff);
}
static int GetStatusCode(Error err) {
Error_ c = GetErrorCode(err);
if (c != Error_StatusCode && c != Error_CtrStatus && c != Error_Curl) {
return 0;
}
return u32(err >> 32);
}
Error Get(const std::string& url, std::string& res);
Error GetFile(const std::string& url, const std::string& res_path);
Error GetGitRelease(const std::string& url, const std::string& asset,
const std::string& path, bool pre);
Error GetAsJson(const std::string& url, nlohmann::json& res);
u64 ProgressCurrent() const { return current; }
u64 ProgressTotal() const { return total; }
private:
u64 current;
u64 total;
};
} // namespace PD

44
include/pd/sound/decoder.hpp Normal file
View File

@ -0,0 +1,44 @@
#pragma once
/*
MIT License
Copyright (c) 2024 - 2025 René Amthor (tobid7)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <pd/core/common.hpp>
namespace PD {
namespace Music {
class Decoder : public SmartCtor<Decoder> {
public:
Decoder() {}
virtual ~Decoder() {}
virtual int Init(const std::string& path) = 0;
virtual void Deinit() = 0;
virtual u32 GetSampleRate() = 0;
virtual u8 GetChannels() = 0;
virtual size_t GetBufSize() = 0;
virtual u64 Decode(u16* buf_address) = 0;
virtual size_t GetFileSamples() = 0;
};
} // namespace Music
} // namespace PD

62
include/pd/sound/metadata.hpp Normal file
View File

@ -0,0 +1,62 @@
#pragma once
/*
MIT License
Copyright (c) 2024 - 2025 René Amthor (tobid7)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <pd/core/common.hpp>
namespace PD {
namespace Music {
class MetaData {
public:
MetaData() {}
~MetaData() {}
std::string Name() const { return name; }
std::string Album() const { return album; }
std::string Year() const { return year; }
std::string Title() const { return title; }
std::string Artist() const { return artist; }
std::string Mdt() const { return mdt; }
std::string Path() const { return path; }
void Name(const std::string &v) { name = v; }
void Album(const std::string &v) { album = v; }
void Year(const std::string &v) { year = v; }
void Title(const std::string &v) { title = v; }
void Artist(const std::string &v) { artist = v; }
void Mdt(const std::string &v) { mdt = v; }
void Path(const std::string &v) { path = v; }
private:
const std::string unk = "Unknown";
std::string title = unk;
std::string album = unk;
std::string year = unk;
std::string name = unk;
std::string path = unk;
std::string artist = unk;
std::string mdt = unk;
};
} // namespace Music
} // namespace PD

52
include/pd/sound/mp3.hpp Normal file
View File

@ -0,0 +1,52 @@
#pragma once
/*
MIT License
Copyright (c) 2024 - 2025 René Amthor (tobid7)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <mpg123.h>
#include <pd/sound/decoder.hpp>
namespace PD {
namespace Music {
class Mp3Decoder : public Decoder {
public:
Mp3Decoder() {}
~Mp3Decoder() {}
int Init(const std::string& path) override;
void Deinit() override;
u32 GetSampleRate() override;
u8 GetChannels() override;
size_t GetBufSize() override;
u64 Decode(u16* buf_address) override;
size_t GetFileSamples() override;
private:
mpg123_handle* handle = nullptr;
size_t buf_size = 0;
u32 rate = 0;
u8 channels = 0;
};
} // namespace Music
} // namespace PD

52
include/pd/sound/player.hpp Normal file
View File

@ -0,0 +1,52 @@
#pragma once
/*
MIT License
Copyright (c) 2024 - 2025 René Amthor (tobid7)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <pd/lib3ds/memory.hpp>
#include <pd/sound/decoder.hpp>
#include <pd/sound/metadata.hpp>
namespace PD {
namespace Music {
class Player : public SmartCtor<Player> {
public:
Player() {}
~Player() {}
private:
MetaData meta;
size_t samples_total = 0;
size_t samples_played = 0;
size_t samples_per_sec = 0;
std::string file;
std::vector<signed short, LinearAllocator<signed short>> buffers[2];
ndspWaveBuf wave_buf[2] = {0};
bool last_buf = false;
int ret = -1;
bool done = false;
bool playing = false;
bool stop = false;
};
} // namespace Music
} // namespace PD

10
include/pd/ui7/container/container.hpp
View File

@ -38,9 +38,9 @@ class Container : public SmartCtor<Container> {
Container(const vec4& box) : pos(box.xy()), size(box.zw()) {}
~Container() {}
void Init(LI::Renderer::Ref r, UI7::DrawList::Ref l, UI7::Theme* lt) {
void Init(LI::Renderer::Ref r, UI7::DrawList::Ref l, UI7::Theme::Ref lt) {
list = l;
linked_theme = lt;
theme = lt;
ren = r;
}
@ -50,6 +50,9 @@ class Container : public SmartCtor<Container> {
vec2 GetPos() { return pos; }
vec2 GetSize() { return size; }
void SetParent(Container::Ref v) { parent = v; }
Container::Ref GetParent() { return parent; }
bool Skippable() const { return skippable; }
bool Removable() const { return rem; }
@ -72,8 +75,9 @@ class Container : public SmartCtor<Container> {
vec2 pos;
vec2 size;
UI7::DrawList::Ref list;
UI7::Theme* linked_theme;
UI7::Theme::Ref theme;
LI::Renderer::Ref ren;
Container::Ref parent;
u32 id = 0;
};
} // namespace UI7

115
include/pd/ui7/menu.hpp
View File

@ -34,8 +34,8 @@ namespace PD {
namespace UI7 {
class Menu : public SmartCtor<Menu> {
public:
Menu(ID id, Theme* tl, Hid::Ref h) {
linked_theme = tl;
Menu(ID id, Theme::Ref tl, Hid::Ref h) {
theme = tl;
this->inp = h;
this->id = id;
this->name = id.GetName();
@ -48,37 +48,97 @@ class Menu : public SmartCtor<Menu> {
};
~Menu() {}
/// Objects
/// Objects ///
/// @brief Render a Simple Label
/// @param label The text to draw
void Label(const std::string& label);
/// @brief Render a Button
/// @param label The buttons text
/// @return if the button was pressed
bool Button(const std::string& label);
/// @brief Render a Checkbox
/// @param label Label of the Checkbox
/// @param v A value to update
void Checkbox(const std::string& label, bool& v);
/// @brief Render an Image
/// @param img Texture reference of the image
/// @param size a Custom Size if needed
void Image(Texture::Ref img, vec2 size = 0.f);
/// Basic API
/// Basic API ///
/// @brief Add the Next object to the same line
void SameLine();
/// @brief Add a Separator Line
void Separator();
/// @brief Render a Separator Line with a Text
/// @todo determinate text position by current alignment
/// @param label The Text to show
void SeparatorText(const std::string& label);
/// @brief Put the last Added Object into the Joinlist
void Join();
/// @brief Add the Last element to the join list
/// and perform an alignment operation
/// @param a Alignment Oeration(s)
void JoinAlign(UI7Align a);
/// @brief Align the Last Object
/// @param a Alignment Operation
void AfterAlign(UI7Align a);
/// @brief Set a Temp alignment op for the next Object
/// @param a Alignment Operation
void NextAlign(UI7Align a) { tmpalign = a; }
/// @brief Align Every Single Object by this operationset
/// @param a Alignment
void PushAlignment(UI7Align a) { alignment = a; }
/// @brief Use default alignment
void PopAlignment() { alignment = UI7Align_Default; }
/// @brief Get a New Position depending on the Alignment
/// @param pos Current Position
/// @param size Object size
/// @param view Viewport [position and size]
/// @param a Alignment Operations
/// @return new position based on the alignment
static vec2 AlignPos(vec2 pos, vec2 size, vec4 view, UI7Align a);
/// @brief Returns a Reference to the theme
/// @return Reference to the base Theme of the context
Theme::Ref GetTheme() { return theme; }
/// @brief Directly return a Color by using the
/// m->ThemeColor(UI7Color_Text) for example
/// @param clr The Input UI7 Color
/// @return The 32bit color value
u32 ThemeColor(UI7Color clr) const { return theme->Get(clr); }
/// API for Custom Objects
/// @brief Handles the Position of Objects in Scrolling Menu
/// @note As Containers have their own FUnc to handle this, this
/// function is only useful to Render Live Objects whicch cannot be aligned
/// by the internal Alignment Api
/// @param pos position reference to write the new position to
/// @param size size of the Object
/// @return if the object can be skipped in rendering
bool HandleScrolling(vec2& pos, const vec2& size);
/// @brief Get the Cursor Position
/// @return Cursor Pos
vec2 Cursor() const { return cursor; }
/// @brief Set the Cursor position
/// @note The old Position can be restored with RestoreCursor
/// @param v New Position
void Cursor(const vec2& v) {
bcursor = cursor;
cursor = v;
}
/// @brief Restore to the last cursor Position
void RestoreCursor() {
cursor = bcursor;
bcursor = vec2();
}
/// @brief Return if a Vertical Scrollbar exists
bool HasVerticalScrollbar() { return scrollbar[1]; }
/// @brief Return if a Horizontal Scrollbar exists
bool HasHorizontalScrollbar() { return scrollbar[0]; }
/// @brief Get the Titlebar height
float TitleBarHeight() { return tbh; }
/// @brief Set a Custom Titlebar heigt
/// @note Could destroy some basic functionality
@ -86,39 +146,72 @@ class Menu : public SmartCtor<Menu> {
/// @brief Init the Cursor
/// @note Useful when using with a Custom TitlebarHeight
void CursorInit() { Cursor(vec2(5, tbh + 5)); }
/// @brief Move the Cursor for new Object
/// @param szs Size of the current Object
void CursorMove(const vec2& szs);
/// @brief Get the ViewArea of the Menu
vec4 ViewArea() const { return view_area; }
/// @brief Get the Main Area of the Menu
/// (only relevant for input)
vec4 MainArea() const { return main_area; }
/// @brief Set a MainArea for input
/// @param v Area where Objects can receive inputs
void MainArea(const vec4& v) { main_area = v; }
/// @brief Get The Scrolling offset
vec2 ScrollOffset() const { return scrolling_off; }
/// @brief Set a Scrolling offset
/// @param v Custom Scrolling offset
void ScrollOffset(const vec2& v) { scrolling_off = v; }
/// @brief Get the Current Scrollmodification value
vec2 ScrollMod() const { return scroll_mod; }
/// @brief Animated Scroll to Position
/// @param pos Destination Position
void ScrollTo(vec2 pos) {
scroll_anim.From(scrolling_off)
.To(pos)
.In(1.f)
.As(scroll_anim.EaseInOutSine);
}
/// @brief Check if Still in ScrollAnimation
bool IsAnimatedScroll() { return !scroll_anim.IsFinished(); }
/// Objects API
/// Objects API ///
/// @brief Push an object to the current ListHandler
/// @param obj Object reference to use
/// @return Reference to the Object (from a time
/// where ObjectPush(Container::New()) was used)
Container::Ref ObjectPush(Container::Ref obj);
/// @brief Search for an Object by an id
/// @param id 32 Bit hash/id
/// @return the found Object or nullptr
Container::Ref FindIDObj(u32 id);
/// Draw Lists
/// Draw Lists ///
/// @brief Background Layer Drawlist
DrawList::Ref BackList() { return back; }
/// @brief Setter for Background Layer Drawlist
void BackList(DrawList::Ref v) { back = v; }
/// @brief Main Layer Drawlist
DrawList::Ref MainList() { return main; }
/// @brief Setter for Main Layer Drawlist
void MainList(DrawList::Ref v) { main = v; }
/// @brief Foreground Layer Drawlist
DrawList::Ref FrontList() { return front; }
/// @brief Setter for Foreground Layer Drawlist
void FrontList(DrawList::Ref v) { front = v; }
/// Advanced
/// Advanced ///
/// @brief Display Debug Labels of the Menu
void DebugLabels();
/// Uneditable Stuff
/// Uneditable Stuff ///
/// @brief Menu Name
std::string GetName() const { return name; }
/// @brief Menu ID [Hash of the Name]
u32 GetID() const { return id; }
private:
@ -166,7 +259,7 @@ class Menu : public SmartCtor<Menu> {
bool scroll_allowed[2];
bool has_touch;
Menu::Ref submenu;
Container::Ref tmp_parent;
/// Objects API
std::vector<Container::Ref> objects;
@ -186,7 +279,7 @@ class Menu : public SmartCtor<Menu> {
vec2 last_size;
// Theme
Theme* linked_theme;
Theme::Ref theme;
// Input Reference
Hid::Ref inp;

2
include/pd/ui7/theme.hpp
View File

@ -48,7 +48,7 @@ enum UI7Color_ {
namespace PD {
namespace UI7 {
/// @brief Theme Class
class Theme {
class Theme : public SmartCtor<Theme> {
public:
public:
Theme() { Default(*this); }

14
include/pd/ui7/ui7.hpp
View File

@ -37,7 +37,7 @@ class Context : public SmartCtor<Context> {
Context(LI::Renderer::Ref ren, Hid::Ref hid) {
this->ren = ren;
this->inp = hid;
Theme::Default(theme);
theme = Theme::New();
back = DrawList::New(ren);
front = DrawList::New(ren);
}
@ -48,8 +48,14 @@ class Context : public SmartCtor<Context> {
Menu::Ref FindMenu(const ID& id);
void EndMenu();
/// Theme Management
Theme& GetTheme() { return theme; }
/// @brief Get Theme reference
/// @return Reference to the base Theme of the context
Theme::Ref GetTheme() { return theme; }
/// @brief Directly return a Color by using the
/// ctx->ThemeColor(UI7Color_Text) for example
/// @param clr The Input UI7 Color
/// @return The 32bit color value
u32 ThemeColor(UI7Color clr) const { return theme->Get(clr); }
/// @brief Update Context (Render menus)
/// @param delta deltatime
@ -85,7 +91,7 @@ class Context : public SmartCtor<Context> {
DrawList::Ref front;
DrawList::Ref back;
// Theme
Theme theme;
Theme::Ref theme;
// Promt Handler
};
} // namespace UI7