Adding and fixing stuff

- Fix HexChar2Int
- Remove some devisions in tween engine
- Add PathAdd function for x, y seperated instead of fvec2
- Readd text wrapping (rd7-palladium maybe)

.gitignore

@@ -0,0 +1,3 @@
+build/
+.cache
+.vscode

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "backends/desktop/glfw"]
+	path = backends/desktop/glfw
+	url = https://github.com/glfw/glfw

.vscode/c_cpp_properties.json

@@ -1,18 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "3DS | Windows",
-            "includePath": [
-                "${workspaceFolder}/**",
-                "C:/devkitpro/libctru/include/**",
-                "C:/devkitpro/devkitARM/include/**",
-                "C:/devkitpro/devkitARM/arm-none-eabi/include/**",
-                "C:/devkitpro/portlibs/3ds/include/**",
-                "/opt/devkitpro/libctru/include/**",
-                "/opt/devkitpro/portlibs/**"
-                
-            ]
-        }
-    ],
-    "version": 4
-} 

.vscode/settings.json

@@ -1,118 +0,0 @@
-{
-    "files.associations": {
-        "array": "cpp",
-        "*.tcc": "cpp",
-        "cctype": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "unordered_map": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
-        "algorithm": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "memory": "cpp",
-        "numeric": "cpp",
-        "type_traits": "cpp",
-        "fstream": "cpp",
-        "initializer_list": "cpp",
-        "iosfwd": "cpp",
-        "iostream": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "new": "cpp",
-        "optional": "cpp",
-        "ostream": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "string": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "typeinfo": "cpp",
-        "utility": "cpp",
-        "atomic": "cpp",
-        "bit": "cpp",
-        "bitset": "cpp",
-        "chrono": "cpp",
-        "codecvt": "cpp",
-        "condition_variable": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "deque": "cpp",
-        "forward_list": "cpp",
-        "map": "cpp",
-        "iomanip": "cpp",
-        "memory_resource": "cpp",
-        "ratio": "cpp",
-        "regex": "cpp",
-        "shared_mutex": "cpp",
-        "valarray": "cpp",
-        "random": "cpp",
-        "cuchar": "cpp",
-        "compare": "cpp",
-        "concepts": "cpp",
-        "numbers": "cpp",
-        "filesystem": "cpp",
-        "xstring": "cpp",
-        "charconv": "cpp",
-        "format": "cpp",
-        "ios": "cpp",
-        "list": "cpp",
-        "locale": "cpp",
-        "mutex": "cpp",
-        "stack": "cpp",
-        "stop_token": "cpp",
-        "thread": "cpp",
-        "xfacet": "cpp",
-        "xhash": "cpp",
-        "xiosbase": "cpp",
-        "xlocale": "cpp",
-        "xlocbuf": "cpp",
-        "xlocinfo": "cpp",
-        "xlocmes": "cpp",
-        "xlocmon": "cpp",
-        "xlocnum": "cpp",
-        "xloctime": "cpp",
-        "xmemory": "cpp",
-        "xstddef": "cpp",
-        "xtr1common": "cpp",
-        "xtree": "cpp",
-        "xutility": "cpp",
-        "queue": "cpp",
-        "semaphore": "cpp",
-        "hash_map": "cpp",
-        "set": "cpp",
-        "unordered_set": "cpp",
-        "source_location": "cpp",
-        "future": "cpp",
-        "cfenv": "cpp",
-        "cinttypes": "cpp",
-        "typeindex": "cpp",
-        "variant": "cpp",
-        "ranges": "cpp",
-        "span": "cpp",
-        "coroutine": "cpp",
-        "__bit_reference": "cpp",
-        "__config": "cpp",
-        "__debug": "cpp",
-        "__errc": "cpp",
-        "__hash_table": "cpp",
-        "__locale": "cpp",
-        "__mutex_base": "cpp",
-        "__node_handle": "cpp",
-        "__split_buffer": "cpp",
-        "__threading_support": "cpp",
-        "__tree": "cpp",
-        "__verbose_abort": "cpp",
-        "complex": "cpp"
-    }
-}

CHANGELOG.md

@@ -1,127 +0,0 @@
-# Palladium Changelog
-## 1.0.0
-- Rename Everyting to PD
-- R7Vec -> NVec
-- Switch from C2D to Lithium (LI7)
-- For the Rest See RenderD7 Changelog below
-- swr -> Rubidium
-- LIFont (TTF Font Renderer)
-- Implement shbin as c++ array
-- Larger Mesaage Box
-- Add Texture Loader
-- Update Image/Error and other sytems to Lithium
-- Remove Render2
-- Add Deltatime to every moving object
-- Restructure Project
-# RenderD7 Changelog
-## 0.9.5
-- Remove Npi Intro and NVID Api
-- Replace Toasts System with Message 
-- Added GetTime
-- Move from Draw to Render2 Api
-- Implement RD7Color and R7Vec2
-- Add new Features to Color::RGBA
-- Cleanup Code
-- Added RenderD7 Keyboard (Overlay)
-- Added Ftrace Overlay
-- Moved MetrikOVL into an Overlay
-- Removed Old Font/Text Handlers
-- Added UI7 (New UI Api)
-- Remove Old UI Api
-- Rewrite of RenderD7::Image
-- Internal Debugger/Database (IDB)
-- Removed BitmapPrinter
-- Added nimg and swr(render2nimg | SoftwareRender)
-- Removed Old Error/Message Handler
-- GetTextSize (extra buffer) + New TextShorter
-- Require specific FLAG for MemTrack
-- Replace all lodepng usage by stb_image
-- Move Asset Generator into single python script
-- Remove INI reader
-- Python based clangformat script
-- Move some Init code into functions to not use twice
-- Added Font class
-- Add LinearAllocator (for std)
-- Fix Crash in FilsSystem
-- Implement basic Theme System
-- Remove 0.9.4 Security
-- Tasks now based on std functional/thread
-- Add Network Support (Download Files, APi Requests)
-- Remove RD7TF
-- Add Cia Installer
-- Move from Init bool values to flags
-## 0.9.4
-- Implement new Security System To prevent from crashes
-- Implement Functiontrace for better Timing Tests
-- Implement MemAlloc Tracker (only size)
-- Add some new Overlays (not functional yet)
-- Complete Rewrite of Overlay System
-- Fixed the FrameEnd Crash
-- New System to get Hardware Info
-- Removed RenderD7 Super Reselution (800px mode)
-## 0.9.3
-- Completly Documented Everything
-- Fix typo in Sprite::getHeight
-- Remove Deprecated/Useless Stuff
-## 0.9.2
-- Add Nvid Support(v0.0.1)
-- Add Basic RenderD7 Splash
-- Faster Graphics Init
-- Fade Effects
-- Fix Changelog Screen 
-## 0.9.1
-- Fix Critical bug in Spritesheet animations
-- Fix RenderD7::Color::Hex (Major performance tweak)
-## 0.9.0
-- Remove Stupid try of Console
-- Add Services list 
-- Clean up Code
-- Added Minimal Init for hax2.x
-## 0.8.5
-- Fix Deltatime
-## 0.8.4
-- A lot of Fixes 
-- New Features for BitmapPrinter
-## 0.8.3
-- Added Overlaycount to Info
-- Addet ResultDecoder for errors
-## 0.8.2
-- Fix a lot of Stuff
-- Use c++17 std::filesystem for RenderD7::Filesystem
-## 0.8.1
-- Add abillity to Get Stdout as string to render it to the screen.
-## 0.8.0
-- Implement BitmapPrinter
-## 0.7.3
-- Implement Over Render Overlay Framework
-## 0.7.2
-- Implement MT to csv file saving
-- Add RGB2HEX
-## 0.7.1
-- Add the New Overlay Handler. Its Just in code and does nothing yet
-## 0.7.0
-- Made Big Progress In the MT Ovl but it still crashes On a 2nd C3D_FrameEnd                                                            \
-- Implement 800px but doesn't work that good
-## 0.6.2
-- Fix Crash when exiting through Home Menu.
-## 0.6.10
-- Rewrite Threadsystem
-- Improve framerate
-## 0.6.02
-- Fix Code in lang.hpp
-- Add Draw Text Left Function (Right since 0.7.0)
-- Add changelog
-## 0.6.01
-- Add Threading system
-## 0.6.0
-- Better Scene Management
-## 0.5.0
-- Fixed some Bugs!
-## 0.4.0 
-- Trying to fix Filesystem and Bugs
-## 0.3.0
-- Recreate D7-Core into RenderD7
-## 0.2.0
-- Trying to create Animations of Images instead of Sheets
-## 0.1.0
-- Inital Release of D7-Core sprite animation plugin

CMakeLists.txt

@@ -0,0 +1,36 @@
+cmake_minimum_required(VERSION 3.22)
+
+# Set Project
+project(palladium LANGUAGES C CXX VERSION 0.6.0)
+
+# Required to add this Variable
+set(PD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
+include(cmake/palladium.cmake)
+
+option(PD_BUILD_TESTS "Sets if TestApp and TestBench get build" OFF)
+option(PD_BUILD_SHARED "Build Shared Libraries" OFF)
+option(PD_BUILD_TOOLS "Build Palladium Tools" OFF)
+
+if(${PD_BUILD_TOOLS})
+    add_subdirectory(tools)
+endif()
+
+## Include Library Source
+
+add_subdirectory(pd/drivers)
+add_subdirectory(pd/core)
+add_subdirectory(pd/image)
+add_subdirectory(pd/external)
+add_subdirectory(pd/lithium)
+add_subdirectory(pd/ui7)
+
+add_library(palladium INTERFACE)
+target_link_libraries(palladium INTERFACE
+    pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
+)
+
+add_dependencies(palladium
+    pd-drivers pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
+)
+
+install(DIRECTORY include DESTINATION ".")

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 tobid7
+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
@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

Makefile

@@ -1,152 +0,0 @@
-#---------------------------------------------------------------------------------
-.SUFFIXES:
-#---------------------------------------------------------------------------------
-
-ifeq ($(strip $(DEVKITARM)),)
-$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
-endif
-
-include $(DEVKITARM)/3ds_rules
-
-export PD_MAJOR	:= 1
-export PD_MINOR	:= 0
-export PD_PATCH	:= 0
-
-VERSION	:=	$(PD_MAJOR).$(PD_MINOR).$(PD_PATCH)
-
-#---------------------------------------------------------------------------------
-# TARGET is the name of the output
-# BUILD is the directory where object files & intermediate files will be placed
-# SOURCES is a list of directories containing source code
-# DATA is a list of directories containing data files
-# INCLUDES is a list of directories containing header files
-#---------------------------------------------------------------------------------
-TARGET		:=	palladium
-SOURCES		:=	source source/base
-DATA		:=	data
-INCLUDES	:=	include
-
-#---------------------------------------------------------------------------------
-# options for code generation
-#---------------------------------------------------------------------------------
-ARCH	:=	-march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
-
-CFLAGS	:=	-g -Wall -Wno-psabi -Werror -mword-relocations \
-			-ffunction-sections -fdata-sections \
-			-fomit-frame-pointer -ffast-math \
-			$(ARCH) $(BUILD_CFLAGS)
-
-CFLAGS	+=	$(INCLUDE) -D__3DS__ -D_GNU_SOURCE=1
-
-CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -std=c++20
-
-ASFLAGS	:=	-g $(ARCH) $(DEFINES)
-
-#---------------------------------------------------------------------------------
-# list of directories containing libraries, this must be the top level containing
-# include and lib
-#---------------------------------------------------------------------------------
-LIBDIRS	:= $(PORTLIBS) $(CTRULIB) 
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(BUILD),$(notdir $(CURDIR)))
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
-CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
-SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
-BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES	:=	$(addsuffix .o,$(BINFILES)) \
-			$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-.PHONY: clean all doc
-
-#---------------------------------------------------------------------------------
-all: lib/libpalladium.a lib/libpalladiumd.a
-
-dist-bin: all
-	@tar --exclude=*~ -cjf palladium-$(VERSION).tar.bz2 include lib
-
-dist-src:
-	@tar --exclude=*~ -cjf palladium-src-$(VERSION).tar.bz2 include source Makefile
-
-dist: dist-src dist-bin
-
-install: dist-bin
-	mkdir -p $(DESTDIR)$(DEVKITPRO)/libctru
-	bzip2 -cd palladium-$(VERSION).tar.bz2 | tar -xf - -C $(DESTDIR)$(DEVKITPRO)/libctru
-
-lib:
-	@[ -d $@ ] || mkdir -p $@
-
-release:
-	@[ -d $@ ] || mkdir -p $@
-
-debug:
-	@[ -d $@ ] || mkdir -p $@
-
-lib/libpalladium.a : lib release $(SOURCES) $(INCLUDES)
-	@$(MAKE) BUILD=release OUTPUT=$(CURDIR)/$@ \
-	BUILD_CFLAGS="-DNDEBUG=1 -O3 -fomit-frame-pointer -fno-math-errno" \
-	DEPSDIR=$(CURDIR)/release \
-	--no-print-directory -C release \
-	-f $(CURDIR)/Makefile
-
-lib/libpalladiumd.a : lib debug $(SOURCES) $(INCLUDES)
-	@$(MAKE) BUILD=debug OUTPUT=$(CURDIR)/$@ \
-	BUILD_CFLAGS="-DDEBUG=1 -Og" \
-	DEPSDIR=$(CURDIR)/debug \
-	--no-print-directory -C debug \
-	-f $(CURDIR)/Makefile
-
-#---------------------------------------------------------------------------------
-clean:
-	@echo clean ...
-	@rm -fr release debug lib
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-$(OUTPUT)	:	$(OFILES)
-
-#---------------------------------------------------------------------------------
-%.bin.o	:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

README.md

@@ -1,62 +1,33 @@
 # Palladium
-Create README ? 
-# RenderD7 as Submodule (0.9.5+)
-To use RenderD7 just use this command: `git submodule add https://github.com/NPI-D7/RenderD7` and add `-b v0.9.5` for example for a specific version.
 
+**Framework / Engine to create Homebrew Apps / Games**
 
-And in Your Project Makefile add this
-```
-# Make Sure to Change this paths if your Submodule
-# is located somewhere else
-RENDERD7_SRC := RenderD7/source RenderD7/external
-RENDERD7_INC := RenderD7/include
-# Libraries used for RenderD7
-# if you already use -lm, -lctru etc place a # before -lm
-RENDERD7_LIBS := -lcurl -lmbedtls -lmbedx509 -lmbedcrypto -lz -lm -lcitro2dd -lcitro3d -lctru
-```
-Now you need to add it to your sources and includes
-```
-SOURCES		:=	source $(RENDERD7_SRC)
-INCLUDES	:=	source $(RENDERD7_INC)
+## Building
+
+Install Dependencies:
+
+```bash
+# This Command will install everything
+(dkp-)pacman -S --noconfirm 3ds-dev 3ds-portlibs
 ```
 
-Example from rd7tf
-### Installation (0.8.0-0.9.4) (OUTDATED)
-Download a Package From Releses Page
-`https://github.com/NPI-D7/RenderD7/releases/download/v0.9.4/renderd7.tar.bz2 -o renderd7.tar.bz2`
-Then Extract it to your Libraries Path
-`bzip2 -cd renderd7.tar.bz2 | tar -xf - -C path_to_your_libs`
-Finally put `-lrenderd7` to the First Place and add the path_to_your_libs
-```
-LIBS	:= -lrenderd7 -lcurl -lstdc++ -lm -lcitro2d -lcitro3d -lctru
-#---------------------------------------------------------------------------------
-# list of directories containing libraries, this must be the top level containing
-# include and lib
-#---------------------------------------------------------------------------------
-LIBDIRS	:= $(PORTLIBS) $(CTRULIB) ../path_to_your_libs
-```
-Make sure that `-lrenderd7` is before `-lcitro2d`, `-lcitro3d`, `-lctru`.
-Here an example tree
-```
-Example-App
-├── gfx
-├── libs
-│   ├── include
-│   │   ├── rd7.hpp
-│   │   └── renderd7
-│   └── lib
-│       ├── librenderd7.a
-│       └── librenderd7d.a
-├── Makefile
-├── romfs
-│   └── gfx
-└── src
-    └── main.cpp
-```
-# Credits
-- NPI-D7
-  - Tobi-D7 Main Dev
+Building:
 
-Some Icons are From
-https://icons8.de/
-See Subfolder Readmes
+If you want to have the lib in a projects `libs` dir or so you can simply add `-DCMAKE_INSTALL_PREFIX=./res` to the cmake command and copy the dirs from res to you libs folder
+
+```bash
+mkdir -p build
+cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release # Make sure to build in Release Mode (exept you want to debug some issues)
+make
+make install
+```
+
+## Credits
+
+| Icon | Username | Description |
+|---|---|---|
+| <img src="https://github.com/tobid7.png" alt="https://github.com/tobid7" width="48"/>                 | [tobid7](https://github.com/tobid7)                 | main dev of RenderD7, Palladium                               |
+| <img src="https://github.com/devkitpro.png" alt="https://github.com/devkitpro" width="48"/>           | [devkitpro](https://github.com/devkitpro)           | devkitarm, picasso, libctru and citro3d                       |
+| <img src="https://github.com/nothings.png" alt="https://github.com/nothings" width="48"/>             | [nothings](https://github.com/nothings)             | stb_image(_write) and stb_truetype                            |
+| <img src="https://github.com/nlohmann.png" alt="https://github.com/nlohmann" width="48"/>             | [nlohmann](https://github.com/nlohmann)             | for json.hpp                                                  |

backends/3ds/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.22)
+
+project(pd-3ds LANGUAGES CXX VERSION 0.6.0)
+
+set(SRC
+    source/bknd-gfx.cpp
+    source/bknd-hid.cpp
+    source/pd-3ds.cpp
+)
+
+pd_add_lib(pd-3ds SRC_FILES ${SRC})
+target_include_directories(pd-3ds PUBLIC include)
+target_link_libraries(pd-3ds PUBLIC m palladium ctru citro3d)

backends/3ds/include/pd-3ds.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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-3ds/bknd-gfx.hpp>
+#include <pd-3ds/bknd-hid.hpp>
+
+namespace PD {
+void Init(void* data = nullptr);
+}

backends/3ds/include/pd-3ds/bknd-gfx.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 <3ds.h>
+#include <citro3d.h>
+
+#include <pd-3ds/linearAllocator.hpp>
+#include <pd/lithium/lithium.hpp>
+
+namespace PD {
+class GfxC3D : public GfxDriver {
+ public:
+  GfxC3D() : GfxDriver("Citro3D") {}
+  ~GfxC3D() = default;
+
+  PD_SHARED(GfxC3D);
+
+  void Init() override;
+  void Deinit() override;
+  void NewFrame() override;
+  void BindTex(PD::Li::TexAddress addr) override;
+  void RenderDrawData(
+      const std::vector<PD::Li::Command::Ref>& Commands) override;
+  PD::Li::Texture::Ref LoadTex(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
+      PD::Li::Texture::Filter filter =
+          PD::Li::Texture::Filter::LINEAR) override;
+
+  std::vector<Li::Vertex, LinearAllocator<Li::Vertex>> VertexBuffer;
+  std::vector<u16, LinearAllocator<u16>> IndexBuffer;
+  int pLocProjection = 0;
+  DVLB_s* ShaderCode;
+  shaderProgram_s Shader;
+  C3D_AttrInfo ShaderInfo;
+};
+}  // namespace PD

backends/3ds/include/pd-3ds/bknd-hid.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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/drivers/drivers.hpp>
+
+namespace PD {
+class Hid3DS : public HidDriver {
+ public:
+  Hid3DS();
+  ~Hid3DS() = default;
+
+  PD_SHARED(Hid3DS);
+
+  void Update() override;
+};
+}  // namespace PD

backends/3ds/include/pd-3ds/linearAllocator.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <3ds.h>
+
+#include <pd/core/common.hpp>
+
+// Custom C++ Allocator class to interface with libctru linear heap memory
+// based on this guide:
+// https://johnfarrier.com/custom-allocators-in-c-high-performance-memory-management/
+
+namespace PD {
+template <typename T>
+class LinearAllocator {
+ public:
+  using value_type = T;
+  LinearAllocator() noexcept = default;
+  template <typename U>
+  constexpr LinearAllocator(const LinearAllocator<U>&) noexcept {}
+
+  T* allocate(std::size_t n) {
+    if (n > max_size()) {
+      throw std::runtime_error("[PD] LinearAllocator: Bad alloc!");
+    }
+    return static_cast<T*>(linearAlloc(n * sizeof(T)));
+  }
+  void deallocate(T* p, std::size_t) noexcept { linearFree(p); }
+
+  template <class U, class... Args>
+  void construct(U* p, Args&&... args) {
+    ::new ((void*)p) U(std::forward<Args>(args)...);
+  }
+
+  template <class U>
+  void destroy(U* p) {
+    p->~U();
+  }
+
+  friend bool operator==(const LinearAllocator, const LinearAllocator) {
+    return true;
+  }
+  friend bool operator!=(const LinearAllocator, const LinearAllocator) {
+    return false;
+  }
+
+  // Use linearSpace free as max_size to not allocate out of bounds
+  // or to b eable to see a crash report screen.
+  size_t max_size() const noexcept { return linearSpaceFree(); }
+};
+}  // namespace PD

backends/3ds/source/bknd-gfx.cpp

@@ -0,0 +1,251 @@
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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-3ds/bknd-gfx.hpp>
+
+/// @brief Shader Code (Unused as i dont want to use libpicasso here (yet))
+/// Update: Picasso breaks the linearRam or ram for somereason
+/// as far as i found out loading anything into linear ram after
+/// using libpicasso to compile a shader leads into a system freeze
+const char* LIShaderCTR = R"(
+; LI7 Shader
+; Constants
+.constf myconst(0.0, 1.0, 0.00392156862745, 0.0)
+.alias  ones  	myconst.yyyy ; Vector full of ones
+
+; Uniforms
+.fvec projection[4]
+
+; Outputs
+.out out_position		position
+.out out_color			color
+.out out_uv				texcoord0
+
+; Inputs
+.alias in_xy		v0
+.alias in_uvc 		v1
+.alias in_col	    v2
+
+.entry vmain
+.proc vmain
+	mov r0.xy, in_xy.xy
+	mov r0.w, ones
+
+	dp4 out_position.x, projection[0], r0
+	dp4 out_position.y, projection[1], r0
+	dp4 out_position.z, projection[2], r0
+	dp4 out_position.w, projection[3], r0
+
+	mov out_uv, in_uvc.xy
+
+	mul r1, myconst.zzzz, in_col
+	mov out_color, r1
+	end
+.end
+)";
+
+// clang-format off
+unsigned char li_shader[] = {
+  0x44, 0x56, 0x4c, 0x42, 0x1, 0x0, 0x0, 0x0, 0xa4, 0x0, 0x0, 0x0, 0x44, 0x56, 0x4c, 0x50, 0x0, 0x0, 0x0, 0x0, 0x28, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x50, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x98, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0x1, 0xf0, 0x7, 0x4e, 0x2, 0x8, 0x2, 0x8, 0x3, 0x18, 0x2, 0x8, 0x4, 0x28, 0x2, 0x8, 0x5, 0x38, 0x2, 0x8, 0x6, 0x10, 0x40, 0x4c, 0x7, 0xf1, 0x27, 0x22, 0x8, 0x10, 0x21, 0x4c, 0x0, 0x0, 0x0, 0x88, 0xac, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa1, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x68, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x62, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x61, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xd5, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x44, 0x56, 0x4c, 0x45, 0x2, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x54, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x54, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x6c, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x74, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x2, 0x0, 0x5f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0x0, 0x1, 0x1, 0x37, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x2, 0x0, 0x1, 0x0, 0xf, 0x0, 0x0, 0x0, 0x3, 0x0, 0x2, 0x0, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x13, 0x0, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0, 0x0, 
+  };
+// clang-format on
+size_t li_shader_size = 0x124;
+
+namespace PD {
+GPU_TEXCOLOR GetTexFmt(Li::Texture::Type type) {
+  if (type == Li::Texture::RGBA32)
+    return GPU_RGBA8;
+  else if (type == Li::Texture::RGB24)
+    return GPU_RGB8;
+  else if (type == Li::Texture::A8)
+    return GPU_A8;
+  return GPU_RGBA8;  // Default
+}
+int GetBPP(Li::Texture::Type type) {
+  if (type == Li::Texture::RGBA32)
+    return 4;
+  else if (type == Li::Texture::RGB24)
+    return 3;
+  else if (type == Li::Texture::A8)
+    return 1;
+  return 0;  // Error
+}
+
+void GfxC3D::Init() {
+  VertexBuffer.resize(4 * 8192);
+  IndexBuffer.resize(6 * 8192);
+
+  Flags |= LiBackendFlags_FlipUV_Y;
+
+  ShaderCode = DVLB_ParseFile((uint32_t*)li_shader, li_shader_size);
+  shaderProgramInit(&Shader);
+  shaderProgramSetVsh(&Shader, &ShaderCode->DVLE[0]);
+  pLocProjection =
+      shaderInstanceGetUniformLocation(Shader.vertexShader, "projection");
+
+  AttrInfo_Init(&ShaderInfo);
+  AttrInfo_AddLoader(&ShaderInfo, 0, GPU_FLOAT, 2);
+  AttrInfo_AddLoader(&ShaderInfo, 1, GPU_FLOAT, 2);
+  AttrInfo_AddLoader(&ShaderInfo, 2, GPU_UNSIGNED_BYTE, 4);
+}
+
+void GfxC3D::Deinit() {
+  shaderProgramFree(&Shader);
+  DVLB_Free(ShaderCode);
+}
+
+void GfxC3D::NewFrame() {
+  C3D_BindProgram(&Shader);
+  C3D_SetAttrInfo(&ShaderInfo);
+  CurrentIndex = 0;
+  CurrentVertex = 0;
+  FrameCounter++;
+  /** Probably completly incorrect but just do it like that */
+  VertexCounter = CurrentVertex;
+  IndexCounter = CurrentIndex;
+}
+
+void GfxC3D::BindTex(PD::Li::TexAddress addr) {
+  C3D_TexBind(0, reinterpret_cast<C3D_Tex*>(addr));
+}
+
+void GfxC3D::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
+  // C3D_BindProgram(&Shader);
+  shaderProgramUse(&Shader);
+  C3D_SetAttrInfo(&ShaderInfo);
+  C3D_Mtx proj;
+  Mtx_OrthoTilt(&proj, 0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f, false);
+  C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, pLocProjection, &proj);
+  // Mat4 proj = Mat4::Ortho(0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f);
+  // C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, pLocProjection, (C3D_Mtx*)&proj);
+  C3D_DepthTest(false, GPU_GREATER, GPU_WRITE_ALL);
+  C3D_TexEnv* env = C3D_GetTexEnv(0);
+  C3D_TexEnvInit(env);
+  C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0);
+  C3D_TexEnvFunc(env, C3D_Both, GPU_MODULATE);
+  size_t index = 0;
+  while (index < Commands.size()) {
+    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
+    if (!Tex) {
+      index++;
+      continue;
+    }
+    bool ScissorEnabled = Commands[index]->ScissorOn;
+    ivec4 ScissorRect = Commands[index]->ScissorRect;
+    size_t StartIndex = CurrentIndex;
+
+    while (index < Commands.size() && Commands[index]->Tex == Tex &&
+           Commands[index]->ScissorOn == ScissorEnabled &&
+           Commands[index]->ScissorRect == ScissorRect) {
+      auto c = Commands[index].get();
+      for (size_t i = 0; i < c->IndexBuffer.Size(); i++) {
+        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.At(i);
+      }
+      for (size_t i = 0; i < c->VertexBuffer.Size(); i++) {
+        VertexBuffer[CurrentVertex++] = c->VertexBuffer.At(i);
+      }
+      index++;
+    }
+    if (ScissorEnabled) {
+      // Figure out this setup was pain
+      C3D_SetScissor(GPU_SCISSOR_NORMAL,
+                     ViewPort.y - (ScissorRect.y + ScissorRect.w),
+                     ViewPort.x - (ScissorRect.x + ScissorRect.z),
+                     ViewPort.y - ScissorRect.y, ViewPort.x - ScissorRect.x);
+    } else {
+      C3D_SetScissor(GPU_SCISSOR_DISABLE, 0, 0, 0, 0);
+    }
+    BindTex(Tex->Address);
+    auto bufInfo = C3D_GetBufInfo();
+    BufInfo_Init(bufInfo);
+    BufInfo_Add(bufInfo, VertexBuffer.data(), sizeof(Li::Vertex), 3, 0x210);
+
+    C3D_DrawElements(GPU_TRIANGLES, CurrentIndex - StartIndex,
+                     C3D_UNSIGNED_SHORT, IndexBuffer.data() + StartIndex);
+  }
+  C3D_DepthTest(true, GPU_GREATER, GPU_WRITE_ALL);
+}
+
+PD::Li::Texture::Ref GfxC3D::LoadTex(const std::vector<PD::u8>& pixels, int w,
+                                     int h, PD::Li::Texture::Type type,
+                                     PD::Li::Texture::Filter filter) {
+  if (w > 1024 || h > 1024) {
+    return nullptr;
+  }
+  // Don't check here as check done before
+  PD::Li::Texture::Ref res = PD::Li::Texture::New();
+  int bpp = GetBPP(type);
+  ivec2 tex_size(w, h);
+  // Pow2
+  if (!PD::BitUtil::IsSingleBit(w)) {
+    tex_size.x = PD::BitUtil::GetPow2((unsigned int)w);
+  }
+  if (!PD::BitUtil::IsSingleBit(h)) {
+    tex_size.y = PD::BitUtil::GetPow2((unsigned int)h);
+  }
+  res->Size.x = w;
+  res->Size.y = h;
+  res->UV = fvec4(0.f, 1.f, ((float)w / (float)tex_size.x),
+                  1.0 - ((float)h / (float)tex_size.y));
+
+  // Texture Setup
+  auto fltr = (filter == Li::Texture::NEAREST ? GPU_NEAREST : GPU_LINEAR);
+  auto tex_fmt = GetTexFmt(type);
+  auto tex = new C3D_Tex;
+  C3D_TexInit(tex, (u16)tex_size.x, (u16)tex_size.y, tex_fmt);
+  C3D_TexSetFilter(tex, fltr, fltr);
+
+  // Using std::fill_n instead cause i hate this error lines
+  // under the memset func in my editor
+  std::fill_n((PD::u8*)tex->data, tex->size, 0);
+  // memset(tex->data, 0, tex->size);s
+
+  /// Probably Remove this if statement in future
+  /// This are the things confirmed as working
+  if (bpp == 3 || bpp == 4 || bpp == 1) {
+    for (int x = 0; x < w; x++) {
+      for (int y = 0; y < h; y++) {
+        int dst_pos = ((((y >> 3) * ((int)tex_size.x >> 3) + (x >> 3)) << 6) +
+                       ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
+                        ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
+                      bpp;
+        int src_pos = (y * w + x) * bpp;
+        /// Best idea i had
+        for (int i = 0; i < bpp; i++) {
+          ((u8*)tex->data)[dst_pos + bpp - 1 - i] = pixels[src_pos + i];
+        }
+      }
+    }
+    C3D_TexFlush(tex);
+  }
+
+  tex->border = 0x00000000;
+  C3D_TexSetWrap(tex, GPU_REPEAT, GPU_REPEAT);
+  res->Address = (Li::TexAddress)tex;
+  std::cout << std::format("Tex {:#08x} Addr {:#08X}",
+                           (Li::TexAddress)res.get(), res->Address)
+            << std::endl;
+  return res;
+}
+}  // namespace PD

