# Changes

- Remove () from vec formatter
 -Add Merge function to DrawList to Move Data into the Current DrawList
- Fix stupid bug in Rect.hpp which caused some problems in line rendering
- Remove some unused UI7 Flags
- io: Allocate FinalDrawList and add GetViewPort func
- Readd TreeNodes to Menu
- Add ABout/Style and Metrics Menu to Context
- Add some Variables for cliprects in ui7 container.hpp
- Add InputHandler functionality to DynObj
- Fix Menu Layout Render Order
- Add Better Menu Sorting to Context
# ppam
- Use stringview instead of hardcoded const char*
# Todos
- Work on the Lithium 3D System
- Fix UI7 Menu Order to Pop new Menus into the front instead of the background
- Add Scrolling support to menu (or integrate it into layout 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.5.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 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

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.5.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,78 @@
+#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/lithium/lithium.hpp>
+
+namespace PD {
+template <typename T>
+class LinearAlloc : public Allocator<T> {
+ public:
+  LinearAlloc() = default;
+  ~LinearAlloc() = default;
+
+  /** Never forget the sizeof(T) again (most painful bug i created) */
+  T* Allocate(size_t n) override { return (T*)linearAlloc(n * sizeof(T)); }
+  void Deallocate(T* ptr) { linearFree(ptr); }
+};
+
+namespace Li {
+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;
+
+  Vec<Vertex, LinearAlloc<Vertex>> VertexBuffer;
+  Vec<u16, LinearAlloc<u16>> IndexBuffer;
+  size_t CurrentVertex = 0;
+  size_t CurrentIndex = 0;
+  Mat4 Projection;
+  int pLocProjection = 0;
+  DVLB_s* ShaderCode;
+  shaderProgram_s Shader;
+  C3D_AttrInfo ShaderInfo;
+  // Stats oder so IDNK zu lange her
+  PD::u32 NumVtx;
+  PD::u32 NumIdx;
+};
+}  // namespace Li
+}  // 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/source/bknd-gfx.cpp

@@ -0,0 +1,250 @@
+/*
+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))
+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 {
+namespace Li {
+GPU_TEXCOLOR GetTexFmt(Texture::Type type) {
+  if (type == Texture::RGBA32)
+    return GPU_RGBA8;
+  else if (type == Texture::RGB24)
+    return GPU_RGB8;
+  else if (type == Texture::A8)
+    return GPU_A8;
+  return GPU_RGBA8;  // Default
+}
+int GetBPP(Texture::Type type) {
+  if (type == Texture::RGBA32)
+    return 4;
+  else if (type == Texture::RGB24)
+    return 3;
+  else if (type == 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++;
+  VertexCounter = NumVtx;
+  IndexCounter = NumIdx;
+  NumVtx = 0;
+  NumIdx = 0;
+}
+
+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);
+  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);
+  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++) {
+        NumIdx++;
+        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.At(i);
+      }
+      for (size_t i = 0; i < c->VertexBuffer.Size(); i++) {
+        NumVtx++;
+        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(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 == 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 = (TexAddress)tex;
+  std::cout << std::format("Tex {:#08x} Addr {:#08X}", (TexAddress)res.get(),
+                           res->Address)
+            << std::endl;
+  return res;
+}
+}  // namespace Li
+}  // namespace PD

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

@@ -0,0 +1,85 @@
+/*
+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") {
+  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::Li::Gfx::Init(PD::Li::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,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 <glad/glad.h>
+
+/** SEPARATOR */
+#include <GLFW/glfw3.h>
+/** SEPARATOR */
+
+#include <pd/lithium/lithium.hpp>
+
+namespace PD {
+namespace Li {
+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<Vertex> VertexBuffer;
+  PD::Vec<PD::u16> IndexBuffer;
+  size_t CurrentVertex = 0;
+  size_t CurrentIndex = 0;
+  GLuint Shader;
+  GLuint pLocProjection;
+  GLuint pLocTex;
+  Mat4 Projection;
+  GLuint VBO, IBO;
+  // Stats oder so IDNK zu lange her
+  PD::u32 NumVtx;
+  PD::u32 NumIdx;
+};
+}  // namespace Li
+}  // namespace PD

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