backends/3ds/source/bknd-hid.cpp

@@ -0,0 +1,87 @@
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 <3ds.h>
+
+#include <pd-3ds/bknd-hid.hpp>
+
+namespace PD {
+Hid3DS::Hid3DS() : HidDriver("Hid3DS") {
+  this->Flags |= Flags_HasTouch;
+  this->Flags |= FLags_HasGamepad;
+  pBinds[KEY_A] = A;
+  pBinds[KEY_B] = B;
+  pBinds[KEY_X] = X;
+  pBinds[KEY_Y] = Y;
+  pBinds[KEY_START] = Start;
+  pBinds[KEY_SELECT] = Select;
+  pBinds[KEY_L] = L;
+  pBinds[KEY_R] = R;
+  pBinds[KEY_DUP] = DUp;
+  pBinds[KEY_DDOWN] = DDown;
+  pBinds[KEY_DLEFT] = DLeft;
+  pBinds[KEY_DRIGHT] = DRight;
+  pBinds[KEY_CPAD_UP] = CPUp;
+  pBinds[KEY_CPAD_DOWN] = CPDown;
+  pBinds[KEY_CPAD_LEFT] = CPLeft;
+  pBinds[KEY_CPAD_RIGHT] = CPRight;
+  pBinds[KEY_CSTICK_UP] = CSUp;
+  pBinds[KEY_CSTICK_DOWN] = CSDown;
+  pBinds[KEY_CSTICK_LEFT] = CSLeft;
+  pBinds[KEY_CSTICK_RIGHT] = CSRight;
+  pBinds[KEY_ZL] = ZL;
+  pBinds[KEY_ZR] = ZR;
+  pBinds[KEY_TOUCH] = Touch;
+}
+
+void Hid3DS::Update() {
+  hidScanInput();
+  for (int i = 0; i < 2; i++) {
+    KeyEvents[i][Event_Down] = 0;
+    KeyEvents[i][Event_Held] = 0;
+    KeyEvents[i][Event_Up] = 0;
+  }
+  u32 kd = hidKeysDown();
+  u32 kh = hidKeysHeld();
+  u32 ku = hidKeysUp();
+  for (auto &b : pBinds) {
+    if (b.first & kd) {
+      KeyEvents[0][Event_Down] |= b.second;
+    }
+    if (b.first & kh) {
+      KeyEvents[0][Event_Held] |= b.second;
+    }
+    if (b.first & ku) {
+      KeyEvents[0][Event_Up] |= b.second;
+    }
+  }
+  if (pLocked) {
+    SwapTab();
+  }
+  touchPosition t;
+  hidTouchRead(&t);
+  pMouse[1] = pMouse[0];  // Cycle pMouse pos
+  pMouse[0] = fvec2(t.px, t.py);
+}
+}  // namespace PD

backends/3ds/source/pd-3ds.cpp

@@ -0,0 +1,36 @@
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 <palladium>
+#include <pd-3ds.hpp>
+
+namespace PD {
+void Init(void* data) {
+  // Dekstop Init Stage
+  // First use default OS Driver
+  PD::OS::Init();
+  PD::Gfx::Init(PD::GfxC3D::New());
+  PD::Hid::Init(PD::Hid3DS::New());
+}
+}  // namespace PD

backends/desktop/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.22)
+
+project(pd-desktop LANGUAGES CXX VERSION 0.5.0)
+
+add_subdirectory(glad)
+add_subdirectory(glfw)
+
+set(SRC
+    source/bknd-gfx.cpp
+    source/bknd-hid.cpp
+    source/pd-desktop.cpp
+)
+
+pd_add_lib(pd-desktop SRC_FILES ${SRC})
+target_include_directories(pd-desktop PUBLIC include)
+target_link_libraries(pd-desktop PUBLIC palladium glad glfw)

backends/desktop/glad/CMakeLists.txt

@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 3.22)
+
+add_library(glad source/glad.c)
+target_include_directories(glad PUBLIC include)

backends/desktop/glad/include/KHR/khrplatform.h

@@ -0,0 +1,311 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are 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 Materials.
+**
+** THE MATERIALS ARE 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
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */

backends/desktop/include/pd-desktop.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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-desktop/bknd-gfx.hpp>
+#include <pd-desktop/bknd-hid.hpp>
+
+namespace PD {
+void Init(void* data = nullptr);
+}

backends/desktop/include/pd-desktop/bknd-gfx.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 <glad/glad.h>
+
+/** SEPARATOR */
+#include <GLFW/glfw3.h>
+/** SEPARATOR */
+
+#include <pd/lithium/lithium.hpp>
+
+namespace PD {
+class GfxGL2 : public GfxDriver {
+ public:
+  GfxGL2() : GfxDriver("OpenGL2") {}
+  ~GfxGL2() = default;
+
+  PD_SHARED(GfxGL2);
+
+  void Init() override;
+  void Deinit() override;
+  void NewFrame() override;
+  void BindTex(PD::Li::TexAddress addr) override;
+  void RenderDrawData(
+      const std::vector<PD::Li::Command::Ref>& Commands) override;
+  PD::Li::Texture::Ref LoadTex(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
+      PD::Li::Texture::Filter filter =
+          PD::Li::Texture::Filter::LINEAR) override;
+
+  PD::Vec<Li::Vertex> VertexBuffer;
+  PD::Vec<PD::u16> IndexBuffer;
+  GLuint Shader;
+  GLuint pLocProjection;
+  GLuint pLocTex;
+  GLuint VBO, IBO;
+};
+}  // namespace PD

backends/desktop/include/pd-desktop/bknd-hid.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 <GLFW/glfw3.h>
+
+#include <pd/drivers/drivers.hpp>
+
+namespace PD {
+class HidGLFW : public HidDriver {
+ public:
+  HidGLFW(GLFWwindow* win);
+  ~HidGLFW() = default;
+
+  PD_SHARED(HidGLFW);
+
+  void Update() override;
+  void GetInputStr(std::string& str) override;
+  void HandleTextOps();
+  bool pTimedHeld(KbKey k) {
+    if (pTimings.count(k)) {
+      if (IsEvent(Event_Up, k)) {
+        pTimings.erase(k);
+        return false;
+      }
+      return (PD::OS::GetTime() - pTimings[k]) > 50;
+    }
+    if (!IsEvent(Event_Held, k)) {
+      if (pTimings.count(k)) {
+        pTimings.erase(k);
+        return false;
+      }
+    }
+    if (IsEvent(Event_Held, k)) {
+      pTimings[k] = PD::OS::GetTime();
+      return true;
+    }
+    return false;
+  }
+
+  /** Data section */
+  GLFWwindow* Window;
+  int PrevState;
+  std::unordered_map<int, int> PrevStates;
+  static std::string* pText;
+  bool pInTextMode = false;
+  PD::u64 pLastUpdate = 0;
+  std::unordered_map<KbKey, u64> pTimings;
+};
+}  // namespace PD

backends/desktop/source/bknd-gfx.cpp

@@ -0,0 +1,256 @@
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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-desktop/bknd-gfx.hpp>
+
+namespace PD {
+const char* vertex_shader = R"(
+  #version 120
+  
+  attribute vec2 pos;
+  attribute vec2 uv;
+  attribute vec4 color;
+  
+  varying vec2 oUV;
+  varying vec4 oColor;
+  
+  // Probably forgot about this matrix and
+  // searched hours for why the rendering isn't working :/
+  uniform mat4 projection;
+  
+  void main() {
+      gl_Position = projection*vec4(pos, 0.0, 1.0);
+      oUV = uv;
+      oColor = color;
+  }
+  )";
+
+const char* frag_shader = R"(
+  #version 120
+      
+  varying vec2 oUV;
+  varying vec4 oColor;
+  
+  uniform sampler2D tex;
+      
+  void main() {
+      vec4 tc = texture2D(tex, oUV);
+      gl_FragColor = tc*oColor;
+  }
+  )";
+
+GLuint compileShader(const std::string& source, GLenum type) {
+  GLuint shader = glCreateShader(type);
+  const char* src = source.c_str();
+  glShaderSource(shader, 1, &src, nullptr);
+  glCompileShader(shader);
+
+  GLint success;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetShaderInfoLog(shader, 512, nullptr, infoLog);
+    std::cerr << "Shader Compilation Error: " << infoLog << std::endl;
+  }
+
+  return shader;
+}
+
+GLuint createShaderProgram(const std::string& vertexShaderSource,
+                           const std::string& fragmentShaderSource) {
+  GLuint vertexShader = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
+  GLuint fragmentShader =
+      compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
+
+  GLuint shaderProgram = glCreateProgram();
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+  glLinkProgram(shaderProgram);
+
+  GLint success;
+  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
+    std::cerr << "Shader Program Linking Error: " << infoLog << std::endl;
+  }
+
+  glDeleteShader(vertexShader);
+  glDeleteShader(fragmentShader);
+
+  return shaderProgram;
+}
+
+void SetupShaderAttribs(GLuint Shader) {
+  GLint _pos = glGetAttribLocation(Shader, "pos");
+  GLint _uv = glGetAttribLocation(Shader, "uv");
+  GLint _color = glGetAttribLocation(Shader, "color");
+  glVertexAttribPointer(_pos, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Pos));
+  glEnableVertexAttribArray(_pos);
+
+  glVertexAttribPointer(_uv, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, UV));
+  glEnableVertexAttribArray(_uv);
+
+  glVertexAttribPointer(_color, 4, GL_UNSIGNED_BYTE, GL_TRUE,
+                        sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Color));
+  glEnableVertexAttribArray(_color);
+}
+
+/** Actual Backend */
+
+void GfxGL2::Init() {
+  VertexBuffer.Resize(4 * 8192);
+  IndexBuffer.Resize(6 * 8192);
+  Shader = createShaderProgram(vertex_shader, frag_shader);
+  glUseProgram(Shader);
+
+  glGenBuffers(1, &VBO);
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+  // Attribs Setup
+  SetupShaderAttribs(Shader);
+
+  glGenBuffers(1, &IBO);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+
+  pLocTex = glGetUniformLocation(Shader, "tex");
+  pLocProjection = glGetUniformLocation(Shader, "projection");
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+void GfxGL2::Deinit() {
+  glDeleteBuffers(1, &VBO);
+  glDeleteBuffers(1, &IBO);
+}
+
+void GfxGL2::NewFrame() {
+  /*
+  glViewport(0, 0, ViewPort.x, ViewPort.y);
+  glClearColor(ClearColor.x, ClearColor.y, ClearColor.z, ClearColor.w);
+  glClear(GL_COLOR_BUFFER_BIT);
+  */
+  Projection = Mat4::Ortho(0.f, ViewPort.x, ViewPort.y, 0.f, -1.f, 1.f);
+  glUseProgram(Shader);
+  glUniformMatrix4fv(pLocProjection, 1, GL_FALSE, Projection.m.data());
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  FrameCounter++;
+  VertexCounter = CurrentVertex;
+  IndexCounter = CurrentIndex;
+  CurrentVertex = 0;
+  CurrentIndex = 0;
+}
+
+void GfxGL2::BindTex(PD::Li::TexAddress addr) {
+  // Actually not using the Address as Address
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, (GLuint)addr);
+  glUniform1i(pLocTex, 0);
+}
+
+void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
+  size_t index = 0;
+  while (index < Commands.size()) {
+    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
+    if (!Tex) {
+      index++;
+      continue;
+    }
+    size_t StartIndex = CurrentIndex;
+    bool ScissorOn = Commands[index]->ScissorOn;
+    ivec4 ScissorRect = Commands[index]->ScissorRect;
+
+    while (index < Commands.size() && Commands[index]->Tex == Tex &&
+           Commands[index]->ScissorOn == ScissorOn &&
+           Commands[index]->ScissorRect == ScissorRect) {
+      auto c = Commands[index].get();
+      for (size_t i = 0; i < c->IndexBuffer.Size(); i++) {
+        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.At(i);
+      }
+      for (size_t i = 0; i < c->VertexBuffer.Size(); i++) {
+        VertexBuffer[CurrentVertex++] = c->VertexBuffer.At(i);
+      }
+      index++;
+    }
+    if (ScissorOn) {
+      glScissor(ScissorRect.x, ViewPort.y - (ScissorRect.y + ScissorRect.w),
+                ScissorRect.z, ScissorRect.w);
+      glEnable(GL_SCISSOR_TEST);
+    } else {
+      glDisable(GL_SCISSOR_TEST);
+    }
+    BindTex(Tex->Address);
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
+                 &VertexBuffer[0], GL_DYNAMIC_DRAW);
+    // For some reason we need to set these every frame for every buffer
+    // Found that out when creating My 3d Engine
+    SetupShaderAttribs(Shader);
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
+                 &IndexBuffer[0], GL_DYNAMIC_DRAW);
+
+    glDrawElements(GL_TRIANGLES, CurrentIndex - StartIndex, GL_UNSIGNED_SHORT,
+                   (void*)(StartIndex * sizeof(PD::u16)));
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    BindTex(0);
+  }
+}
+
+PD::Li::Texture::Ref GfxGL2::LoadTex(const std::vector<PD::u8>& pixels, int w,
+                                     int h, PD::Li::Texture::Type type,
+                                     PD::Li::Texture::Filter filter) {
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  if (type == PD::Li::Texture::Type::RGB24) {
+    fmt = GL_RGB;
+  } else if (type == PD::Li::Texture::Type::A8) {
+    fmt = GL_ALPHA;
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+  if (filter == PD::Li::Texture::Filter::LINEAR) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == PD::Li::Texture::Filter::NEAREST) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  }
+  glBindTexture(GL_TEXTURE_2D, 0);
+  auto res = PD::Li::Texture::New(texID, PD::ivec2(w, h));
+  return res;
+}
+}  // namespace PD

backends/desktop/source/bknd-hid.cpp

@@ -0,0 +1,166 @@
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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-desktop/bknd-hid.hpp>
+namespace PD {
+std::string* HidGLFW::pText;
+// Default Call back (If no Text input is requsted)
+void NullTextCB(GLFWwindow* win, unsigned int c) {}
+// Text callback if requested
+void TextCB(GLFWwindow* win, unsigned int c) {
+  if (!HidGLFW::pText) {
+    return;
+  }
+  *HidGLFW::pText += (char)c;
+}
+HidGLFW::HidGLFW(GLFWwindow* win) : HidDriver("HidGLFW") {
+  Window = win;
+  glfwSetCharCallback(Window, NullTextCB);
+  Flags |= Flags_HasKeyboard;
+  Flags |= Flags_HasMouse;
+  pBinds[GLFW_MOUSE_BUTTON_LEFT] = Touch;
+  /*pBinds[GLFW_KEY_F3] = Kb_3;
+  pBinds[GLFW_KEY_ESCAPE] = Kb_Escape;
+  pBinds[GLFW_KEY_F11] = Kb_F11;
+  pBinds[GLFW_KEY_ESCAPE] = Kb_Escape;
+  pBinds[GLFW_KEY_Q] = Kb_Q;
+  pBinds[GLFW_KEY_W] = Kb_W;
+  pBinds[GLFW_KEY_E] = Kb_E;
+  pBinds[GLFW_KEY_R] = Kb_R;
+  pBinds[GLFW_KEY_T] = Kb_T;
+  pBinds[GLFW_KEY_Z] = Kb_Z;
+  pBinds[GLFW_KEY_U] = Kb_U;
+  pBinds[GLFW_KEY_I] = Kb_I;
+  pBinds[GLFW_KEY_O] = Kb_O;
+  pBinds[GLFW_KEY_P] = Kb_P;
+  pBinds[GLFW_KEY_A] = Kb_A;
+  pBinds[GLFW_KEY_S] = Kb_S;
+  pBinds[GLFW_KEY_D] = Kb_D;
+  pBinds[GLFW_KEY_F] = Kb_F;
+  pBinds[GLFW_KEY_G] = Kb_G;
+  pBinds[GLFW_KEY_H] = Kb_H;
+  pBinds[GLFW_KEY_J] = Kb_J;
+  pBinds[GLFW_KEY_K] = Kb_K;
+  pBinds[GLFW_KEY_L] = Kb_L;
+  pBinds[GLFW_KEY_Y] = Kb_Y;
+  pBinds[GLFW_KEY_X] = Kb_X;
+  pBinds[GLFW_KEY_C] = Kb_C;
+  pBinds[GLFW_KEY_V] = Kb_V;
+  pBinds[GLFW_KEY_B] = Kb_B;
+  pBinds[GLFW_KEY_N] = Kb_N;
+  pBinds[GLFW_KEY_M] = Kb_M;
+  pBinds[GLFW_KEY_LEFT_SHIFT] = Kb_LShift;
+  pBinds[GLFW_KEY_F1] = Kb_F1;
+  pBinds[GLFW_KEY_F2] = Kb_F2;
+  pBinds[GLFW_KEY_F3] = Kb_F3;
+  pBinds[GLFW_KEY_F4] = Kb_F4;
+  pBinds[GLFW_KEY_F5] = Kb_F5;
+  pBinds[GLFW_KEY_F6] = Kb_F6;
+  pBinds[GLFW_KEY_F7] = Kb_F7;
+  pBinds[GLFW_KEY_F8] = Kb_F8;
+  pBinds[GLFW_KEY_F9] = Kb_F9;
+  pBinds[GLFW_KEY_F10] = Kb_F10;
+  pBinds[GLFW_KEY_F11] = Kb_F11;
+  pBinds[GLFW_KEY_F12] = Kb_F12;
+  pBinds[GLFW_KEY_1] = Kb_1;
+  pBinds[GLFW_KEY_2] = Kb_2;
+  pBinds[GLFW_KEY_3] = Kb_3;
+  pBinds[GLFW_KEY_4] = Kb_4;
+  pBinds[GLFW_KEY_5] = Kb_5;
+  pBinds[GLFW_KEY_6] = Kb_6;
+  pBinds[GLFW_KEY_7] = Kb_7;
+  pBinds[GLFW_KEY_8] = Kb_8;
+  pBinds[GLFW_KEY_9] = Kb_9;
+  pBinds[GLFW_KEY_0] = Kb_0;
+  pBinds[GLFW_KEY_BACKSPACE] = Kb_Backspace;
+  pBinds[GLFW_KEY_ENTER] = Kb_Enter;*/
+}
+
+void HidGLFW::Update() {
+  // Clear States
+  for (int i = 0; i < 2; i++) {
+    KeyEvents[i][Event_Down] = 0;
+    KeyEvents[i][Event_Held] = 0;
+    KeyEvents[i][Event_Up] = 0;
+    for (auto& it : KbKeyEvents[i]) {
+      it.second = Event_Null;
+    }
+  }
+  // Keyboard Logic
+  /*for (auto& it : pBinds) {
+    int kbstate = glfwGetKey(Window, it.first);
+    if (kbstate == GLFW_PRESS) {
+      if (PrevStates[it.first] == GLFW_RELEASE) {
+        KbKeyEvents[0][it.second] = Event_Down;
+      }
+      KbKeyEvents[0][it.second] = Event_Held;
+    } else if (kbstate == GLFW_RELEASE && PrevStates[it.first] == GLFW_PRESS) {
+      KbKeyEvents[0][it.second] = Event_Up;
+    }
+    PrevStates[it.first] = kbstate;
+  }*/
+  // Mouse Logic (Todo: Support all mouse buttons)
+  int state = glfwGetMouseButton(Window, GLFW_MOUSE_BUTTON_LEFT);
+  if (state == GLFW_PRESS) {
+    if (PrevState == GLFW_RELEASE) {
+      KeyEvents[0][Event_Down] |= Touch;
+    }
+    KeyEvents[0][Event_Held] |= Touch;
+  } else if (state == GLFW_RELEASE && PrevState == GLFW_PRESS) {
+    KeyEvents[0][Event_Up] |= Touch;
+  }
+
+  PrevState = state;
+  if (pLocked) {
+    SwapTab();
+  }
+  double x, y;
+  glfwGetCursorPos(Window, &x, &y);
+  pMouse[1] = pMouse[0];  // Cycle pMouse pos
+  pMouse[0] = fvec2(x, y);
+  if (pInTextMode && (PD::OS::GetTime() - pLastUpdate) > 50) {
+    pLastUpdate = PD::OS::GetTime();
+    HandleTextOps();
+  }
+}
+
+void HidGLFW::GetInputStr(std::string& str) {
+  pText = &str;
+  glfwSetCharCallback(Window, TextCB);
+  pInTextMode = true;
+}
+
+void HidGLFW::HandleTextOps() {
+  if (!pText) {
+    return;
+  }
+  /*if (pTimedHeld(Kb_Backspace)) {
+    if (!pText->empty()) {
+      pText->pop_back();
+    }
+  } else if (pTimedHeld(Kb_Enter)) {
+    *pText += '\n';
+  }*/
+}
+}  // namespace PD

backends/desktop/source/pd-desktop.cpp

@@ -0,0 +1,43 @@
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 <palladium>
+#include <pd-desktop.hpp>
+
+namespace PD {
+void Init(void* data) {
+  if (!data) {
+    std::cout << "[PD-DRIVERS] Error: pd-desktop requires GLFWwindow* "
+                 "reference as data "
+                 "input!"
+              << std::endl;
+    abort();
+  }
+  // Dekstop Init Stage
+  // First use default OS Driver
+  PD::OS::Init();
+  PD::Gfx::Init(PD::GfxGL2::New());
+  PD::Hid::Init(PD::HidGLFW::New(reinterpret_cast<GLFWwindow*>(data)));
+}
+}  // namespace PD

build_shaders.py

@@ -1,65 +0,0 @@
-import os
-import glob
-import shutil
-from pathlib import Path
-
-# Simple Script to generate/update Shaders
-# WHY? Cause having this stupid .v.pica files in 
-# sourcecode is pain with some buildsystems
-
-def file2array(path, custom_incluse_path):
-    print(path)
-    cip = len(custom_incluse_path)
-    sip = ''
-    if cip > 0:
-        sip = custom_incluse_path
-    name = Path(path).stem
-    filei = open(path, 'rb')
-    buf = filei.read()
-    filei.close()
-    fs = open(name + '.cpp', 'w')
-    fs.write("// THIS FILE WAS GENERATED BY build_shaders.py!!!\n\n")
-    fs.write('#include <'+ sip + name + '.hpp>\n\n')
-    fs.write('// clang-format off\n')
-    fs.write('unsigned char ' + name + '[] = {\n')
-    for byte in buf:
-        fs.write(hex(byte) + ', ')
-    fs.write('\n};\n')
-    fs.write('// clang-format on\n')
-    fs.write('size_t ' + name + '_size = ' + hex(len(buf)) + ';')
-    fs.close()
-    fh = open(name + '.hpp', 'w')
-    fh.write("// THIS FILE WAS GENERATED BY build_shaders.py!!!\n\n")
-    fh.write('#pragma once\n\n')
-    fh.write('#include <cstddef>\n\n')
-    fh.write('extern unsigned char ' + name + '[];\n')
-    fh.write('extern size_t ' + name + '_size;')
-    fh.close()
-
-def build_shader(path):
-    p = os.path.dirname(path)
-    n = Path(Path(path).stem).stem
-    os.system('picasso -o ' + p + '/' + n + '.shbin ' + path)
-
-def cleanup():
-    t3x = glob.glob('shaders/*.shbin')
-    for f in t3x:
-        os.remove(f)
-
-def install_code(what, where):
-    if Path(what).is_dir:
-        os.error('Must be a file!!!')
-    shutil.move(what, where + Path(what).name)
-
-print("Generating...")
-shaders = glob.glob('shaders/*v.pica')
-for object in shaders:
-    name = Path(Path(object).stem).stem
-    bp = os.path.dirname(object)
-    build_shader(object)
-    file2array(bp + '/' + name + '.shbin', 'pd/')
-    install_code(name + '.cpp', 'source/')
-    install_code(name + '.hpp', 'include/pd/')
-
-cleanup()
-print("Done")

clang-format.py

@@ -1,24 +0,0 @@
-import subprocess
-import glob
-from pathlib import Path
-# Format script
-
-def fmt_file(path):
-        if Path(path).is_dir():
-             return # Skip
-        try:
-            subprocess.run(['clang-format', '-i', path, '--style=Google'], check=True)
-        except subprocess.CalledProcessError as e:
-            print('Error for ' + Path(path).stem + ': ' + e)
-
-def fmt_dir(path):
-    sources = glob.glob(path+'/*')
-    for file in sources:
-        fmt_file(file)
-
-print('Formatting...')
-fmt_dir('source')
-fmt_dir('include')
-fmt_dir('include/pd')
-
-print('Done')

cmake/palladium.cmake