@@ -0,0 +1,45 @@
+#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;
+
+  /** Data section */
+  GLFWwindow* Window;
+  int PrevState;
+};
+}  // namespace PD

backends/desktop/source/bknd-gfx.cpp

@@ -0,0 +1,252 @@
+/*
+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 {
+namespace Li {
+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 matric 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;
+}
+
+/** 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);
+
+  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);
+
+  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.Ortho(0.f, ViewPort.x, ViewPort.y, 0.f, -1.f, 1.f);
+  glUniformMatrix4fv(pLocProjection, 1, GL_TRUE, Projection.m);
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  CurrentIndex = 0;
+  CurrentVertex = 0;
+  FrameCounter++;
+  VertexCounter = NumVtx;
+  IndexCounter = NumIdx;
+  NumVtx = 0;
+  NumIdx = 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) {
+  glUseProgram(Shader);
+  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++) {
+        NumIdx++;
+        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.At(i);
+      }
+      for (size_t i = 0; i < c->VertexBuffer.Size(); i++) {
+        NumVtx++;
+        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);
+
+    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 Li
+}  // namespace PD

backends/desktop/source/bknd-hid.cpp

@@ -0,0 +1,58 @@
+/*
+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 {
+HidGLFW::HidGLFW(GLFWwindow* win) : HidDriver("HidGLFW") {
+  Window = win;
+  pBinds[GLFW_MOUSE_BUTTON_LEFT] = Touch;
+}
+
+void HidGLFW::Update() {
+  for (int i = 0; i < 2; i++) {
+    KeyEvents[i][Event_Down] = 0;
+    KeyEvents[i][Event_Held] = 0;
+    KeyEvents[i][Event_Up] = 0;
+  }
+  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);
+}
+}  // 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::Li::Gfx::Init(PD::Li::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,74 @@
+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} PUBLIC
+        -D_GNU_SOURCE=1
+        -DPALLADIUM_VERSION="${PROJECT_VERSION}"
+        -DPALLADIUM_GIT_COMMIT="${GIT_SHORT_HASH}"
+        -DPALLADIUM_GIT_BRANCH="${GIT_BRANCH}"
+        -DBUILD_CTR=1
+    )
+    ### 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,132 @@
+#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 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
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   */
+  Color(const std::string& hex) { Hex(hex); }
+
+  /**
+   * Create Color Object by Hex String
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   * @return Color class itself
+   */
+  Color& Hex(const std::string& hex);
+  /**
+   * 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
+   */
+  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)
+   */
+  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)
+   */
+  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
+   */
+  bool IsLight() const { return (Luminance() >= 0.5); }
+
+  /**
+   * Operator to cast Color to 32Bit Value
+   * @return 32Bit Color Value
+   */
+  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,68 @@
+#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 <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 <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 {
+/** 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,35 @@
+#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/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/io.hpp

@@ -0,0 +1,56 @@
+#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);
+/**
+ * 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,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 {
+class PD_CORE_API Mat4 {
+ public:
+  Mat4() { Zeros(); }
+  ~Mat4() = default;
+
+  void Zeros();
+  void Ortho(float left, float right, float bottom, float top, float near,
+             float far);
+
+  float m[16];
+};
+}  // 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,33 @@
+#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/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/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,123 @@
+#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 {
+/**
+ * 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,259 @@
+#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 / 1000.f;
+    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 / 2);
+        if (t < 1) return (end - start) / 2 * t * t + start;
+        t--;
+        return -(end - start) / 2 * (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 / 2);
+      //   if (t < 1) return (end - start) / 2 * t * t * t + start;
+      //   t--;
+      //   return (end - start) / 2 * (t * t * t * 2) + start;
+      //   break;
+      case EaseInSine:
+        return -(end - start) * cos(time / tend * (M_PI / 2)) + (end - start) +
+               start;
+        break;
+      case EaseOutSine:
+        return (end - start) * sin(time / tend * (M_PI / 2)) + start;
+        break;
+      case EaseInOutSine:
+        return -(end - start) / 2 * (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,164 @@
+#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
+#include <pd/core/common.hpp>
+
+namespace PD {
+template <typename T>
+class vec2 {
+ public:
+  T x;
+  T y;
+
+  vec2() : x(0), y(0) {}
+  template <typename T1>
+  vec2(T1 v) {
+    x = (T)v;
+    y = (T)v;
+  }
+
+  template <typename T1>
+  vec2(vec2<T1> v) {
+    x = (T)v.x;
+    y = (T)v.y;
+  }
+
+  vec2(T x, T y) : x(x), y(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);
+  }
+
+  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);
+  }
+
+  vec2 operator-() const { return vec2(-x, -y); }
+
+  bool operator==(const vec2& v) const { return x == v.x && y == v.y; }
+  bool operator!=(const vec2& v) const { return !(*this == v); }
+
+  double Len() const { return std::sqrt(SqLen()); }
+  double SqLen() const { return x * x + y * y; }
+
+  void SwapXY() {
+    T t = x;
+    x = y;
+    y = t;
+  }
+};
+using fvec2 = vec2<float>;
+using dvec2 = vec2<double>;
+using ivec2 = vec2<int>;
+}  // namespace PD

include/pd/core/vec3.hpp

@@ -0,0 +1,187 @@
+#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
+#include <pd/core/common.hpp>
+
+namespace PD {
+template <typename T>
+class vec3 {
+ public:
+  T x;
+  T y;
+  T z;
+
+  vec3() : x(0), y(0), z(0) {}
+  template <typename T1>
+  explicit vec3(T1 v) {
+    x = (T)v;
+    y = (T)v;
+    z = (T)v;
+  }
+
+  template <typename T1>
+  explicit vec3(vec3<T1> v) {
+    x = (T)v.x;
+    y = (T)v.y;
+    z = (T)v.z;
+  }
+
+  vec3(T x, T y, T z) : x(x), y(y), z(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);
+  }
+
+  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);
+  }
+
+  vec3 operator-() const { return vec3(-x, -y, -z); }
+
+  bool operator==(const vec3& v) const {
+    return x == v.x && y == v.y && z == v.z;
+  }
+  bool operator!=(const vec3& v) const { return !(*this == v); }
+
+  double Len() const { return std::sqrt(SqLen()); }
+  double SqLen() const { return x * x + y * y + z * z; }
+
+  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 dvec3 = vec3<double>;
+using ivec3 = vec3<int>;
+}  // namespace PD

include/pd/core/vec4.hpp

@@ -0,0 +1,223 @@
+#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
+#include <pd/core/common.hpp>
+#include <pd/core/vec2.hpp>  // Extended
+
+namespace PD {
+template <typename T>
+class vec4 {
+ public:
+  T x;
+  T y;
+  T z;
+  T w;
+
+  vec4() : x(0), y(0), z(0), w(0) {}
+  template <typename T1>
+  explicit vec4(T1 v) {
+    x = (T)v;
+    y = (T)v;
+    z = (T)v;
+    w = (T)v;
+  }
+
+  template <typename T1>
+  explicit vec4(vec4<T1> v) {
+    x = (T)v.x;
+    y = (T)v.y;
+    z = (T)v.z;
+    w = (T)v.w;
+  }
+
+  /** Extended Constructor */
+  template <typename T1>
+  explicit vec4(vec2<T1> a, vec2<T1> b) {
+    x = (T)a.x;
+    y = (T)a.y;
+    z = (T)b.x;
+    w = (T)b.y;
+  }
+
+  vec4(T x, T y, T z, T w) : x(x), y(y), z(z), w(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);
+  }
+
+  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);
+  }
+
+  vec4 operator-() const { return vec4(-x, -y, -z, -w); }
+
+  bool operator==(const vec4& v) const {
+    return x == v.x && y == v.y && z == v.z && w == v.w;
+  }
+  bool operator!=(const vec4& v) const { return !(*this == v); }
+
+  double Len() const { return std::sqrt(SqLen()); }
+  double SqLen() const { return x * x + y * y + z * z + w * w; }
+
+  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 dvec4 = vec4<double>;
+using ivec4 = vec4<int>;
+}  // 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,111 @@
+#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 {
+namespace Li {
+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(TexAddress addr) {}
+
+  virtual void RenderDrawData(const std::vector<Command::Ref>& Commands) {}
+
+  virtual Texture::Ref LoadTex(
+      const std::vector<u8>& pixels, int w, int h,
+      Texture::Type type = Texture::Type::RGBA32,
+      Texture::Filter filter = Texture::Filter::LINEAR) {
+    // Texture loading not supported (when this func not get override)
+    return nullptr;
+  }
+
+  Texture::Ref GetSolidTex() { return pSolid; }
+
+  const std::string pName = "NullGfx";
+  LiBackendFlags Flags = 0;
+  ivec2 ViewPort;
+  fvec4 ClearColor;
+  Texture::Ref pSolid;
+
+  /** 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(TexAddress addr) { pGfx->BindTex(addr); }
+
+  static void RenderDrawData(const std::vector<Command::Ref>& Commands) {
+    pGfx->RenderDrawData(Commands);
+  }
+
+  static LiBackendFlags Flags() { return pGfx->Flags; }
+  static Texture::Ref LoadTex(
+      const std::vector<u8>& pixels, int w, int h,
+      Texture::Type type = Texture::Type::RGBA32,
+      Texture::Filter filter = Texture::Filter::LINEAR) {
+    return pGfx->LoadTex(pixels, w, h, type, filter);
+  }
+
+  static Texture::Ref GetSolidTex() { return pGfx->GetSolidTex(); }
+
+  static GfxDriver::Ref pGfx;
+};
+}  // namespace Li
+}  // namespace PD

include/pd/drivers/hid.hpp

@@ -0,0 +1,214 @@
+#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 {
+class HidDriver {
+ public:
+  /** 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
+  };
+
+  /** Event */
+  enum Event {
+    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);
+  /**
+   * 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() {}
+
+  /** Data Section */
+
+  /** Backend Identification Name */
+  const std::string pName;
+
+  /** Key Binds Map */
+  std::unordered_map<u32, u32> pBinds;
+  /** 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];
+};
+
+/** Static Hid Controller */
+class Hid {
+ public:
+  Hid() = default;
+  ~Hid() = default;
+
+  /** Referenec to Drivers enums */
+  using Key = HidDriver::Key;
+  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 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 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/global_db.hpp

@@ -1,78 +0,0 @@
-#pragma once
-
-#include <pd/external/json.hpp>
-#include <pd/palladium.hpp>
-
-namespace Palladium {
-namespace IDB {
-void Start();
-void Stop();
-void Restart();
-}  // namespace IDB
-}  // namespace Palladium
-
-using PDFlags = unsigned int;
-enum PDFlags_ {
-  PDFlags_None = 0,
-  PDFlags_MemTrack = 1 << 0,
-  PDFlags_SceneSystem = 1 << 1,
-  PDFlags_Default = PDFlags_SceneSystem,
-};
-
-using PDMetrikOverlayFlags = unsigned int;
-enum PDMetrikOverlayFlags_ {
-  PDMetrikOverlayFlags_None = 0,       // Displays Nothing
-  PDMetrikOverlayFlags_FPS = 1 << 0,   // Display FPS
-  PDMetrikOverlayFlags_CPU = 1 << 1,   // Display CPU Usage
-  PDMetrikOverlayFlags_GPU = 1 << 2,   // Display GPU Usage
-  PDMetrikOverlayFlags_CMD = 1 << 3,   // Display GPU CMD Usage
-  PDMetrikOverlayFlags_LMM = 1 << 4,   // Display Linear Space Free
-  PDMetrikOverlayFlags_LVT = 1 << 5,   // Display Lithium Vertex Usage
-  PDMetrikOverlayFlags_LID = 1 << 6,   // Display Lithium Indices Usage
-  PDMetrikOverlayFlags_LDM = 1 << 7,   // Display Lithium Draw Command Num
-  PDMetrikOverlayFlags_LDC = 1 << 8,   // Display Lithium Drawcalls Count
-  PDMetrikOverlayFlags_PDO = 1 << 9,   // Display Overlay Info String
-  PDMetrikOverlayFlags_MTD = 1 << 10,  // Display Memory Usage (if enabled)
-  PDMetrikOverlayFlags_CGR = 1 << 11,  // Display CPU Graph
-  PDMetrikOverlayFlags_GGR = 1 << 12,  // Display GPU Graph
-  PDMetrikOverlayFlags_Default =
-      PDMetrikOverlayFlags_FPS | PDMetrikOverlayFlags_CPU |
-      PDMetrikOverlayFlags_GPU | PDMetrikOverlayFlags_CMD |
-      PDMetrikOverlayFlags_LMM | PDMetrikOverlayFlags_LVT |
-      PDMetrikOverlayFlags_LID | PDMetrikOverlayFlags_LDM |
-      PDMetrikOverlayFlags_LDC | PDMetrikOverlayFlags_PDO |
-      PDMetrikOverlayFlags_MTD,  // Enable All of Them exept Graphs
-};
-
-using PDFTraceOverlayFlags = unsigned int;
-enum PDFTraceOverlayFlags_ {
-  PDFTraceOverlayFlags_None = 0,                 // Displays Nothing
-  PDFTraceOverlayFlags_DisplayName = 1 << 0,     // Display Tracename
-  PDFTraceOverlayFlags_DisplayAverage = 1 << 1,  // Display Average Time
-  PDFTraceOverlayFlags_DisplayMin = 1 << 2,      // Display Minimum Time
-  PDFTraceOverlayFlags_DisplayMax = 1 << 3,      // Display Maximum Time
-  PDFTraceOverlayFlags_FillBg = 1 << 4,          // Make Background Darker
-  PDFTraceOverlayFlags_DisplayHelp = 1 << 5,     // Display Info for values
-  PDFTraceOverlayFlags_Default =
-      PDFTraceOverlayFlags_DisplayName | PDFTraceOverlayFlags_DisplayAverage |
-      PDFTraceOverlayFlags_DisplayMin | PDFTraceOverlayFlags_DisplayMax |
-      PDFTraceOverlayFlags_FillBg |
-      PDFTraceOverlayFlags_DisplayHelp,  // Enable All of Them
-};
-
-// Outdated HidApi (HidV2Patched)
-extern u32 d7_hDown;
-extern u32 d7_hHeld;
-extern u32 d7_hUp;
-extern u32 d7_hRepeat;  // Inofficial lol
-extern touchPosition d7_touch;
-
-// Modern Global Api
-extern C3D_RenderTarget *pd_top;
-extern C3D_RenderTarget *pd_top_right;
-extern C3D_RenderTarget *pd_bottom;
-extern PDFlags pd_flags;
-extern PDMetrikOverlayFlags pd_ovl_flags;
-extern PDFTraceOverlayFlags pd_ftrace_ovl_flags;
-// Draw2
-extern float pd_draw2_tsm;

include/pd/image/image.hpp

@@ -0,0 +1,84 @@
+#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/core.hpp>
+#include <pd/image/pd_p_api.hpp>
+
+namespace PD {
+class PD_IMAGE_API Image {
+ public:
+  enum Format {
+    RGBA,    // bpp == 4
+    RGB,     // bpp == 3
+    RGB565,  // bpp == 2 (not supported in laoding)
+    BGR,     // bpp == 3
+    ABGR     // bpp == 4
+  };
+  Image() = default;
+  Image(const std::string& path) { this->Load(path); }
+  Image(const std::vector<u8>& buf) { this->Load(buf); }
+  Image(const std::vector<u8>& buf, int w, int h, int bpp = 4) {
+    this->Copy(buf, w, h, bpp);
+  }
+  ~Image() = default;
+
+  PD_SHARED(Image)
+
+  void Load(const std::string& path);
+  void Load(const std::vector<u8>& buf);
+  void Copy(const std::vector<u8>& buf, int w, int h, int bpp = 4);
+
+  std::vector<PD::u8>& GetBuffer() { return pBuffer; }
+  std::vector<PD::u8> GetBuffer() const { return pBuffer; }
+
+  int Width() const { return pWidth; }
+  int Height() const { return pHeight; }
+  Format Fmt() const { return pFmt; }
+
+  u8& operator[](int idx) { return pBuffer[idx]; }
+  u8 operator[](int idx) const { return pBuffer[idx]; }
+
+  // Probably these make th eabove ones useless
+
+  operator std::vector<PD::u8>&() { return pBuffer; }
+  operator std::vector<PD::u8>() const { return pBuffer; }
+
+  static void Convert(Image::Ref img, Image::Format dst);
+  static void ReTile(Image::Ref img,
+                     std::function<u32(int x, int y, int w)> src,
+                     std::function<u32(int x, int y, int w)> dst);
+  static int Fmt2Bpp(Format fmt);
+
+  std::vector<PD::u8> pBuffer;
+  int pWidth;
+  int pHeight;
+  Format pFmt = Format::RGBA;
+
+ private:
+  /** Leftover variable used for stbi_load */
+  int fmt = 0;
+};
+}  // namespace PD

include/pd/image/img_blur.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 <pd/core/core.hpp>
+#include <pd/image/pd_p_api.hpp>
+
+namespace PD {
+/**
+ * Namepace containing functions to blur images
+ */
+namespace ImgBlur {
+/**
+ * Function to create Gaussian Kernel List
+ * @param radius Rasius to use
+ * @param si sigma value to use
+ * @return list of kernel values
+ */
+PD_IMAGE_API std::vector<float> GaussianKernel(int radius, float si);
+/**
+ * Gaussian Blur for basic Image Buffer
+ * @param buf Image Buffer (unsigned char)
+ * @param w width of the image
+ * @param h width of the image
+ * @param radius Blur radius
+ * @param si Blur sigma
+ * @param idxfn Indexing function
+ */
+PD_IMAGE_API void GaussianBlur(
+    std::vector<u8> &buf, int w, int h, float radius, float si,
+    std::function<int(int, int, int)> idxfn = [](int x, int y, int w) -> int {
+      return y * w + x;
+    });
+/**
+ * Advanced func to access memory directly
+ * @param buf Referenvce to the buffer
+ * @param w width of the image
+ * @param h width of the image
+ * @param bpp Bytes per Pixels (RGB[A], RGB565, etc)
+ * @param radius Blur radius
+ * @param si Blur sigma
+ * @param idxfn Indexing function
+ */
+PD_IMAGE_API void GaussianBlur(
+    void *buf, int w, int h, int bpp, float radius, float si,
+    std::function<int(int, int, int)> idxfn = [](int x, int y, int w) -> int {
+      return y * w + x;
+    });
+}  // namespace ImgBlur
+}  // namespace PD