@@ -0,0 +1,79 @@
+cmake_minimum_required(VERSION 3.22)
+
+## Utilitys of Palladium Library
+
+### RULES ###
+
+# Force C++ 20
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+# Enable Compile Command Export
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+option(PD_INCLUDE_DIR "")
+
+### Helper Function to Build Librarys without have always
+### These includes and definition defines
+function(pd_add_lib TARGET_NAME)
+    set(opts "BUILD_SHARED")
+    set(one_val_args "")
+    set(multi_val_args SRC_FILES DEPENDS)
+    cmake_parse_arguments(ARG "${opts}" "${one_val_args}" "${multi_val_args}" ${ARGN})
+
+    string(REPLACE "-" "_" FLAG_NAME_T ${TARGET_NAME})
+    string(TOUPPER ${FLAG_NAME_T} FLAG_NAME_F)
+
+    if(ARG_BUILD_SHARED)
+        add_library(${TARGET_NAME} SHARED ${ARG_SRC_FILES})
+        target_compile_definitions(${TARGET_NAME} PUBLIC -D${FLAG_NAME_F}_BUILD_SHARED=1)
+        message("Building SHARED library: ${FLAG_NAME_F}_BUILD_SHARED=1")
+    else()
+        add_library(${TARGET_NAME} STATIC ${ARG_SRC_FILES})
+        target_compile_definitions(${TARGET_NAME} PUBLIC -D${FLAG_NAME_F}_BUILD_SHARED=0)
+        message("Building STATIC library: ${FLAG_NAME_F}_BUILD_SHARED=0")
+    endif()
+    target_include_directories(${TARGET_NAME} PUBLIC
+        ${PD_INCLUDE_DIR}
+        ${DEVKITPRO}/portlibs/3ds/include
+    )
+    target_compile_definitions(${TARGET_NAME} PRIVATE
+        -D_GNU_SOURCE=1
+        -DPALLADIUM_VERSION="${PROJECT_VERSION}"
+        -DPALLADIUM_GIT_COMMIT="${GIT_SHORT_HASH}"
+        -DPALLADIUM_GIT_BRANCH="${GIT_BRANCH}"
+        -DBUILD_CTR=1
+    )
+    if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
+        target_compile_options(${TARGET_NAME} PRIVATE
+            -Wno-abi
+        )
+    endif()
+    ### For the libs that depend on another
+    if(ARG_DEPENDS)
+        target_link_libraries(${TARGET_NAME} PUBLIC ${ARG_DEPENDS})
+    endif()
+    install(TARGETS ${TARGET_NAME})
+endfunction()
+
+### GIT HELPER ###
+
+function(pd_git_get_hash ret)
+    execute_process(
+        COMMAND git rev-parse --short HEAD
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE _ret
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    set(${ret} "${_ret}" PARENT_SCOPE)
+endfunction()
+
+function(pd_git_get_branch ret)
+    execute_process(
+        COMMAND git rev-parse --abbrev-ref HEAD
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE _ret
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    set(${ret} "${_ret}" PARENT_SCOPE)
+endfunction()

docs/javascripts/mathjax.js

@@ -1,18 +0,0 @@
-<div class="md-copyright">
-  {% if config.copyright %}
-    <div class="md-copyright__highlight">
-      {{ config.copyright }}
-    </div>
-  {% endif %}
-  {% if not config.extra.generator == false %}
-    Made with
-    <a href="https://doxide.org" target="_blank" rel="noopener">
-      Doxide
-    </a>
-    and
-    <a href="https://squidfunk.github.io/mkdocs-material/" target="_blank" rel="noopener">
-      Material for MkDocs
-    </a>
-  {% endif %}
-</div>
-

docs/overrides/partials/copyright.html

@@ -1,18 +0,0 @@
-<div class="md-copyright">
-  {% if config.copyright %}
-    <div class="md-copyright__highlight">
-      {{ config.copyright }}
-    </div>
-  {% endif %}
-  {% if not config.extra.generator == false %}
-    Made with
-    <a href="https://doxide.org" target="_blank" rel="noopener">
-      Doxide
-    </a>
-    and
-    <a href="https://squidfunk.github.io/mkdocs-material/" target="_blank" rel="noopener">
-      Material for MkDocs
-    </a>
-  {% endif %}
-</div>
-

docs/stylesheets/doxide.css

@@ -1,49 +0,0 @@
-:root {
-  --md-admonition-icon--variable: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M20.41 3c1.39 2.71 1.94 5.84 1.59 9-.2 3.16-1.3 6.29-3.17 9l-1.53-1c1.61-2.43 2.55-5.2 2.7-8 .34-2.8-.11-5.57-1.3-8l1.71-1M5.17 3 6.7 4C5.09 6.43 4.15 9.2 4 12c-.34 2.8.12 5.57 1.3 8l-1.69 1c-1.4-2.71-1.96-5.83-1.61-9 .2-3.16 1.3-6.29 3.17-9m6.91 7.68 2.32-3.23h2.53l-3.78 5 2.2 4.92h-2.26L11.71 14l-2.43 3.33H6.76l3.9-5.12-2.13-4.76h2.27l1.28 3.23Z"/></svg>');
-  --md-admonition-icon--function: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M15.6 5.29c-1.1-.1-2.07.71-2.17 1.82L13.18 10H16v2h-3l-.44 5.07a3.986 3.986 0 0 1-4.33 3.63 4.007 4.007 0 0 1-3.06-1.87l1.5-1.5c.24.74.9 1.31 1.73 1.38 1.1.1 2.07-.71 2.17-1.82L11 12H8v-2h3.17l.27-3.07c.19-2.2 2.13-3.83 4.33-3.63 1.31.11 2.41.84 3.06 1.87l-1.5 1.5c-.24-.74-.9-1.31-1.73-1.38Z"/></svg>');
-  --md-admonition-icon--concept: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M3.75 3.5a.25.25 0 0 0-.25.25v2.062a.75.75 0 1 1-1.5 0V3.75C2 2.783 2.783 2 3.75 2h2.062a.75.75 0 1 1 0 1.5Zm13.688-.75a.75.75 0 0 1 .75-.75h2.062c.966 0 1.75.783 1.75 1.75v2.062a.75.75 0 1 1-1.5 0V3.75a.25.25 0 0 0-.25-.25h-2.062a.75.75 0 0 1-.75-.75ZM2.75 17.438a.75.75 0 0 1 .75.75v2.062c0 .138.112.25.25.25h2.062a.75.75 0 1 1 0 1.5H3.75A1.75 1.75 0 0 1 2 20.25v-2.062a.75.75 0 0 1 .75-.75Zm18.5 0a.75.75 0 0 1 .75.75v2.062A1.75 1.75 0 0 1 20.25 22h-2.062a.75.75 0 1 1 0-1.5h2.062a.25.25 0 0 0 .25-.25v-2.062a.75.75 0 0 1 .75-.75Zm-18.5-8.25a.75.75 0 0 1 .75.75v4.124a.75.75 0 1 1-1.5 0V9.938a.75.75 0 0 1 .75-.75ZM9.188 2.75a.75.75 0 0 1 .75-.75h4.124a.75.75 0 1 1 0 1.5H9.938a.75.75 0 0 1-.75-.75Zm0 18.5a.75.75 0 0 1 .75-.75h4.124a.75.75 0 1 1 0 1.5H9.938a.75.75 0 0 1-.75-.75ZM21.25 9.188a.75.75 0 0 1 .75.75v4.124a.75.75 0 1 1-1.5 0V9.938a.75.75 0 0 1 .75-.75ZM3.75 8.25a.75.75 0 0 1 .75-.75h2a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1-.75-.75Zm5.5 0A.75.75 0 0 1 10 7.5h2A.75.75 0 0 1 12 9h-2a.75.75 0 0 1-.75-.75Zm-1-4.5A.75.75 0 0 1 9 4.5v2a.75.75 0 0 1-1.5 0v-2a.75.75 0 0 1 .75-.75Zm0 5.5A.75.75 0 0 1 9 10v2a.75.75 0 0 1-1.5 0v-2a.75.75 0 0 1 .75-.75Zm0 4.75a.75.75 0 0 1 .75.75v4a.75.75 0 0 1-1.5 0v-4a.75.75 0 0 1 .75-.75ZM14 8.25a.75.75 0 0 1 .75-.75h4a.75.75 0 0 1 0 1.5h-4a.75.75 0 0 1-.75-.75Z"/></svg>');
-  --md-admonition-icon--macro: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="m5.41 21 .71-4h-4l.35-2h4l1.06-6h-4l.35-2h4l.71-4h2l-.71 4h6l.71-4h2l-.71 4h4l-.35 2h-4l-1.06 6h4l-.35 2h-4l-.71 4h-2l.71-4h-6l-.71 4h-2M9.53 9l-1.06 6h6l1.06-6h-6Z"/></svg>');
-}
-
-.md-typeset .admonition.variable, .md-typeset details.variable,
-.md-typeset .admonition.function, .md-typeset details.function,
-.md-typeset .admonition.concept, .md-typeset details.concept,
-.md-typeset .admonition.macro, .md-typeset details.macro {
-  border-color: var(--md-default-fg-color--lighter);
-}
-
-.md-typeset .variable > .admonition-title, .md-typeset .variable > summary,
-.md-typeset .function > .admonition-title, .md-typeset .function > summary,
-.md-typeset .concept > .admonition-title, .md-typeset .concept > summary,
-.md-typeset .macro > .admonition-title, .md-typeset .macro > summary {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-typeset .variable > .admonition-title::before,
-.md-typeset .variable > summary::before {
-  background-color: var(--md-default-fg-color--light);
-  -webkit-mask-image: var(--md-admonition-icon--variable);
-          mask-image: var(--md-admonition-icon--variable);
-}
-
-.md-typeset .function > .admonition-title::before,
-.md-typeset .function > summary::before {
-  background-color: var(--md-default-fg-color--light);
-  -webkit-mask-image: var(--md-admonition-icon--function);
-          mask-image: var(--md-admonition-icon--function);
-}
-
-.md-typeset .concept > .admonition-title::before,
-.md-typeset .concept > summary::before {
-  background-color: var(--md-default-fg-color--light);
-  -webkit-mask-image: var(--md-admonition-icon--concept);
-          mask-image: var(--md-admonition-icon--concept);
-}
-
-.md-typeset .macro > .admonition-title::before,
-.md-typeset .macro > summary::before {
-  background-color: var(--md-default-fg-color--light);
-  -webkit-mask-image: var(--md-admonition-icon--macro);
-          mask-image: var(--md-admonition-icon--macro);
-}
-

doxide.yaml

@@ -1,9 +0,0 @@
-title: Palladium
-description: 
-files:
-  - "include/*.hpp"
-  - "include/pd/*.hpp"
-  - "include/pd/base/*.hpp"
-  - "include/*.h"
-  - "include/pd/*.h"
-  - "include/pd/base/*.h"

include/palladium

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <pd/core/core.hpp>
+#include <pd/drivers/drivers.hpp>
+#include <pd/external/json.hpp>
+#include <pd/image/image.hpp>
+#include <pd/lithium/lithium.hpp>
+#include <pd/ui7/ui7.hpp>

include/pd.hpp

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <pd/Error.hpp>
-#include <pd/Hid.hpp>
-#include <pd/Image.hpp>
-#include <pd/Installer.hpp>
-#include <pd/Lithium.hpp>
-#include <pd/Message.hpp>
-#include <pd/Net.hpp>
-#include <pd/Overlays.hpp>
-#include <pd/Rubidium.hpp>
-#include <pd/Sheet.hpp>
-#include <pd/Sound.hpp>
-#include <pd/Texture.hpp>
-#include <pd/Timer.hpp>
-#include <pd/UI7.hpp>
-#include <pd/base/Allocator.hpp>
-#include <pd/base/FileSystem.hpp>
-#include <pd/global_db.hpp>
-#include <pd/palladium.hpp>
-
-namespace Palladium {
-using Lithium = LI;
-using RB = Rubidium;
-}  // namespace Palladium
-
-namespace PD = Palladium;

include/pd/Error.hpp

@@ -1,18 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace Palladium {
-void Error(const std::string& msg);
-inline void InlineError(const std::string& msg) {
-  std::string location = __FILE__ + std::string(":") + std::to_string(__LINE__);
-  Error("Error: \n" + location + "\n" + msg);
-}
-inline void InlineAssert(bool v, const std::string& msg = "") {
-  if (v == false) {
-    std::string location =
-        __FILE__ + std::string(":") + std::to_string(__LINE__);
-    Error("Assert Failed:\n" + location + "\n" + msg);
-  }
-}
-}  // namespace Palladium

include/pd/Hardware.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-namespace Palladium {
-namespace Hardware {
-/// @brief Initialisize required Services
-void Initialisize();
-/// @brief Check if Headphones are Plugged in
-/// @return true if headphones plugged in
-bool IsHeadphones();
-/// @brief Check if the 3ds Is Charging
-/// @return true if System gets Charged
-bool IsCharging();
-/// @brief Check the Battery Percentage
-/// @return Persentage as int
-int GetBatteryPercentage();
-/// @brief Get current State of 3d Slider
-/// @return current 3dslider poition
-float Get3dSliderLevel();
-/// @brief Get Current state of Sound Slider
-/// @return current SoundSlider state
-float GetSoundSliderLevel();
-/// @brief Get Current Wifi Level
-/// @return current wifi level
-int GetWifiLevel();
-}  // namespace Hardware
-}  // namespace Palladium

include/pd/Hid.hpp

@@ -1,42 +0,0 @@
-// WARNING
-// THIS IS BETA STUFF
-// ITS MAKE LIKE EXTERNAL BUT
-// FOR Palladium ITS INTEGRATED
-
-#pragma once
-
-#include <pd/maths/NVec.hpp>
-#include <string>
-
-namespace Palladium {
-namespace Hid {
-enum Actions {
-  Down = 0,
-  Held = 1,
-  Up = 2,
-  DownRepeat = 3,
-};
-// Register Functions
-// Register Current state values
-void RegKeyDown(uint32_t &key_down);
-void RegKeyHeld(uint32_t &key_held);
-void RegKeyUp(uint32_t &key_up);
-void RegKeyRepeat(uint32_t &repeat);
-void RegTouchCoords(NVec2 &touch_pos);
-// Not Corectly Implemented Yet
-void RegAnalog1Movement(NVec2 &movement);
-void RegAnalog2Movement(NVec2 &movement);
-// Register Keys
-void RegKeyEvent(const std::string &event, uint32_t key);
-// KeyEvents
-bool IsEvent(const std::string &event, Actions action);
-NVec2 GetTouchPosition();
-NVec2 GetLastTouchPosition();
-NVec2 GetTouchDownPosition();
-void Update();
-// Lock/Unlock Input api for example for Keyboard
-void Lock();
-void Unlock();
-void Clear();
-}  // namespace Hid
-}  // namespace Palladium

include/pd/Image.hpp

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <3ds.h>
-
-#include <pd/Texture.hpp>
-#include <pd/maths/NVec.hpp>
-#include <pd/nimg.hpp>
-#include <pd/smart_ctor.hpp>
-#include <string>
-
-namespace Palladium {
-class Image {
- public:
-  Image() = default;
-  Image(const std::string& path) { this->Load(path); }
-  ~Image() = default;
-  PD_SMART_CTOR(Image)
-  void Load(const std::string& path);
-  void From_NIMG(const nimg& image);
-  void Delete();
-
-  Texture::Ref Get();
-  void Set(Texture::Ref i, NVec4 uvs = NVec4(-1, -1, -1, -1));
-  NVec2 GetSize();
-  NVec4 GetUV() { return (custom_uvs.x() != -1) ? custom_uvs : img->GetUV(); }
-  bool Loadet();
-
- private:
-  bool ext = false;
-  Texture::Ref img;
-  NVec4 custom_uvs = NVec4(-1, -1, -1, -1);
-};
-}  // namespace Palladium

include/pd/Installer.hpp

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <3ds.h>  // Result
-
-#include <string>
-
-namespace Palladium {
-struct InstallerInfo {
-  unsigned long long total;
-  unsigned long long current;
-  unsigned int mem_size = 0x80000;
-  bool active = false;
-};
-Result InstallCia(const std::string& path, bool self);
-void InstallSetBuffersSize(unsigned int bytes);
-InstallerInfo InstallGetInfo();
-}  // namespace Palladium

include/pd/Lithium.hpp

@@ -1,238 +0,0 @@
-#pragma once
-#include <citro3d.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <map>
-#include <pd/Texture.hpp>
-#include <pd/base/Allocator.hpp>
-#include <pd/maths/NVec.hpp>
-#include <vector>
-
-#define MAKEFLAG(x) (1 << x)
-
-using PDTextFlags = unsigned int;
-
-enum PDTextFlags_ {
-  PDTextFlags_None = 0,  //< Align is Left and Other things are disabled
-  PDTextFlags_AlignRight = MAKEFLAG(0),
-  PDTextFlags_AlignMid = MAKEFLAG(1),
-  PDTextFlags_Shaddow = MAKEFLAG(2),  // TextBuf Killer lol (doubled Text)
-  PDTextFlags_Wrap = MAKEFLAG(3),
-  PDTextFlags_Short = MAKEFLAG(4),
-  PDTextFlags_Scroll = MAKEFLAG(5),
-};
-
-using PDLithiumFlags = unsigned int;
-
-enum PDLithiumFlags_ {
-  PDLithiumFlags_None = 0,
-  PDLithiumFlags_TMS = MAKEFLAG(0),  // Text Map System
-  PDLithiumFlags_LRS = MAKEFLAG(1),  // Layer Render System
-  PDLithiumFlags_FCS = MAKEFLAG(2),  // Floor Coords System
-  PDLithiumFlags_Default = PDLithiumFlags_TMS,
-};
-
-namespace Palladium {
-class LIFont {
- public:
-  struct CPI {
-    CPI()
-        : codepoint(0),
-          uv(NVec4()),
-          tex(nullptr),
-          szs(NVec2()),
-          off(0.f),
-          invalid(false) {}
-    CPI(bool iv)
-        : codepoint(0),
-          uv(NVec4()),
-          tex(nullptr),
-          szs(NVec2()),
-          off(0.f),
-          invalid(iv) {}
-    unsigned int codepoint;
-    NVec4 uv;
-    Texture::Ref tex;
-    NVec2 szs;
-    float off;
-    bool invalid;
-  };
-  LIFont() = default;
-  ~LIFont() = default;
-  PD_SMART_CTOR(LIFont)
-
-  void LoadTFF(const std::string path, int px_size = 32);
-  void LoadBitmapFont(const std::string& path);
-  void LoadSystemFont();
-
-  int GetPixelHeight();
-  CPI GetCodepoint(unsigned int c);
-  std::string GetName() { return name; };
-
-  bool IsSystemFont() { return sysfnt; }
-
-  void Dump();
-
- private:
-  bool sysfnt = false;
-  std::string name;
-  int pixel_height;
-  std::map<unsigned int, CPI> cpmap;
-  std::vector<Texture::Ref> tex;
-};
-
-class LI {
- public:
-  struct Vtx {
-    Vtx() {}
-    Vtx(NVec2 xy, float u, float v, unsigned int clr) {
-      // Coords
-      pos[0] = xy[0];
-      pos[1] = xy[1];
-      pos[2] = 0.f;
-      // UV
-      uv[0] = u;
-      uv[1] = v;
-      col = clr;
-    }
-    NVec3 pos;
-    NVec2 uv;
-    unsigned int col;
-  };
-  /// CMD TYPES ///
-  /// 0 = SKIP
-  /// 2 = TRIANGLE
-  /// 1 = RECT
-  /// 3 = Circle
-  /////////////////
-  struct Cmd {
-    NVec4 top;
-    NVec4 bot;
-    NVec4 uv;
-    int layer = 0;
-    int cmd_type = 0;
-    bool fcs = false;  // Floor Coords System
-    unsigned int clr = 0;
-    bool sfr = false;  // SysFontRender
-    Texture::Ref tex = nullptr;
-    int index = 0;
-  };
-  /// Text Box ///
-  /// System to Make GetTextDiemnsions
-  /// and Short/Wrap faster
-  struct TextBox {
-    NVec2 size;
-    float time_created;
-    // Optional
-    bool optinal = false;
-    std::string text;
-  };
-  LI() = default;
-  ~LI() = default;
-
-  static void Init();
-  static void Exit();
-
-  // Settings
-  static void EnableFeature(PDLithiumFlags flag) { flags |= flag; }
-  static void DisableFeature(PDLithiumFlags flag) { flags &= ~flag; }
-  static PDLithiumFlags& GetFeatures() { return flags; }
-
-  static void OnScreen(bool bottom);
-  static void Render(C3D_RenderTarget* top, C3D_RenderTarget* bot);
-  static NVec2 GetScreenSize() { return screen_size; }
-  static LIFont::Ref GetFont() { return font; }
-  static void SetFont(LIFont::Ref i) {
-    font_update = true;
-    font = i;
-  }
-  static void UseTexture(Texture::Ref tex = nullptr) {
-    active_texture = tex ? tex : single_color;
-  }
-  static bool IsBottomScreen() { return bottom_screen; }
-  static float GetTextScale() { return text_scale; }
-  static void SetTextScale(float scale) {
-    font_update = true;
-    text_scale = scale;
-  }
-  static void DefaultTextScale() {
-    font_update = true;
-    text_scale = default_text_size;
-  }
-  static void Layer(int v) { layer = v; }
-  static int Layer() { return layer; }
-  static void NewLayer() { layer++; }
-  static NVec2 GetTextDimensions(const std::string& text);
-  static std::string ShortText(const std::string& in, int maxlen, NVec2& dim);
-  static std::string WrapText(const std::string& in, int maxlen, NVec2& dim);
-
-  // Drawing Functions
-  static void DrawRect(NVec2 pos, NVec2 size, unsigned int color, NVec4 uvs);
-  static void DrawLine(NVec2 a, NVec2 b, unsigned int clr, int t = 1);
-  static void DrawCircle(NVec2 pos, float r, unsigned int color, int segments);
-  static void DrawRect(NVec2 pos, NVec2 size, unsigned int color) {
-    UseTexture();
-    DrawRect(pos, size, color, NVec4(0, 1, 1, 0));
-  }
-  static void DrawTriangle(NVec2 a, NVec2 b, NVec2 c, unsigned int color);
-  static void DrawImage(NVec2 pos, Texture::Ref tex, NVec2 size, NVec4 uvs) {
-    UseTexture(tex);
-    DrawRect(pos, size, 0xffffffff, uvs);
-  }
-  static void DrawText(NVec2 pos, unsigned int color, const std::string& text,
-                       PDTextFlags flags = 0, NVec2 ap = NVec2());
-
-  static int Vertices() { return num_vertices; }
-  static int Indices() { return num_indices; }
-  static int Drawcalls() { return num_drawcalls; }
-  static int DarwCommands() { return num_commands; }
-  static size_t GetMaxVerticesNum() { return vertex_buffer.size(); }
-
- private:
-  static void RotateCorner(NVec2& v, float s, float c);
-  static void MakeRect(NVec4& top, NVec4& bot, NVec2 pos, NVec2 szs,
-                       float angle = 0.f);
-  static bool CompareCommands(const Cmd& a, const Cmd& b);
-  static void RenderFrame(bool bottom);
-
-  /// CTX ///
-  static PDLithiumFlags flags;
-  // Font Stuff
-  // Default Font Size in (px)
-  static const float default_font_size;
-  static const float default_text_size;
-  static float text_scale;
-
-  // Renderer Stuff
-  static NVec2 screen_size;
-  static bool bottom_screen;
-  static int layer;
-  static std::vector<Cmd> draw_lists[2];
-  static Texture::Ref active_texture;
-  static Texture::Ref single_color;
-  static std::vector<Vtx, LinearAllocator<Vtx>> vertex_buffer;
-  static std::vector<unsigned short, LinearAllocator<unsigned short>>
-      idx_buffer;
-  static size_t vertex_index;
-  static size_t idx_index;
-  static LIFont::Ref font;
-  static bool font_update;
-  static bool sysfont_render;
-  static std::map<std::string, TextBox> text_sizes;
-  static int cmd_index;
-
-  // Debug
-  static int num_vertices;
-  static int num_drawcalls;
-  static int num_commands;
-  static int num_indices;
-
-  // Shader
-  static DVLB_s* li7_dvlb;
-  static shaderProgram_s li7_prog;
-  static C3D_AttrInfo li7_attr;
-  static int uLoc_proj;
-};
-}  // namespace Palladium

include/pd/Message.hpp

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace Palladium {
-struct Message {
-  Message(std::string t, std::string m) {
-    title = t;
-    message = m;
-    animtime = 0.f;
-  }
-
-  std::string title;
-  std::string message;
-  float animtime;
-};
-
-void ProcessMessages();
-void PushMessage(const Message& msg);
-inline void PushMessage(const std::string& head, const std::string& msg) {
-  PushMessage(Message(head, msg));
-}
-// Config
-void SetMessageIdleStartFrame(int frame);
-void SetMessageTotalAnimationFrames(int total_frames);
-void SetMessageFadeOutStartFrame(int frame);
-}  // namespace Palladium

include/pd/Net.hpp

@@ -1,42 +0,0 @@
-#pragma once
-
-#include <pd/external/json.hpp>
-#include <string>
-
-namespace Palladium {
-namespace Net {
-// Define List of Errors
-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
-};
-// Set an typedefine for Error code
-using Error = unsigned long long;
-// Extract Error_ from Error code
-inline Error_ ErrorCode(Error err) {
-  return static_cast<Error_>(static_cast<unsigned int>(err & 0xffffffff));
-}
-// Extract Http Status code, Curl Error Code or Ctr Result Code
-inline int StatusCode(Error err) {
-  Error_ c = ErrorCode(err);
-  if (c != Error_StatusCode && c != Error_CtrStatus && c != Error_Curl)
-    return 0;
-  return static_cast<unsigned int>(err >> 32);
-}
-Error Download(const std::string& url, std::string& data);
-Error Download2File(const std::string& url, const std::string& path);
-Error GitDownloadRelease(const std::string& url, const std::string& asset_name,
-                         const std::string& path, bool prerelease = false);
-Error JsonApiRequest(const std::string& api_url, nlohmann::json& res);
-unsigned long long GetProgressCurrent();
-unsigned long long GetProgressTotal();
-}  // namespace Net
-}  // namespace Palladium

include/pd/Overlays.hpp

@@ -1,107 +0,0 @@
-#pragma once
-
-#include <pd/Ovl.hpp>
-#include <pd/Timer.hpp>
-#include <pd/base/FunctionTrace.hpp>
-#include <pd/maths/NVec.hpp>
-#include <string>
-
-typedef int PDKeyboard;
-
-enum PDKeyboard_ {
-  PDKeyboard_Default,
-  PDKeyboard_Numpad,
-  PDKeyboard_Password,
-};
-
-enum PDKeyboardState {
-  PDKeyboardState_None = 0,
-  PDKeyboardState_Cancel = 1,
-  PDKeyboardState_Confirm = 2,
-};
-
-using PDKeyboardFlags = unsigned int;
-enum PDKeyboardFlags_ {
-  PDKeyboardFlags_None = 0,
-  PDKeyboardFlags_BlendTop = 1 << 0,
-  PDKeyboardFlags_BlendBottom = 1 << 1,
-  PDKeyboardFlags_LockControls = 1 << 2,
-  PDKeyboardFlags_Default = PDKeyboardFlags_BlendTop |
-                            PDKeyboardFlags_BlendBottom |
-                            PDKeyboardFlags_LockControls,
-};
-
-namespace Palladium {
-class Ovl_Ftrace : public Palladium::Ovl {
- public:
-  /// @brief Constructor
-  Ovl_Ftrace(bool* is_enabled);
-  /// @brief Override for Draw
-  void Draw(void) const override;
-  /// @brief Override for Logic
-  void Logic() override;
-
- private:
-  bool* i_is_enabled;
-};
-
-class Ovl_Metrik : public Palladium::Ovl {
- public:
-  /// @brief Constructor
-  Ovl_Metrik(bool* is_enabled, bool* screen, unsigned int* mt_color,
-             unsigned int* txt_color, float* txt_size);
-  /// @brief Override for Draw
-  void Draw(void) const override;
-  /// @brief Override for Logic
-  void Logic() override;
-
- private:
-  // Mutable internal values
-  mutable std::string mt_fps;
-  mutable std::string mt_cpu;
-  mutable std::string mt_gpu;
-  mutable std::string mt_cmd;
-  mutable std::string mt_lfr;
-  mutable std::string mt_vtx;
-  mutable std::string mt_idx;
-  mutable std::string mt_drc;
-  mutable std::string mt_dmc;
-  mutable std::string mt_mem;
-
-  // Importand Adresses
-  bool* i_is_enabled;
-  bool* i_screen;
-  unsigned int* i_mt_color;
-  unsigned int* i_txt_color;
-  float* i_txt_size;
-  mutable Ftrace::TimeStats cpu_stats;
-  mutable Ftrace::TimeStats gpu_stats;
-  mutable Timer v_update;
-};
-
-class Ovl_Keyboard : public Palladium::Ovl {
- public:
-  /// @brief Constructor
-  /// Keyboard Type not Supported for now
-  Ovl_Keyboard(std::string& ref, PDKeyboardState& state,
-               const std::string& hint = "", PDKeyboard type = 0,
-               PDKeyboardFlags flags = PDKeyboardFlags_Default);
-  /// @brief Deconstructor
-  ~Ovl_Keyboard();
-  /// @brief Override for Draw
-  void Draw(void) const override;
-  /// @brief Override for Logic
-  void Logic() override;
-
- private:
-  mutable std::map<unsigned char, char> shared_data;
-  // Pointer to useres String
-  std::string* typed_text = nullptr;
-  std::string str_bak;
-  PDKeyboardState* state;
-  PDKeyboard type;
-  int mode = 0;
-  int ft3 = 0;
-  PDKeyboardFlags flags;
-};
-}  // namespace Palladium

include/pd/Ovl.hpp

@@ -1,28 +0,0 @@
-#pragma once
-#include <map>
-#include <memory>
-
-namespace Palladium {
-/// @brief The Overlay Class (Used for Toasts for example)
-class Ovl {
- public:
-  /// @brief Deconstructor
-  virtual ~Ovl() {}
-  /// @brief Function Called to Draw this
-  virtual void Draw() const = 0;
-  /// @brief Logic of the Overlay
-  virtual void Logic() = 0;
-  /// @brief Should the overlay be killed
-  /// @return Killed or Not
-  inline bool IsKilled() { return this->iskilled; }
-  /// @brief Kill The Overlay
-  inline void Kill() { iskilled = true; }
-
- private:
-  /// @param iskilled For IsKilled();
-  bool iskilled = false;
-};
-/// @brief Add an Overlay to the Screen
-/// @param scene Overlay to push to Screen
-void AddOvl(std::unique_ptr<Palladium::Ovl> scene);
-}  // namespace Palladium

include/pd/ResultDecoder.hpp

@@ -1,54 +0,0 @@
-#pragma once
-#include <3ds.h>
-
-#include <string>
-
-namespace Palladium {
-/// @brief Decoder for 3ds Result Codes
-class ResultDecoder {
- public:
-  /// @brief Constructor
-  ResultDecoder() {}
-  /// @brief Deconstructor
-  ~ResultDecoder() {}
-  /// @brief Load a Result into Decoder
-  /// @param rescode Result Code
-  void Load(Result rescode);
-  /// @brief Load A Hex Converted Code into Decoder
-  /// @param rescode Result-Hex Code
-  void Load(std::string rescode);
-  /// @brief Get Hex Code
-  /// @return Hex-Code
-  std::string GetCode();
-  /// @brief Get Level Name
-  /// @return Level Name
-  std::string GetLevel();
-  /// @brief Get Level Value
-  /// @return Level Value
-  int GetLevelInt();
-  /// @brief Get The Mosule Name
-  /// @return Module Name
-  std::string GetModule();
-  /// @brief Get The Module Value
-  /// @return Module Value
-  int GetModuleInt();
-  /// @brief Get The Description
-  /// @return Description
-  std::string GetDescription();
-  /// @brief Get The Description Valur
-  /// @return Description Value
-  int GetDescriptionInt();
-  /// @brief Get the Summary
-  /// @return Summary
-  std::string GetSummary();
-  /// @brief Get the Summary Value
-  /// @return Summary Value
-  int GetSummaryInt();
-  /// @brief Write a Result log file to sd
-  void WriteLog(void);
-
- private:
-  /// @param m_rescode Result code
-  Result m_rescode;
-};
-}  // namespace Palladium

include/pd/Rubidium.hpp

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <pd/nimg.hpp>
-#include <pd/smart_ctor.hpp>
-
-namespace Palladium {
-class Rubidium {
- public:
-  Rubidium(int w, int h);
-  Rubidium();
-  ~Rubidium();
-  PD_SMART_CTOR(Rubidium)
-  nimg& GetNimg() { return image; }
-  void LoadFile(const std::string& path);
-  void LoadNimg(const std::string& path);
-
-  // Rendering
-  void DrawPixel(int x, int y, unsigned int color);
-  void DrawRect(int x, int y, int w, int h, unsigned int color, int t = 1);
-  void DrawRectSolid(int x, int y, int w, int h, unsigned int color);
-  void DrawLine(int x1, int y1, int x2, int y2, unsigned int color, int t = 1);
-  void Flip(bool h, bool v);
-  void EnableAA(bool enable) { enable_aa = enable; }
-
- private:
-  // Leinwand (dont know english word for that)
-  nimg image;
-  bool enable_aa = true;
-};
-}  // namespace Palladium

include/pd/Sheet.hpp

@@ -1,23 +0,0 @@
-#pragma once
-#include <tex3ds.h>
-
-#include <pd/Image.hpp>
-#include <pd/Texture.hpp>
-#include <pd/smart_ctor.hpp>
-
-namespace Palladium {
-class Sheet {
- public:
-  Sheet() = default;
-  ~Sheet() = default;
-  PD_SMART_CTOR(Sheet)
-  void LoadT3X(const std::string& path);
-  Texture::Ref Get(int idx);
-  Image::Ref GetImage(int idx);
-
- private:
-  std::vector<Texture::Ref> sprites;
-  Tex3DS_Texture sheet;
-  C3D_Tex* sheet_tex = nullptr;
-};
-}  // namespace Palladium

include/pd/Sound.hpp

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <3ds.h>
-
-#include <pd/smart_ctor.hpp>
-#include <string>
-
-namespace Palladium {
-/** Sound Class */
-class Sound {
- public:
-  /// \brief Construct new Soundeffect
-  /// \param path Path to the .wav file
-  /// \param channel the channel 1-23
-  /// \param toloop true:loop the sound, false: don't loop
-  Sound(const std::string &path, int channel = 1, bool toloop = false);
-  /// @brief Deconstructor
-  ~Sound();
-  PD_SMART_CTOR(Sound)
-  /// @brief Play the sound
-  void Play();
-  /// @brief Stop the sound
-  void Stop();
-
- private:
-  /// \param dataSize Size of the filedata
-  u32 dataSize;
-  /// \param waveBuf For ndsp
-  ndspWaveBuf waveBuf;
-  /// \param data Memmory data of the sound
-  uint8_t *data = NULL;
-  /// \param chnl Channel of the sound
-  int chnl;
-};
-}  // namespace Palladium

include/pd/Sprite.hpp

@@ -1,63 +0,0 @@
-#pragma once
-
-#include <citro3d.h>
-
-#include <pd/Image.hpp>
-#include <pd/smart_ctor.hpp>
-
-namespace Palladium {
-/// @brief Sprite Class
-class Sprite {
- public:
-  /// \brief Construct Sprite
-  Sprite() = default;
-  /// \brief Deconstruct Sprite
-  ~Sprite() = default;
-  PD_SMART_CTOR(Sprite)
-  /// \brief Load a Sprite From SpriteSheet
-  /// \param img the Image to load from.(Palladium::Image)
-  void FromImage(Palladium::Image::Ref img);
-  /// @brief Draw the Sprite
-  /// @return success ?
-  bool Draw();
-  /// @brief Set the Center Position
-  /// @param x X Pos
-  /// @param y Y Pos
-  void SetCenter(float x, float y);
-  /// @brief Set the Sprite's Position
-  /// @param x X Pos
-  /// @param y Y Pos
-  void SetPos(float x, float y);
-  /// @brief Set The Sprite's Scale
-  /// @param x Scale on X-Axis
-  /// @param y Scale on Y-Axis
-  void SetScale(float x, float y);
-  /// @brief Set the Sprite's Rotation
-  /// @param rotation ratation
-  void SetRotation(float rotation);
-  /// @brief Rotate the Sprite
-  /// @param speed Speed to Rotate
-  void Rotate(float speed);
-  /// @brief Get Tje Sprite's Width
-  /// @return Width
-  float GetWidth();
-  /// @brief Get the Sprite's Height
-  /// @return Height
-  float GetHeight();
-  /// @brief Get The Sprite's X Position
-  /// @return X Position
-  float GetPosX();
-  /// @brief Get the Sprite's Y Position
-  /// @return Y Position
-  float GetPosY();
-  NVec2 GetSize();
-  NVec2 GetPos();
-  void SetPos(NVec2 pos);
-  void SetScale(NVec2 scale);
-  void SetRotCenter(NVec2 percentage);
-
- private:
-  ///// @param sprite The Sprite
-  // C2D_Sprite sprite;
-};
-}  // namespace Palladium

include/pd/Tasks.hpp

@@ -1,13 +0,0 @@
-#pragma once
-#include <functional>
-
-namespace Palladium {
-namespace Tasks {
-/// @brief Push A Task
-/// @param fun Function of Your Task
-/// @return index
-int Create(std::function<void()> fun);
-/// @brief Destroy all Tasks
-void DestroyAll();
-}  // namespace Tasks
-}  // namespace Palladium

include/pd/Texture.hpp

@@ -1,77 +0,0 @@
-#pragma once
-#include <citro3d.h>
-
-#include <pd/maths/NVec.hpp>
-#include <pd/smart_ctor.hpp>
-#include <string>
-#include <vector>
-
-namespace Palladium {
-class Texture {
- public:
-  // Define Types supported by the texture loader
-  // For example usefull to waste not as much space
-  // in linear mem
-  enum Type {
-    RGBA32,
-    RGB24,
-    A8,
-  };
-
-  enum Filter {
-    NEAREST,
-    LINEAR,
-  };
-  Texture() {
-    // Set Default UV
-    this->uvs[0] = 0.0f;
-    this->uvs[1] = 1.0f;
-    this->uvs[2] = 1.0f;
-    this->uvs[3] = 0.0f;
-  };
-  ~Texture() { Delete(); }
-  PD_SMART_CTOR(Texture)
-
-  void Delete();
-
-  /// @brief Loads an Image [png, jpg, bmp] as texture
-  /// by default it sets up the texture as RGBA32 and
-  /// only supports RGB24 and RGBA32 images
-  /// @param path Path to file
-  void LoadFile(const std::string& path);
-  /// @brief Loads an Image [png, jpg, bmp] as texture
-  /// by default it sets up the texture as RGBA32 and
-  /// only supports RGB24 and RGBA32 images
-  /// @param data Data of file
-  void LoadFromMemory(const std::vector<unsigned char>& data);
-  /// @brief Create Texture by pixel Data. This function supports
-  /// [RGBA32, RGB24, A8]
-  /// @param data Pixel Data
-  /// @param w Width of data
-  /// @param h Height of Data
-  /// @param type Type of Data (default is RGBA32)
-  void LoadPixels(const std::vector<unsigned char>& data, int w, int h,
-                  Type type = RGBA32, Filter filter = NEAREST);
-
-  /// @brief This function sets up a texture Object based on the input
-  /// Data and a self setup C3D_Tex. You dont need to delete it as
-  /// This class does this automatically
-  void ExternalLoad(C3D_Tex* tex, NVec2 rszs, NVec4 uvs);
-
-  C3D_Tex* Get() { return this->tex; }
-  NVec2 GetTexSize();
-  NVec2 GetSize() { return img_size; }
-  // As the texture is a pow of 2 we need a uv
-  NVec4 GetUV() { return uvs; }
-
-  void AutoDelete(bool enable) { ad = enable; }
-
- private:
-  void MakeTex(std::vector<unsigned char>& buf, int w, int h,
-               Type type = RGBA32, Filter filter = NEAREST);
-  C3D_Tex* tex = nullptr;
-  NVec2 img_size;
-  NVec4 uvs;
-  bool ad = true;
-};
-}  // namespace Palladium

include/pd/ThemeEditor.hpp

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <pd/palladium.hpp>
-
-namespace Palladium {
-class ThemeEditor : public Palladium::Scene {
- public:
-  ThemeEditor();
-  ~ThemeEditor();
-
-  void Update() override;
-
- private:
-  Theme::Ref edit_theme;
-  // Placeholder to save active one to
-  Theme::Ref temp_theme;
-
-  // temp vars for samples
-  bool cm;
-  std::string inpt;
-  int menu = 0;
-
-  // Keyboard
-  PDKeyboardState kbd_state;
-  std::string kbd_text;
-  std::vector<std::string> theme_list;
-};
-}  // namespace Palladium

include/pd/Time.hpp

@@ -1,13 +0,0 @@
-#pragma once
-#include <string>
-
-namespace Palladium {
-/// @brief Format a String
-/// @param fmt_str Format To
-/// @param ... Additional Args
-/// @return Formatted String
-std::string FormatString(std::string fmt_str, ...);
-/// @brief Get Current Time as String
-/// @return Time-String
-std::string GetTimeStr(void);
-}  // namespace Palladium

include/pd/Timer.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <3ds.h>
-
-#include <pd/smart_ctor.hpp>
-
-namespace Palladium {
-class Timer {
- public:
-  Timer(bool autostart = true);
-  ~Timer() {}
-  PD_SMART_CTOR(Timer)
-  void Reset();
-  void Tick();
-  void Pause();
-  void Resume();
-  float Get();
-  float GetLive();
-  bool Running();
-
- private:
-  uint64_t last = 0;
-  uint64_t current = 0;
-  bool is_running = false;
-};
-}  // namespace Palladium

include/pd/UI7.hpp

@@ -1,134 +0,0 @@
-#pragma once
-
-#include <pd/Image.hpp>
-#include <pd/Lithium.hpp>
-#include <pd/base/Color.hpp>
-#include <pd/maths/NVec.hpp>
-#include <pd/smart_ctor.hpp>
-
-#define UI7MAKEFLAG(x) (1 << x)
-
-using UI7MenuFlags = unsigned int;
-
-enum UI7MenuFlags_ {
-  UI7MenuFlags_None = 0,
-  UI7MenuFlags_NoTitlebar = UI7MAKEFLAG(0),
-  UI7MenuFlags_TitleMid = UI7MAKEFLAG(1),
-  UI7MenuFlags_HzScrolling = MAKEFLAG(2),
-  UI7MenuFlags_VtScrolling = MAKEFLAG(3),
-  UI7MenuFlags_Scrolling = UI7MenuFlags_HzScrolling | UI7MenuFlags_VtScrolling,
-};
-
-enum UI7Horizontal {
-  UI7Horizontal_Left = 0,
-  UI7Horizontal_Center = 1,
-  UI7Horizontal_Right = 2,
-};
-
-enum UI7Vertical {
-  UI7Vertical_Top = 0,
-  UI7Vertical_Center = 1,
-  UI7Vertical_Bot = 2,
-};
-
-class DrawCmd;
-class UI7DrawList {
- public:
-  UI7DrawList() = default;
-  ~UI7DrawList() = default;
-
-  void AddRectangle(NVec2 pos, NVec2 szs, PDColor clr);
-  void AddRectangle(NVec2 pos, NVec2 szs, unsigned int clr);
-  void AddTriangle(NVec2 pos0, NVec2 pos1, NVec2 pos2, PDColor clr);
-  void AddTriangle(NVec2 pos0, NVec2 pos1, NVec2 pos2, unsigned int clr);
-  void AddText(NVec2 pos, const std::string &text, PDColor clr,
-               PDTextFlags flags = 0, NVec2 box = NVec2());
-  void AddText(NVec2 pos, const std::string &text, unsigned int clr,
-               PDTextFlags flags = 0, NVec2 box = NVec2());
-  void AddImage(NVec2 pos, Palladium::Image::Ref img);
-  void AddCall(std::shared_ptr<DrawCmd> cmd);
-
-  void Process(bool auto_clear = true);
-  void Clear();
-  int Layer() { return layer; }
-  void Layer(int v) { layer = v; }
-  int BaseLayer() { return bl; }
-  void BaseLayer(int v) { bl = v; }
-
-  PD_SMART_CTOR(UI7DrawList)
-
- private:
-  int layer = 0;
-  int bl = 0;
-  void AddDebugCall(std::shared_ptr<DrawCmd> cmd);
-  std::vector<std::shared_ptr<DrawCmd>> list;
-};
-
-namespace UI7 {
-// Key functions
-void Init();
-void Deinit();
-void Update();
-float GetTime();
-float GetDeltaTime();
-bool &IsDebugging();
-// Internal Function
-// Should not be used
-void Debug();
-bool &DebugMenu();
-
-bool Button(const std::string &label, NVec2 size = NVec2(0, 0));
-void Checkbox(const std::string &label, bool &c);
-void Label(const std::string &label, PDTextFlags flags = 0);
-void Progressbar(float value);
-/// @brief Draw Image in Menu
-/// @param img Pointer f.e to Palladium::Image2
-void Image(Palladium::Image::Ref img);
-void BrowserList(const std::vector<std::string> &entrys, int &selection,
-                 PDTextFlags txtflags = 0, NVec2 size = NVec2(0, 0),
-                 int max_entrys = 13);
-void InputText(const std::string &label, std::string &text,
-               const std::string &hint = "");
-bool BeginMenu(const std::string &title, NVec2 size = NVec2(0, 0),
-               UI7MenuFlags flags = 0);
-void EndMenu();
-void Grid(const std::string &name, const NVec2 &size, const NVec2 &entry_size,
-          void (*display_func)(void *, NVec2), void **data_array,
-          size_t num_entrys);
-void ColorSelector(const std::string &label, unsigned int &color);
-bool BeginTree(const std::string &text);
-void EndTree();
-void Prompt(const std::string &label, int &res,
-            // For Translations
-            const std::string &lcf = "Confirm",
-            const std::string &lcc = "Cancel");
-void ClosePromts();
-NVec2 GetCursorPos();
-void SetCursorPos(NVec2 cp);
-void RestoreCursor();
-void SameLine();
-void Separator();
-// Internal API (For Creating Custom Objects)
-bool InBox(NVec2 inpos, NVec2 boxpos, NVec2 boxsize);
-void MoveCursor(NVec2 size);
-bool HandleScrolling(NVec2 &pos, NVec2 size);
-bool InMenu();
-namespace Menu {
-// All of them return the Main BG DrawList if Menu is null
-UI7DrawList::Ref GetBackgroundList();
-UI7DrawList::Ref GetList();
-UI7DrawList::Ref GetForegroundList();
-// Other Menu Specific Functions
-float GetScrollingOffset();
-void SetScrollingOffset(float off);
-bool IsScrolling();
-}  // namespace Menu
-namespace Next {
-// Alignment in ScreenSpace
-void Align(UI7Horizontal hz = UI7Horizontal_Left,
-           UI7Vertical vt = UI7Vertical_Top);
-}  // namespace Next
-// DrawLists
-UI7DrawList::Ref GetForegroundList();
-UI7DrawList::Ref GetBackgroundList();
-}  // namespace UI7

include/pd/base/Allocator.hpp

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <3ds.h>
-
-#include <memory>
-#include <pd/Error.hpp>
-
-// Write own LinearAllocator for learning
-
-namespace Palladium {
-template <typename T>
-class LinearAllocator : public std::allocator<T> {
- public:
-  typedef size_t size_type;
-  typedef T* pointer;
-  typedef const T* const_pointer;
-
-  template <typename T1>
-  struct rebind {
-    typedef LinearAllocator<T1> other;
-  };
-
-  pointer allocate(size_type n, const void* hint = nullptr) {
-    if (n > this->max_size()) {
-      Palladium::Error(
-          "Linear Allocator: \nBad Alloc -> size is larger than free space!");
-      return nullptr;
-    }
-    return (pointer)linearAlloc(n * sizeof(T));
-  }
-
-  void deallocate(pointer p, size_type) { linearFree((void*)p); }
-
-  size_type max_size() { return linearSpaceFree(); }
-
-  LinearAllocator() throw() {}
-  LinearAllocator(const LinearAllocator<T>& a) throw() : std::allocator<T>(a) {}
-  ~LinearAllocator() throw() {}
-};
-}  // namespace Palladium

include/pd/base/Color.hpp

@@ -1,204 +0,0 @@
-#pragma once
-#include <unistd.h>
-
-#include <cstring>
-#include <memory>
-#include <pd/smart_ctor.hpp>
-#include <string>
-#include <vector>
-
-#define UNPACK_RGBA(col) \
-  (unsigned char)(col >> 24), (col >> 16), (col >> 8), (col)
-#define UNPACK_BGRA(col) \
-  (unsigned char)(col >> 8), (col >> 16), (col >> 24), (col)
-
-inline unsigned int RGBA8(unsigned char r, unsigned char g, unsigned char b,
-                          unsigned char a = 255) {
-  return (r | g << 8 | b << 16 | a << 24);
-}
-
-typedef int PDColor;
-
-// MultiColor (Less FunctionNameLen)
-
-struct Color2 {
-  unsigned int color0;
-  unsigned int color1;
-};
-
-struct Color3 {
-  unsigned int color0;
-  unsigned int color1;
-  unsigned int color2;
-};
-
-struct Color4 {
-  unsigned int color0;
-  unsigned int color1;
-  unsigned int color2;
-  unsigned int color3;
-};
-
-enum PDColor_ {
-  PDColor_Text,  ///< This Color Should always be used for Light Backgrounds
-  PDColor_TextDisabled,  /// Text Disabled Color
-  PDColor_Text2,         ///< And This want for Texts on Dark Backgrounds
-  PDColor_Background,    ///< Your Bg Color
-  PDColor_Header,        ///< Header Color (if the header is dark text2 is used)
-  PDColor_Selector,      ///< Selector Color
-  PDColor_SelectorFade,  ///< Selector FadingTo Color
-  PDColor_List0,         ///< List Color1
-  PDColor_List1,         ///< List Color2
-  PDColor_MessageBackground,  ///< Message Background
-  PDColor_Button,             ///< Button Color
-  PDColor_ButtonHovered,      ///< Button Color if Hovered
-  PDColor_ButtonDisabled,     ///< Button Color if disabled
-  PDColor_ButtonActive,       ///< Button Colkor if Clicked
-  PDColor_Checkmark,          ///< Checkbox Checkmark Color
-  PDColor_FrameBg,            ///< Frame Background Color
-  PDColor_FrameBgHovered,     ///< Frame Background Color if hovered
-  PDColor_Progressbar,        ///< Progressbar Color
-  /// NON COLOR ///
-  PDColor_Len,  ///< Used to define the lengh of this list
-};
-
-namespace Palladium {
-class Theme {
- public:
-  Theme() = default;
-  ~Theme() = default;
-
-  void Load(const std::string &path);
-  void Default();
-  void Save(const std::string &path);
-
-  unsigned int Get(PDColor clr);
-  void Set(PDColor clr, unsigned int v);
-  void Swap(PDColor a, PDColor b);
-  bool Undo();
-  void UndoAll();
-  void TextBy(PDColor bg);
-  PDColor AutoText(PDColor bg);
-  void ClearHistory() { changes.clear(); }
-
-  std::vector<unsigned int> &GetTableRef() { return clr_tab; }
-  // For Smart Pointer
-  PD_SMART_CTOR(Theme);
-
-  // Loader method
-  void CopyOther(Theme::Ref theme);
-
- private:
-  struct change {
-    change(PDColor a, unsigned int f, unsigned int t)
-        : clr(a), from(f), to(t) {}
-    change(PDColor a, PDColor b, unsigned int f, unsigned int t)
-        : clr(a), clr2(b), from(f), to(t) {}
-    PDColor clr;
-    PDColor clr2 = 0;  // Used if Swap
-    unsigned int from;
-    unsigned int to;
-  };
-  // Use a vector for faster access
-  std::vector<unsigned int> clr_tab;
-  std::vector<change> changes;
-};
-
-Theme::Ref ThemeActive();
-/// @brief Change Theme Adress
-/// @param theme your adress
-void ThemeSet(Theme::Ref theme);
-namespace Color {
-/// @brief RGBA Class
-class RGBA {
- public:
-  /// @brief Construct
-  /// @param r
-  /// @param g
-  /// @param b
-  /// @param a
-  RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255)
-      : m_r(r), m_g(g), m_b(b), m_a(a) {}
-  /// @brief Construct
-  /// @param r
-  /// @param g
-  /// @param b
-  /// @param a
-  RGBA(float r, float g, float b, float a = 1.f)
-      : m_r(r * 255.f), m_g(g * 255.f), m_b(b * 255.f), m_a(a * 255.f) {}
-  RGBA(unsigned int in) {
-#define ISIMPLEUNPAK(x, y) (((x) >> y) & 0xFF)
-    m_r = ISIMPLEUNPAK(in, 0);
-    m_g = ISIMPLEUNPAK(in, 8);
-    m_b = ISIMPLEUNPAK(in, 16);
-    m_a = ISIMPLEUNPAK(in, 24);
-  }
-  RGBA(PDColor in) {
-    if (!Palladium::ThemeActive()) return;
-    unsigned int col = Palladium::ThemeActive()->Get(in);
-    m_r = ISIMPLEUNPAK(col, 0);
-    m_g = ISIMPLEUNPAK(col, 8);
-    m_b = ISIMPLEUNPAK(col, 16);
-    m_a = ISIMPLEUNPAK(col, 24);
-  }
-  RGBA &changeR(unsigned char r) {
-    m_r = r;
-    return *this;
-  }
-  RGBA &changeG(unsigned char g) {
-    m_g = g;
-    return *this;
-  }
-  RGBA &changeB(unsigned char b) {
-    m_b = b;
-    return *this;
-  }
-  RGBA &changeA(unsigned char a) {
-    m_a = a;
-    return *this;
-  }
-
-  RGBA &fade_to(const RGBA &color, float p) {
-    m_a =
-        m_a + static_cast<unsigned char>((color.m_a - m_a) * ((p + 1.0f) / 2));
-    m_b =
-        m_b + static_cast<unsigned char>((color.m_b - m_b) * ((p + 1.0f) / 2));
-    m_g =
-        m_g + static_cast<unsigned char>((color.m_g - m_g) * ((p + 1.0f) / 2));
-    m_r =
-        m_r + static_cast<unsigned char>((color.m_r - m_r) * ((p + 1.0f) / 2));
-    return *this;
-  }
-
-  /// @brief Get as Uint32
-  /// @return color
-  unsigned int toRGBA() const { return RGBA8(m_r, m_g, m_b, m_a); }
-
-  // Just calculate the "lightness" f.e. to use Text or Text2
-  float luminance() const {
-    // For Reference https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness
-    return (0.3 * (m_r / 255.f) + 0.59 * (m_g / 255.f) + 0.11 * (m_b / 255.f));
-  }
-
-  bool is_light() {
-    // Gives us the light or dark to not
-    // always use the below "if" statement
-    return (luminance() >= 0.5);
-  }
-
-  unsigned char m_r = 0, m_g = 0, m_b = 0, m_a = 0;
-};
-std::string RGBA2Hex(unsigned int c32);
-/// @brief Convert RGB to Hex
-/// @param r
-/// @param g
-/// @param b
-/// @return Hex-String
-std::string RGB2Hex(int r, int g, int b);
-/// @brief Hex to U32
-/// @param color
-/// @param a
-/// @return Color32
-unsigned int Hex(const std::string &color, unsigned char a = 255);
-}  // namespace Color
-}  // namespace Palladium

include/pd/base/FileSystem.hpp

@@ -1,24 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-namespace Palladium {
-namespace FileSystem {
-/// @brief A Directory Entry
-struct Entry {
-  /// @brief Patf of The Entry
-  std::string path;
-  /// @brief Name of The Entry
-  std::string name;
-  /// @brief Directory or File
-  bool dir = false;
-};
-/// @brief Gets All Entrys of A Directory into a Vector
-/// @param path The Path of the Directory
-/// @return The Vector of found Entrys
-std::vector<Palladium::FileSystem::Entry> GetDirContent(std::string path);
-std::string GetParentPath(std::string path, std::string mount_point);
-std::vector<Entry> GetDirContentsExt(
-    std::string &path, const std::vector<std::string> &extensions);
-}  // namespace FileSystem
-}  // namespace Palladium

include/pd/base/FunctionTrace.hpp

@@ -1,137 +0,0 @@
-#pragma once
-// Base includes
-#include <functional>
-#include <map>
-#include <string>
-
-// 3ds does not support std::chrono
-#include <3ds.h>
-
-/// @brief 3ds System Ticks per milli second
-#define TICKS_PER_MSEC 268111.856
-
-#define f2s(x_) #x_
-#define scomb(x1, x2) std::string(x1 + x2)
-
-namespace Palladium {
-namespace Ftrace {
-class TimeStats {
- public:
-  TimeStats(int len) : len(len), values(len, 0) {}
-
-  void Add(float v) {
-    values[idx] = v;
-    idx = next_index(idx);
-    num_values = std::min(num_values + 1, len);
-  }
-
-  float GetAverage() {
-    float res = 0.f;
-    if (!num_values) {
-      return res;
-    }
-    for (int i = 0; i < num_values; ++i) {
-      res += values[index(i)];
-    }
-    return res / num_values;
-  }
-
-  float GetMax() {
-    float res = 0.f;
-    if (!num_values) {
-      return res;
-    }
-    for (int i = 0; i < num_values; i++) {
-      res = std::max(res, values[index(i)]);
-    }
-    return res;
-  }
-
-  float GetMin() {
-    float res = 0.f;
-    if (!num_values) {
-      return res;
-    }
-    res = values[0];
-    for (int i = 0; i < num_values; i++) {
-      res = std::min(res, values[index(i)]);
-    }
-    return res;
-  }
-
-  const std::vector<float>& GetData() { return values; }
-  const float& operator[](int i) { return values[index(i)]; }
-  const size_t GetLen() { return len; }
-  const size_t GetNumValues() { return num_values; }
-
- private:
-  // Indexing Functions for better overview
-  size_t next_index(size_t current) const { return (current + 1) % len; }
-  size_t index(size_t v) const { return (idx + len - num_values + v) % len; }
-
-  // Data
-  int len = 0;
-  std::vector<float> values;
-  int idx = 0;
-  int num_values = 0;
-};
-/// @brief Result of FTrace
-struct FTRes {
-  FTRes() : time_start(0), time_end(0), time_of(0.f), is_ovl(false), ts(60) {}
-  std::string group;      ///< Group of the Trace
-  std::string func_name;  ///< Function Name
-
-  uint64_t time_start;  ///< when started
-  uint64_t time_end;    ///< when stopped
-  float time_of;        ///< stop - start (how long)
-  bool is_ovl;          ///< is displayed in overlay?
-  TimeStats ts;         ///< Time Stats
-};
-
-/// @brief Map of Traces
-extern std::map<std::string, Palladium::Ftrace::FTRes> pd_traces;
-
-/// @brief Set a Start TracePoint
-/// @param group Set a Group Name
-/// @param func_name Set a Function Name
-inline void Beg(const std::string& group, const std::string& func_name) {
-  std::string trace_id = scomb(group, func_name);
-  auto& trace = pd_traces[trace_id];
-  trace.group = group;
-  trace.func_name = func_name;
-  trace.time_start = svcGetSystemTick();
-}
-/// @brief Set an End TracePoint
-/// @param group Set a Group Name
-/// @param func_name Set a Function Name
-inline void End(const std::string& group, const std::string& func_name) {
-  std::string trace_id = scomb(group, func_name);
-  auto& trace = pd_traces[trace_id];
-  trace.time_end = svcGetSystemTick();
-  trace.time_of =
-      static_cast<float>(trace.time_end - trace.time_start) / TICKS_PER_MSEC;
-  trace.ts.Add(trace.time_of);
-}
-/// @brief Trace a function execution
-/// @param group Set a Group Name
-/// @param name Set a Function Name
-inline void Func(const std::string& group, const std::string& name,
-                 std::function<void()> fun) {
-  if (!fun) return;
-  Beg(group, name);
-  fun();
-  End(group, name);
-}
-
-/// @brief This Starts an Ftrace and
-/// end ist when going out of scope
-struct ScopedTrace {
-  ScopedTrace(std::string g, std::string n) : group(g), name(n) {
-    Ftrace::Beg(g, n);
-  }
-  ~ScopedTrace() { Ftrace::End(group, name); }
-  std::string group;
-  std::string name;
-};
-}  // namespace Ftrace
-}  // namespace Palladium

include/pd/base/Lang.hpp

@@ -1,24 +0,0 @@
-#pragma once
-// clang-format off
-#include <string>
-#include <pd/external/json.hpp>
-// clang-format on
-
-namespace Palladium {
-namespace Lang {
-/// @brief Get 3ds System lang! [en] by default
-/// @return Sytemlang as string
-std::string GetSys();
-/// @brief Get The Translation String
-/// @param key Key of Translation
-/// @return The Translated String
-std::string Get(const std::string &key);
-/// @brief Load A Language json
-/// @param lang The Language Key [en], [de], etc, or getSys()
-void Load(const std::string &lang);
-// New funcs
-std::string GetName();
-std::string GetAuthor();
-std::string GetShortcut();
-}  // namespace Lang
-}  // namespace Palladium

include/pd/base/Memory.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-namespace Palladium {
-namespace Memory {
-/// @brief Metriks struct For the Internal Tracker
-struct memory_metrics {
-  unsigned int t_TotalAllocated = 0;  ///< Total Allocated Memory
-  unsigned int t_TotalFreed = 0;      ///< Total Deleted Memory
-  /// @brief Gets the Currently Allocated Memory
-  unsigned int t_CurrentlyAllocated() {
-    return t_TotalAllocated - t_TotalFreed;
-  }
-};
-/// @brief Get Total Allocated Memory
-/// @return Total Allocated Memory
-size_t GetTotalAllocated();
-/// @brief Get Total Deleted Memory
-/// @return Total Deleted Memory
-size_t GetTotalFreed();
-/// @brief Get Current Allocated Memory
-/// @return Current Allocated Memory
-size_t GetCurrent();
-}  // namespace Memory
-}  // namespace Palladium

include/pd/base/stringtool.hpp

@@ -1,98 +0,0 @@
-#pragma once
-#include <format>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include <string>
-
-namespace Palladium {
-/// @brief Check if A String ends with
-/// @param name Input String
-/// @param extensions Extensions to Check for
-/// @return Ends with or not
-inline bool NameIsEndingWith(const std::string &name,
-                             const std::vector<std::string> &extensions) {
-  if (name.substr(0, 2) == "._") return false;
-
-  if (name.size() == 0) return false;
-
-  if (extensions.size() == 0) return true;
-
-  for (int i = 0; i < (int)extensions.size(); i++) {
-    const std::string ext = extensions.at(i);
-    if (strcasecmp(name.c_str() + name.size() - ext.size(), ext.c_str()) == 0)
-      return true;
-  }
-
-  return false;
-}
-/// @brief Format Milliseconds to clean string (Stolen from one of my Mc
-/// Plugins)
-/// @param t_time Time in ms
-/// @return String
-inline std::string MsTimeFmt(float t_time, bool dems = false) {
-  std::string res;
-
-  if (t_time < 0.000001f) {
-    res = std::format("{:.2f}ns", t_time * 1000000.f);
-  } else if (t_time < 0.001f) {
-    res = std::format("{:.2f}µs", t_time * 1000.f); 
-  } else if (t_time < 1.0f) {
-    res = std::format("{:.2f}ms", t_time);
-  } else if (t_time < 60000.0f) {
-    int seconds = static_cast<int>(t_time / 1000.0f);
-    float milliseconds = t_time - (seconds * 1000.0f);
-    if (seconds) {
-      res = std::format("{}s {:.2f}ms", seconds, milliseconds);
-    }
-    res = std::format("{:.2f}ms", milliseconds);
-  } else {
-    int minutes = static_cast<int>(t_time / 60000.0f);
-    int seconds = static_cast<int>((t_time - (minutes * 60000.0f)) / 1000.0f);
-    float milliseconds = t_time - (minutes * 60000.0f) - (seconds * 1000.0f);
-
-    res = std::format("{}m {}s {:.2f}ms", minutes, seconds, milliseconds);
-  }
-
-  return res;
-}
-
-inline std::string FormatBytes(int bytes) {
-  char out[32];
-
-  if (bytes == 1)
-    snprintf(out, sizeof(out), "%d Byte", bytes);
-
-  else if (bytes < 1024)
-    snprintf(out, sizeof(out), "%d Bytes", bytes);
-
-  else if (bytes < 1024 * 1024)
-    snprintf(out, sizeof(out), "%.1f KB", (float)bytes / 1024);
-
-  else if (bytes < 1024 * 1024 * 1024)
-    snprintf(out, sizeof(out), "%.1f MB", (float)bytes / 1024 / 1024);
-
-  else
-    snprintf(out, sizeof(out), "%.1f GB", (float)bytes / 1024 / 1024 / 1024);
-
-  return out;
-}
-}  // namespace Palladium
-
-template <class T>
-T GetFileName(T const &path, T const &delims = "/\\") {
-  return path.substr(path.find_last_of(delims) + 1);
-}
-template <class T>
-T remove_ext(T const &filename) {
-  typename T::size_type const p(filename.find_last_of('.'));
-  return p > 0 && p != T::npos ? filename.substr(0, p) : filename;
-}
-
-template <typename T>
-std::string Int_To_Hex(T i) {
-  std::stringstream stream;
-  stream << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex
-         << i;
-  return stream.str();
-}

include/pd/core/bit_util.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 {
+/**
+ * Binary Utillity Functions
+ */
+namespace BitUtil {
+/**
+ * Check if a 32 Bit number only set a sigle bit to 1
+ * @param v 32 bit unsigned int
+ * @return true if its a single bit number
+ */
+PD_CORE_API bool IsSingleBit(u32 v);
+/**
+ * Get the Next Power of two Number
+ * @param v Current Number
+ * @return Next Number thats a Pow of 2
+ */
+PD_CORE_API u32 GetPow2(u32 v);
+}  // namespace BitUtil
+}  // namespace PD

include/pd/core/color.hpp

@@ -0,0 +1,149 @@
+#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/core/strings.hpp>
+
+namespace PD {
+class PD_CORE_API Color {
+ public:
+  /**
+   * Default Constructor (all variables are set to 0)
+   */
+  constexpr Color() : r(0), g(0), b(0), a(0) {}
+  constexpr ~Color() {}
+  /**
+   * Constructor for 32Bit Color Input
+   * @param color 32Bit Color value
+   */
+  constexpr Color(u32 clr) {
+    a = (clr >> 24) & 0xff;
+    b = (clr >> 16) & 0xff;
+    g = (clr >> 8) & 0xff;
+    r = clr & 0xff;
+  }
+  /**
+   * Constructor for 8Bit Input
+   * @param r Red Value
+   * @param g Green Value
+   * @param b Blue Value
+   * @param a Optional Alpha Value (Defaults to 255)
+   */
+  constexpr Color(int r, int g, int b, int a = 255) : r(r), g(g), b(b), a(a) {}
+  /**
+   * Constructor for float Input
+   * @param r Red Value
+   * @param g Green Value
+   * @param b Blue Value
+   * @param a Optional Alpha Value (Defaults to 1.0f)
+   * @note There is no Check if the number is between 0.0 and 1.0
+   */
+  constexpr Color(float r, float g, float b, float a = 1.f)
+      : r(static_cast<u8>(255.f * r)),
+        g(static_cast<u8>(255.f * g)),
+        b(static_cast<u8>(255.f * b)),
+        a(static_cast<u8>(255.f * a)) {}
+  /**
+   * Constructor for Hex Input (is abel to run at compile time xD)
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   */
+  constexpr Color(const std::string_view& hex) { Hex(hex); }
+
+  /**
+   * Create Color Object by Hex String (at compile time btw)
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   * @return Color class itself
+   */
+  constexpr Color& Hex(const std::string_view& hex) {
+    if (!(hex.length() == 7 || hex.length() == 9)) {
+      throw "[PD] Color: hex string is not rgb or rgba!";
+    }
+    r = PD::Strings::HexChar2Int(hex[1]) * 16 +
+        PD::Strings::HexChar2Int(hex[2]);
+    g = PD::Strings::HexChar2Int(hex[3]) * 16 +
+        PD::Strings::HexChar2Int(hex[4]);
+    b = PD::Strings::HexChar2Int(hex[5]) * 16 +
+        PD::Strings::HexChar2Int(hex[6]);
+    if (hex.length() == 9) {
+      a = PD::Strings::HexChar2Int(hex[7]) * 16 +
+          PD::Strings::HexChar2Int(hex[8]);
+    } else {
+      a = 255;
+    }
+    return *this;
+  }
+  /**
+   * Convert this Color Object to Hex string
+   * @param rgba [default false] sets if 8 or 6 digit color should be returned
+   * @return Color Hex String
+   */
+  std::string Hex(bool rgba = false) const;
+
+  /**
+   * Fade from Current to another Color
+   * @param color Color to fade to
+   * @param p Amount (supports -1.0 to 1.0 for use of sine)
+   * @return Class Reference
+   */
+  constexpr Color& Fade(const Color& color, float p) {
+    a = static_cast<u8>((color.a - a) * ((p + 1.f) / 2));
+    b = static_cast<u8>((color.b - b) * ((p + 1.f) / 2));
+    g = static_cast<u8>((color.g - g) * ((p + 1.f) / 2));
+    r = static_cast<u8>((color.r - r) * ((p + 1.f) / 2));
+    return *this;
+  }
+
+  /**
+   * Get 32Bit Color Value
+   * @return 32Bit Color Value (ABGR iirc)
+   */
+  constexpr u32 Get() const { return (a << 24) | (b << 16) | (g << 8) | r; }
+  /**
+   * Get The Luminance of the Color
+   * @return luminance (from 0.0 to 1.0)
+   */
+  constexpr float Luminance() const {
+    // For Reference https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness
+    return (0.3 * (r / 255.f) + 0.59 * (g / 255.f) + 0.11 * (b / 255.f));
+  }
+  /**
+   * Check if the Color is Light or Dark
+   * @return true if light
+   */
+  constexpr bool IsLight() const { return (Luminance() >= 0.5); }
+
+  /**
+   * Operator to cast Color to 32Bit Value
+   * @return 32Bit Color Value
+   */
+  constexpr operator u32() const { return Get(); }
+
+  /** Public Access Data section */
+  u8 r;
+  u8 g;
+  u8 b;
+  u8 a;
+};
+}  // namespace PD

include/pd/core/common.hpp

@@ -0,0 +1,73 @@
+#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 <array>
+#include <chrono>
+#include <cinttypes>
+#include <cmath>
+#include <filesystem>  // Requires C++ 17 or later
+#include <format>      // Requires C++ 20 or later
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <numbers>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <vector>
+
+/** Dynamic Lib loading */
+#include <pd/core/pd_p_api.hpp>
+
+/** Memory Management */
+
+#define PD_SHARED(x)                                         \
+  using Ref = std::shared_ptr<x>;                            \
+  template <typename... Args>                                \
+  static Ref New(Args&&... args) {                           \
+    return std::make_shared<x>(std::forward<Args>(args)...); \
+  }
+
+#define PD_UNIQUE(x)                                         \
+  using Ref = std::unique_ptr<x>;                            \
+  template <typename... Args>                                \
+  static Ref New(Args&&... args) {                           \
+    return std::make_unique<x>(std::forward<Args>(args)...); \
+  }
+
+#define PD_BIT(x) (1 << x)
+
+namespace PD {
+[[noreturn]] inline void Throw(const std::string& str) {
+  throw std::runtime_error("[PD] " + str);
+}
+/** Types */
+using u8 = unsigned char;
+using u16 = unsigned short;
+using u32 = unsigned int;
+using u64 = unsigned long long;
+}  // namespace PD

include/pd/core/core.hpp

@@ -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/bit_util.hpp>
+#include <pd/core/color.hpp>
+#include <pd/core/fnv.hpp>
+#include <pd/core/io.hpp>
+#include <pd/core/mat.hpp>
+#include <pd/core/sl/sl.hpp>
+#include <pd/core/strings.hpp>
+#include <pd/core/timer.hpp>
+#include <pd/core/timetrace.hpp>
+#include <pd/core/tween.hpp>
+#include <pd/core/vec.hpp>

include/pd/core/fnv.hpp

@@ -0,0 +1,53 @@
+#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 {
+/**
+ * FNV-1a 32Bit hasing function
+ * https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+ */
+constexpr u32 FNV1A32(std::string_view str) {
+  u32 ret = 0x811c9dc5;  // Offset basis
+  for (auto& it : str) {
+    ret ^= it;
+    ret *= 0x01000193;  // Prime
+  }
+  return ret;
+}
+/**
+ * FNV-1a 64Bit hasing function
+ * https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+ */
+constexpr u64 FNV1A64(std::string_view str) {
+  u64 ret = 0xcbf29ce484222325;  // Offset basis
+  for (auto& it : str) {
+    ret ^= it;
+    ret *= 0x00000100000001b3;  // Prime
+  }
+  return ret;
+}
+}  // namespace PD

include/pd/core/fquat.hpp

@@ -0,0 +1,55 @@
+#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.
+ */
+
+// This file is based on fvec4
+
+#include <pd/core/common.hpp>
+#include <pd/core/vec4.hpp>
+
+namespace PD {
+class fquat : public fvec4 {
+  constexpr fquat() : fvec4(0.f, 0.f, 0.f, 1.f) {}
+  constexpr fquat(float x, float y, float z, float w) : fvec4(x, y, z, w) {}
+  constexpr fquat(const fvec4& v) : fvec4(v) {}
+
+  static fquat Identity() { return fquat(0.f, 0.f, 0.f, 1.f); }
+
+  constexpr fquat Conjugate() const { return fquat(-x, -y, -z, w); }
+  fquat Inverse() const {
+    float len = SqLen();
+    if (len == 0.0f) {
+      return fquat();
+    }
+    return Conjugate() / len;
+  }
+
+  fquat operator*(const fquat& v) const {
+    return fquat(w * v.x + x * v.w + y * v.z - z * v.y,
+                 w * v.y - x * v.z + y * v.w + z * v.x,
+                 w * v.z + x * v.y - y * v.x + z * v.w,
+                 w * v.w - x * v.x - y * v.y - z * v.z);
+  }
+};
+}  // namespace PD

include/pd/core/io.hpp

@@ -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 {
+/**
+ * Set of File Functions
+ */
+namespace IO {
+/**
+ * Load a File into an 8Bit Memory Buffer
+ * @param path Path to the File
+ * @return 8Bit FileBuffer
+ */
+PD_CORE_API std::vector<u8> LoadFile2Mem(const std::string& path);
+/**
+ * Load a File into a std::string
+ * @param path Path to the File
+ * @return std::string file content
+ */
+PD_CORE_API std::string LoadFile2Str(const std::string& path);
+/**
+ * Hash a 8Bit Memory Buffer
+ * @param data 8Bit input Buffer
+ * @return 32Bit Hash
+ */
+PD_CORE_API u32 HashMemory(const std::vector<u8>& data);
+/**
+ * Function to decrompress RLE buffer
+ * @param data Data buffer to decompress
+ */
+PD_CORE_API void DecompressRLE(std::vector<u8>& data);
+/**
+ * Function to compress data with RLE Algorithm
+ * @param data Data buf
+ */
+PD_CORE_API void CompressRLE(std::vector<u8>& data);
+}  // namespace IO
+}  // namespace PD

include/pd/core/mat.hpp

@@ -0,0 +1,142 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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/core/vec3.hpp>
+
+namespace PD {
+namespace Numbers {
+constexpr float Tau = std::numbers::pi * 2.f;
+}
+constexpr float Radians(float v) { return v * (Numbers::Tau / 360.0f); }
+/**
+ * Minimal Mtx4 Lib that precomputes
+ * basic stuff stuff at compiletime
+ *
+ * This Lib includes Patches for work with Citro3D as well
+ *
+ * @note That this is not a full Matrix Library
+ */
+
+struct PD_CORE_API Mat4 {
+  std::array<float, 16> m;
+  constexpr Mat4() : m{} {}
+  constexpr static Mat4 Diagonal(float x, float y, float z, float w) {
+    Mat4 ret;
+    ret(0, 0) = x;
+    ret(1, 1) = y;
+    ret(2, 2) = z;
+    ret(3, 3) = w;
+    return ret;
+  }
+  constexpr static Mat4 Identity() { return Diagonal(1, 1, 1, 1); }
+
+  constexpr float* Ptr() { return m.data(); }
+  constexpr const float* Ptr() const { return m.data(); }
+
+  constexpr float& operator()(int row, int col) {
+#ifdef __3DS__
+    // 3ds is full reverse order iirc
+    return m[row * 4 + (3 - col)];
+#else
+    return m[col * 4 + row];
+#endif
+  }
+  constexpr float operator()(int row, int col) const {
+#ifdef __3DS__
+    // 3ds is full reverse order iirc
+    return m[row * 4 + (3 - col)];
+#else
+    return m[col * 4 + row];
+#endif
+  }
+
+  constexpr Mat4 operator*(const Mat4& v) const {
+    Mat4 ret;
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        float t = 0.f;
+        for (int k = 0; k < 4; k++) {
+          t += (*this)(i, k) * v(k, j);
+        }
+        ret(i, j) = t;
+      }
+    }
+    return ret;
+  }
+
+  constexpr Mat4& operator*=(const Mat4& v) {
+    *this = *this * v;
+    return *this;
+  }
+
+  constexpr static Mat4 Translate(float x, float y, float z) {
+    Mat4 ret = Identity();
+    ret(0, 3) = x;
+    ret(1, 3) = y;
+    ret(2, 3) = z;
+    return ret;
+  }
+
+  constexpr static Mat4 Scale(float x, float y, float z) {
+    Mat4 ret;
+    ret(0, 0) = x;
+    ret(1, 1) = y;
+    ret(2, 2) = z;
+    ret(3, 3) = 1.f;
+    return ret;
+  }
+
+  constexpr static Mat4 Ortho(float l, float r, float b, float t, float n,
+                              float f) {
+    Mat4 ret;
+#ifdef __3DS__  // Patch to rotate the Matrix correctly
+    ret(0, 1) = 2.f / (t - b);
+    ret(0, 3) = (b + t) / (b - t);
+    ret(1, 0) = 2.f / (l - r);
+    ret(1, 3) = (l + r) / (r - l);
+    ret(2, 2) = 1.f / (n - f);
+    ret(2, 3) = 0.5f * (n + f) / (n - f) - 0.5f;
+#else
+    ret(0, 0) = 2.0f / (r - l);
+    ret(0, 3) = -(r + l) / (r - l);
+    ret(1, 1) = 2.0f / (t - b);
+    ret(1, 3) = -(t + b) / (t - b);
+    ret(2, 2) = -2.0f / (f - n);
+    ret(2, 3) = -(f + n) / (f - n);
+#endif
+    ret(3, 3) = 1.f;
+    return ret;
+  }
+
+  static Mat4 Rotate(fvec3 axis, float a);
+  static Mat4 RotateX(float a);
+  static Mat4 RotateY(float a);
+  static Mat4 RotateZ(float a);
+  static Mat4 Perspective(float fov, float aspect, float n, float f);
+  static Mat4 LookAt(const fvec3& pos, const fvec3& center, const fvec3& up);
+};
+}  // namespace PD

include/pd/core/pd_p_api.hpp

@@ -0,0 +1,51 @@
+#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.
+ */
+
+/** Generated with ppam */
+
+#ifdef _WIN32  // Windows (MSVC Tested)
+#ifdef PD_CORE_BUILD_SHARED
+#define PD_CORE_API __declspec(dllexport)
+#else
+#define PD_CORE_API __declspec(dllimport)
+#endif
+#elif defined(__APPLE__)  // macOS (untested yet)
+#ifdef PD_CORE_BUILD_SHARED
+#define PD_CORE_API __attribute__((visibility("default")))
+#else
+#define PD_CORE_API
+#endif
+#elif defined(__linux__)  // Linux (untested yet)
+#ifdef PD_CORE_BUILD_SHARED
+#define PD_CORE_API __attribute__((visibility("default")))
+#else
+#define PD_CORE_API
+#endif
+#elif defined(__3DS__)  // 3ds Specific
+// Only Static supported
+#define PD_CORE_API
+#else
+#define PD_CORE_API
+#endif

include/pd/core/sl/allocator.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 {
+/**
+ * Custom Allocator for Custom Vec and probably other stuff in future
+ */
+template <typename T>
+class Allocator {
+ public:
+  Allocator() = default;
+  ~Allocator() = default;
+
+  virtual T* Allocate(size_t n) { return new T[n]; }
+  virtual T* AllocateRaw(size_t n) {
+    return reinterpret_cast<T*>(::operator new(sizeof(T) * n));
+  }
+  virtual void DeallocateRaw(T* ptr) { operator delete(ptr); }
+  virtual void Deallocate(T* ptr) { delete[] ptr; }
+  template <typename... Args>
+  void Construct(T* ptr, Args&&... args) {
+    new (ptr) T(std::forward<Args>(args)...);
+  }
+  void Destroy(T* ptr) { ptr->~T(); }
+};
+}  // namespace PD

include/pd/core/sl/hashmap.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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/core/sl/list.hpp>
+#include <pd/core/sl/pair.hpp>
+
+namespace PD {
+template <typename K, typename V, size_t bucket_count = 10>
+class HashMap {
+ public:
+  HashMap() {}
+  ~HashMap() {}
+
+  void Insert(const K& k, const V& v) {
+    size_t idx = Hash(k);
+    auto& bukket = pBuckets[idx];
+    for (auto& it : bukket) {
+      if (it.First == k) {
+        it.Second = v;
+        return;
+      }
+    }
+    bukket.PushBack(Pair(k, v));
+  }
+
+  bool Contains(const K& k) const {
+    size_t idx = Hash(k);
+    auto& bukket = pBuckets[idx];
+
+    for (auto& it : bukket) {
+      if (it.First == k) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void Clear() {
+    for (size_t i = 0; i < bucket_count; i++) {
+      pBuckets[i].Clear();
+    }
+  }
+
+  size_t Hash(const K& k) const { return std::hash<K>{}(k) % bucket_count; }
+  PD::List<PD::Pair<K, V>> pBuckets[bucket_count];
+};
+}  // namespace PD

include/pd/core/sl/list.hpp

@@ -0,0 +1,210 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 {
+template <typename T>
+class List {
+ public:
+  List() {}
+  ~List() {}
+
+  struct Node {
+    Node(const T& v) : Data(v) {}
+    T Data;
+    Node* Prev = nullptr;
+    Node* Next = nullptr;
+  };
+
+  class Iterator {
+   public:
+    Iterator(Node* n) : pNode(n) {}
+    T& operator*() { return pNode->Data; }
+    Iterator& operator++() {
+      pNode = pNode->Next;
+      return *this;
+    }
+    bool operator!=(const Iterator& o) const { return pNode != o.pNode; }
+
+    Node* pNode = nullptr;
+  };
+
+  void PushFront(const T& val) {
+    Node* node = new Node(val);
+    // node->Data = val;
+    node->Prev = nullptr;
+    node->Next = pHead;
+    if (pHead) {
+      pHead->Prev = node;
+    }
+    pHead = node;
+    if (!pTail) {
+      pTail = node;
+    }
+    pSize++;
+  }
+
+  void PushBack(const T& val) {
+    Node* node = new Node(val);
+    // node->Data = val;
+    node->Prev = pTail;
+    node->Next = nullptr;
+    if (pTail) {
+      pTail->Next = node;
+    }
+    pTail = node;
+    if (!pHead) {
+      pHead = node;
+    }
+    pSize++;
+  }
+
+  void PopFront() {
+    if (!pHead) {
+      return;
+    }
+    Node* t = pHead;
+    pHead = pHead->Next;
+    if (pHead) {
+      pHead->Prev = nullptr;
+    } else {
+      pTail = nullptr;
+    }
+    delete t;
+    pSize--;
+  }
+
+  void PopBack() {
+    if (!pTail) {
+      return;
+    }
+    Node* t = pTail;
+    pTail = pTail->Prev;
+    if (pTail) {
+      pTail->Next = nullptr;
+    } else {
+      pHead = nullptr;
+    }
+    delete t;
+    pSize--;
+  }
+
+  void Clear() {
+    while (pHead) {
+      PopFront();
+    }
+  }
+
+  void Remove(const T& v) {
+    Node* s = pHead;
+    while (s) {
+      if (s->Data == v) {
+        if (s->Prev) {
+          s->Prev->Next = s->Next;
+        } else {
+          pHead = s->Next;
+        }
+        if (s->Next) {
+          s->Next->Prev = s->Prev;
+        } else {
+          pTail = s->Prev;
+        }
+        delete s;
+        pSize--;
+        return;
+      }
+      s = s->Next;
+    }
+  }
+
+  void Reverse() {
+    Node* cur = pHead;
+    while (cur) {
+      Node* temp = cur->Prev;
+      cur->Prev = cur->Next;
+      cur->Next = temp;
+      cur = cur->Prev;
+    }
+    Node* temp = pHead;
+    pHead = pTail;
+    pTail = temp;
+  }
+
+  T& Front() {
+    if (pHead) {
+      return pHead->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  const T& Front() const {
+    if (pHead) {
+      return pHead->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  T& Back() {
+    if (pTail) {
+      return pTail->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  const T& Back() const {
+    if (pTail) {
+      return pTail->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  size_t Size() const { return pSize; }
+
+  Iterator begin() { return Iterator(pHead); }
+  Iterator end() { return Iterator(nullptr); }
+
+ private:
+  Node* Find(const T& v) const {
+    Node* t = pHead;
+    while (t) {
+      if (t->Data == v) {
+        return t;
+      }
+      t = t->Next;
+    }
+    return nullptr;
+  }
+
+  Node* pHead = nullptr;
+  Node* pTail = nullptr;
+  size_t pSize = 0;
+};
+}  // namespace PD

include/pd/core/sl/pair.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 {
+template <typename T1, typename T2>
+class Pair {
+ public:
+  Pair() = default;
+  Pair(const T1& f, const T2& s) : First(f), Second(s) {}
+  Pair(T1&& f, T2&& s) : First(std::move(f)), Second(std::move(s)) {}
+  ~Pair() = default;
+
+  T1 First;
+  T2 Second;
+};
+}  // namespace PD

include/pd/core/sl/sl.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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/sl/allocator.hpp>
+#include <pd/core/sl/hashmap.hpp>
+#include <pd/core/sl/list.hpp>
+#include <pd/core/sl/pair.hpp>
+#include <pd/core/sl/stack.hpp>
+#include <pd/core/sl/tools.hpp>
+#include <pd/core/sl/u128.hpp>
+#include <pd/core/sl/vector.hpp>

include/pd/core/sl/stack.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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/core/sl/vector.hpp>
+
+namespace PD {
+/**
+ * Custom Stack class (caus std::stack ofsten lead to memory coruption)
+ */
+template <typename T, typename Alloc = Allocator<T>>
+class Stack {
+ public:
+  Stack() = default;
+  explicit Stack(size_t cap) : pVec(cap) {}
+
+  void Push(const T& val) { pVec.Add(val); }
+
+  void Pop() {
+    if (pVec.Size() == 0) {
+      exit(1);
+    }
+    pVec.PopBack();
+  }
+
+  T& Top() {
+    if (pVec.Size() == 0) {
+      exit(1);
+    }
+    return pVec[pVec.Size() - 1];
+  }
+
+  const T& Top() const {
+    if (pVec.Size() == 0) {
+      exit(1);
+    }
+    return pVec[pVec.Size() - 1];
+  }
+
+  bool IsEmpty() const { return pVec.Size() == 0; }
+  size_t Size() const { return pVec.Size(); }
+  void Clear() { pVec.Clear(); }
+
+ private:
+  Vec<T, Alloc> pVec;
+};
+}  // namespace PD

include/pd/core/sl/tools.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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 {
+/**
+ * Function to get Arraysize for any type using modern c++ to
+ * get the size at compiletime instead of runtime
+ * @note this function only works for Arrays declared as
+ * type arr[size] and not for pointer references.
+ * This function will precalculate the size at compile time
+ * while keeping the code clean to not hardcode arraysizes
+ * into functions like std::fill_n
+ */
+template <typename T, size_t N>
+constexpr size_t ArraySize(T (&)[N]) noexcept {
+  return N;
+}
+}  // namespace PD

include/pd/core/sl/u128.hpp

@@ -0,0 +1,127 @@
+#pragma once
+
+#include <pd/core/common.hpp>
+
+namespace PD {
+/**
+ * 128 Bit support for all platforms probably
+ * only used for flag checks in Keyboard/Mouse Input driver
+ */
+class u128 {
+ public:
+  u64 pLow = 0;
+  u64 pHigh = 0;
+
+  constexpr u128() : pLow(0), pHigh(0) {}
+  constexpr u128(u64 l, u64 h = 0) : pLow(l), pHigh(h) {}
+
+  /**
+   * Best way so far to create flags that go over 63
+   * like `1 << 65` is just `u128::Flag(65)`
+   */
+  constexpr static u128 Flag(u32 i) {
+    if (i < 64) {
+      return u128(1ULL << i, 0);
+    } else if (i < 128) {
+      return u128(0, 1ULL << (i - 64));
+    }
+    return u128();
+  }
+
+  constexpr u128 operator+(const u128& v) const {
+    u128 ret;
+    ret.pLow = pLow + v.pLow;
+    ret.pHigh = pHigh + v.pHigh + (ret.pLow < pLow);
+    return ret;
+  }
+
+  constexpr u128 operator&(const u128& v) const {
+    return u128(pLow & v.pLow, pHigh & v.pHigh);
+  }
+
+  constexpr u128 operator<<(u32 s) const {
+    if (s == 0) {
+      return *this;
+    }
+    if (s >= 128) {
+      return u128();
+    }
+    if (s >= 64) {
+      return u128(0, pLow << (s - 64));
+    }
+    return u128(pLow << s, (pHigh << s) | (pLow >> (64 - s)));
+  }
+
+  constexpr u128 operator>>(u32 s) const {
+    if (s == 0) {
+      return *this;
+    }
+    if (s >= 128) {
+      return u128();
+    }
+    if (s >= 64) {
+      return u128(pHigh >> (s - 64), 0);
+    }
+    return u128((pLow >> s) | (pHigh << (64 - s)), pHigh >> s);
+  }
+
+  constexpr u128& operator|=(const u128& v) {
+    pLow |= v.pLow;
+    pHigh |= v.pHigh;
+    return *this;
+  }
+
+  constexpr u128 operator|(const u128& v) const {
+    return u128(pLow | v.pLow, pHigh | v.pHigh);
+  }
+
+  constexpr u128& operator&=(const u128& v) {
+    pLow &= v.pLow;
+    pHigh &= v.pHigh;
+    return *this;
+  }
+
+  constexpr u128 operator~() const { return u128(~pLow, ~pHigh); }
+
+  /**
+   * Old why to make if checks possible
+   * Problem was that a operator& is required
+   * with u128 as result
+   */
+  // bool operator&(const u128& v) const {
+  //   return pLow & v.pLow || pHigh & v.pHigh;
+  // }
+
+  constexpr bool operator==(const u128& v) const {
+    return pLow == v.pLow && pHigh == v.pHigh;
+  }
+
+  /**
+   * Use explicit here to make sure it is only for checking and not for
+   * some error leading implicit bool assignments...
+   */
+  constexpr explicit operator bool() const { return pLow != 0 || pHigh != 0; }
+
+  /** Deprecated way to handle `flag & SomeFlag` */
+  constexpr bool Has(const u128& v) const {
+    return pLow & v.pLow || pHigh & v.pHigh;
+  }
+
+  constexpr bool operator!=(const u128& v) const { return !(*this == v); }
+};
+}  // namespace PD
+
+namespace std {
+/**
+ * Provide c++ STL support for unordered map to u128
+ */
+template <>
+struct hash<PD::u128> {
+  size_t operator()(const PD::u128& k) const {
+    // just combine hashes of the parts usign simple xor op
+    size_t h0 = std::hash<PD::u64>{}(k.pLow);
+    size_t h1 = std::hash<PD::u64>{}(k.pHigh);
+    return h0 ^ (h1 << 1);
+  }
+};
+}  // namespace std

include/pd/core/sl/vector.hpp

@@ -0,0 +1,165 @@
+#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/core/sl/allocator.hpp>
+
+namespace PD {
+/**
+ * Open Access Vector class (Alternative to std::vector)
+ */
+template <typename T, typename Alloc = Allocator<T>>
+class Vec {
+ public:
+  Vec() {
+    pData = pAllocator.Allocate(2);
+    pCap = 2;
+    Clear();
+    pPos = 0;
+  };
+  Vec(const size_t& Size) {
+    pData = pAllocator.Allocate(Size + 2);
+    pCap = Size + 2;
+    Clear();
+    pPos = Size;
+  }
+  Vec(const size_t& Size, const T& v) {
+    pData = pAllocator.Allocate(Size + 2);
+    pCap = Size + 2;
+    Clear();
+    pPos = Size;
+    std::fill_n(pData, Size, v);
+  }
+  Vec(const T* s, const T* e) {
+    pData = pAllocator.Allocate(2);
+    pCap = 2;
+    Clear();
+    pPos = 0;
+    Resize(e - s);
+    std::copy_n(s, e - s, pData);
+  }
+  Vec(const Vec& v) {
+    pCap = v.pCap;
+    pPos = v.pPos;
+    pData = pAllocator.Allocate(pCap);
+    for (size_t i = 0; i < pPos; i++) {
+      pData[i] = v.pData[i];
+    }
+  }
+  ~Vec() { pAllocator.Deallocate(pData); }
+
+  void Add(const T& v) {
+    if (pPos >= pCap) {
+      Reserve(pCap * 2);
+    }
+    pData[pPos++] = v;
+  }
+
+  void PopBack() {
+    if (pPos == 0) return;
+    pPos--;
+  }
+
+  T Pop() {
+    if (pPos == 0) {
+      // Todo: LOG
+      exit(1);
+    }
+    return pData[pPos--];
+  }
+
+  T& At(const size_t& Idx) {
+    if (Idx >= pPos) {
+      // Log
+      exit(1);
+    }
+    return pData[Idx];
+  }
+
+  const T& At(const size_t& Idx) const {
+    if (Idx >= pPos) {
+      // Log
+      exit(1);
+    }
+    return pData[Idx];
+  }
+
+  T& operator[](const size_t& Idx) { return At(Idx); }
+  const T& operator[](const size_t& Idx) const { return At(Idx); }
+  void operator+=(T v) { Add(v); }
+
+  T* Begin() { return pData; }
+  const T* Begin() const { return pData; }
+  T* End() { return pData + pPos; }
+  const T* End() const { return pData + pPos; }
+
+  // Support: `for(auto& it : Vec)` //
+  T* begin() { return pData; }
+  const T* begin() const { return pData; }
+  T* end() { return pData + pPos; }
+  const T* end() const { return pData + pPos; }
+
+  T* Data() { return pData; }
+  T* Data() const { return pData; }
+  size_t Size() const { return pPos; }
+  size_t Capacity() const { return pCap; }
+  void Clear() {
+    // Avoid memset to support std::string for now
+    // probably revert this decision based if it lacks performance
+    // or make it a setting
+    std::fill(pData, pData + pCap, T());
+    pPos = 0;
+  }
+
+  void Reserve(const size_t& Size) {
+    if (Size <= pCap) return;
+    T* tmp = pAllocator.Allocate(Size);
+    std::fill(tmp, tmp + Size, T());
+    std::copy(pData, pData + pCap, tmp);
+    pAllocator.Deallocate(pData);
+    pData = tmp;
+    pCap = Size;
+  }
+
+  void Resize(size_t Size) {
+    if (Size < pPos) {
+      pPos = Size;
+    } else if (Size > pCap) {
+      Reserve(Size);
+    }
+    std::fill(pData + pPos, pData + Size, T());
+    pPos = Size;
+  }
+
+  // Allocator
+  Alloc pAllocator;
+  // Data Reference Pointer
+  T* pData;
+  // Capacity
+  size_t pCap;
+  // Current Position (Size)
+  size_t pPos;
+};
+}  // namespace PD

include/pd/core/strings.hpp

@@ -0,0 +1,130 @@
+#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 {
+/**
+ * Set of String Utillity Functions
+ */
+namespace Strings {
+constexpr int HexChar2Int(char c) {
+  /** Imagine man hat ne lookup table dafür verwendet :/ */
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
+  if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
+  return -1;  // Error
+}
+/**
+ * Check if a String ends with a specific extension
+ * @param str Input string
+ * @param exts List of Extensions to check for
+ * @return true if one of the extensions is found in the String
+ */
+PD_CORE_API bool StringEndsWith(const std::string& str,
+                                const std::vector<std::string>& exts);
+/**
+ * Function to Create a wstring of a string
+ * @param s Input String to Convert
+ * @return Result wstring
+ * @note Returns Empty if it has an error
+ */
+PD_CORE_API std::wstring MakeWstring(const std::string& s);
+/**
+ * Generate a Formatted String by an Nanoseconds Input
+ * @param nanos Nanoseconds Input
+ * @return Result String
+ */
+PD_CORE_API const std::string FormatNanos(unsigned long long nanos);
+/**
+ * Generate a Formatted String by an Milliseconds Input
+ * @param millis Milliseconds Input
+ * @return Result String
+ */
+PD_CORE_API const std::string FormatMillis(unsigned long long millis);
+/**
+ * Create a formatted String by an input bytes value
+ * @param bytes value in bytes
+ * @result Formatted String for example `2.5MB`
+ */
+PD_CORE_API const std::string FormatBytes(unsigned long long bytes);
+/**
+ * Extract the Filename out of a Path
+ * @param path Path to extract from
+ * @param saperators Path Split Chars
+ * @return extracted filename
+ */
+PD_CORE_API const std::string GetFileName(
+    const std::string& path, const std::string& saperators = "/\\");
+/**
+ * Remove Extension from a Path / Filename
+ * @param path Input Path
+ * @return Path without Extension
+ */
+PD_CORE_API const std::string PathRemoveExtension(const std::string& path);
+/**
+ * Function to Convert a Type to a hex value
+ * @tparam T Type
+ * @param v value
+ * @return hex string beginning with 0x
+ */
+template <typename T>
+inline const std::string ToHex(const T& v) {
+  std::stringstream s;
+  s << "0x" << std::setfill('0') << std::setw(sizeof(v) * 2) << std::hex << v;
+  return s.str();
+}
+/**
+ * Generate a Hash out of a string
+ * @param s String to hash
+ * @return 32Bit Hash
+ */
+PD_CORE_API u32 FastHash(const std::string& s);
+/**
+ * Function to Generate a Compiler Name and Version String
+ * Based on their Macros
+ * @return CompilerName: Version
+ */
+inline const std::string GetCompilerVersion() {
+  /// As the function looks like this Project is meant to
+  /// Be ported to other systems as well
+  std::stringstream res;
+#ifdef __clang__  // Check clang first
+  res << "Clang: " << __clang_major__ << ".";
+  res << __clang_minor__ << ".";
+  res << __clang_patchlevel__;
+#elif __GNUC__
+  res << "GCC: " << __GNUC__;
+  res << "." << __GNUC_MINOR__ << ".";
+  res << __GNUC_PATCHLEVEL__;
+#elif _MSC_VER
+  res << "MSVC: " << _MSC_VER;
+#else
+  res << "Unknown Compiler";
+#endif
+  return res.str();
+}
+}  // namespace Strings
+}  // namespace PD

include/pd/core/timer.hpp

@@ -0,0 +1,85 @@
+#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 {
+/**
+ * Timer class
+ */
+class PD_CORE_API Timer {
+ public:
+  /**
+   * Constructor
+   * @param auto_start [default true] sets if timer should start after creation
+   */
+  Timer(bool auto_start = true);
+  /**
+   * Unused Deconstructor
+   */
+  ~Timer() {}
+
+  PD_SHARED(Timer);
+
+  /**
+   * Resume Timer if Paused
+   */
+  void Rseume();
+  /**
+   * Pause Timer if not Paused
+   */
+  void Pause();
+  /**
+   * Update Timer
+   */
+  void Update();
+  /**
+   * Reset Timer
+   */
+  void Reset();
+  /**
+   * Check if the Timer is Running
+   * @return true if its running
+   */
+  bool IsRunning() const;
+  /**
+   *  Get 64 Bit milliseconds value
+   *  @return 64Bit millis
+   */
+  u64 Get();
+  /**
+   * Get as Seconds
+   * @return seconds as floating number
+   */
+  double GetSeconds();
+
+  /** Start of the Timer */
+  u64 pStart;
+  /** Current Time */
+  u64 pNow;
+  /** Is Running */
+  bool pIsRunning = false;
+};
+}  // namespace PD

include/pd/core/timetrace.hpp

@@ -0,0 +1,262 @@
+#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 {
+/**
+ * Class to calculate Maximum/Minimum and Average Timings
+ */
+class TimeStats {
+public:
+  /**
+   * Constructor taking a lengh for the List
+   * @param l Lengh of the data list
+   */
+  TimeStats(int l) : len(l), val(l, 0) {}
+  ~TimeStats() = default;
+
+  PD_SHARED(TimeStats);
+
+  /**
+   * Add a New Value to the list
+   * @param v value to add
+   */
+  void Add(u64 v) {
+    val[idx] = v;
+    idx = next(idx);
+    num_val = std::min(num_val + 1, len);
+  }
+
+  /**
+   * Get Avarage Num
+   * @return Average
+   */
+  u64 GetAverage() {
+    if (!num_val)
+      return 0.f;
+    u64 res = 0;
+    for (int i = 0; i < num_val; i++) {
+      res += val[smart_idx(i)];
+    }
+    return res / num_val;
+  }
+
+  /**
+   * Get Minimum Num
+   * @return Minimum value
+   */
+  u64 GetMin() {
+    if (!num_val)
+      return 0.f;
+    u64 res = std::numeric_limits<u64>::max();
+    for (int i = 0; i < num_val; i++) {
+      res = std::min(val[smart_idx(i)], res);
+    }
+    return res;
+  }
+
+  /**
+   * Get Maximum Value
+   * @return Max Value
+   */
+  u64 GetMax() {
+    if (!num_val)
+      return 0.f;
+    u64 res = 0;
+    for (int i = 0; i < num_val; i++) {
+      res = std::max(val[smart_idx(i)], res);
+    }
+    return res;
+  }
+
+  /**
+   * Clear the List
+   */
+  void Clear() {
+    val.assign(len, 0);
+    idx = 0;
+    num_val = 0;
+  }
+
+  /**
+   * Get Data Buffer
+   * @return data bufer (not edidable)
+   */
+  const std::vector<u64> &GetData() { return val; }
+  /**
+   * Access an element in the list [not edidable]
+   * @return value to access
+   */
+  const u64 &operator[](int i) { return val[smart_idx(i)]; }
+  /**
+   * Get List Lengh
+   * @return Lengh
+   */
+  const size_t GetLen() { return len; }
+  /**
+   * Get Number of Values
+   * @return number of values
+   */
+  const size_t GetNumValues() { return num_val; }
+
+private:
+  /**
+   * Get the Next Position to write to
+   * @param c current position
+   * @return next position
+   */
+  size_t next(size_t c) const { return (c + 1) % len; }
+  /**
+   * Smart Indexing in for loops to make sure to
+   * not index a value that was not set yet
+   * @param v pos in for loop
+   * @return indexing pos
+   */
+  size_t smart_idx(size_t v) const { return (idx + len - num_val + v) % len; }
+
+  /** Lengh of the list */
+  int len = 0;
+  /** Value Storage */
+  std::vector<u64> val;
+  int idx = 0;
+  int num_val = 0;
+};
+/**
+ * Timatrace Functions
+ */
+namespace TT {
+/**
+ * Data Structure for a TimeTrace Result
+ */
+class Res {
+public:
+  /** Constructore that Inits a protocol at size of 60 frames */
+  Res() : start(0), end(0) { protocol = TimeStats::New(60); }
+  ~Res() = default;
+
+  PD_SHARED(Res);
+
+  /**
+   * Setter for the ID (Name)
+   * @param v ID of the Trace
+   */
+  void SetID(const std::string &v) { id = v; }
+  /**
+   * Getter for the traces ID
+   * @return Trace ID
+   */
+  const std::string GetID() { return id; }
+  /**
+   * Setter for the Start Value
+   * @param v start time
+   */
+  void SetStart(u64 v) { start = v; }
+  /**
+   * Getter for the Start time
+   * @return start time
+   */
+  u64 GetStart() { return start; }
+  /**
+   * Setter for the End Time
+   * @param v end time
+   */
+  void SetEnd(u64 v) {
+    end = v;
+    protocol->Add(GetLastDiff());
+  }
+  /**
+   * Getter for the End Time
+   * @result end time
+   */
+  u64 GetEnd() { return end; }
+
+  /**
+   * Get Last Diffrence between end and start
+   * @return end - start
+   */
+  u64 GetLastDiff() { return end - start; }
+  /**
+   * Get Protcol Reference
+   * @return Protocol Ref
+   */
+  TimeStats::Ref GetProtocol() { return protocol; }
+
+private:
+  /** Trace ID */
+  std::string id;
+  /** Start time */
+  u64 start;
+  /** End Time */
+  u64 end;
+  /** Protocol */
+  TimeStats::Ref protocol;
+};
+/**
+ * Begin a Trace
+ * @param id Name of the Trace
+ */
+PD_CORE_API void Beg(const std::string &id);
+/**
+ * End a Trace
+ * @param id Name of the Trace
+ */
+PD_CORE_API void End(const std::string &id);
+/**
+ * Collect Start end end of the trace by tracking
+ * when the Scope object goes out of scope
+ *
+ * Example:
+ * ```cpp
+ * void SomeFunction() {
+ *    // Create a Scoped Trace called "SomeFunc"
+ *    PD::TT::Scope st("SomeFunc");
+ *    // Do your functions stuff
+ *    // End at the end it goes out of
+ *    // scope which collects the end time
+ * }
+ * ```
+ */
+class Scope {
+public:
+  /**
+   * Constructor requiring a Name for the Trace
+   * @param id Name of the Trace
+   */
+  Scope(const std::string &id) {
+    this->ID = id;
+    Beg(id);
+  }
+  /**
+   * Deconstructor getting the end time when going out of scope
+   */
+  ~Scope() { End(ID); }
+
+private:
+  /** Trace Name/ID */
+  std::string ID;
+};
+} // namespace TT
+} // namespace PD

include/pd/core/tween.hpp

@@ -0,0 +1,228 @@
+#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>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+namespace PD {
+/**
+ * D7 Tween Engine (or something like that)
+ * @tparam T Any Numeric value
+ */
+template <typename T>
+class Tween {
+ public:
+  /**
+   * Effects Table
+   */
+  enum Effect {
+    Linear,          ///< Linear Movement [works]
+    EaseInQuad,      ///< EaseInQuad Movement [works]
+    EaseOutQuad,     ///< EaseOutQuad Movement [works]
+    EaseInOutQuad,   ///< EaseInOutQuad Movement [works]
+    EaseInCubic,     ///< EaseInCubic Movement [not tested]
+    EaseOutCubic,    ///< EaseOutCubic Movement [not tested]
+    EaseInOutCubic,  ///< EaseInOutCubic Movement [disabled]
+    EaseInSine,      ///< EaseInSine Movement [works]
+    EaseOutSine,     ///< EaseOutSine Movement [works]
+    EaseInOutSine,   ///< EaseInOutSine Movement [not tested]
+  };
+  Tween() = default;
+  ~Tween() = default;
+
+  /**
+   * Update Tween
+   * @param delta deltatime
+   */
+  void Update(float delta) {
+    time += delta * 0.001f;
+    if (time > tend) {
+      finished = true;
+      time = tend;
+    }
+  }
+
+  /**
+   * Check if Tween is finished
+   * @return true if finished
+   */
+  bool IsFinished() const { return finished; }
+
+  /**
+   * Force finish the animation
+   * @return Class reference
+   */
+  Tween& Finish() {
+    time = tend;
+    finished = true;
+    return *this;
+  }
+
+  /**
+   * Set Start Value
+   * @tparam T datatype of the Tween
+   * @param start Start Value
+   * @return class Reference
+   */
+  Tween& From(const T& start) {
+    Reset();
+    this->start = start;
+    return *this;
+  }
+  /**
+   * Set End Value
+   * @tparam T datatype of the Tween
+   * @param end End Value
+   * @return class Reference
+   */
+  Tween& To(const T& end) {
+    Reset();
+    this->end = end;
+    return *this;
+  }
+  /**
+   * Set the Duration (in seconds)
+   * @param seconds Duration
+   * @return class Reference
+   */
+  Tween& In(float seconds) {
+    Reset();
+    tend = seconds;
+    return *this;
+  }
+  /**
+   * Set Effect of the Tween
+   * @param e Effect
+   * @return class Reference
+   */
+  Tween& As(const Effect& e) {
+    effect = e;
+    return *this;
+  }
+  /**
+   * Reset to time 0
+   * @return class Reference
+   */
+  Tween& Reset() {
+    finished = false;
+    time = 0.f;
+    return *this;
+  }
+  /**
+   * Get the Prograss in percent (0.0 to 1.0) of the tween
+   * @return progress value
+   */
+  float Progress() const { return time / tend; }
+
+  /**
+   * Swap Start and end Position of the Tween
+   * @return class reference
+   */
+  Tween& Swap() {
+    T temp = start;
+    start = end;
+    end = temp;
+    return *this;
+  }
+
+  T Get() const {
+    float t = 0.f;
+    switch (effect) {
+      case EaseInQuad:
+        t = time / tend;
+        return (end - start) * t * t + start;
+        break;
+      case EaseOutQuad:
+        t = time / tend;
+        return -(end - start) * t * (t - 2) + start;
+        break;
+      case EaseInOutQuad:
+        t = time / (tend * 0.5f);
+        if (t < 1) return (end - start) * 0.5f * t * t + start;
+        t--;
+        return -(end - start) * 0.5f * (t * (t - 2) - 1) + start;
+        break;
+      case EaseInCubic:
+        t = time / tend;
+        return (end - start) * t * t * t + start;
+        break;
+      case EaseOutCubic:
+        t = time / tend;
+        t--;
+        return (end - start) * (t * t * t + 1) + start;
+        break;
+      // case EaseInOutCubic:
+      //   t = time / (tend *0.5f);
+      //   if (t < 1) return (end - start) *0.5f * t * t * t + start;
+      //   t--;
+      //   return (end - start) *0.5f * (t * t * t * 2) + start;
+      //   break;
+      case EaseInSine:
+        return -(end - start) * cos(time / tend * (M_PI * 0.5f)) +
+               (end - start) + start;
+        break;
+      case EaseOutSine:
+        return (end - start) * sin(time / tend * (M_PI * 0.5f)) + start;
+        break;
+      case EaseInOutSine:
+        return -(end - start) * 0.5f * (cos(M_PI * time / tend) - 1) + start;
+        break;
+
+      default:  // Linear
+        return (end - start) * (time / tend) + start;
+        break;
+    }
+  }
+
+  /**
+   * Operator that returns the current value calculated
+   * by time and effect
+   */
+  operator T() const { return Get(); }
+
+ private:
+  /** Animation Effect */
+  Effect effect;
+  /** Time */
+  float time = 0.f;
+  /**
+   * End time
+   * Defaulting to one to prevent div zero
+   * without a safetey check
+   * not implementing one cause if the user is
+   * Writing a In(0.f) its their fault
+   */
+  float tend = 1.f;
+  /** Start value */
+  T start;
+  /** end value */
+  T end;
+  /** is finished value */
+  bool finished = false;
+};
+}  // namespace PD

include/pd/core/vec.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 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/core/vec2.hpp>
+#include <pd/core/vec3.hpp>
+#include <pd/core/vec4.hpp>
+
+/** Define Formatters for C++ 20 */
+
+/**
+ * WHY DOES MSVC ALWAYS NEED THESE EXTRA THINGS
+ */
+
+template <typename T, typename CharT>
+struct std::formatter<PD::vec2<T>, CharT> : std::formatter<T, CharT> {
+  template <typename FormatContext>
+  auto format(const PD::vec2<T>& v, FormatContext& ctx) const {
+    return std::format_to(ctx.out(), "{}, {}", v.x, v.y);
+  }
+};
+
+template <typename T, typename CharT>
+struct std::formatter<PD::vec3<T>, CharT> : std::formatter<T, CharT> {
+  template <typename FormatContext>
+  auto format(const PD::vec3<T>& v, FormatContext& ctx) const {
+    return std::format_to(ctx.out(), "{}, {}, {}", v.x, v.y, v.z);
+  }
+};
+
+template <typename T, typename CharT>
+struct std::formatter<PD::vec4<T>, CharT> : std::formatter<T, CharT> {
+  template <typename FormatContext>
+  auto format(const PD::vec4<T>& v, FormatContext& ctx) const {
+    return std::format_to(ctx.out(), "{}, {}, {}, {}", v.x, v.y, v.z, v.w);
+  }
+};

include/pd/core/vec2.hpp

@@ -0,0 +1,197 @@
+#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.
+ */
+
+// This file is generated by lazyvec 2.0.0
+
+#include <pd/core/common.hpp>
+
+namespace PD {
+template <typename T>
+class vec2 {
+ public:
+  T x;
+  T y;
+
+  // Constructors
+
+  constexpr vec2() : x(0), y(0) {}
+  template <typename T1>
+  constexpr vec2(T1 v) {
+    x = (T)v;
+    y = (T)v;
+  }
+
+  template <typename T1>
+  constexpr vec2(const vec2<T1>& v) {
+    x = (T)v.x;
+    y = (T)v.y;
+  }
+
+  constexpr explicit vec2(T x, T y) : x(x), y(y) {}
+
+  // Operations
+
+  template <typename T1>
+  vec2<T>& operator+=(T1 v) {
+    x += (T)v;
+    y += (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T>& operator+=(const vec2<T1>& v) {
+    x += (T)v.x;
+    y += (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T> operator+(T1 v) const {
+    return vec2<T>(x + (T)v, y + (T)v);
+  }
+
+  template <typename T1>
+  vec2<T> operator+(const vec2<T1>& v) const {
+    return vec2<T>(x + (T)v.x, y + (T)v.y);
+  }
+
+  template <typename T1>
+  vec2<T>& operator-=(T1 v) {
+    x -= (T)v;
+    y -= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T>& operator-=(const vec2<T1>& v) {
+    x -= (T)v.x;
+    y -= (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T> operator-(T1 v) const {
+    return vec2<T>(x - (T)v, y - (T)v);
+  }
+
+  template <typename T1>
+  vec2<T> operator-(const vec2<T1>& v) const {
+    return vec2<T>(x - (T)v.x, y - (T)v.y);
+  }
+
+  template <typename T1>
+  vec2<T>& operator*=(T1 v) {
+    x *= (T)v;
+    y *= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T>& operator*=(const vec2<T1>& v) {
+    x *= (T)v.x;
+    y *= (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T> operator*(T1 v) const {
+    return vec2<T>(x * (T)v, y * (T)v);
+  }
+
+  template <typename T1>
+  vec2<T> operator*(const vec2<T1>& v) const {
+    return vec2<T>(x * (T)v.x, y * (T)v.y);
+  }
+
+  template <typename T1>
+  vec2<T>& operator/=(T1 v) {
+    x /= (T)v;
+    y /= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T>& operator/=(const vec2<T1>& v) {
+    x /= (T)v.x;
+    y /= (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  vec2<T> operator/(T1 v) const {
+    return vec2<T>(x / (T)v, y / (T)v);
+  }
+
+  template <typename T1>
+  vec2<T> operator/(const vec2<T1>& v) const {
+    return vec2<T>(x / (T)v.x, y / (T)v.y);
+  }
+
+  // Generic Operations
+
+  vec2 operator-() const { return vec2(-x, -y); }
+  template <typename T1>
+  bool operator==(const vec2<T1>& v) const {
+    return x == (T)v.x && y == (T)v.y;
+  }
+  template <typename T1>
+  bool operator!=(const vec2<T1>& v) const {
+    return !(*this == v);
+  }
+
+  // Functions
+
+  double Len() const { return std::sqrt(SqLen()); }
+  double SqLen() const { return x * x + y * y; }
+
+  template <typename T1>
+  double Distance(const vec2<T1>& v) const {
+    return (*this - v).Len();
+  }
+
+  vec2<T> Normalize() const {
+    double l = Len();
+    if (l == 0) {
+      return *this;
+    }
+    return *this / (T)l;
+  }
+
+  template <typename T1>
+  T Dot(const vec2<T1>& v) const {
+    return x * (T)v.x + y * (T)v.y;
+  }
+
+  // Swap Functions
+  void SwapXY() {
+    T t = x;
+    x = y;
+    y = t;
+  }
+};
+using fvec2 = vec2<float>;
+using ivec2 = vec2<int>;
+using dvec2 = vec2<double>;
+}  // namespace PD

include/pd/core/vec3.hpp

@@ -0,0 +1,235 @@
+#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.
+ */
+
+// This file is generated by lazyvec 2.0.0
+
+#include <pd/core/common.hpp>
+// Extended includes (rename if you use other filenames/paths)
+#include <pd/core/vec2.hpp>
+
+namespace PD {
+template <typename T>
+class vec3 {
+ public:
+  T x;
+  T y;
+  T z;
+
+  // Constructors
+
+  constexpr vec3() : x(0), y(0), z(0) {}
+  template <typename T1>
+  constexpr vec3(T1 v) {
+    x = (T)v;
+    y = (T)v;
+    z = (T)v;
+  }
+
+  template <typename T1>
+  constexpr vec3(const vec3<T1>& v) {
+    x = (T)v.x;
+    y = (T)v.y;
+    z = (T)v.z;
+  }
+
+  constexpr explicit vec3(T x, T y, T z) : x(x), y(y), z(z) {}
+
+  // Extended Constructors
+  template <typename T1>
+  constexpr explicit vec3(const vec2<T1>& xy, T1 z) {
+    {
+      x = (T)xy.x;
+      y = (T)xy.y;
+      this->z = (T)z;
+    }
+  }
+
+  // Operations
+
+  template <typename T1>
+  vec3<T>& operator+=(T1 v) {
+    x += (T)v;
+    y += (T)v;
+    z += (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T>& operator+=(const vec3<T1>& v) {
+    x += (T)v.x;
+    y += (T)v.y;
+    z += (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T> operator+(T1 v) const {
+    return vec3<T>(x + (T)v, y + (T)v, z + (T)v);
+  }
+
+  template <typename T1>
+  vec3<T> operator+(const vec3<T1>& v) const {
+    return vec3<T>(x + (T)v.x, y + (T)v.y, z + (T)v.z);
+  }
+
+  template <typename T1>
+  vec3<T>& operator-=(T1 v) {
+    x -= (T)v;
+    y -= (T)v;
+    z -= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T>& operator-=(const vec3<T1>& v) {
+    x -= (T)v.x;
+    y -= (T)v.y;
+    z -= (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T> operator-(T1 v) const {
+    return vec3<T>(x - (T)v, y - (T)v, z - (T)v);
+  }
+
+  template <typename T1>
+  vec3<T> operator-(const vec3<T1>& v) const {
+    return vec3<T>(x - (T)v.x, y - (T)v.y, z - (T)v.z);
+  }
+
+  template <typename T1>
+  vec3<T>& operator*=(T1 v) {
+    x *= (T)v;
+    y *= (T)v;
+    z *= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T>& operator*=(const vec3<T1>& v) {
+    x *= (T)v.x;
+    y *= (T)v.y;
+    z *= (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T> operator*(T1 v) const {
+    return vec3<T>(x * (T)v, y * (T)v, z * (T)v);
+  }
+
+  template <typename T1>
+  vec3<T> operator*(const vec3<T1>& v) const {
+    return vec3<T>(x * (T)v.x, y * (T)v.y, z * (T)v.z);
+  }
+
+  template <typename T1>
+  vec3<T>& operator/=(T1 v) {
+    x /= (T)v;
+    y /= (T)v;
+    z /= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T>& operator/=(const vec3<T1>& v) {
+    x /= (T)v.x;
+    y /= (T)v.y;
+    z /= (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  vec3<T> operator/(T1 v) const {
+    return vec3<T>(x / (T)v, y / (T)v, z / (T)v);
+  }
+
+  template <typename T1>
+  vec3<T> operator/(const vec3<T1>& v) const {
+    return vec3<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z);
+  }
+
+  // Generic Operations
+
+  vec3 operator-() const { return vec3(-x, -y, -z); }
+  template <typename T1>
+  bool operator==(const vec3<T1>& v) const {
+    return x == (T)v.x && y == (T)v.y && z == (T)v.z;
+  }
+  template <typename T1>
+  bool operator!=(const vec3<T1>& v) const {
+    return !(*this == v);
+  }
+
+  // Functions
+
+  double Len() const { return std::sqrt(SqLen()); }
+  double SqLen() const { return x * x + y * y + z * z; }
+
+  template <typename T1>
+  double Distance(const vec3<T1>& v) const {
+    return (*this - v).Len();
+  }
+
+  vec3<T> Normalize() const {
+    double l = Len();
+    if (l == 0) {
+      return *this;
+    }
+    return *this / (T)l;
+  }
+
+  template <typename T1>
+  T Dot(const vec3<T1>& v) const {
+    return x * (T)v.x + y * (T)v.y + z * (T)v.z;
+  }
+
+  template <typename T1>
+  vec3<T> Cross(const vec3<T1>& v) const {
+    return vec3<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
+  }
+
+  // Swap Functions
+  void SwapXY() {
+    T t = x;
+    x = y;
+    y = t;
+  }
+  void SwapXZ() {
+    T t = x;
+    x = z;
+    z = t;
+  }
+  void SwapYZ() {
+    T t = y;
+    y = z;
+    z = t;
+  }
+};
+using fvec3 = vec3<float>;
+using ivec3 = vec3<int>;
+using dvec3 = vec3<double>;
+}  // namespace PD

include/pd/core/vec4.hpp

@@ -0,0 +1,268 @@
+#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.
+ */
+
+// This file is generated by lazyvec 2.0.0
+
+#include <pd/core/common.hpp>
+// Extended includes (rename if you use other filenames/paths)
+#include <pd/core/vec2.hpp>
+#include <pd/core/vec3.hpp>
+
+namespace PD {
+template <typename T>
+class vec4 {
+ public:
+  T x;
+  T y;
+  T z;
+  T w;
+
+  // Constructors
+
+  constexpr vec4() : x(0), y(0), z(0), w(0) {}
+  template <typename T1>
+  constexpr vec4(T1 v) {
+    x = (T)v;
+    y = (T)v;
+    z = (T)v;
+    w = (T)v;
+  }
+
+  template <typename T1>
+  constexpr vec4(const vec4<T1>& v) {
+    x = (T)v.x;
+    y = (T)v.y;
+    z = (T)v.z;
+    w = (T)v.w;
+  }
+
+  constexpr explicit vec4(T x, T y, T z, T w) : x(x), y(y), z(z), w(w) {}
+
+  // Extended Constructors
+  template <typename T1>
+  constexpr explicit vec4(const vec2<T1>& xy, const vec2<T1>& zw) {
+    {
+      x = (T)xy.x;
+      y = (T)xy.y;
+      z = (T)zw.x;
+      w = (T)zw.y;
+    }
+  }
+
+  template <typename T1>
+  constexpr explicit vec4(const vec3<T1>& xyz, T1 w) {
+    {
+      x = (T)xyz.x;
+      y = (T)xyz.y;
+      z = (T)xyz.z;
+      this->w = (T)w;
+    }
+  }
+
+  // Operations
+
+  template <typename T1>
+  vec4<T>& operator+=(T1 v) {
+    x += (T)v;
+    y += (T)v;
+    z += (T)v;
+    w += (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T>& operator+=(const vec4<T1>& v) {
+    x += (T)v.x;
+    y += (T)v.y;
+    z += (T)v.z;
+    w += (T)v.w;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T> operator+(T1 v) const {
+    return vec4<T>(x + (T)v, y + (T)v, z + (T)v, w + (T)v);
+  }
+
+  template <typename T1>
+  vec4<T> operator+(const vec4<T1>& v) const {
+    return vec4<T>(x + (T)v.x, y + (T)v.y, z + (T)v.z, w + (T)v.w);
+  }
+
+  template <typename T1>
+  vec4<T>& operator-=(T1 v) {
+    x -= (T)v;
+    y -= (T)v;
+    z -= (T)v;
+    w -= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T>& operator-=(const vec4<T1>& v) {
+    x -= (T)v.x;
+    y -= (T)v.y;
+    z -= (T)v.z;
+    w -= (T)v.w;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T> operator-(T1 v) const {
+    return vec4<T>(x - (T)v, y - (T)v, z - (T)v, w - (T)v);
+  }
+
+  template <typename T1>
+  vec4<T> operator-(const vec4<T1>& v) const {
+    return vec4<T>(x - (T)v.x, y - (T)v.y, z - (T)v.z, w - (T)v.w);
+  }
+
+  template <typename T1>
+  vec4<T>& operator*=(T1 v) {
+    x *= (T)v;
+    y *= (T)v;
+    z *= (T)v;
+    w *= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T>& operator*=(const vec4<T1>& v) {
+    x *= (T)v.x;
+    y *= (T)v.y;
+    z *= (T)v.z;
+    w *= (T)v.w;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T> operator*(T1 v) const {
+    return vec4<T>(x * (T)v, y * (T)v, z * (T)v, w * (T)v);
+  }
+
+  template <typename T1>
+  vec4<T> operator*(const vec4<T1>& v) const {
+    return vec4<T>(x * (T)v.x, y * (T)v.y, z * (T)v.z, w * (T)v.w);
+  }
+
+  template <typename T1>
+  vec4<T>& operator/=(T1 v) {
+    x /= (T)v;
+    y /= (T)v;
+    z /= (T)v;
+    w /= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T>& operator/=(const vec4<T1>& v) {
+    x /= (T)v.x;
+    y /= (T)v.y;
+    z /= (T)v.z;
+    w /= (T)v.w;
+    return *this;
+  }
+
+  template <typename T1>
+  vec4<T> operator/(T1 v) const {
+    return vec4<T>(x / (T)v, y / (T)v, z / (T)v, w / (T)v);
+  }
+
+  template <typename T1>
+  vec4<T> operator/(const vec4<T1>& v) const {
+    return vec4<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z, w / (T)v.w);
+  }
+
+  // Generic Operations
+
+  vec4 operator-() const { return vec4(-x, -y, -z, -w); }
+  template <typename T1>
+  bool operator==(const vec4<T1>& v) const {
+    return x == (T)v.x && y == (T)v.y && z == (T)v.z && w == (T)v.w;
+  }
+  template <typename T1>
+  bool operator!=(const vec4<T1>& v) const {
+    return !(*this == v);
+  }
+
+  // Functions
+
+  double Len() const { return std::sqrt(SqLen()); }
+  double SqLen() const { return x * x + y * y + z * z + w * w; }
+
+  template <typename T1>
+  double Distance(const vec4<T1>& v) const {
+    return (*this - v).Len();
+  }
+
+  vec4<T> Normalize() const {
+    double l = Len();
+    if (l == 0) {
+      return *this;
+    }
+    return *this / (T)l;
+  }
+
+  template <typename T1>
+  T Dot(const vec4<T1>& v) const {
+    return x * (T)v.x + y * (T)v.y + z * (T)v.z + w * (T)v.w;
+  }
+
+  // Swap Functions
+  void SwapXY() {
+    T t = x;
+    x = y;
+    y = t;
+  }
+  void SwapXZ() {
+    T t = x;
+    x = z;
+    z = t;
+  }
+  void SwapXW() {
+    T t = x;
+    x = w;
+    w = t;
+  }
+  void SwapYZ() {
+    T t = y;
+    y = z;
+    z = t;
+  }
+  void SwapYW() {
+    T t = y;
+    y = w;
+    w = t;
+  }
+  void SwapZW() {
+    T t = z;
+    z = w;
+    w = t;
+  }
+};
+using fvec4 = vec4<float>;
+using ivec4 = vec4<int>;
+using dvec4 = vec4<double>;
+}  // namespace PD

include/pd/drivers/drivers.hpp

@@ -0,0 +1,28 @@
+#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/drivers/gfx.hpp>
+#include <pd/drivers/hid.hpp>
+#include <pd/drivers/os.hpp>

include/pd/drivers/gfx.hpp

@@ -0,0 +1,114 @@
+#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/core.hpp>
+#include <pd/lithium/command.hpp>
+#include <pd/lithium/texture.hpp>
+
+using LiBackendFlags = PD::u32;
+enum LiBackendFlags_ {
+  LiBackendFlags_None = 0,
+  LiBackendFlags_FlipUV_Y = PD_BIT(0),  // Essential for font loading
+};
+
+namespace PD {
+class GfxDriver {
+ public:
+  GfxDriver(const std::string& name = "NullGfx") : pName(name) {};
+  ~GfxDriver() = default;
+
+  PD_SHARED(GfxDriver);
+
+  void PostInit();
+
+  virtual void Init() {}
+  virtual void Deinit() {}
+  virtual void NewFrame() {}
+
+  virtual void BindTex(Li::TexAddress addr) {}
+
+  virtual void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {}
+
+  void SetViewPort(const ivec2& vp) { ViewPort = vp; }
+
+  virtual Li::Texture::Ref LoadTex(
+      const std::vector<u8>& pixels, int w, int h,
+      Li::Texture::Type type = Li::Texture::Type::RGBA32,
+      Li::Texture::Filter filter = Li::Texture::Filter::LINEAR) {
+    // Texture loading not supported (when this func not get override)
+    return nullptr;
+  }
+
+  Li::Texture::Ref GetSolidTex() { return pSolid; }
+
+  const std::string pName = "NullGfx";
+  LiBackendFlags Flags = 0;
+  ivec2 ViewPort;
+  Mat4 Projection;
+  Li::Texture::Ref pSolid;
+  size_t CurrentVertex = 0;
+  size_t CurrentIndex = 0;
+
+  /** Debug Variables */
+
+  // Optional Index counter
+  u32 IndexCounter;
+  // Optional Vertex counter
+  u32 VertexCounter;
+  // Optional Frame Counter
+  u64 FrameCounter;
+};
+
+/** Static Gfx Controller */
+class Gfx {
+ public:
+  Gfx() = default;
+  ~Gfx() = default;
+
+  static void Init(GfxDriver::Ref d);
+
+  static void Deinit() { pGfx->Deinit(); }
+  static void NewFrame() { pGfx->NewFrame(); }
+
+  static void BindTex(Li::TexAddress addr) { pGfx->BindTex(addr); }
+  static void SetViewPort(const ivec2& vp) { pGfx->SetViewPort(vp); }
+
+  static void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {
+    pGfx->RenderDrawData(Commands);
+  }
+
+  static LiBackendFlags Flags() { return pGfx->Flags; }
+  static Li::Texture::Ref LoadTex(
+      const std::vector<u8>& pixels, int w, int h,
+      Li::Texture::Type type = Li::Texture::Type::RGBA32,
+      Li::Texture::Filter filter = Li::Texture::Filter::LINEAR) {
+    return pGfx->LoadTex(pixels, w, h, type, filter);
+  }
+
+  static Li::Texture::Ref GetSolidTex() { return pGfx->GetSolidTex(); }
+
+  static GfxDriver::Ref pGfx;
+};
+}  // namespace PD

include/pd/drivers/hid.hpp

@@ -0,0 +1,296 @@
+#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 PURPHidE 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/core.hpp>
+
+namespace PD {
+/** Did not found a better solution yet sadly */
+namespace HidKb {
+// Lets use u128 here
+using KbKey = u128;
+constexpr static KbKey Kb_No = 0;
+constexpr static KbKey Kb_Escape = KbKey::Flag(0);
+constexpr static KbKey Kb_Q = KbKey::Flag(1);
+constexpr static KbKey Kb_W = KbKey::Flag(2);
+constexpr static KbKey Kb_E = KbKey::Flag(3);
+constexpr static KbKey Kb_R = KbKey::Flag(4);
+constexpr static KbKey Kb_T = KbKey::Flag(5);
+constexpr static KbKey Kb_Z = KbKey::Flag(6);
+constexpr static KbKey Kb_U = KbKey::Flag(7);
+constexpr static KbKey Kb_I = KbKey::Flag(8);
+constexpr static KbKey Kb_O = KbKey::Flag(9);
+constexpr static KbKey Kb_P = KbKey::Flag(10);
+constexpr static KbKey Kb_A = KbKey::Flag(11);
+constexpr static KbKey Kb_S = KbKey::Flag(12);
+constexpr static KbKey Kb_D = KbKey::Flag(13);
+constexpr static KbKey Kb_F = KbKey::Flag(14);
+constexpr static KbKey Kb_G = KbKey::Flag(15);
+constexpr static KbKey Kb_H = KbKey::Flag(16);
+constexpr static KbKey Kb_J = KbKey::Flag(17);
+constexpr static KbKey Kb_K = KbKey::Flag(18);
+constexpr static KbKey Kb_L = KbKey::Flag(19);
+constexpr static KbKey Kb_Y = KbKey::Flag(20);
+constexpr static KbKey Kb_X = KbKey::Flag(21);
+constexpr static KbKey Kb_C = KbKey::Flag(22);
+constexpr static KbKey Kb_V = KbKey::Flag(23);
+constexpr static KbKey Kb_B = KbKey::Flag(24);
+constexpr static KbKey Kb_N = KbKey::Flag(25);
+constexpr static KbKey Kb_M = KbKey::Flag(26);
+constexpr static KbKey Kb_1 = KbKey::Flag(27);
+constexpr static KbKey Kb_2 = KbKey::Flag(28);
+constexpr static KbKey Kb_3 = KbKey::Flag(29);
+constexpr static KbKey Kb_4 = KbKey::Flag(30);
+constexpr static KbKey Kb_5 = KbKey::Flag(31);
+constexpr static KbKey Kb_6 = KbKey::Flag(32);
+constexpr static KbKey Kb_7 = KbKey::Flag(33);
+constexpr static KbKey Kb_8 = KbKey::Flag(34);
+constexpr static KbKey Kb_9 = KbKey::Flag(35);
+constexpr static KbKey Kb_0 = KbKey::Flag(36);
+constexpr static KbKey Kb_F1 = KbKey::Flag(37);
+constexpr static KbKey Kb_F2 = KbKey::Flag(38);
+constexpr static KbKey Kb_F3 = KbKey::Flag(39);
+constexpr static KbKey Kb_F4 = KbKey::Flag(40);
+constexpr static KbKey Kb_F5 = KbKey::Flag(41);
+constexpr static KbKey Kb_F6 = KbKey::Flag(42);
+constexpr static KbKey Kb_F7 = KbKey::Flag(43);
+constexpr static KbKey Kb_F8 = KbKey::Flag(44);
+constexpr static KbKey Kb_F9 = KbKey::Flag(45);
+constexpr static KbKey Kb_F10 = KbKey::Flag(46);
+constexpr static KbKey Kb_F11 = KbKey::Flag(47);
+constexpr static KbKey Kb_F12 = KbKey::Flag(48);
+constexpr static KbKey Kb_MouseLeft = KbKey::Flag(120);
+}  // namespace HidKb
+class HidDriver {
+ public:
+  enum Flags : u32 {
+    Flags_None = 0,
+    FLags_HasGamepad = 1 << 0,
+    Flags_HasKeyboard = 1 << 1,
+    Flags_HasTouch = 1 << 2,
+    Flags_HasMouse = 1 << 3,
+  };
+  // Todo: Name to GpKey (GamepadKey)
+  /** Key [Controller] */
+  enum Key : u32 {
+    No = 0,                    ///< No Key
+    A = 1 << 0,                ///< A
+    B = 1 << 1,                ///< B
+    X = 1 << 2,                ///< X
+    Y = 1 << 3,                ///< Y
+    Start = 1 << 4,            ///< Start
+    Select = 1 << 5,           ///< Select
+    L = 1 << 6,                ///< L
+    R = 1 << 7,                ///< R
+    DUp = 1 << 8,              ///< Dpad Up
+    DDown = 1 << 9,            ///< Dpad down
+    DLeft = 1 << 10,           ///< Dpad left
+    DRight = 1 << 11,          ///< Dpad right
+    CPUp = 1 << 12,            ///< Cpad up
+    CPDown = 1 << 13,          ///< cpad down
+    CPLeft = 1 << 14,          ///< cpad left
+    CPRight = 1 << 15,         ///< Cpad right
+    CSUp = 1 << 16,            ///< Cstick up
+    CSDown = 1 << 17,          ///< cstick down
+    CSLeft = 1 << 18,          ///< cstick left
+    CSRight = 1 << 19,         ///< cstick right
+    ZL = 1 << 20,              ///< ZL
+    ZR = 1 << 21,              ///< ZR
+    Touch = 1 << 22,           ///< Touch
+    Up = DUp | CPUp,           ///< DPad or CPad Up
+    Down = DDown | CPDown,     ///< DPad or CPad Down
+    Left = DLeft | CPLeft,     ///< DPad or CPad Left
+    Right = DRight | CPRight,  ///< DPad or CPad Right
+  };
+
+  using KbKey = HidKb::KbKey;
+
+  /** Event */
+  enum Event {
+    Event_Null,
+    Event_Down,  ///< Key Pressed
+    Event_Held,  ///< Key Held
+    Event_Up,    ///< Key released
+  };
+
+  HidDriver(const std::string& name = "NullHid") : pName(name) {};
+  virtual ~HidDriver() = default;
+  PD_SHARED(HidDriver);
+
+  /**
+   * Get Mouse Position
+   * @return Mouse pos
+   */
+  fvec2 MousePos() const {
+    return pMouse[0];
+  } /**
+     * Get Last Mouse Position (from last frame)
+     * @return Mouse pos
+     */
+  fvec2 MousePosLast() const { return pMouse[1]; }
+
+  /**
+   * Check for a Button Event
+   * @param e Event Type
+   * @param keys Keys to check for
+   * @return if key(s) doing the requiested event
+   */
+  bool IsEvent(Event e, Key keys);
+  bool IsEvent(Event e, KbKey key);
+  /**
+   * Check for Key Press Event
+   * @param keys set of keys
+   * @return true if key is pressed
+   */
+  bool IsDown(Key keys) const { return KeyEvents[0].at(Event_Down) & keys; }
+  /**
+   * Check for Key Held Event
+   * @param keys set of keys
+   * @return true if key is held
+   */
+  bool IsHeld(Key keys) const { return KeyEvents[0].at(Event_Held) & keys; }
+  /**
+   * Check for Key Release Event
+   * @param keys set of keys
+   * @return true if key is released
+   */
+  bool IsUp(Key keys) const { return KeyEvents[0].at(Event_Up) & keys; }
+
+  /**
+   * Sett all keyevents to 0
+   */
+  void Clear() {
+    for (int i = 0; i < 2; i++) {
+      KeyEvents[i][Event_Down] = 0;
+      KeyEvents[i][Event_Up] = 0;
+      KeyEvents[i][Event_Held] = 0;
+    }
+  }
+
+  /**
+   * Lock input driver
+   * @param v lock or not lock
+   */
+  void Lock(bool v) {
+    if (v != pLocked) {
+      SwapTab();
+    }
+    pLocked = v;
+  }
+
+  /**
+   * Check if Driver is locked
+   * @return true if locked
+   */
+  bool Locked() const { return pLocked; }
+
+  /**
+   * Lock Input Driver
+   */
+  void Lock() {
+    if (!pLocked) {
+      SwapTab();
+    }
+    pLocked = true;
+  }
+  /**
+   * Unlock Input Driver
+   */
+  void Unlock() {
+    if (pLocked) {
+      SwapTab();
+    }
+    pLocked = false;
+  }
+
+  /**
+   * Template Update Function for a device specific driver
+   */
+  virtual void Update();
+  /**
+   * Get Text from Keyboard
+   */
+  virtual void GetInputStr(std::string& str) {}
+
+  /** Data Section */
+
+  /** Backend Identification Name */
+  const std::string pName;
+
+  /** Flags */
+  u32 Flags = 0;
+
+  /** Key Binds Map */
+  std::unordered_map<u32, u32> pBinds;
+  std::unordered_map<u128, u128> pKbBinds;
+  /** Swap Tabe Function */
+  void SwapTab();
+  /** Using 2 Positions for Current and Last */
+  fvec2 pMouse[2];
+  /** Lock State */
+  bool pLocked = false;
+  /** Key Event Table Setup */
+  std::unordered_map<Event, u32> KeyEvents[2];
+  /** Keyboard Key Event Table Setup */
+  std::unordered_map<Event, u128> KbKeyEvents[2];
+};
+
+/** Static Hid Controller */
+class Hid {
+ public:
+  Hid() = default;
+  ~Hid() = default;
+
+  /** Referenec to Drivers enums */
+  using Key = HidDriver::Key;
+  using KbKey = HidKb::KbKey;
+  using Event = HidDriver::Event;
+
+  static void Init(HidDriver::Ref v = nullptr) {
+    if (v) {
+      pHid = v;
+    } else {
+      pHid = HidDriver::New();
+    }
+  }
+
+  static bool IsEvent(Event e, Key keys) { return pHid->IsEvent(e, keys); }
+  static bool IsEvent(Event e, KbKey key) { return pHid->IsEvent(e, key); }
+  static bool IsDown(Key keys) { return pHid->IsDown(keys); }
+  static bool IsUp(Key keys) { return pHid->IsUp(keys); }
+  static bool IsHeld(Key keys) { return pHid->IsHeld(keys); }
+  static fvec2 MousePos() { return pHid->MousePos(); }
+  static fvec2 MousePosLast() { return pHid->MousePosLast(); }
+  static void Clear() { pHid->Clear(); }
+  static void Lock() { pHid->Lock(); }
+  static void Lock(bool v) { pHid->Lock(v); }
+  static void Unlock() { pHid->Unlock(); }
+  static bool Locked() { return pHid->Locked(); }
+  static void Update() { pHid->Update(); }
+  static u32 GetFlags() { return pHid->Flags; }
+  static void GetStrInput(std::string& str) { pHid->GetInputStr(str); }
+
+  static HidDriver::Ref pHid;
+};
+}  // namespace PD

include/pd/drivers/os.hpp

@@ -0,0 +1,71 @@
+#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/core/timetrace.hpp>
+
+namespace PD {
+using TraceMap = std::map<std::string, TT::Res::Ref>;
+
+class OsDriver {
+ public:
+  OsDriver() = default;
+  virtual ~OsDriver() = default;
+  PD_SHARED(OsDriver);
+
+  virtual u64 GetTime();
+  virtual u64 GetNanoTime();
+  TraceMap& GetTraceMap();
+  TT::Res::Ref& GetTraceRef(const std::string& id);
+  bool TraceExist(const std::string& id);
+
+  TraceMap pTraces;
+};
+
+/** Static Os Controller */
+class OS {
+ public:
+  OS() = default;
+  ~OS() = default;
+
+  static void Init(OsDriver::Ref v = nullptr) {
+    if (v) {
+      pOs = v;
+    } else {
+      pOs = OsDriver::New();
+    }
+  }
+
+  static u64 GetTime() { return pOs->GetTime(); }
+  static u64 GetNanoTime() { return pOs->GetNanoTime(); }
+  static TraceMap& GetTraceMap() { return pOs->GetTraceMap(); }
+  static TT::Res::Ref& GetTraceRef(const std::string& id) {
+    return pOs->GetTraceRef(id);
+  }
+  static bool TraceExist(const std::string& id) { return pOs->TraceExist(id); }
+
+  static OsDriver::Ref pOs;
+};
+}  // namespace PD

include/pd/drivers/pd_p_api.hpp

@@ -0,0 +1,26 @@
+#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.
+ */
+
+#define PD_DEF_EXP(x, y) x y = nullptr

include/pd/drivers/snd.hpp

@@ -0,0 +1,45 @@
+#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/core.hpp>
+
+namespace PD {
+class Snd {
+ public:
+  Snd(const std::string& name = "NullSnd") : pName(name) {};
+  ~Snd() = default;
+
+  PD_SHARED(Snd);
+
+  virtual void Init() {}
+  virtual void Deinit() {}
+  virtual bool Done(int buf_idx) {}
+  virtual void Update(int buf_idx, void* data) {}
+  virtual bool IsChannelPlaying(int chn) {}
+  virtual bool IsChannelPaused(int chn) {}
+
+  const std::string pName = "NullSnd";
+};
+}  // namespace PD