reset layers and give menus a base layer to gather perfect ordered rendering

Scrolling was hardcoded to 3ds sCrEeNhEiGhT wTh

.clang-format

@@ -0,0 +1,334 @@
+---
+Language:        Cpp
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: true
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveShortCaseStatements:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCaseArrows: false
+  AlignCaseColons: false
+AlignConsecutiveTableGenBreakingDAGArgColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenCondOperatorColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenDefinitionColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments:
+  Kind:            Always
+  OverEmptyLines:  0
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowBreakBeforeNoexceptSpecifier: Never
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseExpressionOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AllowShortNamespacesOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AttributeMacros:
+  - __capability
+  - absl_nonnull
+  - absl_nullable
+  - absl_nullability_unknown
+BinPackArguments: true
+BinPackLongBracedList: true
+BinPackParameters: BinPack
+BitFieldColonSpacing: Both
+BracedInitializerIndentWidth: -1
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterExternBlock: false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakAdjacentStringLiterals: true
+BreakAfterAttributes: Leave
+BreakAfterJavaFieldAnnotations: false
+BreakAfterReturnType: None
+BreakArrays:     true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Attach
+BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTemplateCloser: false
+BreakBeforeTernaryOperators: true
+BreakBinaryOperations: Never
+BreakConstructorInitializers: BeforeColon
+BreakFunctionDefinitionParameters: false
+BreakInheritanceList: BeforeColon
+BreakStringLiterals: true
+BreakTemplateDeclarations: Yes
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+EnumTrailingComma: Leave
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseBlocks: false
+IndentCaseLabels: true
+IndentExportBlock: true
+IndentExternBlock: AfterExternBlock
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentRequiresClause: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+InsertBraces:    false
+InsertNewlineAtEOF: false
+InsertTrailingCommas: None
+IntegerLiteralSeparator:
+  Binary:          0
+  BinaryMinDigits: 0
+  Decimal:         0
+  DecimalMinDigits: 0
+  Hex:             0
+  HexMinDigits:    0
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLines:
+  AtEndOfFile:     false
+  AtStartOfBlock:  false
+  AtStartOfFile:   true
+KeepFormFeed:    false
+LambdaBodyIndentation: Signature
+LineEnding:      DeriveLF
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MainIncludeChar: Quote
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+OneLineFormatOffRegex: ''
+PackConstructorInitializers: NextLine
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakBeforeMemberAccess: 150
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakScopeResolution: 500
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyIndentedWhitespace: 0
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+PPIndentWidth:   -1
+QualifierAlignment: Leave
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: pb
+    BasedOnStyle:    google
+ReferenceAlignment: Pointer
+ReflowComments:  Always
+RemoveBracesLLVM: false
+RemoveEmptyLinesInUnwrappedLines: false
+RemoveParentheses: Leave
+RemoveSemicolon: false
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SkipMacroDefinitionBody: false
+SortIncludes:
+  Enabled:         true
+  IgnoreCase:      false
+SortJavaStaticImport: Before
+SortUsingDeclarations: LexicographicNumeric
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterOperatorKeyword: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeJsonColon: false
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterNot:        false
+  AfterOverloadedOperator: false
+  AfterPlacementOperator: true
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  Never
+SpacesInContainerLiterals: true
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParens:  Never
+SpacesInParensOptions:
+  ExceptDoubleParentheses: false
+  InCStyleCasts:   false
+  InConditionalStatements: false
+  InEmptyParentheses: false
+  Other:           false
+SpacesInSquareBrackets: false
+Standard:        Auto
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TableGenBreakInsideDAGArg: DontBreak
+TabWidth:        8
+UseTab:          Never
+VerilogBreakBetweenInstancePorts: true
+WhitespaceSensitiveMacros:
+  - BOOST_PP_STRINGIZE
+  - CF_SWIFT_NAME
+  - NS_SWIFT_NAME
+  - PP_STRINGIZE
+  - STRINGIZE
+WrapNamespaceBodyWithEmptyLines: Leave
+...
+

.clangd

@@ -0,0 +1,6 @@
+CompileFlags:
+  CompilationDatabase: build/default-release
+  Add: []
+
+Completion:
+  HeaderInsertion: Never

.gitattributes

@@ -0,0 +1 @@
+vendor/* linguist-vendored

.gitignore

@@ -1 +1,4 @@
-build/
+build*/
+.cache
+.vscode
+.DS_Store

.gitmodules

@@ -0,0 +1,12 @@
+[submodule "vendor/stb"]
+	path = vendor/stb
+	url = https://github.com/nothings/stb.git
+[submodule "vendor/glfw"]
+	path = vendor/glfw
+	url = https://github.com/glfw/glfw.git
+[submodule "vendor/libpicasso"]
+	path = vendor/libpicasso
+	url = https://github.com/tobid7/libpicasso
+[submodule "vendor/spirv-helper"]
+	path = vendor/spirv-helper
+	url = https://github.com/tobid7/spirv-helper.git

.vscode/c_cpp_properties.json

@@ -1,36 +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/**"
-            ],
-            "defines": [
-                "BUILD_CTR"
-            ],
-            "compilerPath": "C:/devkitPro/devkitARM/bin/arm-none-eabi-g++.exe",
-            "intelliSenseMode": "gcc-arm",
-            "cStandard": "c11",
-            "cppStandard": "c++20"
-        },
-        {
-            "name": "3DS | Linux",
-            "includePath": [
-                "${workspaceFolder}/**",
-                "/opt/devkitpro/libctru/include/**",
-                "/opt/devkitpro/portlibs/3ds/include/**"
-            ],
-            "defines": [
-                "BUILD_CTR"
-            ],
-            "cStandard": "c17",
-            "cppStandard": "gnu++20",
-            "intelliSenseMode": "gcc-arm"
-        }
-    ],
-    "version": 4
-}

.vscode/launch.json

@@ -1,21 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "3DS GDB",
-            "type": "cppdbg",
-            "request": "launch",
-            "program": "${workspaceFolder}/build/test.elf",
-            "miDebuggerServerAddress": "localhost:4003",
-            "miDebuggerPath": "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gdb.exe",
-            "cwd": "${workspaceFolder}",
-            "externalConsole": true,
-            "setupCommands": [
-                {
-                    "description": "Enable pretty-printing for gdb",
-                    "text": "-enable-pretty-printing",
-                    "ignoreFailures": true
-                }
-            ]
-        }
-    ]
-}

.vscode/settings.json

@@ -1,120 +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",
-        "any": "cpp",
-        "text_encoding": "cpp"
-    }
-}

CMakeLists.txt

@@ -1,212 +1,184 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.22)
 
-### Helper Function to Build Librarys without have always
+include(GNUInstallDirs)
-### These includes and definition defines
-function(add_pd_lib TARGET_NAME)
-set(opts "")
-set(one_val_args "")
-set(multi_val_args SRC_FILES DEPENDS)
-cmake_parse_arguments(ARG "${opts}" "${one_val_args}" "${multi_val_args}" ${ARGN})
-
-add_library(${TARGET_NAME} STATIC ${ARG_SRC_FILES})
-target_include_directories(${TARGET_NAME} PUBLIC
-    include
-    ${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()
-
-# Setup Toolchain if not specified
-# Could propably avoided by using arm-none-eabi-cmake
-if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
-    if(DEFINED ENV{DEVKITPRO})
-        set(CMAKE_TOOLCHAIN_FILE "$ENV{DEVKITPRO}/cmake/3DS.cmake" CACHE PATH "toolchain file")
-    else()
-        message(FATAL_ERROR "Please define DEVKITPRO to point to your SDK path!")
-    endif()
-endif()
-
-## Get Current Git Commit Value
-execute_process(
-    COMMAND git rev-parse --short HEAD
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_SHORT_HASH
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-
-## Get Current Git Branch
-execute_process(
-    COMMAND git rev-parse --abbrev-ref HEAD
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_BRANCH
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
 
 # Set Project
-project(palladium LANGUAGES C CXX VERSION 0.3.2)
+project(palladium LANGUAGES C CXX VERSION 0.7.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 Library" OFF)
+option(PD_BUILD_TOOLS "Build Palladium Tools" OFF)
+option(PD_INCLUDE_STB_IMAGE "Inlude stb image symbols in palladium" ON)
 
-# Enable Compile Command Export
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+    add_compile_options(-Wno-psabi)
-
-# Force C++ 20
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
-
-# Set Special C and CXX flags
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-psabi -O2")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_C_FLAGS} -fno-rtti -fno-exceptions")
-
-## Core Source Code
-set(CORE_SRC
-source/core/common.cpp
-source/core/bit_util.cpp
-source/core/color.cpp
-source/core/io.cpp
-source/core/strings.cpp
-source/core/sys.cpp
-source/core/timer.cpp
-source/core/timetrace.cpp)
-
-## Image Source Code
-set(IMAGE_SRC
-source/image/image.cpp
-source/image/img_blur.cpp
-source/image/img_convert.cpp)
-
-## External Source Code
-set(EXTERNAL_SRC
-source/external/stb.cpp)
-
-## Drivers Source Code
-set(DRVS_SRC
-source/drivers/hid.cpp)
-
-## Lib3ds Source Code
-set(L3DS_SRC
-source/lib3ds/gamepad_icons.cpp
-source/lib3ds/result_decoder.cpp
-source/lib3ds/drv_hid.cpp
-source/lib3ds/hwinfo.cpp
-source/lib3ds/os.cpp)
-
-## Lithium Source Code
-set(LI_SRC
-source/lithium/li7_shader.cpp
-source/lithium/spritesheet.cpp
-source/lithium/texture.cpp
-source/lithium/font.cpp
-source/lithium/objects.cpp
-source/lithium/renderer.cpp)
-
-## Sounbd Source Code
-set(SOUND_SRC
-source/sound/mp3.cpp)
-
-## Overlay source Code
-set(OVL_SRC
-source/overlays/keyboard.cpp
-source/overlays/message_mgr.cpp
-source/overlays/overlay_mgr.cpp
-source/overlays/performance.cpp
-source/overlays/settings.cpp)
-
-## App Source Code
-set(APP_SRC
-source/app/app.cpp
-source/app/lang.cpp
-source/app/error.cpp)
-
-## UI7 Source Code
-set(UI7_SRC
-source/ui7/drawlist.cpp
-source/ui7/io.cpp
-source/ui7/layout.cpp
-source/ui7/menu.cpp
-source/ui7/theme.cpp
-source/ui7/ui7.cpp
-source/ui7/container/container.cpp
-source/ui7/container/button.cpp
-source/ui7/container/checkbox.cpp
-source/ui7/container/coloredit.cpp
-source/ui7/container/dragdata.cpp
-source/ui7/container/image.cpp
-source/ui7/container/label.cpp)
-
-#### Creating the Libraries (if activated) ####
-add_pd_lib(pd-core SRC_FILES ${CORE_SRC})
-add_pd_lib(pd-image SRC_FILES ${IMAGE_SRC} DEPENDS pd-core)
-add_pd_lib(pd-external SRC_FILES ${EXTERNAL_SRC})
-add_pd_lib(pd-drivers SRC_FILES ${DRVS_SRC} DEPENDS pd-core)
-add_pd_lib(pd-lib3ds SRC_FILES ${L3DS_SRC} DEPENDS pd-drivers)
-add_pd_lib(pd-lithium SRC_FILES ${LI_SRC} DEPENDS pd-core pd-image pd-external citro3d)
-add_pd_lib(pd-sound SRC_FILES ${SOUND_SRC} DEPENDS pd-core mpg123)
-add_pd_lib(pd-overlays SRC_FILES ${OVL_SRC} DEPENDS pd-lithium)
-add_pd_lib(pd-app SRC_FILES ${APP_SRC} DEPENDS pd-overlays pd-drivers pd-lib3ds)
-add_pd_lib(pd-ui7 SRC_FILES ${UI7_SRC} DEPENDS pd-drivers pd-lithium)
-
-add_library(palladium INTERFACE)
-target_link_libraries(palladium INTERFACE
-pd-core pd-image pd-external pd-drivers pd-lib3ds
-pd-lithium pd-overlays pd-app pd-ui7
-)
-
-add_dependencies(palladium
-pd-core pd-image pd-external pd-drivers
-pd-lib3ds pd-lithium pd-overlays pd-app pd-ui7
-)
-
-add_library(palladium-lite INTERFACE)
-target_link_libraries(palladium-lite INTERFACE
-pd-core pd-image pd-external pd-drivers pd-lib3ds
-pd-lithium
-)
-
-add_dependencies(palladium-lite
-pd-core pd-image pd-external pd-drivers
-pd-lib3ds pd-lithium
-)
-
-if(PD_BUILD_TESTS)
-add_executable(test test/app/main.cpp)
-target_include_directories(test PUBLIC include test/app)
-target_link_directories(test PUBLIC ${CMAKE_BINARY_DIR})
-target_link_libraries(test PUBLIC palladium citro3d ctru m)
-
-add_executable(testbench test/bench/main.cpp)
-target_include_directories(testbench PUBLIC include test/bench)
-target_link_directories(testbench PUBLIC ${CMAKE_BINARY_DIR})
-target_link_libraries(testbench PUBLIC palladium citro3d ctru m)
-# Generate 3DSX
-ctr_generate_smdh(
-    ${CMAKE_BINARY_DIR}/test.smdh
-    NAME "${APP_NAME}"
-    DESCRIPTION "Palladium test app"
-    AUTHOR "tobid7"
-    ICON "test/romfs/icon.png"
-)
-ctr_create_3dsx(
-    test
-    OUTPUT "${CMAKE_BINARY_DIR}/test.3dsx"
-    SMDH "${CMAKE_BINARY_DIR}/test.smdh"
-    ROMFS "${CMAKE_SOURCE_DIR}/test/romfs"
-)
-ctr_create_3dsx(
-    testbench
-    OUTPUT "${CMAKE_BINARY_DIR}/testbench.3dsx"
-    SMDH "${CMAKE_BINARY_DIR}/test.smdh"
-    ROMFS "${CMAKE_SOURCE_DIR}/test/romfs"
-)
 endif()
 
-install(DIRECTORY include DESTINATION ".")
+if(${PD_BUILD_TOOLS})
+    add_subdirectory(tools)
+endif()
+
+add_subdirectory(vendor)
+
+# # Include Library Source
+set(PD_SOURCES
+    # Common
+    source/common.cpp
+
+    # Core
+    source/core/bits.cpp
+    source/core/color.cpp
+    source/core/io.cpp
+    source/core/mat.cpp
+    source/core/strings.cpp
+    source/core/timer.cpp
+    source/core/timetrace.cpp
+
+    # Image
+    source/image/convert.cpp
+    source/image/image.cpp
+
+    # Drivers
+    source/drivers/os.cpp
+    source/drivers/gfx.cpp
+    source/drivers/hid.cpp
+
+    # Lithium
+    source/lithium/command.cpp
+    source/lithium/drawlist.cpp
+    source/lithium/font.cpp
+    source/lithium/math.cpp
+    source/lithium/pools.cpp
+
+    # UI7
+    source/ui7/io.cpp
+    source/ui7/layout.cpp
+    source/ui7/menu.cpp
+    source/ui7/theme.cpp
+    source/ui7/ui7.cpp
+    source/ui7/container/button.cpp
+    source/ui7/container/checkbox.cpp
+    source/ui7/container/coloredit.cpp
+    source/ui7/container/container.cpp
+    source/ui7/container/dragdata.cpp
+    source/ui7/container/dynobj.cpp
+    source/ui7/container/image.cpp
+    source/ui7/container/label.cpp
+    source/ui7/container/slider.cpp
+
+    # Ultra
+    source/ultra/canvas.cpp
+    source/ultra/layout.cpp
+    source/ultra/elems/element.cpp
+    source/ultra/elems/rect.cpp
+    source/ultra/elems/text.cpp
+    source/ultra/elems/image.cpp
+    source/ultra/elems/button.cpp
+)
+
+if(${PD_BUILD_SHARED})
+    add_library(palladium SHARED ${PD_SOURCES})
+    target_compile_definitions(palladium PRIVATE PD_BUILD_SHARED)
+else()
+    add_library(palladium STATIC ${PD_SOURCES})
+    target_compile_definitions(palladium PUBLIC PD_BUILD_STATIC)
+endif()
+
+target_link_libraries(palladium
+    PUBLIC stb
+)
+
+target_compile_definitions(palladium
+    PUBLIC
+    PD_DEBUG
+    $<$<OR:$<BOOL:${PD_INCLUDE_STB_IMAGE}>,$<BOOL:${PD_BUILD_SHARED}>>:PD_INCLUDE_STB_IMAGE> # Always on in shared build
+)
+target_compile_options(palladium
+    PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
+    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/source=source
+    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/include=include
+    >
+)
+
+add_library(palladium::palladium ALIAS palladium)
+
+target_include_directories(palladium
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_compile_options(palladium
+    PRIVATE
+    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:GNU,Clang>>:-O0 -g>
+    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU,Clang>>:-O3>
+
+    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:MSVC>>:/Od /Zi>
+    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:MSVC>>:/O2>
+)
+
+install(
+    TARGETS palladium
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+install(
+    DIRECTORY include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+install(EXPORT palladiumTargets
+    FILE palladiumTargets.cmake
+    NAMESPACE palladium::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+    cmake/palladiumConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    INSTALL_DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    VERSION
+    ${PROJECT_VERSION}
+    COMPATIBILITY
+    SameMajorVersion
+)
+
+install(
+    FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+find_program(CLANG_FORMAT clang-format)
+
+file(GLOB_RECURSE PD_FMTFILES
+    CONFIGURE_DEPENDS
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/core/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/gfx/source/*.cpp
+)
+
+add_custom_target(pd-clang-format
+    COMMAND ${CLANG_FORMAT} --style=file -i ${PD_FMTFILES}
+    COMMENT "Formatting Project Sources"
+)
+
+add_subdirectory(backends)
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tests)
+endif()

CMakePresets.json

@@ -0,0 +1,14 @@
+{
+    "version": 10,
+    "cmakeMinimumRequired": {
+        "major": 3,
+        "minor": 22,
+        "patch": 0
+    },
+    "include": [
+        "cmake/presets/default.json",
+        "cmake/presets/3ds.json",
+        "cmake/presets/switch.json",
+        "cmake/presets/msvc.json"
+    ]
+}

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 - 2025 tobid7
+Copyright (c) 2024 - 2026 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

README.md

@@ -23,28 +23,11 @@ make
 make install
 ```
 
-## Libraries
-
-| Name | Last Updated | Platform | Depends |
-|---|---|---|---|
-| pd-core | 0.2.6 | multi | none |
-| pd-external | 0.1.0 | multi | none |
-| pd-image | 0.2.6 | multi | pd-core |
-| pd-drivers | 0.2.4 | multi | pd-core |
-| pd-lib3ds | 0.2.4 | 3ds | pd-core, pd-drivers |
-| pd-net | 0.2.4 | 3ds | pd-core, pd-lib3ds |
-| pd-lithium | 0.2.9 | 3ds | pd-core, pd-image pd-lib3ds, citro3d |
-| pd-sound | 0.2.4 | 3ds | pd-core, mpg123 |
-| pd-overlays | 0.2.4 | 3ds | pd-core, pd-image, pd-lib3ds, pd-lithium, pd-ui7 |
-| pd-ui7 | 0.3.1 | 3ds | pd-core, pd-image, pd-lib3ds, pd-lithium |
-| pd-app | 0.2.4 | 3ds | pd-core, pd-image, pd-lib3ds, pd-lithium |
-
 ## 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/Universal-Team.png" alt="https://github.com/Universal-Team" width="48"/> | [Universal-Team](https://github.com/Universal-Team) | Inspiration for Lang System, Cia Installer Code |
 | <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/CMakeLists.txt

@@ -0,0 +1,90 @@
+cmake_minimum_required(VERSION 3.22)
+
+project(pd-system)
+
+option(PD_ENABLE_OPENGL2 "Enable OpenGL 2.1 (On Supported Hardware)" ON)
+option(PD_ENABLE_OPENGL3 "Enable OpenGL 3.3 (On Supported Hardware)" ON)
+option(PD_ENABLE_DIRECTX9 "Enable DirectX9 Support" ON)
+option(PD_ENABLE_CITRO3D "Enable Citro3D Support (3DS)" OFF)
+option(PD_ENABLE_VULKAN "Not implemented yet" OFF)
+option(PD_ENABLE_HID_GLFW "Enable GLFW Input Driver" ON)
+option(PD_ENABLE_HID_NX "Enable NX Input Driver" OFF)
+option(PD_ENABLE_HID3DS "Enable 3ds Input Driver" OFF)
+
+if(NOT WIN32) # cause we are not on windows...
+    set(PD_ENABLE_DIRECTX9 OFF)
+endif()
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
+    set(PD_ENABLE_OPENGL2 OFF)
+    set(PD_ENABLE_OPENGL3 OFF)
+    set(PD_ENABLE_VULKAN OFF)
+    set(PD_ENABLE_CITRO3D ON)
+    set(PD_ENABLE_HID_GLFW OFF)
+    set(PD_ENABLE_HID_NX OFF)
+    set(PD_ENABLE_HID3DS ON)
+elseif(${CMAKE_SYSTEM_NAME} STREQUAL "NintendoSwitch")
+    set(PD_ENABLE_OPENGL2 OFF)
+    set(PD_ENABLE_OPENGL3 ON)
+    set(PD_ENABLE_VULKAN OFF)
+    set(PD_ENABLE_CITRO3D OFF)
+    set(PD_ENABLE_HID_NX ON) # Best case for Nintendo Switch
+    set(PD_ENABLE_HID_GLFW ON) # Technically supported but not recommended
+endif()
+
+add_library(pd-system STATIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gl-helper.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl2.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl3.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_directx9.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_citro3d.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/hid_3ds.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/hid_glfw.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/hid_nx.cpp
+)
+
+target_include_directories(pd-system
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+    # Why is this not a default include (same problem as with the __SWITCH__ define)
+    $<$<STREQUAL:${CMAKE_SYSTEM_NAME},NintendoSwitch>:${DEVKITPRO}/portlibs/switch/include>
+)
+
+target_compile_options(palladium
+    PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
+    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/source=source
+    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/include=include
+    >
+)
+
+target_compile_definitions(pd-system
+    PUBLIC
+    $<$<BOOL:${PD_ENABLE_OPENGL2}>:PD_ENABLE_OPENGL2>
+    $<$<BOOL:${PD_ENABLE_OPENGL3}>:PD_ENABLE_OPENGL3>
+    $<$<BOOL:${PD_ENABLE_VULKAN}>:PD_ENABLE_VULKAN>
+    $<$<BOOL:${PD_ENABLE_DIRECTX9}>:PD_ENABLE_DIRECTX9>
+    $<$<BOOL:${PD_ENABLE_CITRO3D}>:PD_ENABLE_CITRO3D>
+    $<$<BOOL:${PD_ENABLE_HID_GLFW}>:PD_ENABLE_HID_GLFW>
+    $<$<BOOL:${PD_ENABLE_HID_NX}>:PD_ENABLE_HID_NX>
+    $<$<BOOL:${PD_ENABLE_HID3DS}>:PD_ENABLE_HID3DS>
+)
+
+# Palladium
+target_link_libraries(pd-system PUBLIC palladium::palladium)
+
+
+# Depandant Lib includes (i love this cmake feature)
+target_link_libraries(pd-system PUBLIC
+    $<$<BOOL:${PD_ENABLE_DIRECTX9}>:d3d9 d3dcompiler> # DirectX9
+    $<$<BOOL:${PD_ENABLE_CITRO3D}>:pica::pica citro3d ctru> # 3ds
+    $<$<BOOL:${PD_ENABLE_OPENGL3}>:spirv-helper> # OpenGL3
+    # Include Glad if we have any OpenGL Usage
+    $<$<OR:$<BOOL:${PD_ENABLE_OPENGL2}>,$<BOOL:${PD_ENABLE_OPENGL3}>>:glad>
+    $<$<BOOL:${PD_ENABLE_HID_NX}>:nx> # Hid NX requirement
+    # Hid GLFW requirement
+    $<$<BOOL:${PD_ENABLE_HID_GLFW}>:
+    $<$<STREQUAL:${CMAKE_SYSTEM_NAME},NintendoSwitch>:glfw3>
+    $<$<NOT:$<STREQUAL:${CMAKE_SYSTEM_NAME},NintendoSwitch>>:glfw>>
+
+)

backends/README.md

@@ -0,0 +1,24 @@
+# Backends
+
+- [Graphics](#graphics)
+  - [OpenGL2](#opengl2-legacy)
+  - [OpenGL3](#opengl3-modern-opengl)
+  - [DirectX9](#directx9-could-potentially-cover-more-then-opengl2)
+  - [Citro3D](#citro3d-3ds)
+
+## Graphics
+
+### OpenGL2 (Legacy)
+
+> [!NOTE]
+> As SPIRV to GLSL 120 translation doesn't work, your'e forced to write separate shaders for this backend
+
+### OpenGL3+ (Modern OpenGL)
+
+### DirectX9 (Could potentially cover more than OpenGL2)
+
+### Citro3D (3DS)
+
+> [!NOTE]
+> This backend requires shaders as binary file, directly in the code or as string for libpicasso
+> The Fragment Stage is special and is still wip

backends/include/pd_system/ctr-linear-allocator.hpp

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

backends/include/pd_system/gfx_citro3d.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <pd/drivers/gfx.hpp>
+#include <pd_system/ctr-linear-allocator.hpp>
+
+namespace PD {
+struct GfxCitro3DConfig {
+  // Vertex Allocator
+  template <typename T>
+  using VertexAlloc = LinearAllocator<T>;
+  // Index Allocator
+  template <typename T>
+  using IndexAlloc = LinearAllocator<T>;
+};
+
+class GfxCitro3D : public GfxDriverBase<GfxCitro3DConfig> {
+ public:
+  GfxCitro3D() : GfxDriverBase("Citro3D") {}
+  ~GfxCitro3D() {}
+
+  void SysInit() override;
+  void SysDeinit() override;
+  void Submit(size_t count, size_t start) override;
+  void BindTexture(TextureID id) override;
+  void SysReset() override;
+  Li::Texture LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      TextureFormat type = TextureFormat::RGBA32,
+      TextureFilter filter = TextureFilter::Linear) override;
+  void DeleteTexture(const Li::Texture& tex) override;
+  void UploadPools() override;
+
+ private:
+  struct Impl;
+  Impl* impl = nullptr;
+};
+}  // namespace PD

backends/include/pd_system/gfx_directx9.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <pd/drivers/gfx.hpp>
+
+namespace PD {
+struct GfxDirectX9Config {
+  // Vertex Allocator
+  template <typename T>
+  using VertexAlloc = std::allocator<T>;
+  // Index Allocator
+  template <typename T>
+  using IndexAlloc = std::allocator<T>;
+};
+
+class GfxDirectX9 : public GfxDriverBase<GfxDirectX9Config> {
+ public:
+  GfxDirectX9(void* device = nullptr)
+      : GfxDriverBase("DirectX9"), pDevice(device) {}
+  ~GfxDirectX9() {}
+
+  void SysInit() override;
+  void SysDeinit() override;
+  void Submit(size_t count, size_t start) override;
+  void BindTexture(TextureID id) override;
+  void SysReset() override;
+  Li::Texture LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      TextureFormat type = TextureFormat::RGBA32,
+      TextureFilter filter = TextureFilter::Linear) override;
+  void DeleteTexture(const Li::Texture& tex) override;
+  void UploadPools() override;
+
+ private:
+  struct Impl;
+  Impl* impl = nullptr;
+  void* pDevice = nullptr;
+};
+}  // namespace PD

backends/include/pd_system/gfx_opengl2.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <pd/drivers/gfx.hpp>
+
+namespace PD {
+struct GfxOpenGL2Config {
+  // Vertex Allocator
+  template <typename T>
+  using VertexAlloc = std::allocator<T>;
+  // Index Allocator
+  template <typename T>
+  using IndexAlloc = std::allocator<T>;
+};
+
+class GfxOpenGL2 : public GfxDriverBase<GfxOpenGL2Config> {
+ public:
+  GfxOpenGL2() : GfxDriverBase("OpenGL2") {}
+  ~GfxOpenGL2() {}
+
+  void SysInit() override;
+  void SysDeinit() override;
+  void Submit(size_t count, size_t start) override;
+  void BindTexture(TextureID id) override;
+  void SysReset() override;
+  Li::Texture LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      TextureFormat type = TextureFormat::RGBA32,
+      TextureFilter filter = TextureFilter::Linear) override;
+  void DeleteTexture(const Li::Texture& tex) override;
+  void UploadPools() override;
+
+ private:
+  void pSetupShaderAttribs(u32 shader);
+  u32 pShader = 0;
+  u32 VBO = 0;
+  u32 IBO = 0;
+  int pLocTex = 0;
+  int pLocAlfa = 0;
+  int pLocIsSDF = 0;
+  int pLocProjection = 0;
+  static const char* pVertCode;
+  static const char* pFragCode;
+};
+}  // namespace PD

backends/include/pd_system/gfx_opengl3.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <pd/drivers/gfx.hpp>
+
+namespace PD {
+struct GfxOpenGL3Config {
+  // Vertex Allocator
+  template <typename T>
+  using VertexAlloc = std::allocator<T>;
+  // Index Allocator
+  template <typename T>
+  using IndexAlloc = std::allocator<T>;
+};
+
+class GfxOpenGL3 : public GfxDriverBase<GfxOpenGL3Config> {
+ public:
+  GfxOpenGL3() : GfxDriverBase("OpenGL3") {}
+  ~GfxOpenGL3() {}
+
+  void SysInit() override;
+  void SysDeinit() override;
+  void Submit(size_t count, size_t start) override;
+  void BindTexture(TextureID id) override;
+  void SysReset() override;
+  Li::Texture LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      TextureFormat type = TextureFormat::RGBA32,
+      TextureFilter filter = TextureFilter::Linear) override;
+  void DeleteTexture(const Li::Texture& tex) override;
+  void UploadPools() override;
+
+ private:
+  u32 pShader = 0;
+  u32 VBO = 0;
+  u32 IBO = 0;
+  u32 VAO = 0;
+  int pLocTex = 0;
+  int pLocAlfa = 0;
+  int pLocIsSDF = 0;
+  int pLocProjection = 0;
+};
+}  // namespace PD

backends/include/pd_system/gl-helper.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <pd/common.hpp>
+
+namespace PD {
+u32 CreateShaderProgram(const char* vert, const char* frag);
+}

backends/include/pd_system/hid_3ds.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <pd/drivers/hid.hpp>
+
+namespace PD {
+class Hid3DS : public HidDriver {
+ public:
+  Hid3DS();
+  ~Hid3DS();
+
+  void Update() override;
+
+ private:
+  struct Impl;
+  Impl* impl;
+};
+}  // namespace PD

backends/include/pd_system/hid_glfw.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <pd/drivers/hid.hpp>
+
+typedef struct GLFWwindow GLFWwindow;
+typedef struct GLFWgamepadstate GLFWgamepadstate;
+
+namespace PD {
+class HidGlfw : public HidDriver {
+ public:
+  HidGlfw(GLFWwindow* window);
+  ~HidGlfw();
+
+  void Update() override;
+
+ private:
+  void HandleAxisKey(GLFWgamepadstate s, int iK, int eA, bool negative);
+  struct Impl;
+  Impl* impl;
+};
+}  // namespace PD

backends/include/pd_system/hid_nx.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <pd/drivers/hid.hpp>
+
+namespace PD {
+class HidNX : public HidDriver {
+ public:
+  HidNX();
+  ~HidNX();
+
+  void Update() override;
+
+ private:
+  struct Impl;
+  Impl* impl;
+};
+}  // namespace PD

backends/include/pd_system/shaders.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace PD {
+/**
+ * Shader blobs
+ * Required for OpenGL3, and maybe later for vulkan
+ * Shaders can be found in /tools/pdsg/shaders
+ */
+namespace Shaders {
+// clang-format off
+const unsigned int VertexShader[] = { 0x7230203, 0x10000, 0x8000B, 0x2B, 0x0, 0x20011, 0x1, 0x6000B, 0x1, 0x4C534C47, 0x6474732E, 0x3035342E, 0x0, 0x3000E, 0x0, 0x1, 0xB000F, 0x0, 0x4, 0x6E69616D, 0x0, 0xD, 0x19, 0x24, 0x25, 0x27, 0x29, 0x30003, 0x2, 0x1CC, 0x40005, 0x4, 0x6E69616D, 0x0, 0x60005, 0xB, 0x505F6C67, 0x65567265, 0x78657472, 0x0, 0x60006, 0xB, 0x0, 0x505F6C67, 0x7469736F, 0x6E6F69, 0x70006, 0xB, 0x1, 0x505F6C67, 0x746E696F, 0x657A6953, 0x0, 0x70006, 0xB, 0x2, 0x435F6C67, 0x4470696C, 0x61747369, 0x65636E, 0x70006, 0xB, 0x3, 0x435F6C67, 0x446C6C75, 0x61747369, 0x65636E, 0x30005, 0xD, 0x0, 0x30005, 0x11, 0x4F4255, 0x60006, 0x11, 0x0, 0x6A6F7270, 0x69746365, 0x6E6F, 0x30005, 0x13, 0x6F6275, 0x30005, 0x19, 0x736F70, 0x30005, 0x24, 0x56556F, 0x30005, 0x25, 0x7675, 0x40005, 0x27, 0x6C6F436F, 0x726F, 0x40005, 0x29, 0x6F6C6F63, 0x72, 0x30047, 0xB, 0x2, 0x50048, 0xB, 0x0, 0xB, 0x0, 0x50048, 0xB, 0x1, 0xB, 0x1, 0x50048, 0xB, 0x2, 0xB, 0x3, 0x50048, 0xB, 0x3, 0xB, 0x4, 0x30047, 0x11, 0x2, 0x40048, 0x11, 0x0, 0x5, 0x50048, 0x11, 0x0, 0x7, 0x10, 0x50048, 0x11, 0x0, 0x23, 0x0, 0x40047, 0x13, 0x21, 0x0, 0x40047, 0x13, 0x22, 0x0, 0x40047, 0x19, 0x1E, 0x0, 0x40047, 0x24, 0x1E, 0x0, 0x40047, 0x25, 0x1E, 0x1, 0x40047, 0x27, 0x1E, 0x1, 0x40047, 0x29, 0x1E, 0x2, 0x20013, 0x2, 0x30021, 0x3, 0x2, 0x30016, 0x6, 0x20, 0x40017, 0x7, 0x6, 0x4, 0x40015, 0x8, 0x20, 0x0, 0x4002B, 0x8, 0x9, 0x1, 0x4001C, 0xA, 0x6, 0x9, 0x6001E, 0xB, 0x7, 0x6, 0xA, 0xA, 0x40020, 0xC, 0x3, 0xB, 0x4003B, 0xC, 0xD, 0x3, 0x40015, 0xE, 0x20, 0x1, 0x4002B, 0xE, 0xF, 0x0, 0x40018, 0x10, 0x7, 0x4, 0x3001E, 0x11, 0x10, 0x40020, 0x12, 0x2, 0x11, 0x4003B, 0x12, 0x13, 0x2, 0x40020, 0x14, 0x2, 0x10, 0x40017, 0x17, 0x6, 0x2, 0x40020, 0x18, 0x1, 0x17, 0x4003B, 0x18, 0x19, 0x1, 0x4002B, 0x6, 0x1B, 0x0, 0x4002B, 0x6, 0x1C, 0x3F800000, 0x40020, 0x21, 0x3, 0x7, 0x40020, 0x23, 0x3, 0x17, 0x4003B, 0x23, 0x24, 0x3, 0x4003B, 0x18, 0x25, 0x1, 0x4003B, 0x21, 0x27, 0x3, 0x40020, 0x28, 0x1, 0x7, 0x4003B, 0x28, 0x29, 0x1, 0x50036, 0x2, 0x4, 0x0, 0x3, 0x200F8, 0x5, 0x50041, 0x14, 0x15, 0x13, 0xF, 0x4003D, 0x10, 0x16, 0x15, 0x4003D, 0x17, 0x1A, 0x19, 0x50051, 0x6, 0x1D, 0x1A, 0x0, 0x50051, 0x6, 0x1E, 0x1A, 0x1, 0x70050, 0x7, 0x1F, 0x1D, 0x1E, 0x1B, 0x1C, 0x50091, 0x7, 0x20, 0x16, 0x1F, 0x50041, 0x21, 0x22, 0xD, 0xF, 0x3003E, 0x22, 0x20, 0x4003D, 0x17, 0x26, 0x25, 0x3003E, 0x24, 0x26, 0x4003D, 0x7, 0x2A, 0x29, 0x3003E, 0x27, 0x2A, 0x100FD, 0x10038, };
+// clang-format on
+// clang-format off
+const unsigned int FragmentShader[] = { 0x7230203, 0x10000, 0x8000B, 0x50, 0x0, 0x20011, 0x1, 0x6000B, 0x1, 0x4C534C47, 0x6474732E, 0x3035342E, 0x0, 0x3000E, 0x0, 0x1, 0x8000F, 0x0, 0x4, 0x6E69616D, 0x0, 0x11, 0x2C, 0x2E, 0x30003, 0x2, 0x1CC, 0x40005, 0x4, 0x6E69616D, 0x0, 0x30005, 0x9, 0x6374, 0x30005, 0xD, 0x786574, 0x30005, 0x11, 0x56556F, 0x50005, 0x16, 0x68737550, 0x61746144, 0x0, 0x50006, 0x16, 0x0, 0x61666C61, 0x0, 0x50006, 0x16, 0x1, 0x735F7369, 0x6664, 0x40005, 0x18, 0x68737570, 0x0, 0x40005, 0x23, 0x68706C61, 0x61, 0x50005, 0x2C, 0x67617246, 0x6F6C6F43, 0x72, 0x40005, 0x2E, 0x6C6F436F, 0x726F, 0x40047, 0xD, 0x21, 0x0, 0x40047, 0xD, 0x22, 0x0, 0x40047, 0x11, 0x1E, 0x0, 0x30047, 0x16, 0x2, 0x50048, 0x16, 0x0, 0x23, 0x0, 0x50048, 0x16, 0x1, 0x23, 0x4, 0x40047, 0x2E, 0x1E, 0x1, 0x20013, 0x2, 0x30021, 0x3, 0x2, 0x30016, 0x6, 0x20, 0x40017, 0x7, 0x6, 0x4, 0x40020, 0x8, 0x7, 0x7, 0x90019, 0xA, 0x6, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x3001B, 0xB, 0xA, 0x40020, 0xC, 0x0, 0xB, 0x4003B, 0xC, 0xD, 0x0, 0x40017, 0xF, 0x6, 0x2, 0x40020, 0x10, 0x1, 0xF, 0x4003B, 0x10, 0x11, 0x1, 0x4002B, 0x6, 0x13, 0x0, 0x40015, 0x15, 0x20, 0x1, 0x4001E, 0x16, 0x15, 0x15, 0x40020, 0x17, 0x9, 0x16, 0x4003B, 0x17, 0x18, 0x9, 0x4002B, 0x15, 0x19, 0x1, 0x40020, 0x1A, 0x9, 0x15, 0x4002B, 0x15, 0x1D, 0x0, 0x20014, 0x1E, 0x40020, 0x22, 0x7, 0x6, 0x4002B, 0x6, 0x24, 0x3EE66666, 0x4002B, 0x6, 0x25, 0x3F0CCCCD, 0x40015, 0x26, 0x20, 0x0, 0x4002B, 0x26, 0x27, 0x3, 0x40020, 0x2B, 0x3, 0x7, 0x4003B, 0x2B, 0x2C, 0x3, 0x40020, 0x2D, 0x1, 0x7, 0x4003B, 0x2D, 0x2E, 0x1, 0x40017, 0x2F, 0x6, 0x3, 0x40020, 0x33, 0x1, 0x6, 0x50036, 0x2, 0x4, 0x0, 0x3, 0x200F8, 0x5, 0x4003B, 0x8, 0x9, 0x7, 0x4003B, 0x22, 0x23, 0x7, 0x4003D, 0xB, 0xE, 0xD, 0x4003D, 0xF, 0x12, 0x11, 0x70058, 0x7, 0x14, 0xE, 0x12, 0x2, 0x13, 0x3003E, 0x9, 0x14, 0x50041, 0x1A, 0x1B, 0x18, 0x19, 0x4003D, 0x15, 0x1C, 0x1B, 0x500AB, 0x1E, 0x1F, 0x1C, 0x1D, 0x300F7, 0x21, 0x0, 0x400FA, 0x1F, 0x20, 0x3B, 0x200F8, 0x20, 0x50041, 0x22, 0x28, 0x9, 0x27, 0x4003D, 0x6, 0x29, 0x28, 0x8000C, 0x6, 0x2A, 0x1, 0x31, 0x24, 0x25, 0x29, 0x3003E, 0x23, 0x2A, 0x4003D, 0x7, 0x30, 0x2E, 0x8004F, 0x2F, 0x31, 0x30, 0x30, 0x0, 0x1, 0x2, 0x4003D, 0x6, 0x32, 0x23, 0x50041, 0x33, 0x34, 0x2E, 0x27, 0x4003D, 0x6, 0x35, 0x34, 0x50085, 0x6, 0x36, 0x32, 0x35, 0x50051, 0x6, 0x37, 0x31, 0x0, 0x50051, 0x6, 0x38, 0x31, 0x1, 0x50051, 0x6, 0x39, 0x31, 0x2, 0x70050, 0x7, 0x3A, 0x37, 0x38, 0x39, 0x36, 0x3003E, 0x2C, 0x3A, 0x200F9, 0x21, 0x200F8, 0x3B, 0x50041, 0x1A, 0x3C, 0x18, 0x1D, 0x4003D, 0x15, 0x3D, 0x3C, 0x500AB, 0x1E, 0x3E, 0x3D, 0x1D, 0x300F7, 0x40, 0x0, 0x400FA, 0x3E, 0x3F, 0x4C, 0x200F8, 0x3F, 0x4003D, 0x7, 0x41, 0x2E, 0x8004F, 0x2F, 0x42, 0x41, 0x41, 0x0, 0x1, 0x2, 0x50041, 0x22, 0x43, 0x9, 0x27, 0x4003D, 0x6, 0x44, 0x43, 0x50041, 0x33, 0x45, 0x2E, 0x27, 0x4003D, 0x6, 0x46, 0x45, 0x50085, 0x6, 0x47, 0x44, 0x46, 0x50051, 0x6, 0x48, 0x42, 0x0, 0x50051, 0x6, 0x49, 0x42, 0x1, 0x50051, 0x6, 0x4A, 0x42, 0x2, 0x70050, 0x7, 0x4B, 0x48, 0x49, 0x4A, 0x47, 0x3003E, 0x2C, 0x4B, 0x200F9, 0x40, 0x200F8, 0x4C, 0x4003D, 0x7, 0x4D, 0x9, 0x4003D, 0x7, 0x4E, 0x2E, 0x50085, 0x7, 0x4F, 0x4D, 0x4E, 0x3003E, 0x2C, 0x4F, 0x200F9, 0x40, 0x200F8, 0x40, 0x200F9, 0x21, 0x200F8, 0x21, 0x100FD, 0x10038, };
+// clang-format on
+}  // namespace Shaders
+}  // namespace PD

backends/include/pdsystem

@@ -0,0 +1,11 @@
+#pragma once
+
+// Gfx
+#include <pd_system/gfx_citro3d.hpp>
+#include <pd_system/gfx_directx9.hpp>
+#include <pd_system/gfx_opengl2.hpp>
+#include <pd_system/gfx_opengl3.hpp>
+
+// Hid
+#include <pd_system/hid_3ds.hpp>
+#include <pd_system/hid_glfw.hpp>

backends/source/gfx_citro3d.cpp

@@ -0,0 +1,287 @@
+// Well yes, i finally try it
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/formatters.hpp>
+#include <pd_system/gfx_citro3d.hpp>
+
+#if defined(PD_ENABLE_CITRO3D) && defined(__3DS__)
+
+#include <3ds.h>
+#include <citro3d.h>
+
+#include <pd/drivers/drivers.hpp>
+#include <pica.hpp>
+
+namespace PD {
+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
+)";
+
+struct GfxCitro3D::Impl {
+  C3D_AttrInfo pAttr;
+  shaderProgram_s pShader;
+  DVLB_s* pCode;
+  int uLocProjection = 0;
+  C3D_Tex* CurrentTex = nullptr;
+  std::vector<u8> pShaderRaw;
+
+  GPU_TEXCOLOR TextureTranslateFormat(TextureFormat fmt) {
+    switch (fmt) {
+      case PD::TextureFormat::A8:
+        return GPU_A8;
+      case PD::TextureFormat::RGB24:
+        return GPU_RGB8;
+      case PD::TextureFormat::RGBA32:
+        return GPU_RGBA8;
+      default:
+        return GPU_RGBA8;
+    }
+  }
+
+  int TextureFormat2Bpp(TextureFormat fmt) {
+    switch (fmt) {
+      case PD::TextureFormat::A8:
+        return 1;
+      case PD::TextureFormat::RGB24:
+        return 3;
+      case PD::TextureFormat::RGBA32:
+        return 4;
+      default:
+        return 0;
+    }
+  }
+
+  void SetupPixelStage(bool sdf) {
+    shaderProgramUse(&pShader);
+    C3D_BindProgram(&pShader);
+    C3D_SetAttrInfo(&pAttr);
+    C3D_DepthTest(false, GPU_GREATER, GPU_WRITE_ALL);
+    if (!CurrentTex) return;
+    C3D_TexEnv* env = C3D_GetTexEnv(0);
+    C3D_TexEnvInit(env);
+    C3D_TexEnv* env1 = C3D_GetTexEnv(1);
+    C3D_TexEnvInit(env1);
+
+    if (sdf) {
+      C3D_TexEnvSrc(env, C3D_RGB, GPU_PRIMARY_COLOR);
+      C3D_TexEnvFunc(env, C3D_RGB, GPU_REPLACE);
+
+      C3D_TexEnvColor(env, 0x60606060);
+      C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE0, GPU_CONSTANT);
+      C3D_TexEnvOpAlpha(env, GPU_TEVOP_A_SRC_ALPHA, GPU_TEVOP_A_SRC_ALPHA);
+      C3D_TexEnvFunc(env, C3D_Alpha, GPU_SUBTRACT);
+      C3D_TexEnvScale(env, C3D_Alpha, GPU_TEVSCALE_4);
+
+      C3D_TexEnvSrc(env1, C3D_RGB, GPU_PREVIOUS);
+      C3D_TexEnvFunc(env1, C3D_RGB, GPU_REPLACE);
+
+      C3D_TexEnvSrc(env1, C3D_Alpha, GPU_PREVIOUS, GPU_PRIMARY_COLOR);
+      C3D_TexEnvOpAlpha(env, GPU_TEVOP_A_SRC_ALPHA, GPU_TEVOP_A_SRC_ALPHA);
+      C3D_TexEnvFunc(env1, C3D_Alpha, GPU_MODULATE);
+    } else {
+      switch (CurrentTex->fmt) {
+        case GPU_A4:
+        case GPU_A8:
+        case GPU_L4:
+        case GPU_L8:
+          C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE0);
+          C3D_TexEnvFunc(env, C3D_RGB, GPU_REPLACE);
+          C3D_TexEnvFunc(env, C3D_Alpha, GPU_MODULATE);
+          break;
+        case GPU_RGB565:
+          C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE0);
+          C3D_TexEnvFunc(env, C3D_RGB, GPU_MODULATE);
+          C3D_TexEnvFunc(env, C3D_Alpha, GPU_REPLACE);
+          break;
+
+        default:
+          C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0);
+          C3D_TexEnvFunc(env, C3D_Both, GPU_MODULATE);
+          break;
+      }
+    }
+  }
+};
+
+void GfxCitro3D::SysInit() {
+  if (impl) return;
+  PDLOG("GfxCitro3D::SysInit();");
+  impl = new Impl();
+  Flags |= PDGfxBackendFlags_FlipUV_Y;
+  impl->pShaderRaw = Pica::AssembleCode(LIShaderCTR);
+  impl->pCode = DVLB_ParseFile((uint32_t*)impl->pShaderRaw.data(),
+                               impl->pShaderRaw.size());
+  shaderProgramInit(&impl->pShader);
+  shaderProgramSetVsh(&impl->pShader, &impl->pCode->DVLE[0]);
+  impl->uLocProjection = shaderInstanceGetUniformLocation(
+      impl->pShader.vertexShader, "projection");
+
+  AttrInfo_Init(&impl->pAttr);
+  AttrInfo_AddLoader(&impl->pAttr, 0, GPU_FLOAT, 2);
+  AttrInfo_AddLoader(&impl->pAttr, 1, GPU_FLOAT, 2);
+  AttrInfo_AddLoader(&impl->pAttr, 2, GPU_UNSIGNED_BYTE, 4);
+}
+
+void GfxCitro3D::SysDeinit() {
+  if (!impl) return;
+  shaderProgramFree(&impl->pShader);
+  DVLB_Free(impl->pCode);
+  delete impl;
+  impl = nullptr;
+  PDLOG("GfxCitro3D::SysDeinit()");
+}
+
+void GfxCitro3D::Submit(size_t count, size_t start) {
+  if (!impl) return;
+  BindTexture(CurrentTex);
+  impl->SetupPixelStage(CurrentTexIsSDF);  // needs to be called after
+  C3D_Mtx proj;
+  Mtx_OrthoTilt(&proj, 0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f, false);
+  C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, impl->uLocProjection, &proj);
+  // C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, impl->uLocProjection,
+  //                  (C3D_Mtx*)&Projection);
+  C3D_DrawElements(GPU_TRIANGLES, count, C3D_UNSIGNED_SHORT,
+                   GetIndexBufPtr(start));
+  impl->CurrentTex = nullptr;
+}
+
+void GfxCitro3D::BindTexture(TextureID id) {
+  if (!impl || !id) return;
+  impl->CurrentTex = (C3D_Tex*)id;
+  C3D_TexBind(0, (C3D_Tex*)id);
+}
+
+void GfxCitro3D::SysReset() {
+  if (!impl) return;
+  C3D_CullFace(GPU_CULL_NONE);
+}
+
+Li::Texture GfxCitro3D::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  if (!impl || w > 1024 || h > 1024) return Li::Texture();
+  if (pixels.size() !=
+      static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type))) {
+    PDERR("Failed to load Texture due to Size mismatch: {} != {}",
+          pixels.size(),
+          static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type)));
+    return Li::Texture();
+  }
+  // Don't check here as check done before
+  PD::Li::Texture res;
+  int bpp = impl->TextureFormat2Bpp(type);
+  ivec2 tex_size(w, h);
+  // Pow2
+  if (!PD::Bits::IsSingleBit(w)) {
+    tex_size.x = PD::Bits::GetPow2((unsigned int)w);
+  }
+  if (!PD::Bits::IsSingleBit(h)) {
+    tex_size.y = PD::Bits::GetPow2((unsigned int)h);
+  }
+  res.SetSize(w, h);
+  res.SetUV(0.f, 1.f, ((float)w / (float)tex_size.x),
+            1.0 - ((float)h / (float)tex_size.y));
+
+  // Texture Setup
+  auto fltr = (filter == TextureFilter::Linear ? GPU_NEAREST : GPU_LINEAR);
+  auto tex_fmt = impl->TextureTranslateFormat(type);
+  auto tex = new C3D_Tex;
+  C3D_TexInit(tex, (u16)tex_size.x, (u16)tex_size.y, tex_fmt);
+  C3D_TexSetFilter(tex, fltr, fltr);
+
+  std::memset((PD::u8*)tex->data, 0x0, tex->size);
+
+  /// 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.SetID((TextureID)tex);
+  RegisterTexture(res);
+  PDLOG("GfxCitro3D::LoadTexture -> {{ {} }}, [{}, {}]", res, type, filter);
+  return res;
+}
+
+void GfxCitro3D::DeleteTexture(const Li::Texture& tex) {
+  if (!tex.GetID()) return;
+  UnregisterTexture(tex);
+  C3D_Tex* t = reinterpret_cast<C3D_Tex*>(tex.GetID());
+  C3D_TexDelete(t);
+  delete t;
+}
+
+void GfxCitro3D::UploadPools() {
+  auto buf = C3D_GetBufInfo();
+  BufInfo_Init(buf);
+  BufInfo_Add(buf, GetVertexBufPtr(0), sizeof(Li::Vertex), 3, 0x210);
+}
+}  // namespace PD
+#else
+namespace PD {
+void GfxCitro3D::SysInit() {
+  PDERR(
+      "GfxCitro3D::SysInit: Citro3D Driver is not included in "
+      "palladium-system");
+}
+void GfxCitro3D::SysDeinit() {}
+void GfxCitro3D::Submit(size_t count, size_t start) {}
+void GfxCitro3D::BindTexture(TextureID id) {}
+void GfxCitro3D::SysReset() {}
+Li::Texture GfxCitro3D::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  return Li::Texture();
+}
+void GfxCitro3D::DeleteTexture(const Li::Texture& tex) {}
+void GfxCitro3D::UploadPools() {}
+}  // namespace PD
+#endif

backends/source/gfx_directx9.cpp

@@ -0,0 +1,308 @@
+// Well yes, i finally try it
+
+#include <pd/lithium/formatters.hpp>
+#include <pd_system/gfx_directx9.hpp>
+
+// Sicher ist sicher
+#if defined(PD_ENABLE_DIRECTX9) && defined(_WIN32)
+#include <d3d9.h>
+#include <d3dcompiler.h>
+
+#include <pd/drivers/drivers.hpp>
+
+namespace PD {
+static const char* g_vsCode = R"(
+float4x4 projection;
+
+struct VS_IN {
+  float2 pos : POSITION0;
+  float2 uv  : TEXCOORD0;
+  float4 col : COLOR0;
+};
+
+struct VS_OUT {
+  float4 pos : POSITION0;
+  float2 uv  : TEXCOORD0;
+  float4 col : COLOR0;
+};
+
+VS_OUT main(VS_IN input) {
+  VS_OUT o;
+  o.pos = mul(projection, float4(input.pos, 0.0, 1.0)); 
+  o.uv = input.uv;
+  o.col = input.col.bgra;
+  return o;
+}
+)";
+
+static const char* g_psCode = R"(
+sampler2D tex : register(s0);
+float alfa : register(c1);
+float is_sdf : register(c2);
+
+struct PS_IN {
+  float2 uv  : TEXCOORD0;
+  float4 col : COLOR0;
+};
+
+float4 main(PS_IN input) : COLOR0 {
+  float4 tc = tex2D(tex, input.uv);
+  if (is_sdf > 0.5) {
+    float alpha = smoothstep(0.45, 0.55, tc.a);
+    return float4(input.col.rgb, alpha * input.col.a);
+  } else if (alfa > 0.5)
+    return float4(input.col.rgb, tc.a * input.col.a);
+  else
+    return tc * input.col;
+}
+)";
+
+struct GfxDirectX9::Impl {
+  IDirect3DDevice9* Device = nullptr;
+  IDirect3DVertexBuffer9* VBO = nullptr;
+  IDirect3DIndexBuffer9* IBO = nullptr;
+  IDirect3DVertexDeclaration9* Decl = nullptr;
+  IDirect3DVertexShader9* VS = nullptr;
+  IDirect3DPixelShader9* FS = nullptr;
+  IDirect3DTexture9* CurrentTex = nullptr;
+  size_t VertexBufferSize = 0;
+  size_t IndexBufferSize = 0;
+};
+
+void GfxDirectX9::SysInit() {
+  if (impl) return;
+  PDLOG("GfxDirectX9::SysInit();");
+  impl = new Impl();
+  impl->Device = (IDirect3DDevice9*)pDevice;
+  if (impl->Device) {
+    D3DVERTEXELEMENT9 elements[]{
+        {0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,
+         0},
+        {0, 8, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,
+         0},
+        {0, 16, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,
+         0},
+        D3DDECL_END()};
+    impl->Device->CreateVertexDeclaration(elements, &impl->Decl);
+
+    ID3DBlob* vsBlob = nullptr;
+    ID3DBlob* errBlob = nullptr;
+    HRESULT hr = D3DCompile(g_vsCode, strlen(g_vsCode), nullptr, nullptr,
+                            nullptr, "main", "vs_2_0", 0, 0, &vsBlob, &errBlob);
+    if (FAILED(hr)) {
+      PDERR("Vertex Shader compile error: {}",
+            errBlob ? (char*)errBlob->GetBufferPointer() : "");
+    } else {
+      impl->Device->CreateVertexShader((DWORD*)vsBlob->GetBufferPointer(),
+                                       &impl->VS);
+    }
+    if (vsBlob) vsBlob->Release();
+    if (errBlob) errBlob->Release();
+
+    ID3DBlob* psBlob = nullptr;
+    errBlob = nullptr;
+    hr = D3DCompile(g_psCode, strlen(g_psCode), nullptr, nullptr, nullptr,
+                    "main", "ps_2_0", 0, 0, &psBlob, &errBlob);
+    if (FAILED(hr)) {
+      PDLOG("Pixel Shader compile error: {}",
+            errBlob ? (char*)errBlob->GetBufferPointer() : "");
+    } else {
+      impl->Device->CreatePixelShader((DWORD*)psBlob->GetBufferPointer(),
+                                      &impl->FS);
+    }
+    if (psBlob) psBlob->Release();
+    if (errBlob) errBlob->Release();
+  } else {
+    PDERR(
+        "GfxDirectX9::SysInit Error: pDevice is not set!\nYOu need to include "
+        "your D3D9 Device as "
+        "folowing:\nPD::Gfx::UseDriver<PD::GfxDirectX9>(D3D9Device);");
+  }
+}
+
+void GfxDirectX9::SysDeinit() {
+  if (!impl || !impl->Device) return;
+  if (impl->VBO) impl->VBO->Release();
+  if (impl->IBO) impl->IBO->Release();
+  if (impl->Decl) impl->Decl->Release();
+  if (impl->VS) impl->VS->Release();
+  if (impl->FS) impl->FS->Release();
+  delete impl;
+  impl = nullptr;
+  PDLOG("GfxDirectX9::SysDeinit()");
+}
+
+void GfxDirectX9::Submit(size_t count, size_t start) {
+  if (!impl || !impl->Device || !impl->VBO || !impl->IBO) return;
+
+  BindTexture(CurrentTex);
+
+  impl->Device->SetVertexShaderConstantF(0, Projection.Ptr(), 4);
+
+  impl->Device->SetStreamSource(0, impl->VBO, 0, sizeof(PD::Li::Vertex));
+  impl->Device->SetIndices(impl->IBO);
+  impl->Device->SetVertexDeclaration(impl->Decl);
+  impl->Device->SetVertexShader(impl->VS);
+  impl->Device->SetPixelShader(impl->FS);
+
+  impl->Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0,
+                                     GetVertexPoolSize(), start, count / 3);
+}
+
+void GfxDirectX9::BindTexture(TextureID id) {
+  if (!impl || !impl->Device) return;
+  impl->CurrentTex = (IDirect3DTexture9*)id;
+  impl->Device->SetTexture(0, impl->CurrentTex);
+
+  bool a8 = false;
+  if (impl->CurrentTex) {
+    D3DSURFACE_DESC desc;
+    impl->CurrentTex->GetLevelDesc(0, &desc);
+    a8 = (desc.Format == D3DFMT_A8);
+  }
+
+  float v = a8 ? 1.0f : 0.0f;
+  impl->Device->SetPixelShaderConstantF(0, &v, 1);
+
+  float sdf = CurrentTexIsSDF ? 1.0f : 0.0f;
+  impl->Device->SetPixelShaderConstantF(1, &sdf, 1);
+}
+
+void GfxDirectX9::SysReset() {
+  if (!impl || !impl->Device) return;
+
+  impl->Device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+  impl->Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
+  impl->Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
+  impl->Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
+
+  impl->Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
+  impl->Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
+  impl->Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
+}
+
+Li::Texture GfxDirectX9::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                     int h, TextureFormat type,
+                                     TextureFilter filter) {
+  if (!impl || !impl->Device) return Li::Texture();
+  if (pixels.size() !=
+      static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type))) {
+    PDERR("Failed to load Texture due to Size mismatch: {} != {}",
+          pixels.size(),
+          static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type)));
+    return Li::Texture();
+  }
+  IDirect3DTexture9* tex = nullptr;
+  D3DFORMAT fmt = D3DFMT_A8R8G8B8;
+  if (type == TextureFormat::RGB24)
+    fmt = D3DFMT_X8R8G8B8;
+  else if (type == TextureFormat::A8)
+    fmt = D3DFMT_A8;
+
+  HRESULT hr = impl->Device->CreateTexture(w, h, 1, 0, fmt, D3DPOOL_MANAGED,
+                                           &tex, nullptr);
+  if (FAILED(hr) || !tex) return Li::Texture();
+
+  D3DLOCKED_RECT rect;
+  tex->LockRect(0, &rect, nullptr, 0);
+
+  if (type == TextureFormat::RGB24) {
+    u8* dstRow = reinterpret_cast<u8*>(rect.pBits);
+    for (int y = 0; y < h; ++y) {
+      u32* dst = reinterpret_cast<u32*>(dstRow);
+      for (int x = 0; x < w; ++x) {
+        u8 r = pixels[(y * w + x) * 3 + 0];
+        u8 g = pixels[(y * w + x) * 3 + 1];
+        u8 b = pixels[(y * w + x) * 3 + 2];
+        dst[x] = (0xFF << 24) | (r << 16) | (g << 8) | b;
+      }
+      dstRow += rect.Pitch;
+    }
+  } else if (type == TextureFormat::RGBA32) {
+    u8* dstRow = reinterpret_cast<u8*>(rect.pBits);
+    for (int y = 0; y < h; ++y) {
+      u32* dst = reinterpret_cast<u32*>(dstRow);
+      for (int x = 0; x < w; ++x) {
+        u8 r = pixels[(y * w + x) * 4 + 0];
+        u8 g = pixels[(y * w + x) * 4 + 1];
+        u8 b = pixels[(y * w + x) * 4 + 2];
+        u8 a = pixels[(y * w + x) * 4 + 3];
+        dst[x] = (a << 24) | (r << 16) | (g << 8) | b;
+      }
+      dstRow += rect.Pitch;
+    }
+  } else if (type == TextureFormat::A8) {
+    u8* dstRow = reinterpret_cast<u8*>(rect.pBits);
+    for (int y = 0; y < h; ++y) {
+      memcpy(dstRow, &pixels[y * w], w);
+      dstRow += rect.Pitch;
+    }
+  }
+
+  tex->UnlockRect(0);
+  Li::Texture res;
+  res.SetID((TextureID)tex);
+  res.SetSize(w, h);
+  res.SetUV(0.f, 0.f, 1.f, 1.f);
+  RegisterTexture(res);
+  PDLOG("GfxDirectX9::LoadTexture -> {{ {} }}, [{}, {}]", res, type, filter);
+  return res;
+}
+
+void GfxDirectX9::DeleteTexture(const Li::Texture& tex) {
+  if (!tex.GetID()) return;
+  UnregisterTexture(tex);
+  IDirect3DTexture9* t = (IDirect3DTexture9*)tex.GetID();
+  t->Release();
+}
+void GfxDirectX9::UploadPools() {
+  if (!impl || !impl->Device) return;
+
+  if (!impl->VBO || impl->VertexBufferSize != GetVertexPoolSize()) {
+    if (impl->VBO) impl->VBO->Release();
+    impl->Device->CreateVertexBuffer(GetVertexPoolSize() * sizeof(Li::Vertex),
+                                     D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED,
+                                     &impl->VBO, nullptr);
+    impl->VertexBufferSize = GetVertexPoolSize();
+  }
+
+  if (!impl->IBO || impl->IndexBufferSize != GetIndexPoolSize()) {
+    if (impl->IBO) impl->IBO->Release();
+    impl->Device->CreateIndexBuffer(GetIndexPoolSize() * sizeof(u16),
+                                    D3DUSAGE_WRITEONLY, D3DFMT_INDEX16,
+                                    D3DPOOL_MANAGED, &impl->IBO, nullptr);
+    impl->IndexBufferSize = GetIndexPoolSize();
+  }
+
+  void* vptr;
+  impl->VBO->Lock(0, 0, &vptr, 0);
+  memcpy(vptr, GetVertexBufPtr(0),
+         GetVertexPoolSize() * sizeof(PD::Li::Vertex));
+  impl->VBO->Unlock();
+
+  void* iptr;
+  impl->IBO->Lock(0, 0, &iptr, 0);
+  memcpy(iptr, GetIndexBufPtr(0), GetIndexPoolSize() * sizeof(u16));
+  impl->IBO->Unlock();
+}
+}  // namespace PD
+#else
+namespace PD {
+void GfxDirectX9::SysInit() {
+  PDERR(
+      "GfxDirectX9::SysInit: DirectX9 Driver is not included in "
+      "palladium-system");
+}
+void GfxDirectX9::SysDeinit() {}
+void GfxDirectX9::Submit(size_t count, size_t start) {}
+void GfxDirectX9::BindTexture(TextureID id) {}
+void GfxDirectX9::SysReset() {}
+Li::Texture GfxDirectX9::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                     int h, TextureFormat type,
+                                     TextureFilter filter) {
+  return Li::Texture();
+}
+void GfxDirectX9::DeleteTexture(const Li::Texture& tex) {}
+void GfxDirectX9::UploadPools() {}
+}  // namespace PD
+#endif

backends/source/gfx_opengl2.cpp

@@ -0,0 +1,207 @@
+#include <pd/lithium/formatters.hpp>
+#include <pd_system/gfx_opengl2.hpp>
+
+#if defined(PD_ENABLE_OPENGL2)
+#include <glad/glad.h>
+
+#include <pd/drivers/drivers.hpp>
+#include <pd_system/gl-helper.hpp>
+
+namespace PD {
+
+const char* GfxOpenGL2::pVertCode = R"(
+  #version 120
+  
+  attribute vec2 pos;
+  attribute vec2 uv;
+  attribute vec4 color;
+  
+  varying vec2 oUV;
+  varying vec4 oColor;
+  
+  // Probably forgot about this matrix and
+  // searched hours for why the rendering isn't working :/
+  uniform mat4 projection;
+  
+  void main() {
+      gl_Position = projection*vec4(pos, 0.0, 1.0);
+      oUV = uv;
+      oColor = color;
+  }
+  )";
+
+const char* GfxOpenGL2::pFragCode = R"(
+  #version 120
+      
+  varying vec2 oUV;
+  varying vec4 oColor;
+  
+  uniform sampler2D tex;
+  uniform bool alfa;
+  uniform bool is_sdf;
+      
+  void main() {
+    vec4 tc = texture2D(tex, oUV);
+    if (is_sdf) {
+      float dist = tc.a;
+      float alpha = smoothstep(0.45, 0.55, dist);
+      gl_FragColor = vec4(oColor.rgb, alpha * oColor.a);
+    } else if (alfa) {
+      gl_FragColor = vec4(oColor.rgb, tc.a * oColor.a);
+    } else {
+      gl_FragColor = tc * oColor;
+    }
+  }
+  )";
+
+void GfxOpenGL2::pSetupShaderAttribs(u32 shader) {
+  GLint _pos = glGetAttribLocation(shader, "pos");
+  GLint _uv = glGetAttribLocation(shader, "uv");
+  GLint _color = glGetAttribLocation(shader, "color");
+  glVertexAttribPointer(_pos, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, pos));
+  glEnableVertexAttribArray(_pos);
+
+  glVertexAttribPointer(_uv, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, uv));
+  glEnableVertexAttribArray(_uv);
+
+  glVertexAttribPointer(_color, 4, GL_UNSIGNED_BYTE, GL_TRUE,
+                        sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, color));
+  glEnableVertexAttribArray(_color);
+}
+
+void GfxOpenGL2::SysInit() {
+  pShader = CreateShaderProgram(pVertCode, pFragCode);
+  glUseProgram(pShader);
+  glGenBuffers(1, &VBO);
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+  glGenBuffers(1, &IBO);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+
+  pSetupShaderAttribs(pShader);
+  pLocTex = glGetUniformLocation(pShader, "tex");
+  pLocAlfa = glGetUniformLocation(pShader, "alfa");
+  pLocIsSDF = glGetUniformLocation(pShader, "is_sdf");
+  pLocProjection = glGetUniformLocation(pShader, "projection");
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+void GfxOpenGL2::SysDeinit() {
+  glDeleteBuffers(1, &VBO);
+  glDeleteBuffers(1, &IBO);
+  PDLOG("GfxOpenGL2::SysDeinit()");
+}
+
+void GfxOpenGL2::Submit(size_t count, size_t start) {
+  BindTexture(CurrentTex);
+  glUseProgram(pShader);
+  glUniformMatrix4fv(pLocProjection, 1, GL_FALSE, Projection.m.data());
+
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+  pSetupShaderAttribs(pShader);
+
+  glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT,
+                 reinterpret_cast<void*>(start * sizeof(u16)));
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+  BindTexture(0);
+}
+
+void GfxOpenGL2::BindTexture(TextureID id) {
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, (GLuint)id);
+  glUniform1i(pLocTex, 0);
+  GLint fmt = 0;
+  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
+  glUniform1i(pLocAlfa, fmt == GL_ALPHA);
+  glUniform1i(pLocIsSDF, CurrentTexIsSDF);
+}
+
+void GfxOpenGL2::SysReset() {
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+Li::Texture GfxOpenGL2::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  if (pixels.size() !=
+      static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type))) {
+    PDERR("Failed to load Texture due to Size mismatch: {} != {}",
+          pixels.size(),
+          static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type)));
+    return Li::Texture();
+  }
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  if (type == TextureFormat::RGB24) {
+    fmt = GL_RGB;
+  } else if (type == TextureFormat::A8) {
+    fmt = GL_ALPHA;
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+  if (filter == TextureFilter::Linear) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == TextureFilter::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);
+  Li::Texture res;
+  res.SetID(texID);
+  res.SetSize(w, h);
+  res.SetUV(0.f, 0.f, 1.f, 1.f);
+  RegisterTexture(res);
+  PDLOG("GfxOpenGL2::LoadTexture -> {{ {} }}, [{}, {}]", res, type, filter);
+  return res;
+}
+
+void GfxOpenGL2::DeleteTexture(const Li::Texture& tex) {
+  UnregisterTexture(tex);
+  GLuint tex_ = tex.GetID();
+  glDeleteTextures(1, &tex_);
+}
+
+void GfxOpenGL2::UploadPools() {
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+  glBufferData(GL_ARRAY_BUFFER, GetVertexPoolSize() * sizeof(PD::Li::Vertex),
+               GetVertexBufPtr(0), GL_DYNAMIC_DRAW);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, GetIndexPoolSize() * sizeof(u16),
+               GetIndexBufPtr(0), GL_DYNAMIC_DRAW);
+}
+}  // namespace PD
+#else
+namespace PD {
+void GfxOpenGL2::SysInit() {
+  PDERR(
+      "GfxOpenGL2::SysInit: OpenGL2 Driver is not included in "
+      "palladium-system");
+}
+void GfxOpenGL2::SysDeinit() {}
+void GfxOpenGL2::Submit(size_t count, size_t start) {}
+void GfxOpenGL2::BindTexture(TextureID id) {}
+void GfxOpenGL2::SysReset() {}
+Li::Texture GfxOpenGL2::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  return Li::Texture();
+}
+void GfxOpenGL2::DeleteTexture(const Li::Texture& tex) {}
+void GfxOpenGL2::pSetupShaderAttribs(u32 shader) {}
+void GfxOpenGL2::UploadPools() {}
+}  // namespace PD
+#endif

backends/source/gfx_opengl3.cpp

@@ -0,0 +1,182 @@
+#include <pd/lithium/formatters.hpp>
+#include <pd_system/gfx_opengl3.hpp>
+
+#if defined(PD_ENABLE_OPENGL3)
+#include <glad/glad.h>
+
+#include <pd/drivers/drivers.hpp>
+#include <pd_system/gl-helper.hpp>
+#include <pd_system/shaders.hpp>
+#include <spirv-helper.hpp>
+
+namespace PD {
+void GfxOpenGL3::SysInit() {
+  std::string vcode = SpirvHelper::SPV2GLSL(
+      std::vector<unsigned int>(
+          Shaders::VertexShader,
+          Shaders::VertexShader +
+              (sizeof(Shaders::VertexShader) / sizeof(unsigned int))),
+      330, false);
+  std::string fcode = SpirvHelper::SPV2GLSL(
+      std::vector<unsigned int>(
+          Shaders::FragmentShader,
+          Shaders::FragmentShader +
+              (sizeof(Shaders::FragmentShader) / sizeof(unsigned int))),
+      330, false);
+  PDLOG("Vertex: \n{}", vcode);
+  PDLOG("Fragment: \n{}", fcode);
+  pShader = CreateShaderProgram(vcode.c_str(), fcode.c_str());
+  glUseProgram(pShader);
+  glGenVertexArrays(1, &VAO);
+  glBindVertexArray(VAO);
+  glGenBuffers(1, &VBO);
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, pos));
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, uv));
+  glEnableVertexAttribArray(2);
+  glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, color));
+
+  glGenBuffers(1, &IBO);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+
+  pLocTex = glGetUniformLocation(pShader, "tex");
+  pLocAlfa = glGetUniformLocation(pShader, "push.alfa");
+  pLocIsSDF = glGetUniformLocation(pShader, "push.is_sdf");
+  pLocProjection = glGetUniformLocation(pShader, "ubo.projection");
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+  glBindVertexArray(0);
+}
+
+void GfxOpenGL3::SysDeinit() {
+  glDeleteBuffers(1, &VBO);
+  glDeleteBuffers(1, &IBO);
+  glDeleteVertexArrays(1, &VAO);
+  PDLOG("GfxOpenGL3::SysDeinit()");
+}
+
+void GfxOpenGL3::Submit(size_t count, size_t start) {
+  BindTexture(CurrentTex);
+  glUseProgram(pShader);
+  glUniformMatrix4fv(pLocProjection, 1, GL_FALSE, Projection.m.data());
+
+  glBindVertexArray(VAO);
+  glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT,
+                 reinterpret_cast<void*>(start * sizeof(u16)));
+  glBindVertexArray(0);
+
+  BindTexture(0);
+}
+
+void GfxOpenGL3::BindTexture(TextureID id) {
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, (GLuint)id);
+  glUniform1i(pLocTex, 0);
+  GLint fmt = 0;
+  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
+  glUniform1i(pLocAlfa, fmt == GL_R8);
+  glUniform1i(pLocIsSDF, CurrentTexIsSDF);
+}
+
+void GfxOpenGL3::SysReset() {
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+Li::Texture GfxOpenGL3::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  if (pixels.size() !=
+      static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type))) {
+    PDERR("Failed to load Texture due to Size mismatch: {} != {}",
+          pixels.size(),
+          static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type)));
+    return Li::Texture();
+  }
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  GLenum ifmt = GL_RGBA8;
+  if (type == TextureFormat::RGB24) {
+    ifmt = GL_RGB8;
+    fmt = GL_RGB;
+  } else if (type == TextureFormat::A8) {
+    ifmt = GL_R8;
+    fmt = GL_RED;
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, ifmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+
+  if (type == TextureFormat::A8) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_RED);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_ONE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_ONE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_ONE);
+  }
+  if (filter == TextureFilter::Linear) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == TextureFilter::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);
+  Li::Texture res;
+  res.SetID(texID);
+  res.SetSize(w, h);
+  res.SetUV(0.f, 0.f, 1.f, 1.f);
+  RegisterTexture(res);
+  PDLOG("GfxOpenGL3::LoadTexture -> {{ {} }}, [{}, {}]", res, type, filter);
+  return res;
+}
+
+void GfxOpenGL3::DeleteTexture(const Li::Texture& tex) {
+  UnregisterTexture(tex);
+  GLuint tex_ = tex.GetID();
+  glDeleteTextures(1, &tex_);
+}
+
+void GfxOpenGL3::UploadPools() {
+  glBindVertexArray(VAO);
+
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+  glBufferData(GL_ARRAY_BUFFER, GetVertexPoolSize() * sizeof(PD::Li::Vertex),
+               GetVertexBufPtr(0), GL_DYNAMIC_DRAW);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, GetIndexPoolSize() * sizeof(u16),
+               GetIndexBufPtr(0), GL_DYNAMIC_DRAW);
+
+  glBindVertexArray(0);
+}
+}  // namespace PD
+#else
+namespace PD {
+void GfxOpenGL3::SysInit() {
+  PDERR(
+      "GfxOpenGL3::SysInit: OpenGL3 Driver is not included in "
+      "palladium-system");
+}
+void GfxOpenGL3::SysDeinit() {}
+void GfxOpenGL3::Submit(size_t count, size_t start) {}
+void GfxOpenGL3::BindTexture(TextureID id) {}
+void GfxOpenGL3::SysReset() {}
+Li::Texture GfxOpenGL3::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  return Li::Texture();
+}
+void GfxOpenGL3::DeleteTexture(const Li::Texture& tex) {}
+void GfxOpenGL3::UploadPools() {}
+}  // namespace PD
+#endif

backends/source/gl-helper.cpp

@@ -0,0 +1,48 @@
+#if defined(PD_ENABLE_OPENGL2) || defined(PD_ENABLE_OPENGL3)
+#include <glad/glad.h>
+
+#include <iostream>
+#include <pd_system/gl-helper.hpp>
+
+namespace PD {
+GLuint compileShader(const char* src, GLenum type) {
+  GLuint shader = glCreateShader(type);
+  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;
+}
+u32 CreateShaderProgram(const char* vert, const char* frag) {
+  GLuint vertexShader = compileShader(vert, GL_VERTEX_SHADER);
+  GLuint fragmentShader = compileShader(frag, 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);
+
+  if (success) PDLOG("Shader [{}] compiled sucessfully", shaderProgram);
+
+  return shaderProgram;
+}
+}  // namespace PD
+#endif

backends/source/hid_3ds.cpp

@@ -0,0 +1,82 @@
+#include <pd_system/hid_3ds.hpp>
+#if defined(PD_ENABLE_HID3DS) && defined(__3DS__)
+#include <3ds.h>
+namespace PD {
+struct Hid3DS::Impl {
+  std::string* Text;
+  bool InTextMode = false;
+};
+
+Hid3DS::Hid3DS() : HidDriver("Hid3DS") {
+  impl = new Impl;
+
+  pFlags |= PDHidBackendFlags_HasGamepad;
+  pFlags |= PDHidBackendFlags_HasTouch;
+
+  pGamepad[KEY_A] = HidInternal::Gamepad::A;
+  pGamepad[KEY_B] = HidInternal::Gamepad::B;
+  pGamepad[KEY_X] = HidInternal::Gamepad::X;
+  pGamepad[KEY_Y] = HidInternal::Gamepad::Y;
+  pGamepad[KEY_START] = HidInternal::Gamepad::Start;
+  pGamepad[KEY_SELECT] = HidInternal::Gamepad::Select;
+  pGamepad[KEY_L] = HidInternal::Gamepad::L;
+  pGamepad[KEY_R] = HidInternal::Gamepad::R;
+  pGamepad[KEY_DUP] = HidInternal::Gamepad::DUp;
+  pGamepad[KEY_DDOWN] = HidInternal::Gamepad::DDown;
+  pGamepad[KEY_DLEFT] = HidInternal::Gamepad::DLeft;
+  pGamepad[KEY_DRIGHT] = HidInternal::Gamepad::DRight;
+  pGamepad[KEY_CPAD_UP] = HidInternal::Gamepad::CPUp;
+  pGamepad[KEY_CPAD_DOWN] = HidInternal::Gamepad::CPDown;
+  pGamepad[KEY_CPAD_LEFT] = HidInternal::Gamepad::CPLeft;
+  pGamepad[KEY_CPAD_RIGHT] = HidInternal::Gamepad::CPRight;
+  pGamepad[KEY_CSTICK_UP] = HidInternal::Gamepad::CSUp;
+  pGamepad[KEY_CSTICK_DOWN] = HidInternal::Gamepad::CSDown;
+  pGamepad[KEY_CSTICK_LEFT] = HidInternal::Gamepad::CSLeft;
+  pGamepad[KEY_CSTICK_RIGHT] = HidInternal::Gamepad::CSRight;
+  pGamepad[KEY_ZL] = HidInternal::Gamepad::ZL;
+  pGamepad[KEY_ZR] = HidInternal::Gamepad::ZR;
+  pGamepad[KEY_TOUCH] = HidInternal::Gamepad::Touch;
+}
+
+Hid3DS::~Hid3DS() { delete impl; }
+
+void Hid3DS::Update() {
+  HidDriver::Update();  // clear stats
+  hidScanInput();
+  u32 kd = hidKeysDown();
+  u32 kh = hidKeysHeld();
+  u32 ku = hidKeysUp();
+
+  for (const auto& b : pGamepad) {
+    if (b.first & kd) {
+      pGamepadEvents[0][Event::Down] |= b.second;
+    }
+    if (b.first & kh) {
+      pGamepadEvents[0][Event::Held] |= b.second;
+    }
+    if (b.first & ku) {
+      pGamepadEvents[0][Event::Up] |= b.second;
+    }
+  }
+
+  /*if (pLocked) {
+    SwapTab();
+  }*/
+  touchPosition t;
+  hidTouchRead(&t);
+  pMouse[0] = fvec2(t.px, t.py);
+}
+}  // namespace PD
+#else
+struct GLFWgamepadstate {};
+namespace PD {
+
+Hid3DS::Hid3DS() : HidDriver("Hid3DS") {}
+
+Hid3DS::~Hid3DS() {}
+
+void Hid3DS::Update() {
+  HidDriver::Update();  // clear stats
+}
+}  // namespace PD
+#endif

backends/source/hid_glfw.cpp

@@ -0,0 +1,156 @@
+#include <pd_system/hid_glfw.hpp>
+#ifdef PD_ENABLE_HID_GLFW
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+namespace PD {
+struct HidGlfw::Impl {
+  GLFWwindow* Win;
+  int PrevState;
+  std::unordered_map<int, int> PrevStates;
+  std::unordered_map<int, int> GPPrevStates;
+  GLFWcharfun OldTextCB;
+  std::string* Text;
+  bool InTextMode = false;
+};
+
+constexpr int KEY_BASE = GLFW_GAMEPAD_BUTTON_LAST;
+constexpr int KEY_LSTICK_LEFT = KEY_BASE + 1;
+constexpr int KEY_LSTICK_RIGHT = KEY_BASE + 2;
+constexpr int KEY_LSTICK_UP = KEY_BASE + 3;
+constexpr int KEY_LSTICK_DOWN = KEY_BASE + 4;
+constexpr int KEY_RSTICK_LEFT = KEY_BASE + 5;
+constexpr int KEY_RSTICK_RIGHT = KEY_BASE + 6;
+constexpr int KEY_RSTICK_UP = KEY_BASE + 7;
+constexpr int KEY_RSTICK_DOWN = KEY_BASE + 8;
+constexpr int KEY_LEFT_TRIGGER = KEY_BASE + 9;
+constexpr int KEY_RIGHT_TRIGGER = KEY_BASE + 10;
+constexpr int KEY_LAST = KEY_RIGHT_TRIGGER;
+
+HidGlfw::HidGlfw(GLFWwindow* win) : HidDriver("HidGlfw") {
+  impl = new Impl;
+  impl->Win = win;
+
+  pFlags |= PDHidBackendFlags_HasMouse;
+  pFlags |= PDHidBackendFlags_HasKeyboard;
+  if (glfwJoystickPresent(GLFW_JOYSTICK_1)) {
+    pFlags |= PDHidBackendFlags_HasGamepad;
+  }
+  pGamepad[GLFW_GAMEPAD_BUTTON_A] = HidInternal::Gamepad::A;
+  pGamepad[GLFW_GAMEPAD_BUTTON_B] = HidInternal::Gamepad::B;
+  pGamepad[GLFW_GAMEPAD_BUTTON_X] = HidInternal::Gamepad::X;
+  pGamepad[GLFW_GAMEPAD_BUTTON_Y] = HidInternal::Gamepad::Y;
+  pGamepad[GLFW_GAMEPAD_BUTTON_START] = HidInternal::Gamepad::Start;
+  pGamepad[GLFW_GAMEPAD_BUTTON_BACK] = HidInternal::Gamepad::Select;
+  pGamepad[GLFW_GAMEPAD_BUTTON_DPAD_LEFT] = HidInternal::Gamepad::DLeft;
+  pGamepad[GLFW_GAMEPAD_BUTTON_DPAD_RIGHT] = HidInternal::Gamepad::DRight;
+  pGamepad[GLFW_GAMEPAD_BUTTON_DPAD_UP] = HidInternal::Gamepad::DUp;
+  pGamepad[GLFW_GAMEPAD_BUTTON_DPAD_DOWN] = HidInternal::Gamepad::DDown;
+  pGamepad[GLFW_GAMEPAD_BUTTON_LEFT_BUMPER] = HidInternal::Gamepad::L;
+  pGamepad[GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER] = HidInternal::Gamepad::R;
+  pGamepad[GLFW_GAMEPAD_BUTTON_LEFT_THUMB] = HidInternal::Gamepad::LStick;
+  pGamepad[GLFW_GAMEPAD_BUTTON_RIGHT_THUMB] = HidInternal::Gamepad::RStick;
+  pGamepad[KEY_LEFT_TRIGGER] = HidInternal::Gamepad::ZL;
+  pGamepad[KEY_RIGHT_TRIGGER] = HidInternal::Gamepad::ZR;
+  pGamepad[KEY_LSTICK_LEFT] = HidInternal::Gamepad::CPLeft;
+  pGamepad[KEY_LSTICK_RIGHT] = HidInternal::Gamepad::CPRight;
+  pGamepad[KEY_LSTICK_UP] = HidInternal::Gamepad::CPUp;
+  pGamepad[KEY_LSTICK_DOWN] = HidInternal::Gamepad::CPDown;
+  pGamepad[KEY_RSTICK_LEFT] = HidInternal::Gamepad::CSLeft;
+  pGamepad[KEY_RSTICK_RIGHT] = HidInternal::Gamepad::CSRight;
+  pGamepad[KEY_RSTICK_UP] = HidInternal::Gamepad::CSUp;
+  pGamepad[KEY_RSTICK_DOWN] = HidInternal::Gamepad::CSDown;
+  for (int i = 0; i <= KEY_LAST; i++) {
+    impl->GPPrevStates[i] = 0;
+  }
+}
+
+HidGlfw::~HidGlfw() { delete impl; }
+
+void HidGlfw::Update() {
+  HidDriver::Update();  // clear stats
+  GLFWgamepadstate gpstate;
+  int gps = glfwGetGamepadState(GLFW_JOYSTICK_1, &gpstate);
+  if (gps == GLFW_TRUE) {
+    HandleAxisKey(gpstate, KEY_LEFT_TRIGGER, GLFW_GAMEPAD_AXIS_LEFT_TRIGGER,
+                  false);
+    HandleAxisKey(gpstate, KEY_RIGHT_TRIGGER, GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER,
+                  false);
+    HandleAxisKey(gpstate, KEY_LSTICK_LEFT, GLFW_GAMEPAD_AXIS_LEFT_X, true);
+    HandleAxisKey(gpstate, KEY_LSTICK_RIGHT, GLFW_GAMEPAD_AXIS_LEFT_X, false);
+    HandleAxisKey(gpstate, KEY_LSTICK_UP, GLFW_GAMEPAD_AXIS_LEFT_Y, true);
+    HandleAxisKey(gpstate, KEY_LSTICK_DOWN, GLFW_GAMEPAD_AXIS_LEFT_Y, false);
+    HandleAxisKey(gpstate, KEY_RSTICK_LEFT, GLFW_GAMEPAD_AXIS_RIGHT_X, true);
+    HandleAxisKey(gpstate, KEY_RSTICK_RIGHT, GLFW_GAMEPAD_AXIS_RIGHT_X, false);
+    HandleAxisKey(gpstate, KEY_RSTICK_UP, GLFW_GAMEPAD_AXIS_RIGHT_Y, true);
+    HandleAxisKey(gpstate, KEY_RSTICK_DOWN, GLFW_GAMEPAD_AXIS_RIGHT_Y, false);
+    pLStick[0].x = gpstate.axes[GLFW_GAMEPAD_AXIS_LEFT_X];
+    pLStick[0].y = gpstate.axes[GLFW_GAMEPAD_AXIS_LEFT_Y];
+    pRStick[0].x = gpstate.axes[GLFW_GAMEPAD_AXIS_RIGHT_X];
+    pRStick[0].y = gpstate.axes[GLFW_GAMEPAD_AXIS_RIGHT_Y];
+    for (int i = 0; i <= GLFW_GAMEPAD_BUTTON_LAST; i++) {
+      if (gpstate.buttons[i] == GLFW_PRESS) {
+        if (impl->GPPrevStates[i] == GLFW_RELEASE) {
+          pGamepadEvents[0][Event::Down] |= pGamepad[i];
+        }
+        pGamepadEvents[0][Event::Held] |= pGamepad[i];
+      } else if (gpstate.buttons[i] == GLFW_RELEASE &&
+                 impl->GPPrevStates[i] == GLFW_PRESS) {
+        pGamepadEvents[0][Event::Up] |= pGamepad[i];
+      }
+      impl->GPPrevStates[i] = gpstate.buttons[i];
+    }
+  }
+  int state = glfwGetMouseButton(impl->Win, GLFW_MOUSE_BUTTON_LEFT);
+  if (state == GLFW_PRESS) {
+    if (impl->PrevState == GLFW_RELEASE) {
+      pGamepadEvents[0][Event::Down] |= HidInternal::Touch;
+    }
+    pGamepadEvents[0][Event::Held] |= HidInternal::Touch;
+  } else if (state == GLFW_RELEASE && impl->PrevState == GLFW_PRESS) {
+    pGamepadEvents[0][Event::Up] |= HidInternal::Touch;
+  }
+
+  impl->PrevState = state;
+  // if (pLocked) {
+  //   SwapTab();
+  // }
+  double x, y;
+  glfwGetCursorPos(impl->Win, &x, &y);
+  pMouse[0] = fvec2(x, y);
+}
+
+void HidGlfw::HandleAxisKey(GLFWgamepadstate s, int iK, int eA, bool negative) {
+  if (s.axes[eA] <= 1.f && s.axes[eA] >= -1.f) {
+    if (s.axes[eA] > 0.05f && !negative) {
+      if (impl->GPPrevStates[iK] == GLFW_RELEASE) {
+        pGamepadEvents[0][Event::Down] |= pGamepad[iK];
+      }
+      pGamepadEvents[0][Event::Held] |= pGamepad[iK];
+    }
+    if (s.axes[eA] < -0.05f && negative) {
+      if (impl->GPPrevStates[iK] == GLFW_RELEASE) {
+        pGamepadEvents[0][Event::Down] |= pGamepad[iK];
+      }
+      pGamepadEvents[0][Event::Held] |= pGamepad[iK];
+    }
+  }
+  impl->GPPrevStates[iK] = (s.axes[eA] <= -0.05 && s.axes[eA] >= 0.05 &&
+                            s.axes[eA] >= -1.f && s.axes[eA] <= 1);
+}
+}  // namespace PD
+#else
+struct GLFWgamepadstate {};
+namespace PD {
+
+HidGlfw::HidGlfw(GLFWwindow* win) : HidDriver("HidGlfw") {}
+
+HidGlfw::~HidGlfw() {}
+
+void HidGlfw::Update() {
+  HidDriver::Update();  // clear stats
+}
+void HidGlfw::HandleAxisKey(GLFWgamepadstate s, int iK, int eA, bool negative) {
+}
+}  // namespace PD
+#endif

backends/source/hid_nx.cpp

@@ -0,0 +1,31 @@
+
+#include <pd_system/hid_nx.hpp>
+
+#ifdef PD_ENABLE_HID_NX
+#include <switch.h>
+
+namespace PD {
+struct HidNX::Impl {
+  PadState Pad;
+};
+
+HidNX::HidNX() : HidDriver("HidNX") { impl = new Impl; }
+
+HidNX::~HidNX() { delete impl; }
+
+void HidNX::Update() {
+  HidDriver::Update();  // clear stats
+}
+}  // namespace PD
+#else
+namespace PD {
+
+HidNX::HidNX() : HidDriver("HidNX") {}
+
+HidNX::~HidNX() {}
+
+void HidNX::Update() {
+  HidDriver::Update();  // clear stats
+}
+}  // namespace PD
+#endif

cmake/palladium.cmake

@@ -0,0 +1,34 @@
+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)
+
+### 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()

cmake/palladiumConfig.cmake.in

@@ -0,0 +1,6 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/palladiumTargets.cmake")
+if(NOT TARGET palladium::pd-desktop AND PALLADIUM_FIND_DESKTOP)
+    find_dependency(palladium::pd-desktop OPTIONAL)
+endif()

cmake/presets/3ds.json

@@ -0,0 +1,35 @@
+{
+    "version": 10,
+    "configurePresets": [
+        {
+            "name": "3ds-debug",
+            "generator": "Ninja",
+            "displayName": "Nintendo 3DS Debug",
+            "binaryDir": "${sourceDir}/build/3ds-debug",
+            "toolchainFile": "/opt/devkitPro/cmake/3DS.cmake",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        },
+        {
+            "name": "3ds-release",
+            "generator": "Ninja",
+            "displayName": "Nintendo 3DS Release",
+            "binaryDir": "${sourceDir}/build/3ds-release",
+            "toolchainFile": "/opt/devkitPro/cmake/3DS.cmake",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "3ds-release",
+            "configurePreset": "3ds-release"
+        },
+        {
+            "name": "3ds-debug",
+            "configurePreset": "3ds-debug"
+        }
+    ]
+}

cmake/presets/default.json

@@ -0,0 +1,33 @@
+{
+    "version": 10,
+    "configurePresets": [
+        {
+            "name": "default-debug",
+            "generator": "Ninja",
+            "displayName": "Default Debug",
+            "binaryDir": "${sourceDir}/build/default-debug",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        },
+        {
+            "name": "default-release",
+            "generator": "Ninja",
+            "displayName": "Default Release",
+            "binaryDir": "${sourceDir}/build/default-release",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "default-release",
+            "configurePreset": "default-release"
+        },
+        {
+            "name": "default-debug",
+            "configurePreset": "default-debug"
+        }
+    ]
+}

cmake/presets/msvc.json

@@ -0,0 +1,24 @@
+{
+    "version": 10,
+    "configurePresets": [
+        {
+            "name": "msvc",
+            "cmakeExecutable": "C:\\Program Files\\CMake\\bin\\cmake.exe",
+            "displayName": "MSVC",
+            "generator": "Visual Studio 17 2022",
+            "binaryDir": "${sourceDir}/build/msvc-build"
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "msvc-release",
+            "configuration": "Release",
+            "configurePreset": "msvc"
+        },
+        {
+            "name": "msvc-debug",
+            "configuration": "Debug",
+            "configurePreset": "msvc"
+        }
+    ]
+}

cmake/presets/switch.json

@@ -0,0 +1,37 @@
+{
+    "version": 10,
+    "configurePresets": [
+        {
+            "name": "switch-debug",
+            "generator": "Ninja",
+            "displayName": "Nintendo Switch Debug",
+            "binaryDir": "${sourceDir}/build/switch-debug",
+            "toolchainFile": "/opt/devkitPro/cmake/Switch.cmake",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "SPV_EXCLUDE_GLSLANG": "ON"
+            }
+        },
+        {
+            "name": "switch-release",
+            "generator": "Ninja",
+            "displayName": "Nintendo Switch Release",
+            "binaryDir": "${sourceDir}/build/switch-release",
+            "toolchainFile": "/opt/devkitPro/cmake/Switch.cmake",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release",
+                "SPV_EXCLUDE_GLSLANG": "ON"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "switch-release",
+            "configurePreset": "switch-release"
+        },
+        {
+            "name": "switch-debug",
+            "configurePreset": "switch-debug"
+        }
+    ]
+}

docs/javascripts/mathjax.js

@@ -1,16 +0,0 @@
-window.MathJax = {
-  tex: {
-    inlineMath: [["\\(", "\\)"]],
-    displayMath: [["\\[", "\\]"]],
-    processEscapes: true,
-    processEnvironments: true
-  },
-  options: {
-    ignoreHtmlClass: ".*|",
-    processHtmlClass: "arithmatex"
-  }
-};
-
-document$.subscribe(() => { 
-  MathJax.typesetPromise()
-})

docs/javascripts/tablesort.js

@@ -1,6 +0,0 @@
-document$.subscribe(function() {
-  var tables = document.querySelectorAll("article table:not([class])")
-  tables.forEach(function(table) {
-    new Tablesort(table)
-  })
-})

docs/overrides/partials/copyright.html

@@ -1,22 +0,0 @@
-<div class="md-copyright">
-  {% if config.copyright %}
-  <div class="md-copyright__highlight">
-    {{ config.copyright }}
-  </div>
-  {% endif %}
-  {% if not config.extra.generator == false %}
-  &copy; 2024 -
-  <script>document.write(new Date().getFullYear());</script>
-  <a href="https://github.com/tobid7">
-    tobid7
-  </a>
-  - Kassel, Germany | 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,58 +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--typedef: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M 13.43 7.11 L 13.18 10 H 17 V 12 H 13 L 12.56 17.07 A 1 1 0 0 0 15.287 17.261 L 17.028 17.48 A 1 1 0 0 1 10.57 16.89 L 11 12 H 8 V 10 H 11.17 L 11.44 6.93 Z"/></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.typedef, .md-typeset details.typedef,
-.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 .typedef > .admonition-title, .md-typeset .typedef > 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 .typedef > .admonition-title::before,
-.md-typeset .typedef > summary::before {
-  background-color: var(--md-default-fg-color--light);
-  -webkit-mask-image: var(--md-admonition-icon--typedef);
-          mask-image: var(--md-admonition-icon--typedef);
-}
-
-.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,15 +0,0 @@
-title: Palladium
-description: 
-files:
-  - "include/*.hpp"
-  - "include/pd/app/*.hpp"
-  - "include/pd/core/*.hpp"
-  - "include/pd/drivers/*.hpp"
-  - "include/pd/image/*.hpp"
-  - "include/pd/lib3ds/*.hpp"
-  - "include/pd/lithium/*.hpp"
-  - "include/pd/net/*.hpp"
-  - "include/pd/overlays/*.hpp"
-  - "include/pd/sound/*.hpp"
-  - "include/pd/ui7/*.hpp"
-  - "include/pd/ui7/container/*.hpp"

include/palladium

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,14 +23,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <3ds.h>
+#include <pd/core/core.hpp>
-
+#include <pd/drivers/drivers.hpp>
-#include <pd/core/common.hpp>
+#include <pd/image/image.hpp>
-#include <pd/core/markdown.hpp>
+#include <pd/lithium/lithium.hpp>
-
+#include <pd/ui7/ui7.hpp>
-namespace PD {
-class ResultDecoder {
- public:
-  ResultDecoder(Result res);
-};
-}  // namespace PD

include/pd.hpp

@@ -1,71 +0,0 @@
-#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.
- */
-
-// Core
-#include <pd/core/bit_util.hpp>
-#include <pd/core/color.hpp>
-#include <pd/core/common.hpp>
-#include <pd/core/io.hpp>
-#include <pd/core/strings.hpp>
-#include <pd/core/sys.hpp>
-#include <pd/core/timer.hpp>
-#include <pd/core/timetrace.hpp>
-#include <pd/core/vec.hpp>
-// Graphics
-#include <pd/lithium/renderer.hpp>
-#include <pd/lithium/spritesheet.hpp>
-// Image
-#include <pd/image/image.hpp>
-#include <pd/image/img_blur.hpp>
-#include <pd/image/img_convert.hpp>
-// Drivers
-#include <pd/drivers/hid.hpp>
-// Overlays
-#include <pd/overlays/keyboard.hpp>
-#include <pd/overlays/message_mgr.hpp>
-#include <pd/overlays/overlay_mgr.hpp>
-#include <pd/overlays/performance.hpp>
-#include <pd/overlays/settings.hpp>
-// UI7
-#include <pd/ui7/ui7.hpp>
-// Lib3ds
-#include <pd/lib3ds/hwinfo.hpp>
-#include <pd/lib3ds/memory.hpp>
-#include <pd/lib3ds/os.hpp>
-#include <pd/lib3ds/result_decoder.hpp>
-// App
-#include <pd/app/app.hpp>
-#include <pd/app/error.hpp>
-#include <pd/app/lang.hpp>
-
-/// Setup these as non Namespaced access by default
-#ifndef PD_MATH_NAMESPACED
-using vec2 = PD::vec2;
-using vec3 = PD::vec3;
-using vec4 = PD::vec4;
-#endif
-
-// namespace Palladium = PD;

include/pd/app/app.hpp

@@ -1,231 +0,0 @@
-#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/timer.hpp>
-#include <pd/core/timetrace.hpp>
-#include <pd/lib3ds/drv_hid.hpp>
-#include <pd/lithium/renderer.hpp>
-#include <pd/overlays/message_mgr.hpp>
-#include <pd/overlays/overlay_mgr.hpp>
-
-namespace PD {
-/**
- * Template Class for a User Application on the 3ds
- */
-class App {
- public:
-  /**
-   * alias for AppFlags
-   */
-  using AppFlags = u32;
-  /**
-   * App Flags
-   *
-   * - Probably only the default Setup should be used
-   */
-  enum AppFlags_ {
-    AppFlags_None = 0,                   ///< Do Nothing
-    AppFLags_UserLoop = 1 << 0,          ///< Handle User MainLoop
-    AppFlags_HandleOverlays = 1 << 1,    ///< Process Overlays
-    AppFlags_HandleMessageMgr = 1 << 2,  ///< Process Messages
-    AppFlags_HandleRendering = 1 << 3,   ///< Handle Rendering
-    /// Default Flags
-    AppFlags_Default = AppFlags_HandleMessageMgr | AppFlags_HandleOverlays |
-                       AppFlags_HandleRendering | AppFLags_UserLoop,
-  };
-  /**
-   * alias for AppInitFlags
-   */
-  using AppInitFlags = u32;
-  /**
-   * App Init Flags
-   */
-  enum AppInitFlags_ {
-    AppInitFlags_None = 0,  ///< Do nothing (probably a useles ability)
-    AppInitFlags_MountRomfs = 1 << 0,    ///< Mount Romfs on PreInit
-    AppInitFlags_InitGraphics = 1 << 1,  ///< Default Init Graphics for GPU use
-    AppInitFlags_New3dsMode = 1 << 2,    ///< Enable New3DS Speedup
-    AppInitFlags_InitGraphicsNoC3D = 1 << 3,  ///< Init GFX for Buf Modification
-    AppInitFlags_InitLithium = 1 << 4,        ///< Init 2D Rendering Engine
-    /// I dont have a name for this one yet
-    /// It Inits Internal Directory structure
-    AppInitFlags_UnnamedOption1 = 1 << 5,
-    AppInitFlags_InitHwInfo = 1 << 6,  ///< Init HwInfo from lib3ds
-    /// Default App Init Flags
-    AppInitFlags_Default = AppInitFlags_MountRomfs | AppInitFlags_InitGraphics |
-                           AppInitFlags_New3dsMode | AppInitFlags_InitLithium,
-  };
-  /**
-   * App Constructor that can Optionally set a name for the App
-   * @param name App Name Defaults to App
-   */
-  App(const std::string& name = "App") {
-    if (too) {
-      Error("Only one App can be created at the same time!");
-    }
-    this->name = name;
-    too++;
-  }
-  /**
-   * App Deconstructor
-   */
-  ~App() { too--; }
-
-  /**
-   * Templete function where the user can Init his stuff
-   */
-  virtual void Init() {}
-  /**
-   * Template function to deinit stuff (most is deinit automatically
-   * but it is still possible that some things need to be ordered manually)
-   */
-  virtual void Deinit() {}
-  /**
-   * Template User MainLoop
-   * @param delta Delta time
-   * @param time App Run time
-   * @return false to exit the App
-   */
-  virtual bool MainLoop(float delta, float time) { return false; }
-
-  /**
-   * Function to actually run the app
-   *
-   * Example:
-   * ```cpp
-   * int main() {
-   *    UserApp app;
-   *    app.Run();
-   *    return 0;
-   * }
-   * ```
-   */
-  void Run();
-  /**
-   * Get the Renderer Reference
-   * @return Renderer Reference
-   */
-  LI::Renderer::Ref Renderer() { return renderer; }
-  /**
-   * Get Message Manager Reference
-   * @return Message Manager Reference
-   */
-  MessageMgr::Ref Messages() { return msg_mgr; }
-  /**
-   * Get Overlay Manager Reference
-   * @return Overlay Manager Reference
-   */
-  OverlayMgr::Ref Overlays() { return overlay_mgr; }
-  /**
-   * Get Input Driver Reference
-   * @return Input Driver Reference
-   */
-  Hid::Ref Input() { return input_mgr; }
-  /**
-   *  Get Framerate
-   * @return frames per second
-   */
-  float GetFps() const { return fps; }
-
-  /**
-   * Enable Runtime Feature(s) (AppFlags)
-   * @param flags Flag(s) to enable
-   */
-  void FeatureEnable(AppFlags flags) { runtimeflags |= flags; }
-  /**
-   * Disable Runtime Feature(s) (AppFlags)
-   * @param flags Flag(s) to disable
-   */
-  void FeatureDisable(AppFlags flags) { runtimeflags &= ~flags; }
-  /**
-   * Get Reference Access to runtimeflags
-   * @return reference to runtimeflags
-   */
-  AppFlags& GetFeatureSet() { return runtimeflags; }
-
-  /**
-   * Get App Datadirectory (if enabled in AppInitFlags)
-   * @return App Data Directory
-   */
-  std::string GetDataDirectory();
-
- protected:
-  /**
-   * Top Screen Reference
-   */
-  Screen::Ref Top;
-  /**
-   * Bottom Screen Reference
-   */
-  Screen::Ref Bottom;
-  /**
-   * AppInitFlags
-   *
-   * - Can only be edited in your App class Constructor
-   * - Editing them Later will not effect the Deinit Process
-   * Example:
-   * ```cpp
-   * class YourApp : public PD::App {
-   *    public:
-   *    YourApp(): App("YourApp") {
-   *        AppInitFlags |= AppInitFlags_InitLithium;
-   *    }
-   * }
-   * ```
-   */
-  AppInitFlags InitFlags = AppInitFlags_Default;
-
- private:
-  /** Runtime Flags (can be edited) */
-  AppFlags runtimeflags = AppFlags_Default;
-  /** Safe Copy to prevent from editing befor Deinit */
-  AppInitFlags SafeInitFlags = AppInitFlags_Default;
-  /** PreInit Handler */
-  void PreInit();
-  /** Post Deinit Handler */
-  void PostDeinit();
-  /** Renderer Reference */
-  LI::Renderer::Ref renderer;
-  /** Message Manager */
-  MessageMgr::Ref msg_mgr;
-  /** Overlay Manager */
-  OverlayMgr::Ref overlay_mgr;
-  /** Input Driver */
-  Hid::Ref input_mgr;
-  /** Timer to track the App Runtime */
-  Timer::Ref app_time;
-  /** Last Time (for delta time and fps calculation) */
-  u64 last_time;
-  /** Framerate */
-  float fps;
-
-  /** App Name */
-  std::string name;
-
-  /** A static variable to make sure only one App instance can exist */
-  static int too;
-};
-}  // namespace PD

include/pd/app/lang.hpp

@@ -1,98 +0,0 @@
-#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 {
-/**
- * Language System
- *
- * - Translations are saved into json files
- * - path should point to a directory containing the json files
- * - example for filenames: `en.json`, `de.json`, `fr.json`
- */
-class Lang : public SmartCtor<Lang> {
- public:
-  Lang() = default;
-  ~Lang() = default;
-
-  /**
-   * Function to set the path to search for Language files
-   * @param path Path to search the files
-   */
-  void SetBasePath(const std::string &path) { langs_path = path; }
-  /**
-   * Load a language file by the language key
-   * @param lang_key Language key for example `de`
-   */
-  void Load(const std::string &lang_key) {
-    LoadFile(langs_path + "/" + lang_key + ".json");
-  }
-  /**
-   * Directly load a Language file from a specific path
-   * @param path Path to load the file from
-   */
-  void LoadFile(const std::string &path);
-  /**
-   * Get a String by a `Keyword`
-   * @param k Keyword to search for
-   * @return Returns the string or if none found it returns the Keyword
-   */
-  const std::string &Get(const std::string &k);
-  /**
-   * Get the Language Name
-   * @return Returns the Language Name
-   */
-  const std::string &GetName() { return lang_name; }
-  /**
-   * Get the Language ID / Key
-   * @return Returns the Language ID
-   */
-  const std::string &GetID() { return lang_id; }
-  /**
-   * Get the Language Author(s)
-   * @return Returns the Author(s) of the Language file
-   */
-  const std::string &GetAuthor() { return lang_author; }
-  /**
-   * Get the Language File Search Path
-   * @return Returns Path where the Files are searched for
-   */
-  const std::string &GetPath() { return langs_path; }
-
- private:
-  const int ver = 0;
-  /** Language Files Root path */
-  std::string langs_path = "romfs:/lang";
-  /** Language Name */
-  std::string lang_name;
-  /** Language ID / Key */
-  std::string lang_id;
-  /** Language Author */
-  std::string lang_author;
-  /** KEY - STRING Table for faster Key access */
-  std::map<std::string, std::string> ltable;
-};
-}  // namespace PD

include/pd/common.hpp

@@ -0,0 +1,109 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 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.
+ */
+
+#if defined(__GNUG__) && !defined(_MSC_VER)
+#include <cxxabi.h>
+#endif
+
+#include <array>
+#include <chrono>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <exception>
+#include <format>
+#include <fstream>
+#include <numbers>
+#include <pd/pd_p_api.hpp>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace PD {
+enum class LogLevel {
+  None,
+  Info,
+  Warning,
+  Error,
+};
+[[noreturn]] inline void Throw(const std::string& msg) {
+  throw std::runtime_error(msg);
+}
+using u8 = unsigned char;
+using u16 = unsigned short;
+using u32 = unsigned int;
+using u64 = unsigned long long;
+using ptr = uintptr_t;
+PD_API void LogFilter(LogLevel minimum);
+PD_API void Log(const std::string& txt, LogLevel lvl = LogLevel::Info);
+template <typename... Args>
+void Log(std::format_string<Args...> fmt, Args&&... args) {
+  std::string msg = std::format(fmt, std::forward<Args>(args)...);
+  Log(msg, LogLevel::Info);
+}
+template <typename... Args>
+void Log(LogLevel lvl, std::format_string<Args...> fmt, Args&&... args) {
+  std::string msg = std::format(fmt, std::forward<Args>(args)...);
+  Log(msg, lvl);
+}
+template <typename T>
+std::string TypeName() {
+#ifdef __RTTI
+#if defined(__GNUG__) && !defined(_MSC_VER)
+  int res = 0;
+  std::unique_ptr<char, void (*)(void*)> up{
+      abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &res), std::free};
+  return (res == 0) ? up.get() : typeid(T).name();
+#else
+  return typeid(T).name();  // no demangler available :/
+#endif
+#else
+  return "";
+#endif
+}
+}  // namespace PD
+
+#if defined(__GNUC__) || defined(__clang__)
+#define PDPRETTYFUNC __PRETTY_FUNCTION__
+#elif defined(_MSC_VER)
+#define PDPRETTYFUNC __FUNCSIG__
+#else
+#define PDPRETTYFUNC __FUNCTION__
+#endif
+#ifdef PD_DEBUG
+#define PDLOG(fmt, ...) \
+  PD::Log("[{}:{}]: " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
+#define PDWARN(fmt, ...)                                              \
+  PD::Log(PD::LogLevel::Warning, "[{}:{}]: " fmt, __FILE__, __LINE__, \
+          ##__VA_ARGS__)
+#define PDERR(fmt, ...)                                             \
+  PD::Log(PD::LogLevel::Error, "[{}:{}]: " fmt, __FILE__, __LINE__, \
+          ##__VA_ARGS__)
+#else
+#define PDLOG(fmt, ...)
+#define PDWARN(fmt, ...)
+#define PDERR(fmt, ...)
+#endif

include/pd/core/bits.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (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
@@ -24,24 +23,21 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
-/**
+namespace Bits {
- * 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
  */
-bool IsSingleBit(u32 v);
+PD_API bool IsSingleBit(u32 v);
 /**
  * Get the Next Power of two Number
  * @param v Current Number
  * @return Next Number thats a Pow of 2
  */
-u32 GetPow2(u32 v);
+PD_API u32 GetPow2(u32 v);
-}  // namespace BitUtil
+}  // namespace Bits
 }  // namespace PD

include/pd/core/color.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (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
@@ -24,33 +23,26 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
+#include <pd/core/strings.hpp>
 
 namespace PD {
-/**
+class PD_API Color {
- * Color class
- *
- * - Supports hex input starting with a # and 6 or 8 digits
- * - Supports rgb(a) 8Bit unsigned number input
- * - Supports rgb(a) float input from 0.0 to 1.0
- * - Supports 32Bit input color
- * @note Safetey checks are disabled for maximum performance
- */
-class Color {
  public:
   /**
    * Default Constructor (all variables are set to 0)
    */
-  Color() : m_r(0), m_g(0), m_b(0), m_a(0) {}
+  constexpr Color() : r(0), g(0), b(0), a(0) {}
+  constexpr ~Color() {}
   /**
    * Constructor for 32Bit Color Input
    * @param color 32Bit Color value
    */
-  Color(u32 color) {
+  constexpr Color(u32 clr) {
-    m_a = (color >> 24) & 0xff;
+    a = (clr >> 24) & 0xff;
-    m_b = (color >> 16) & 0xff;
+    b = (clr >> 16) & 0xff;
-    m_g = (color >> 8) & 0xff;
+    g = (clr >> 8) & 0xff;
-    m_r = color & 0xff;
+    r = clr & 0xff;
   }
   /**
    * Constructor for 8Bit Input
@@ -59,12 +51,7 @@ class Color {
    * @param b Blue Value
    * @param a Optional Alpha Value (Defaults to 255)
    */
-  Color(u8 r, u8 g, u8 b, u8 a = 255) {
+  constexpr Color(int r, int g, int b, int a = 255) : r(r), g(g), b(b), a(a) {}
-    m_r = r;
-    m_g = g;
-    m_b = b;
-    m_a = a;
-  }
   /**
    * Constructor for float Input
    * @param r Red Value
@@ -73,28 +60,46 @@ class Color {
    * @param a Optional Alpha Value (Defaults to 1.0f)
    * @note There is no Check if the number is between 0.0 and 1.0
    */
-  Color(float r, float g, float b, float a = 1.f) {
+  constexpr Color(float r, float g, float b, float a = 1.f)
-    m_r = static_cast<u8>(255.f * r);
+      : r(static_cast<u8>(255.f * r)),
-    m_g = static_cast<u8>(255.f * g);
+        g(static_cast<u8>(255.f * g)),
-    m_b = static_cast<u8>(255.f * b);
+        b(static_cast<u8>(255.f * b)),
-    m_a = static_cast<u8>(255.f * a);
+        a(static_cast<u8>(255.f * a)) {}
-  }
   /**
-   * Constructor for Hex Input
+   * Constructor for Hex Input (is abel to run at compile time xD)
    * @param hex Hex String in `#ffffff` or `#ffffffff` format
    */
-  Color(const std::string& hex) { Hex(hex); }
+  constexpr Color(const std::string_view& hex) { Hex(hex); }
-  /**
-   * Unused Deconstructor
-   */
-  ~Color() {}
 
   /**
-   * Create Color Object by Hex String
+   * Constructor for Hex Input (is abel to run at compile time xD)
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   */
+  constexpr Color(const char* hex) { Hex(std::string_view{hex}); }
+
+  /**
+   * Create Color Object by Hex String (at compile time btw)
    * @param hex Hex String in `#ffffff` or `#ffffffff` format
    * @return Color class itself
    */
-  Color& Hex(const std::string& hex);
+  constexpr Color& Hex(const std::string_view& hex) {
+    if (!(hex.length() == 7 || hex.length() == 9)) {
+      PD::Throw("[PD] Color: hex string is not rgb or rgba!");
+    }
+    r = PD::Strings::HexChar2Int(hex[1]) * 16 +
+        PD::Strings::HexChar2Int(hex[2]);
+    g = PD::Strings::HexChar2Int(hex[3]) * 16 +
+        PD::Strings::HexChar2Int(hex[4]);
+    b = PD::Strings::HexChar2Int(hex[5]) * 16 +
+        PD::Strings::HexChar2Int(hex[6]);
+    if (hex.length() == 9) {
+      a = PD::Strings::HexChar2Int(hex[7]) * 16 +
+          PD::Strings::HexChar2Int(hex[8]);
+    } else {
+      a = 255;
+    }
+    return *this;
+  }
   /**
    * Convert this Color Object to Hex string
    * @param rgba [default false] sets if 8 or 6 digit color should be returned
@@ -102,109 +107,68 @@ class Color {
    */
   std::string Hex(bool rgba = false) const;
 
-  /**
-   * Setter for Red
-   * @param v value
-   * @return Color class reference
-   */
-  Color& r(u8 v) {
-    m_r = v;
-    return *this;
-  }
-  /**
-   * Getter for Red
-   * @return Red Value
-   */
-  u8 r() const { return m_r; }
-  /**
-   * Setter for Green
-   * @param v value
-   * @return Color class reference
-   */
-  Color& g(u8 v) {
-    m_g = v;
-    return *this;
-  }
-  /**
-   * Getter for Green
-   * @return Green Value
-   */
-  u8 g() const { return m_r; }
-  /**
-   * Setter for Blue
-   * @param v value
-   * @return Color class reference
-   */
-  Color& b(u8 v) {
-    m_b = v;
-    return *this;
-  }
-  /**
-   * Getter for Blue
-   * @return Blue Value
-   */
-  u8 b() const { return m_r; }
-  /**
-   * Setter for Alpha
-   * @param v value
-   * @return Color class reference
-   */
-  Color& a(u8 v) {
-    m_a = v;
-    return *this;
-  }
-  /**
-   * Getter for Alpha
-   * @return Alpha Value
-   */
-  u8 a() const { return m_r; }
-
   /**
    * 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) {
+  constexpr Color& Fade(const Color& color, float p) {
-    m_a = static_cast<u8>((color.a() - m_a) * ((p + 1.f) / 2));
+    a = static_cast<u8>((color.a - a) * ((p + 1.f) / 2));
-    m_b = static_cast<u8>((color.b() - m_b) * ((p + 1.f) / 2));
+    b = static_cast<u8>((color.b - b) * ((p + 1.f) / 2));
-    m_g = static_cast<u8>((color.g() - m_g) * ((p + 1.f) / 2));
+    g = static_cast<u8>((color.g - g) * ((p + 1.f) / 2));
-    m_r = static_cast<u8>((color.r() - m_r) * ((p + 1.f) / 2));
+    r = static_cast<u8>((color.r - r) * ((p + 1.f) / 2));
     return *this;
   }
+
+  /**
+   * Lerp
+   * @param v Target color
+   * @param t interpolation factor
+   * @return Class Reference
+   */
+  constexpr Color& Lerp(const Color& v, float t) {
+    a = static_cast<u8>(a + (v.a - a) * t);
+    b = static_cast<u8>(b + (v.b - b) * t);
+    g = static_cast<u8>(g + (v.g - g) * t);
+    r = static_cast<u8>(r + (v.r - r) * t);
+    return *this;
+  }
+
   /**
    * Get 32Bit Color Value
-   * @return 32Bit Color Value
+   * @return 32Bit Color Value (ABGR iirc)
    */
-  u32 Get() const { return (m_a << 24) | (m_b << 16) | (m_g << 8) | m_r; }
+  constexpr u32 Get() const { return (a << 24) | (b << 16) | (g << 8) | r; }
   /**
    * Get The Luminance of the Color
    * @return luminance (from 0.0 to 1.0)
    */
-  float Luminance() const {
+  constexpr 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));
+    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); }
+  constexpr bool IsLight() const { return (Luminance() >= 0.5); }
 
   /**
    * Operator to cast Color to 32Bit Value
    * @return 32Bit Color Value
    */
-  operator u32() const { return Get(); }
+  constexpr operator u32() const { return Get(); }
 
- private:
+  const float rf() const { return static_cast<float>(r) / 255.f; }
-  /** Red Value */
+  const float gf() const { return static_cast<float>(g) / 255.f; }
-  u8 m_r;
+  const float bf() const { return static_cast<float>(b) / 255.f; }
-  /** Green Value */
+  const float af() const { return static_cast<float>(a) / 255.f; }
-  u8 m_g;
+
-  /** Blue Value */
+  /** Public Access Data section */
-  u8 m_b;
+  u8 r;
-  /** Alpha Value */
+  u8 g;
-  u8 m_a;
+  u8 b;
+  u8 a;
 };
 }  // namespace PD

include/pd/core/common.hpp

@@ -1,120 +0,0 @@
-#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>
-
-namespace PD {
-/**
- * SmartCtor (std::shared_ptr) Template class for Smart Pointers
- *
- * - Just add : public PD::SmartCtor<YourClass> to your class
- * @tparam T Your Class
- */
-template <typename T>
-class SmartCtor {
- public:
-  /** Reference alias for std::shared_ptr<Type> */
-  using Ref = std::shared_ptr<T>;
-
-  /**
-   * static Function to Create a New Reference
-   * @param args Additional Arguments (Depends on your classes Constructors)
-   * @return New Reference Object
-   */
-  template <typename... Args>
-  static Ref New(Args&&... args) {
-    return std::make_shared<T>(std::forward<Args>(args)...);
-  }
-};
-/**
- * Wrapper for SmartCtor<Type>::New(Args)
- * @tparam T Class Type
- * @param args Arguments
- * @return Type Reference (SmartPointer)
- */
-template <typename T, typename... Args>
-SmartCtor<T>::Ref New(Args&&... args) {
-  return SmartCtor<T>::New(std::forward<Args>(args)...);
-}
-// Defines
-
-/** alias for 64 Bit unsigned integer */
-using u64 = unsigned long long;
-/** alias for 32 Bit unsigned integer */
-using u32 = unsigned int;
-/** alias for 16 Bit unsigned integer */
-using u16 = unsigned short;
-/** alias for 8 Bit unsigned integer */
-using u8 = unsigned char;
-
-/**
- * LinInfo Compile Information
- */
-namespace LibInfo {
-/**
- * Get the Compiler Name and Version the lib got Compiled with
- * @return Compiler Name / Version
- */
-const std::string CompiledWith();
-/**
- * Get the C++ Version used to compile the lib
- * @return C++ Version (__cplusplus)
- */
-const std::string CxxVersion();
-/**
- * Get the Buildtime of the Library
- * @return Build Time
- */
-const std::string BuildTime();
-/**
- * Get the Library Version
- * @return Library Version String
- */
-const std::string Version();
-/**
- * Get the Git Commit the Lib got compiled in
- * @return Git Commit 7digit short hash
- */
-const std::string Commit();
-/**
- * Get the Git Branch which was active when compiling the lib
- * @return Git Branch
- */
-const std::string Branch();
-}  // namespace LibInfo
-}  // namespace PD

include/pd/core/core.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 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/bits.hpp>
+#include <pd/core/color.hpp>
+#include <pd/core/fnv.hpp>
+#include <pd/core/formatters.hpp>
+#include <pd/core/fquat.hpp>
+#include <pd/core/hashid.hpp>
+#include <pd/core/io.hpp>
+#include <pd/core/mat.hpp>
+#include <pd/core/pool.hpp>
+#include <pd/core/strings.hpp>
+#include <pd/core/timer.hpp>
+#include <pd/core/timetrace.hpp>
+#include <pd/core/tween.hpp>
+#include <pd/core/u128.hpp>
+#include <pd/core/vec.hpp>

include/pd/core/fnv.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (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
@@ -24,48 +23,48 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <3ds.h>
+#include <pd/common.hpp>
-
-#include <pd/app/error.hpp>
-#include <pd/core/common.hpp>
 
 namespace PD {
 /**
- * Custom C++ Allocator for 3DS linear Memory
+ * FNV-1a 32Bit hasing function
- * Used for Everything that has to do with Rendering or sound
+ * https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
- * Dont going into that much detail here
- *
- * Example:
- * ```cpp
- * // Index Buffer for Rendering using Linear Allocator
- * std::vector<u16, PD::LinearAllocator<u16>> index_buf;
- * ```
  */
+constexpr u32 FNV1A32(std::string_view str) {
+  u32 ret = 0x811c9dc5;  // Offset basis
+  for (auto& it : str) {
+    ret ^= it;
+    ret *= 0x01000193;  // Prime
+  }
+  return ret;
+}
+/**
+ * FNV-1a 64Bit hasing function
+ * https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+ */
+constexpr u64 FNV1A64(std::string_view str) {
+  u64 ret = 0xcbf29ce484222325;  // Offset basis
+  for (auto& it : str) {
+    ret ^= it;
+    ret *= 0x00000100000001b3;  // Prime
+  }
+  return ret;
+}
+
+namespace Detail {
 template <typename T>
-class LinearAllocator : public std::allocator<T> {
+struct FNV1A {};
- public:
-  using size_type = size_t;
-  using pointer = T*;
-  using const_pointer = const T*;
 
-  template <typename T1>
+template <>
-  struct rebind {
+struct FNV1A<u32> {
-    using other = LinearAllocator<T1>;
+  static constexpr u32 Hash(std::string_view str) { return FNV1A32(str); }
-  };
+  static constexpr u32 Hash(const std::string& str) { return FNV1A32(str); }
-
-  pointer allocate(size_type n, const void* hint = nullptr) {
-    if (n > this->max_size()) {
-      Error("Linear Alloc failed (no space left)");
-      return nullptr;
-    }
-    return (pointer)linearAlloc(n * sizeof(T));
-  }
-  void deallocate(pointer p, size_type) { linearFree((void*)p); }
-  size_type max_size() { return linearSpaceFree(); }
-
-  LinearAllocator() noexcept {}
-  LinearAllocator(const LinearAllocator<T>& a) noexcept
-      : std::allocator<T>(a) {}
-  ~LinearAllocator() noexcept {}
 };
+
+template <>
+struct FNV1A<u64> {
+  static constexpr u64 Hash(std::string_view str) { return FNV1A64(str); }
+  static constexpr u64 Hash(const std::string& str) { return FNV1A64(str); }
+};
+}  // namespace Detail
 }  // namespace PD

include/pd/core/formatters.hpp

@@ -0,0 +1,98 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 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/color.hpp>
+
+template <>
+struct std::formatter<PD::Color> : std::formatter<std::string> {
+  enum class ColorFmt {
+    Hex,
+    Rgbf,
+    Rgb,
+    Rgba,
+    Rgbaf,
+  };
+  ColorFmt mode = ColorFmt::Hex;
+  constexpr auto parse(std::format_parse_context& ctx) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+
+    if (it == end || *it == '}') return it;
+
+    if (check(it, end, 5, "rgbaf")) {
+      mode = ColorFmt::Rgbaf;
+      it += 5;
+    } else if (check(it, end, 4, "rgba")) {
+      mode = ColorFmt::Rgba;
+      it += 4;
+    } else if (check(it, end, 4, "rgbf")) {
+      mode = ColorFmt::Rgbf;
+      it += 4;
+    } else if (check(it, end, 3, "rgb")) {
+      mode = ColorFmt::Rgb;
+      it += 3;
+    } else if (check(it, end, 3, "hex")) {
+      mode = ColorFmt::Hex;
+      it += 3;
+    } else {
+      throw std::format_error("invalid format for PD::Color");
+    }
+
+    if (it == end || *it != '}')
+      throw std::format_error("invalid format for PD::Color");
+
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(const PD::Color& value, FormatContext& ctx) const {
+    switch (mode) {
+      case ColorFmt::Hex:
+        return std::format_to(ctx.out(), "#{:02X}{:02X}{:02X}{:02X}", value.r,
+                              value.g, value.b, value.a);
+      case ColorFmt::Rgb:
+        return std::format_to(ctx.out(), "{}, {}, {}", value.r, value.g,
+                              value.b);
+      case ColorFmt::Rgba:
+        return std::format_to(ctx.out(), "{}, {}, {}, {}", value.r, value.g,
+                              value.b, value.a);
+      case ColorFmt::Rgbf:
+        return std::format_to(ctx.out(), "{}, {}, {}", value.rf(), value.gf(),
+                              value.bf());
+      case ColorFmt::Rgbaf:
+        return std::format_to(ctx.out(), "{}, {}, {}, {}", value.rf(),
+                              value.gf(), value.bf(), value.af());
+      default:
+        return ctx.out();
+    }
+  }
+
+  constexpr bool check(std::format_parse_context::const_iterator it,
+                       std::format_parse_context::const_iterator end,
+                       size_t len, const char* what) {
+    return (end - it >= static_cast<std::ptrdiff_t>(len) &&
+            std::string_view(&*it, len) == what);  // msvc things...
+  }
+};

include/pd/core/fquat.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,35 +23,33 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+// This file is based on fvec4
-#include <pd/drivers/hid.hpp>
+
-#include <pd/lithium/renderer.hpp>
+#include <pd/common.hpp>
+#include <pd/core/vec4.hpp>
 
 namespace PD {
-/**
+class fquat : public fvec4 {
- * Overlay Template class
+  constexpr fquat() : fvec4(0.f, 0.f, 0.f, 1.f) {}
- */
+  constexpr fquat(float x, float y, float z, float w) : fvec4(x, y, z, w) {}
-class Overlay : public SmartCtor<Overlay> {
+  constexpr fquat(const fvec4& v) : fvec4(v) {}
- public:
-  Overlay() = default;
-  virtual ~Overlay() = default;
 
-  /**
+  static fquat Identity() { return fquat(0.f, 0.f, 0.f, 1.f); }
-   * Update Function for Overlay input and rendering
-   * @param delta Deltatime
-   * @param ren Renderer reference
-   * @param inp Input Driver
-   */
-  virtual void Update(float delta, LI::Renderer::Ref ren, Hid::Ref inp) = 0;
 
-  /** Check if killed to remove from Overlay Manager */
+  constexpr fquat Conjugate() const { return fquat(-x, -y, -z, w); }
-  bool IsKilled() const { return kill; }
+  fquat Inverse() const {
+    float len = SqLen();
+    if (len == 0.0f) {
+      return fquat();
+    }
+    return Conjugate() / len;
+  }
 
- protected:
+  fquat operator*(const fquat& v) const {
-  /** Internall Kill function to call from your Overlay */
+    return fquat(w * v.x + x * v.w + y * v.z - z * v.y,
-  void Kill() { kill = true; }
+                 w * v.y - x * v.z + y * v.w + z * v.x,
-
+                 w * v.z + x * v.y - y * v.x + z * v.w,
- private:
+                 w * v.w - x * v.x - y * v.y - z * v.z);
-  bool kill = false;  ///< Should be killed or not
+  }
 };
 }  // namespace PD

include/pd/core/hashid.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <pd/core/fnv.hpp>
+#include <pd/core/strings.hpp>
+
+namespace PD {
+template <typename T>
+class HashID {
+ public:
+  using __Type = T;
+
+  constexpr HashID() {};
+  constexpr HashID(T id) { pID = id; }
+  HashID(const std::string& name) {
+    pID = Detail::FNV1A<T>::Hash(name);
+#ifdef PD_HASHID_KEEP_STR
+    pName = name;
+#endif
+  }
+  constexpr HashID(const char* name) {
+    pID = Detail::FNV1A<T>::Hash(std::string_view(name));
+#ifdef PD_HASHID_KEEP_STR
+    pName = name;
+#endif
+  }
+  ~HashID() {}
+
+  constexpr T Get() { return pID; }
+
+  std::string GetName() const {
+#ifdef PD_HASHID_KEEP_STR
+    return pName;
+#else
+    return std::format("hash({:#08x})", pID);
+#endif
+  }
+
+  operator T() const { return pID; }
+  // operator std::string() const { return GetName(); }
+
+ private:
+  T pID;
+#ifdef PD_HASHID_KEEP_STR
+  str pName;
+#endif
+};
+
+using HashID32 = HashID<u32>;
+using HashID64 = HashID<u64>;
+}  // namespace PD

include/pd/core/io.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
@@ -35,12 +35,28 @@ namespace IO {
  * @param path Path to the File
  * @return 8Bit FileBuffer
  */
-std::vector<u8> LoadFile2Mem(const std::string& path);
+PD_API std::vector<u8> LoadFile2Mem(const std::string& path);
+/**
+ * Load a File into a std::string
+ * @param path Path to the File
+ * @return std::string file content
+ */
+PD_API std::string LoadFile2Str(const std::string& path);
 /**
  * Hash a 8Bit Memory Buffer
  * @param data 8Bit input Buffer
  * @return 32Bit Hash
  */
-u32 HashMemory(const std::vector<u8>& data);
+PD_API u32 HashMemory(const std::vector<u8>& data);
+/**
+ * Function to decrompress RLE buffer
+ * @param data Data buffer to decompress
+ */
+PD_API void DecompressRLE(std::vector<u8>& data);
+/**
+ * Function to compress data with RLE Algorithm
+ * @param data Data buf
+ */
+PD_API void CompressRLE(std::vector<u8>& data);
 }  // namespace IO
 }  // namespace PD

include/pd/core/markdown.hpp

@@ -1,103 +0,0 @@
-#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 Markdown {
- public:
-  Markdown() = default;
-  ~Markdown() = default;
-
-  void Header(const std::string& hdr, int lvl = 2) {
-    if (task != 0 || lvl < 1 || lvl > 10) {
-      return;
-    }
-    /// Directly create the string with its amount of #
-    std::string str(lvl, '#');
-    str += " ";
-    str += hdr;
-    s << str << std::endl << std::endl;
-  }
-
-  void BeginTable(const std::vector<std::string>& head) {
-    if (task != 0) {
-      return;
-    }
-    ctc = head.size();
-    for (auto& it : head) {
-      s << "| " << it << " ";
-    }
-    s << "|\n";
-    for (int i = 0; i < ctc; i++) {
-      s << "|---";
-    }
-    s << "|\n";
-    task = 1;
-  }
-
-  Markdown& TableAddEntry(const std::string& e) {
-    if (task != 1) {
-      return *this;
-    }
-    ctci++;
-    s << "| " << e << " ";
-    if (ctci == ctc) {
-      s << "|\n";
-      ctci = 0;
-    }
-    return *this;
-  }
-
-  void EndTable() {
-    if (task != 1) {
-      return;
-    }
-    s << std::endl;
-    task = 0;
-  }
-
-  void Write(const std::string& path) {
-    std::ofstream f(path);
-    if (!f) {
-      return;
-    }
-    f << s.str();
-    f.close();
-  }
-
- private:
-  /// @brief Tasks
-  /// 0 = free
-  /// 1 = table
-  /// 2 = text
-  int task = 0;
-  /// @brief Current Table Columns
-  int ctc = 0;
-  /// @brief Current Table Column Index
-  int ctci = 0;
-  std::stringstream s;
-};
-}  // namespace PD

include/pd/core/mat.hpp

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

include/pd/core/pool.hpp

@@ -0,0 +1,166 @@
+#pragma once
+
+#include <memory>
+#include <pd/common.hpp>
+namespace PD {
+// lets take use of c++ 20 concepts
+// https://en.cppreference.com/w/cpp/language/constraints.html
+template <typename T>
+concept Resettable = requires(T& v) { v.Reset(); };
+
+template <typename T, typename Alloc = std::allocator<T>>
+class Pool {
+ public:
+  using value_type = T;
+  using iterator = T*;
+  using const_iterator = const T*;
+
+  Pool() = default;
+  ~Pool() {
+    if (pData) {
+      for (size_t i = 0; i < pCap; i++) {
+        std::allocator_traits<Alloc>::destroy(pAlloc, &pData[i]);
+      }
+      pAlloc.deallocate(pData, pCap);
+      pData = nullptr;
+    }
+  }
+
+  static Pool* Create(size_t size) { return new Pool(size); }
+
+  void Init(size_t size) {
+    pPos = 0;
+    pCap = size;
+    pData = pAlloc.allocate(size);
+    for (size_t i = 0; i < pCap; i++) {
+      std::allocator_traits<Alloc>::construct(pAlloc, &pData[i]);
+    }
+    PDLOG("Pool::Init({})", size);
+  }
+
+  Pool(const Pool&) = delete;
+  Pool(Pool&&) = delete;
+  Pool& operator=(const Pool&) = delete;
+  Pool& operator=(Pool&&) = delete;
+
+  T* Allocate(size_t num = 1) {
+    ExpandIf(num);
+    T* ret = &pData[pPos];
+    pPos += num;
+    return ret;
+  }
+
+  void Push(const T& elem) {
+    T* e = Allocate(1);
+    *e = elem;
+  }
+
+  void Put(size_t idx, const T& elem) {
+    if (idx >= pCap) ExpandIf(idx);
+    pData[idx] = elem;
+  }
+
+  void ExpandIf(size_t req) {
+    if ((pPos + req) <= pCap) return;
+    size_t ncap = std::max(pCap * 2, pPos + req);
+    T* nu = pAlloc.allocate(ncap);
+    if (pData) {
+      for (size_t i = 0; i < pPos; i++) {
+        std::allocator_traits<Alloc>::construct(
+            pAlloc, &nu[i], std::move_if_noexcept(pData[i]));
+      }
+      for (size_t i = 0; i < pCap; i++) {
+        std::allocator_traits<Alloc>::destroy(pAlloc, &pData[i]);
+      }
+      pAlloc.deallocate(pData, pCap);
+    }
+    for (size_t i = pPos; i < ncap; i++) {
+      std::allocator_traits<Alloc>::construct(pAlloc, &nu[i]);
+    }
+    PDLOG("Pool::ExpandIf({}): {} -> {}", req, pCap, ncap);
+    pData = nu;
+    pCap = ncap;
+  }
+
+  void Reset() {
+    for (size_t i = 0; i < pCap; i++) {
+      std::allocator_traits<Alloc>::destroy(pAlloc, &pData[i]);
+    }
+    pPos = 0;
+    for (size_t i = 0; i < pCap; i++) {
+      std::allocator_traits<Alloc>::construct(pAlloc, &pData[i]);
+    }
+  }
+
+  void ResetFast() {
+    if constexpr (Resettable<T>) {
+      for (size_t i = 0; i < pPos; i++) {
+        pData[i].Reset();
+      }
+    } else if constexpr (!std::is_trivially_destructible_v<T>) {
+      PDWARN(
+          "ResetFast should only be executed with a non destructible type or a "
+          "class/struct that has a Reset func! {} is not "
+          "trivially_destructible and has no reset func.",
+          TypeName<T>());
+    }
+    pPos = 0;
+  }
+
+  /** THE ILLEGAL RESET FUNC */
+  void NoReset() { pPos = 0; }
+
+  /**
+   * Copy the data of another pool
+   */
+  void AppendCopy(const Pool& v) {
+    if (!v.size()) return;
+    ExpandIf(v.size());
+    for (size_t i = 0; i < v.size(); i++) {
+      pData[pPos + i] = v.pData[i];
+    }
+    pPos += v.size();
+  }
+
+  /**
+   * Move the data of another pool
+   */
+  void AppendMove(Pool& v) {
+    if (!v.size()) return;
+    ExpandIf(v.size());
+    for (size_t i = 0; i < v.size(); i++) {
+      pData[pPos + i] = std::move(v.pData[i]);
+    }
+    pPos += v.size();
+    v.ResetFast();
+  }
+
+  size_t size() const { return pPos; }
+  size_t capacity() const { return pCap; }
+  T& at(size_t idx) { return pData[idx]; }
+  const T& at(size_t idx) const { return pData[idx]; }
+  iterator begin() { return pData; }
+  iterator end() { return pData + pPos; }
+  const_iterator begin() const { return pData; }
+  const_iterator end() const { return pData + pPos; }
+
+  T& operator[](size_t idx) { return at(idx); }
+  const T& operator[](size_t idx) const { return at(idx); }
+
+ private:
+  Pool(size_t size) : pCap(size), pPos(0) {
+    pPos = 0;
+    pCap = size;
+    pData = pAlloc.allocate(size);
+    for (size_t i = 0; i < pCap; i++) {
+      std::allocator_traits<Alloc>::construct(pAlloc, &pData[i]);
+    }
+    PDLOG("Pool::Init({})", size);
+  }
+
+  size_t pCap = 0;
+  size_t pPos = 0;
+  Alloc pAlloc;
+  T* pData = nullptr;
+};
+}  // namespace PD

include/pd/core/strings.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,61 +23,67 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
  * Set of String Utillity Functions
  */
 namespace Strings {
+constexpr int HexChar2Int(char c) {
+  /** Imagine man hat ne lookup table dafür verwendet :/ */
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
+  if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
+  return -1;  // Error
+}
 /**
  * Check if a String ends with a specific extension
  * @param str Input string
  * @param exts List of Extensions to check for
  * @return true if one of the extensions is found in the String
  */
-bool StringEndsWith(const std::string& str,
+PD_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 Currently using std::filesystem::path for this as wstring_convert
+ * @note Returns Empty if it has an error
- * got removed in c++ 20
  */
-std::wstring MakeWstring(const std::string& s);
+PD_API std::wstring MakeWstring(const std::string& s);
 /**
  * Generate a Formatted String by an Nanoseconds Input
  * @param nanos Nanoseconds Input
  * @return Result String
  */
-const std::string FormatNanos(unsigned long long nanos);
+PD_API const std::string FormatNanos(unsigned long long nanos);
 /**
  * Generate a Formatted String by an Milliseconds Input
  * @param millis Milliseconds Input
  * @return Result String
  */
-const std::string FormatMillis(unsigned long long millis);
+PD_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`
  */
-const std::string FormatBytes(unsigned long long bytes);
+PD_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
  */
-const std::string GetFileName(const std::string& path,
+PD_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
  */
-const std::string PathRemoveExtension(const std::string& path);
+PD_API const std::string PathRemoveExtension(const std::string& path);
 /**
  * Function to Convert a Type to a hex value
  * @tparam T Type
@@ -86,39 +92,79 @@ const std::string PathRemoveExtension(const std::string& path);
  */
 template <typename T>
 inline const std::string ToHex(const T& v) {
-  std::stringstream s;
+  return std::format("{0:0{1}X}", v, sizeof(v) * 2);
-  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
  */
-u32 FastHash(const std::string& s);
+PD_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() {
+inline const char* GetCompilerVersion() {
-  /// As the function looks like this Project is meant to
+/// As the function looks like this Project is meant to
-  /// Be ported to other systems as well
+/// Be ported to other systems as well
-  std::stringstream res;
+#define __mks(x) #x
-#ifdef __GNUC__
+#define mkstring(x) __mks(x)
-  res << "GCC: " << __GNUC__;
+#ifdef __clang__  // Check clang first
-  res << "." << __GNUC_MINOR__ << ".";
+  return "Clang: " mkstring(__clang_major__) "." mkstring(
-  res << __GNUC_PATCHLEVEL__;
+      __clang_minor__) "." mkstring(__clang_patchlevel__);
-#elif __clang__
+#elif __GNUC__
-  res << "Clang: " << __clang_major__ << ".";
+  return "GCC: " mkstring(__GNUC__) "." mkstring(__GNUC_MINOR__) "." mkstring(
-  res << __clang_minor__ << ".";
+      __GNUC_PATCHLEVEL__);
-  res << __clang_patchlevel__;
 #elif _MSC_VER
-  res << "MSVC: " << _MSC_VER;
+  return "MSVC; " mkstring(_MSC_VER);
 #else
-  res << "Unknown Compiler";
+  return "Unknown Compiler";
 #endif
-  return res.str();
 }
 }  // namespace Strings
+class U8Iterator {
+ public:
+  explicit U8Iterator(const char* s) : ptr(reinterpret_cast<const u8*>(s)) {}
+  ~U8Iterator() = default;
+
+  bool Decode32(u32& ret) {
+    if (ptr == nullptr || *ptr == 0) return false;
+    u8 c = *ptr;
+    if (c < 0x80) {
+      ret = c;
+      ptr += 1;
+    } else if ((c >> 5) == 0x6) {
+      ret = ((c & 0x1F) << 6) | (ptr[1] & 0x3F);
+      ptr += 2;
+    } else if ((c >> 4) == 0xE) {
+      ret = ((c & 0x0F) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
+      ptr += 3;
+    } else {
+      ret = ((c & 0x07) << 18) | ((ptr[1] & 0x3F) << 12) |
+            ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
+      ptr += 4;
+    }
+    return true;
+  }
+
+  bool PeekNext32(u32& ret) {
+    if (ptr == nullptr || *(ptr + 1) == 0) return false;
+    u8 c = *ptr;
+    if (c < 0x80) {
+      ret = c;
+    } else if ((c >> 5) == 0x6) {
+      ret = ((c & 0x1F) << 6) | (ptr[1] & 0x3F);
+    } else if ((c >> 4) == 0xE) {
+      ret = ((c & 0x0F) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
+    } else {
+      ret = ((c & 0x07) << 18) | ((ptr[1] & 0x3F) << 12) |
+            ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
+    }
+    return true;
+  }
+
+ private:
+  const u8* ptr = nullptr;
+};
 }  // namespace PD

include/pd/core/sys.hpp

@@ -1,66 +0,0 @@
-#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 {
-/**
- * Namespace containing functions for get Millis and Get Nanos
- */
-namespace Sys {
-/**
- * alias for the TimeTrace Traces Map
- */
-using TraceMap = std::map<std::string, TT::Res::Ref>;
-/**
- * Get Current Time in Milliseconds
- * @return 64Bit value of millis
- */
-u64 GetTime();
-/**
- * Get Current Time in Nanoseconds
- * @return 64Bit value of nanos
- */
-u64 GetNanoTime();
-/**
- * Get a TimeTrace Reference by its string ID
- * @param id trace name
- * @return Trace reference or nullptr if not found
- */
-TT::Res::Ref& GetTraceRef(const std::string& id);
-/**
- * Check if a Trace with the name exists
- * @param id tracename to search
- * @return true if exist
- */
-bool TraceExist(const std::string& id);
-/**
- * Get TraceMap Reference
- * @return edidable Reference to the TraceMap
- */
-TraceMap& GetTraceMap();
-}  // namespace Sys
-}  // namespace PD

include/pd/core/timer.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,14 +23,13 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
-#include <pd/core/sys.hpp>
 
 namespace PD {
 /**
  * Timer class
  */
-class Timer : public SmartCtor<Timer> {
+class PD_API Timer {
  public:
   /**
    * Constructor
@@ -41,6 +40,7 @@ class Timer : public SmartCtor<Timer> {
    * Unused Deconstructor
    */
   ~Timer() {}
+
   /**
    * Resume Timer if Paused
    */
@@ -73,12 +73,11 @@ class Timer : public SmartCtor<Timer> {
    */
   double GetSeconds();
 
- private:
   /** Start of the Timer */
-  u64 start;
+  u64 pStart;
   /** Current Time */
-  u64 now;
+  u64 pNow;
   /** Is Running */
-  bool is_running = false;
+  bool pIsRunning = false;
 };
 }  // namespace PD

include/pd/core/timetrace.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,13 +23,14 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <map>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
  * Class to calculate Maximum/Minimum and Average Timings
  */
-class TimeStats : public SmartCtor<TimeStats> {
+class TimeStats {
  public:
   /**
    * Constructor taking a lengh for the List
@@ -100,12 +101,12 @@ class TimeStats : public SmartCtor<TimeStats> {
    * Get Data Buffer
    * @return data bufer (not edidable)
    */
-  const std::vector<u64> &GetData() { return val; }
+  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)]; }
+  const u64& operator[](int i) { return val[smart_idx(i)]; }
   /**
    * Get List Lengh
    * @return Lengh
@@ -146,17 +147,17 @@ namespace TT {
 /**
  * Data Structure for a TimeTrace Result
  */
-class Res : public SmartCtor<Res> {
+class Res {
  public:
   /** Constructore that Inits a protocol at size of 60 frames */
-  Res() { protocol = TimeStats::New(60); }
+  Res() : start(0), end(0), protocol(60) {}
   ~Res() = default;
 
   /**
    * Setter for the ID (Name)
    * @param v ID of the Trace
    */
-  void SetID(const std::string &v) { id = v; }
+  void SetID(const std::string& v) { id = v; }
   /**
    * Getter for the traces ID
    * @return Trace ID
@@ -178,7 +179,8 @@ class Res : public SmartCtor<Res> {
    */
   void SetEnd(u64 v) {
     end = v;
-    protocol->Add(GetLastDiff());
+    diff = end - start;
+    protocol.Add(GetLastDiff());
   }
   /**
    * Getter for the End Time
@@ -190,33 +192,39 @@ class Res : public SmartCtor<Res> {
    * Get Last Diffrence between end and start
    * @return end - start
    */
-  u64 GetLastDiff() { return end - start; }
+  u64 GetLastDiff() { return diff; }
   /**
    * Get Protcol Reference
    * @return Protocol Ref
    */
-  TimeStats::Ref GetProtocol() { return protocol; }
+  TimeStats& GetProtocol() { return protocol; }
 
  private:
   /** Trace ID */
   std::string id;
   /** Start time */
-  u64 start;
+  u64 start = 0;
   /** End Time */
-  u64 end;
+  u64 end = 0;
+  /** Last Diff */
+  u64 diff = 0;
   /** Protocol */
-  TimeStats::Ref protocol;
+  TimeStats protocol;
 };
+using TraceMap = std::map<std::string, TT::Res>;
 /**
  * Begin a Trace
  * @param id Name of the Trace
  */
-void Beg(const std::string &id);
+PD_API void Beg(const std::string& id);
 /**
  * End a Trace
  * @param id Name of the Trace
  */
-void End(const std::string &id);
+PD_API void End(const std::string& id);
+PD_API TraceMap& GetTraceMap();
+PD_API TT::Res& GetTraceRef(const std::string& id);
+PD_API bool TraceExist(const std::string& id);
 /**
  * Collect Start end end of the trace by tracking
  * when the Scope object goes out of scope
@@ -238,18 +246,18 @@ class Scope {
    * Constructor requiring a Name for the Trace
    * @param id Name of the Trace
    */
-  Scope(const std::string &id) {
+  Scope(const std::string& id) {
-    this->id = id;
+    this->ID = id;
     Beg(id);
   }
   /**
    * Deconstructor getting the end time when going out of scope
    */
-  ~Scope() { End(id); }
+  ~Scope() { End(ID); }
 
  private:
   /** Trace Name/ID */
-  std::string id;
+  std::string ID;
 };
 }  // namespace TT
 }  // namespace PD

include/pd/core/tween.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,7 +23,11 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/vec.hpp>
+#include <pd/common.hpp>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
 namespace PD {
 /**
@@ -56,7 +60,7 @@ class Tween {
    * @param delta deltatime
    */
   void Update(float delta) {
-    time += delta / 1000.f;
+    time += delta * 0.001f;
     if (time > tend) {
       finished = true;
       time = tend;
@@ -146,11 +150,7 @@ class Tween {
     return *this;
   }
 
-  /**
+  T Get() const {
-   * Operator that returns the current value calculated
-   * by time and effect
-   */
-  operator T() {
     float t = 0.f;
     switch (effect) {
       case EaseInQuad:
@@ -162,10 +162,10 @@ class Tween {
         return -(end - start) * t * (t - 2) + start;
         break;
       case EaseInOutQuad:
-        t = time / (tend / 2);
+        t = time / (tend * 0.5f);
-        if (t < 1) return (end - start) / 2 * t * t + start;
+        if (t < 1) return (end - start) * 0.5f * t * t + start;
         t--;
-        return -(end - start) / 2 * (t * (t - 2) - 1) + start;
+        return -(end - start) * 0.5f * (t * (t - 2) - 1) + start;
         break;
       case EaseInCubic:
         t = time / tend;
@@ -177,20 +177,20 @@ class Tween {
         return (end - start) * (t * t * t + 1) + start;
         break;
       // case EaseInOutCubic:
-      //   t = time / (tend / 2);
+      //   t = time / (tend *0.5f);
-      //   if (t < 1) return (end - start) / 2 * t * t * t + start;
+      //   if (t < 1) return (end - start) *0.5f * t * t * t + start;
       //   t--;
-      //   return (end - start) / 2 * (t * t * t * 2) + start;
+      //   return (end - start) *0.5f * (t * t * t * 2) + start;
       //   break;
       case EaseInSine:
-        return -(end - start) * cos(time / tend * (M_PI / 2)) + (end - start) +
+        return -(end - start) * cos(time / tend * (M_PI * 0.5f)) +
-               start;
+               (end - start) + start;
         break;
       case EaseOutSine:
-        return (end - start) * sin(time / tend * (M_PI / 2)) + start;
+        return (end - start) * sin(time / tend * (M_PI * 0.5f)) + start;
         break;
       case EaseInOutSine:
-        return -(end - start) / 2 * (cos(M_PI * time / tend) - 1) + start;
+        return -(end - start) * 0.5f * (cos(M_PI * time / tend) - 1) + start;
         break;
 
       default:  // Linear
@@ -199,6 +199,12 @@ class Tween {
     }
   }
 
+  /**
+   * Operator that returns the current value calculated
+   * by time and effect
+   */
+  operator T() const { return Get(); }
+
  private:
   /** Animation Effect */
   Effect effect;

include/pd/core/u128.hpp

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

include/pd/core/vec.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,402 +23,37 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-// Why Creating this:
+#include <pd/common.hpp>
-// Cause using makes coding much better structured
+#include <pd/core/vec2.hpp>
-// and easy to use like in glsl or glm
+#include <pd/core/vec3.hpp>
+#include <pd/core/vec4.hpp>
 
-#include <pd/core/common.hpp>
+/** Define Formatters for C++ 20 */
 
-namespace PD {
+/**
-struct vec2 {
+ * WHY DOES MSVC ALWAYS NEED THESE EXTRA THINGS
-  // Init Funcs
+ */
-  vec2() {
+
-    v[0] = 0;
+template <typename T, typename CharT>
-    v[1] = 0;
+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);
   }
-  vec2(float x, float y) {
-    v[0] = x;
-    v[1] = y;
-  }
-  vec2(const vec2 &i) {
-    v[0] = i[0];
-    v[1] = i[1];
-  }
-  vec2(float i) {
-    v[0] = i;
-    v[1] = i;
-  }
-
-  // Operations
-  // Add
-  vec2 &operator+=(const vec2 &i) {
-    v[0] += i[0];
-    v[1] += i[1];
-    return *this;
-  }
-
-  vec2 &operator+=(const float &i) {
-    v[0] += i;
-    v[1] += i;
-    return *this;
-  }
-
-  vec2 operator+(const vec2 &i) const { return vec2(v[0] + i[0], v[1] + i[1]); }
-  vec2 operator+(const float &i) const { return vec2(v[0] + i, v[1] + i); }
-
-  // Sub
-  vec2 &operator-=(const vec2 &i) {
-    v[0] -= i[0];
-    v[1] -= i[1];
-    return *this;
-  }
-
-  vec2 &operator-=(const float &i) {
-    v[0] -= i;
-    v[1] -= i;
-    return *this;
-  }
-
-  vec2 operator-(const vec2 &i) const { return vec2(v[0] - i[0], v[1] - i[1]); }
-  vec2 operator-(const float &i) const { return vec2(v[0] - i, v[1] - i); }
-
-  // Mul
-  vec2 &operator*=(const vec2 &i) {
-    v[0] *= i[0];
-    v[1] *= i[1];
-    return *this;
-  }
-
-  vec2 &operator*=(const float &i) {
-    v[0] *= i;
-    v[1] *= i;
-    return *this;
-  }
-
-  vec2 operator*(const vec2 &i) const { return vec2(v[0] * i[0], v[1] * i[1]); }
-  vec2 operator*(const float &i) const { return vec2(v[0] * i, v[1] * i); }
-
-  // Div
-  vec2 &operator/=(const vec2 &i) {
-    v[0] /= i[0];
-    v[1] /= i[1];
-    return *this;
-  }
-
-  vec2 &operator/=(const float &i) {
-    v[0] /= i;
-    v[1] /= i;
-    return *this;
-  }
-
-  vec2 operator/(const vec2 &i) const { return vec2(v[0] / i[0], v[1] / i[1]); }
-  vec2 operator/(const float &i) const { return vec2(v[0] / i, v[1] / i); }
-
-  // Compare
-  bool operator==(const vec2 &in) const {
-    return v[0] == in[0] && v[1] == in[1];
-  }
-
-  bool operator!=(const vec2 &in) const {
-    // use the first comparefuncs result
-    // and swap it lol
-    return !(*this == in);
-  }
-
-  vec2 operator-() const { return vec2(-v[0], -v[1]); }
-  float operator[](int i) const { return v[i]; }
-  float &operator[](int i) { return v[i]; }
-
-  float len() const { return sqrt(sqlen()); }
-  float sqlen() const { return v[0] * v[0] + v[1] * v[1]; }
-
-  float x() const { return v[0]; }
-  float &x() { return v[0]; }
-  float y() const { return v[1]; }
-  float &y() { return v[1]; }
-  // Internal Values
-  float v[2];
 };
 
-struct vec3 {
+template <typename T, typename CharT>
-  // Init Funcs
+struct std::formatter<PD::vec3<T>, CharT> : std::formatter<T, CharT> {
-  vec3() {
+  template <typename FormatContext>
-    v[0] = 0.f;
+  auto format(const PD::vec3<T>& v, FormatContext& ctx) const {
-    v[1] = 0.f;
+    return std::format_to(ctx.out(), "{}, {}, {}", v.x, v.y, v.z);
-    v[2] = 0.f;
   }
-  vec3(float x, float y, float z) {
-    v[0] = x;
-    v[1] = y;
-    v[2] = z;
-  }
-  vec3(const vec3 &i) {
-    v[0] = i[0];
-    v[1] = i[1];
-    v[2] = i[2];
-  }
-  vec3(float i) {
-    v[0] = i;
-    v[1] = i;
-    v[2] = i;
-  }
-  //// PD REWRITE ADDITIONAL CONTENT ////
-  vec3(const vec2 &xy, float z) {
-    v[0] = xy[0];
-    v[1] = xy[1];
-    v[2] = z;
-  }
-  vec3(float x, const vec2 &yz) {
-    v[0] = x;
-    v[1] = yz[0];
-    v[2] = yz[1];
-  }
-
-  // Operations
-  // Add
-  vec3 &operator+=(const vec3 &i) {
-    v[0] += i[0];
-    v[1] += i[1];
-    v[2] += i[2];
-    return *this;
-  }
-
-  vec3 &operator+=(const float &i) {
-    v[0] += i;
-    v[1] += i;
-    v[2] += i;
-    return *this;
-  }
-
-  vec3 operator+(const vec3 &i) const {
-    return vec3(v[0] + i[0], v[1] + i[1], v[2] + i[2]);
-  }
-  vec3 operator+(const float &i) const {
-    return vec3(v[0] + i, v[1] + i, v[2] + i);
-  }
-
-  // Sub
-  vec3 &operator-=(const vec3 &i) {
-    v[0] -= i[0];
-    v[1] -= i[1];
-    v[2] -= i[2];
-    return *this;
-  }
-
-  vec3 &operator-=(const float &i) {
-    v[0] -= i;
-    v[1] -= i;
-    v[2] -= i;
-    return *this;
-  }
-
-  vec3 operator-(const vec3 &i) const {
-    return vec3(v[0] - i[0], v[1] - i[1], v[2] - i[2]);
-  }
-  vec3 operator-(const float &i) const {
-    return vec3(v[0] - i, v[1] - i, v[2] - i);
-  }
-
-  // Mul
-  vec3 &operator*=(const vec3 &i) {
-    v[0] *= i[0];
-    v[1] *= i[1];
-    v[2] *= i[2];
-    return *this;
-  }
-
-  vec3 &operator*=(const float &i) {
-    v[0] *= i;
-    v[1] *= i;
-    v[2] *= i;
-    return *this;
-  }
-
-  vec3 operator*(const vec3 &i) const {
-    return vec3(v[0] * i[0], v[1] * i[1], v[2] * i[2]);
-  }
-  vec3 operator*(const float &i) const {
-    return vec3(v[0] * i, v[1] * i, v[2] * i);
-  }
-
-  // Div
-  vec3 &operator/=(const vec3 &i) {
-    v[0] /= i[0];
-    v[1] /= i[1];
-    v[2] /= i[2];
-    return *this;
-  }
-
-  vec3 &operator/=(const float &i) {
-    v[0] /= i;
-    v[1] /= i;
-    v[2] /= i;
-    return *this;
-  }
-
-  vec3 operator/(const vec3 &i) const {
-    return vec3(v[0] / i[0], v[1] / i[1], v[2] / i[2]);
-  }
-  vec3 operator/(const float &i) const {
-    return vec3(v[0] / i, v[1] / i, v[2] / i);
-  }
-
-  // Compare
-  bool operator==(const vec3 &in) const {
-    return v[0] == in[0] && v[1] == in[1] && v[2] == v[2];
-  }
-
-  bool operator!=(const vec3 &in) const {
-    // use the first comparefuncs result
-    // and swap it lol
-    return !(*this == in);
-  }
-
-  // Base
-  vec3 operator-() const { return vec3(-v[0], -v[1], -v[2]); }
-  float operator[](int i) const { return v[i]; }
-  float &operator[](int i) { return v[i]; }
-
-  float len() const { return sqrt(sqlen()); }
-  float sqlen() const { return v[0] * v[0] + v[1] * v[1] + v[2] * v[2]; }
-
-  float x() const { return v[0]; }
-  float &x() { return v[0]; }
-  float y() const { return v[1]; }
-  float &y() { return v[1]; }
-  float z() const { return v[2]; }
-  float &z() { return v[2]; }
-
-  //// PALLADIUM REWRITE ADDITIONAL CONTENT ////
-  vec2 xy() const { return vec2(v[0], v[1]); }
-  vec2 yz() const { return vec2(v[1], v[2]); }
-
-  float v[3];
 };
 
-struct vec4 {
+template <typename T, typename CharT>
-  // Init Funcs
+struct std::formatter<PD::vec4<T>, CharT> : std::formatter<T, CharT> {
-  vec4() {
+  template <typename FormatContext>
-    v[0] = 0.f;
+  auto format(const PD::vec4<T>& v, FormatContext& ctx) const {
-    v[1] = 0.f;
+    return std::format_to(ctx.out(), "{}, {}, {}, {}", v.x, v.y, v.z, v.w);
-    v[2] = 0.f;
-    v[3] = 0.f;
   }
-  vec4(float x, float y, float z, float w) {
-    v[0] = x;
-    v[1] = y;
-    v[2] = z;
-    v[3] = w;
-  }
-  vec4(const vec4 &i) {
-    v[0] = i[0];
-    v[1] = i[1];
-    v[2] = i[2];
-    v[3] = i[3];
-  }
-
-  vec4(const vec2 &i0, const vec2 &i1) {
-    v[0] = i0[0];
-    v[1] = i0[1];
-    v[2] = i1[0];
-    v[3] = i1[1];
-  }
-  vec4(float i) {
-    v[0] = i;
-    v[1] = i;
-    v[2] = i;
-    v[3] = i;
-  }
-
-  vec4(const vec3 &xyz, float w) {
-    v[0] = xyz[0];
-    v[1] = xyz[1];
-    v[2] = xyz[2];
-    v[3] = w;
-  }
-
-  vec4(float x, const vec3 &yzw) {
-    v[0] = x;
-    v[1] = yzw[1];
-    v[2] = yzw[2];
-    v[3] = yzw[3];
-  }
-
-  // Operators
-  // Add
-  vec4 &operator+=(const vec4 &i) {
-    v[0] += i[0];
-    v[1] += i[1];
-    v[2] += i[2];
-    v[3] += i[3];
-    return *this;
-  }
-
-  vec4 operator+(const vec4 &i) const {
-    return vec4(v[0] + i[0], v[1] + i[1], v[2] + i[2], v[3] + i[3]);
-  }
-
-  // Sub
-  vec4 &operator-=(const vec4 &i) {
-    v[0] -= i[0];
-    v[1] -= i[1];
-    v[2] -= i[2];
-    v[3] -= i[3];
-    return *this;
-  }
-
-  vec4 operator-(const vec4 &i) const {
-    return vec4(v[0] - i[0], v[1] - i[1], v[2] - i[2], v[3] - i[3]);
-  }
-
-  // Compare
-  bool operator==(const vec4 &in) const {
-    return v[0] == in[0] && v[1] == in[1] && v[2] == in[2] && v[3] == in[3];
-  }
-
-  bool operator!=(const vec4 &in) const {
-    // use the first comparefuncs result
-    // and swap it lol
-    return !(*this == in);
-  }
-
-  // Base
-  vec4 operator-() const { return vec4(-v[0], -v[1], -v[2], -v[3]); }
-  float operator[](int i) const { return v[i]; }
-  float &operator[](int i) { return v[i]; }
-
-  float len() const { return sqrt(sqlen()); }
-  float sqlen() const {
-    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
-  }
-
-  // Vec Acess
-  float x() const { return v[0]; }
-  float &x() { return v[0]; }
-  float y() const { return v[1]; }
-  float &y() { return v[1]; }
-  float z() const { return v[2]; }
-  float &z() { return v[2]; }
-  float w() const { return v[3]; }
-  float &w() { return v[3]; }
-  vec2 xy() const { return vec2(v[0], v[1]); }
-  vec2 zw() const { return vec2(v[2], v[3]); }
-  vec3 xyz() const { return vec3(v[0], v[1], v[2]); }
-  vec3 yzw() const { return vec3(v[1], v[2], v[3]); }
-  // Quaternion Acess
-  float r() const { return v[0]; }
-  float &r() { return v[0]; }
-  float k() const { return v[1]; }
-  float &k() { return v[1]; }
-  float j() const { return v[2]; }
-  float &j() { return v[2]; }
-  float i() const { return v[3]; }
-  float &i() { return v[3]; }
-  vec2 rk() const { return vec2(v[0], v[1]); }
-  vec2 ji() const { return vec2(v[2], v[3]); }
-  vec3 rkj() const { return vec3(v[0], v[1], v[2]); }
-  vec3 kji() const { return vec3(v[1], v[2], v[3]); }
-  // Internal Values
-  float v[4];
 };
-}  // namespace PD

include/pd/core/vec2.hpp

@@ -0,0 +1,197 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+// This file is generated by lazyvec 2.1.0
+
+#include <pd/common.hpp>
+
+namespace PD {
+template <typename T>
+class vec2 {
+ public:
+  T x;
+  T y;
+
+  // Constructors
+
+  constexpr vec2() : x(0), y(0) {}
+  template <typename T1>
+  constexpr vec2(T1 v) {
+    x = (T)v;
+    y = (T)v;
+  }
+
+  template <typename T1>
+  constexpr vec2(const vec2<T1>& v) {
+    x = (T)v.x;
+    y = (T)v.y;
+  }
+
+  constexpr explicit vec2(T x, T y) : x(x), y(y) {}
+
+  // Operations
+
+  template <typename T1>
+  constexpr vec2<T>& operator+=(T1 v) {
+    x += (T)v;
+    y += (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T>& operator+=(const vec2<T1>& v) {
+    x += (T)v.x;
+    y += (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator+(T1 v) const {
+    return vec2<T>(x + (T)v, y + (T)v);
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator+(const vec2<T1>& v) const {
+    return vec2<T>(x + (T)v.x, y + (T)v.y);
+  }
+
+  template <typename T1>
+  constexpr vec2<T>& operator-=(T1 v) {
+    x -= (T)v;
+    y -= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T>& operator-=(const vec2<T1>& v) {
+    x -= (T)v.x;
+    y -= (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator-(T1 v) const {
+    return vec2<T>(x - (T)v, y - (T)v);
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator-(const vec2<T1>& v) const {
+    return vec2<T>(x - (T)v.x, y - (T)v.y);
+  }
+
+  template <typename T1>
+  constexpr vec2<T>& operator*=(T1 v) {
+    x *= (T)v;
+    y *= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T>& operator*=(const vec2<T1>& v) {
+    x *= (T)v.x;
+    y *= (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator*(T1 v) const {
+    return vec2<T>(x * (T)v, y * (T)v);
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator*(const vec2<T1>& v) const {
+    return vec2<T>(x * (T)v.x, y * (T)v.y);
+  }
+
+  template <typename T1>
+  constexpr vec2<T>& operator/=(T1 v) {
+    x /= (T)v;
+    y /= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T>& operator/=(const vec2<T1>& v) {
+    x /= (T)v.x;
+    y /= (T)v.y;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator/(T1 v) const {
+    return vec2<T>(x / (T)v, y / (T)v);
+  }
+
+  template <typename T1>
+  constexpr vec2<T> operator/(const vec2<T1>& v) const {
+    return vec2<T>(x / (T)v.x, y / (T)v.y);
+  }
+
+  // Generic Operations
+
+  constexpr vec2 operator-() const { return vec2(-x, -y); }
+  template <typename T1>
+  constexpr bool operator==(const vec2<T1>& v) const {
+    return x == (T)v.x && y == (T)v.y;
+  }
+  template <typename T1>
+  constexpr bool operator!=(const vec2<T1>& v) const {
+    return !(*this == v);
+  }
+
+  // Functions
+
+  double Len() const { return std::sqrt(SqLen()); }
+  constexpr double SqLen() const { return x * x + y * y; }
+
+  template <typename T1>
+  double Distance(const vec2<T1>& v) const {
+    return (*this - v).Len();
+  }
+
+  vec2<T> Normalize() const {
+    double l = Len();
+    if (l == 0) {
+      return *this;
+    }
+    return *this / (T)l;
+  }
+
+  template <typename T1>
+  constexpr T Dot(const vec2<T1>& v) const {
+    return x * (T)v.x + y * (T)v.y;
+  }
+
+  // Swap Functions
+  constexpr void SwapXY() {
+    T t = x;
+    x = y;
+    y = t;
+  }
+};
+using fvec2 = vec2<float>;
+using ivec2 = vec2<int>;
+using dvec2 = vec2<double>;
+}  // namespace PD

include/pd/core/vec3.hpp

@@ -0,0 +1,235 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+// This file is generated by lazyvec 2.1.0
+
+#include <pd/common.hpp>
+// Extended includes (rename if you use other filenames/paths)
+#include <pd/core/vec2.hpp>
+
+namespace PD {
+template <typename T>
+class vec3 {
+ public:
+  T x;
+  T y;
+  T z;
+
+  // Constructors
+
+  constexpr vec3() : x(0), y(0), z(0) {}
+  template <typename T1>
+  constexpr vec3(T1 v) {
+    x = (T)v;
+    y = (T)v;
+    z = (T)v;
+  }
+
+  template <typename T1>
+  constexpr vec3(const vec3<T1>& v) {
+    x = (T)v.x;
+    y = (T)v.y;
+    z = (T)v.z;
+  }
+
+  constexpr explicit vec3(T x, T y, T z) : x(x), y(y), z(z) {}
+
+  // Extended Constructors
+  template <typename T1>
+  constexpr explicit vec3(const vec2<T1>& xy, T1 z) {
+    {
+      x = (T)xy.x;
+      y = (T)xy.y;
+      this->z = (T)z;
+    }
+  }
+
+  // Operations
+
+  template <typename T1>
+  constexpr vec3<T>& operator+=(T1 v) {
+    x += (T)v;
+    y += (T)v;
+    z += (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T>& operator+=(const vec3<T1>& v) {
+    x += (T)v.x;
+    y += (T)v.y;
+    z += (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T> operator+(T1 v) const {
+    return vec3<T>(x + (T)v, y + (T)v, z + (T)v);
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec3<T>& operator-=(T1 v) {
+    x -= (T)v;
+    y -= (T)v;
+    z -= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T>& operator-=(const vec3<T1>& v) {
+    x -= (T)v.x;
+    y -= (T)v.y;
+    z -= (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T> operator-(T1 v) const {
+    return vec3<T>(x - (T)v, y - (T)v, z - (T)v);
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec3<T>& operator*=(T1 v) {
+    x *= (T)v;
+    y *= (T)v;
+    z *= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T>& operator*=(const vec3<T1>& v) {
+    x *= (T)v.x;
+    y *= (T)v.y;
+    z *= (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T> operator*(T1 v) const {
+    return vec3<T>(x * (T)v, y * (T)v, z * (T)v);
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec3<T>& operator/=(T1 v) {
+    x /= (T)v;
+    y /= (T)v;
+    z /= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T>& operator/=(const vec3<T1>& v) {
+    x /= (T)v.x;
+    y /= (T)v.y;
+    z /= (T)v.z;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr vec3<T> operator/(T1 v) const {
+    return vec3<T>(x / (T)v, y / (T)v, z / (T)v);
+  }
+
+  template <typename T1>
+  constexpr vec3<T> operator/(const vec3<T1>& v) const {
+    return vec3<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z);
+  }
+
+  // Generic Operations
+
+  constexpr vec3 operator-() const { return vec3(-x, -y, -z); }
+  template <typename T1>
+  constexpr bool operator==(const vec3<T1>& v) const {
+    return x == (T)v.x && y == (T)v.y && z == (T)v.z;
+  }
+  template <typename T1>
+  constexpr bool operator!=(const vec3<T1>& v) const {
+    return !(*this == v);
+  }
+
+  // Functions
+
+  double Len() const { return std::sqrt(SqLen()); }
+  constexpr double SqLen() const { return x * x + y * y + z * z; }
+
+  template <typename T1>
+  double Distance(const vec3<T1>& v) const {
+    return (*this - v).Len();
+  }
+
+  vec3<T> Normalize() const {
+    double l = Len();
+    if (l == 0) {
+      return *this;
+    }
+    return *this / (T)l;
+  }
+
+  template <typename T1>
+  constexpr T Dot(const vec3<T1>& v) const {
+    return x * (T)v.x + y * (T)v.y + z * (T)v.z;
+  }
+
+  template <typename T1>
+  constexpr vec3<T> Cross(const vec3<T1>& v) const {
+    return vec3<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
+  }
+
+  // Swap Functions
+  constexpr void SwapXY() {
+    T t = x;
+    x = y;
+    y = t;
+  }
+  constexpr void SwapXZ() {
+    T t = x;
+    x = z;
+    z = t;
+  }
+  constexpr void SwapYZ() {
+    T t = y;
+    y = z;
+    z = t;
+  }
+};
+using fvec3 = vec3<float>;
+using ivec3 = vec3<int>;
+using dvec3 = vec3<double>;
+}  // namespace PD

include/pd/core/vec4.hpp

@@ -0,0 +1,268 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+// This file is generated by lazyvec 2.1.0
+
+#include <pd/common.hpp>
+// Extended includes (rename if you use other filenames/paths)
+#include <pd/core/vec2.hpp>
+#include <pd/core/vec3.hpp>
+
+namespace PD {
+template <typename T>
+class vec4 {
+ public:
+  T x;
+  T y;
+  T z;
+  T w;
+
+  // Constructors
+
+  constexpr vec4() : x(0), y(0), z(0), w(0) {}
+  template <typename T1>
+  constexpr vec4(T1 v) {
+    x = (T)v;
+    y = (T)v;
+    z = (T)v;
+    w = (T)v;
+  }
+
+  template <typename T1>
+  constexpr vec4(const vec4<T1>& v) {
+    x = (T)v.x;
+    y = (T)v.y;
+    z = (T)v.z;
+    w = (T)v.w;
+  }
+
+  constexpr explicit vec4(T x, T y, T z, T w) : x(x), y(y), z(z), w(w) {}
+
+  // Extended Constructors
+  template <typename T1>
+  constexpr explicit vec4(const vec2<T1>& xy, const vec2<T1>& zw) {
+    {
+      x = (T)xy.x;
+      y = (T)xy.y;
+      z = (T)zw.x;
+      w = (T)zw.y;
+    }
+  }
+
+  template <typename T1>
+  constexpr explicit vec4(const vec3<T1>& xyz, T1 w) {
+    {
+      x = (T)xyz.x;
+      y = (T)xyz.y;
+      z = (T)xyz.z;
+      this->w = (T)w;
+    }
+  }
+
+  // Operations
+
+  template <typename T1>
+  constexpr vec4<T>& operator+=(T1 v) {
+    x += (T)v;
+    y += (T)v;
+    z += (T)v;
+    w += (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec4<T> operator+(T1 v) const {
+    return vec4<T>(x + (T)v, y + (T)v, z + (T)v, w + (T)v);
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec4<T>& operator-=(T1 v) {
+    x -= (T)v;
+    y -= (T)v;
+    z -= (T)v;
+    w -= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec4<T> operator-(T1 v) const {
+    return vec4<T>(x - (T)v, y - (T)v, z - (T)v, w - (T)v);
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec4<T>& operator*=(T1 v) {
+    x *= (T)v;
+    y *= (T)v;
+    z *= (T)v;
+    w *= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec4<T> operator*(T1 v) const {
+    return vec4<T>(x * (T)v, y * (T)v, z * (T)v, w * (T)v);
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec4<T>& operator/=(T1 v) {
+    x /= (T)v;
+    y /= (T)v;
+    z /= (T)v;
+    w /= (T)v;
+    return *this;
+  }
+
+  template <typename T1>
+  constexpr 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>
+  constexpr vec4<T> operator/(T1 v) const {
+    return vec4<T>(x / (T)v, y / (T)v, z / (T)v, w / (T)v);
+  }
+
+  template <typename T1>
+  constexpr vec4<T> operator/(const vec4<T1>& v) const {
+    return vec4<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z, w / (T)v.w);
+  }
+
+  // Generic Operations
+
+  constexpr vec4 operator-() const { return vec4(-x, -y, -z, -w); }
+  template <typename T1>
+  constexpr bool operator==(const vec4<T1>& v) const {
+    return x == (T)v.x && y == (T)v.y && z == (T)v.z && w == (T)v.w;
+  }
+  template <typename T1>
+  constexpr bool operator!=(const vec4<T1>& v) const {
+    return !(*this == v);
+  }
+
+  // Functions
+
+  double Len() const { return std::sqrt(SqLen()); }
+  constexpr double SqLen() const { return x * x + y * y + z * z + w * w; }
+
+  template <typename T1>
+  double Distance(const vec4<T1>& v) const {
+    return (*this - v).Len();
+  }
+
+  vec4<T> Normalize() const {
+    double l = Len();
+    if (l == 0) {
+      return *this;
+    }
+    return *this / (T)l;
+  }
+
+  template <typename T1>
+  constexpr T Dot(const vec4<T1>& v) const {
+    return x * (T)v.x + y * (T)v.y + z * (T)v.z + w * (T)v.w;
+  }
+
+  // Swap Functions
+  constexpr void SwapXY() {
+    T t = x;
+    x = y;
+    y = t;
+  }
+  constexpr void SwapXZ() {
+    T t = x;
+    x = z;
+    z = t;
+  }
+  constexpr void SwapXW() {
+    T t = x;
+    x = w;
+    w = t;
+  }
+  constexpr void SwapYZ() {
+    T t = y;
+    y = z;
+    z = t;
+  }
+  constexpr void SwapYW() {
+    T t = y;
+    y = w;
+    w = t;
+  }
+  constexpr void SwapZW() {
+    T t = z;
+    z = w;
+    w = t;
+  }
+};
+using fvec4 = vec4<float>;
+using ivec4 = vec4<int>;
+using dvec4 = vec4<double>;
+}  // namespace PD

include/pd/drivers/drivers.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <pd/drivers/gfx.hpp>
+#include <pd/drivers/hid.hpp>
+#include <pd/drivers/os.hpp>

include/pd/drivers/gfx.hpp

@@ -0,0 +1,313 @@
+#pragma once
+
+#include <pd/core/mat.hpp>
+#include <pd/drivers/interface.hpp>
+#include <pd/lithium/drawlist.hpp>
+#include <pd/lithium/pools.hpp>
+#include <pd/lithium/texture.hpp>
+
+using PDGfxBackendFlags = PD::u32;
+enum PDGfxBackendFlags_ {
+  PDGfxBackendFlags_None = 0,
+  PDGfxBackendFlags_FlipUV_Y = 1 << 0,   // Essential for font loading
+  PDGfxBackendFlags_WindingCW = 1 << 0,  // Use CW instead of CCW winding
+};
+
+namespace PD {
+
+// Pre interface class
+class PD_API GfxDriver : public DriverInterface {
+ public:
+  GfxDriver(std::string_view name);
+  virtual ~GfxDriver();
+
+  virtual void Init() {}
+  virtual void Deinit() {
+    DeleteTexture(pWhite);
+    SysDeinit();
+  }
+
+  void SetViewPort(const ivec2& size);
+  void SetViewPort(int x, int y);
+  virtual void BindTexture(TextureID id) {}
+  void Reset();
+  virtual Li::Texture LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      TextureFormat type = TextureFormat::RGBA32,
+      TextureFilter filter = TextureFilter::Linear) {
+    return Li::Texture();
+  }
+  virtual void DeleteTexture(const Li::Texture& tex) {}
+  virtual void Draw(const Li::Drawlist& commands) {}
+  Li::Texture::Ptr GetWhiteTexture() { return &pWhite; }
+  PDGfxBackendFlags GetFlags() { return Flags; }
+
+  size_t GetNumVertices() const { return CountVertices; }
+  size_t GetNumIndices() const { return CountIndices; }
+  size_t GetNumDrawcalls() const { return CountDrawcalls; }
+  size_t GetNumCommands() const { return CountCommands; }
+
+  // Global Pool Interface
+  virtual size_t AllocateVertices(size_t count, PD::ptr accessor) = 0;
+  virtual size_t AllocateIndices(size_t count, PD::ptr accessor) = 0;
+  virtual bool ExpandVertices(size_t count, PD::ptr accessor) = 0;
+  virtual bool ExpandIndices(size_t count, PD::ptr accessor) = 0;
+  virtual void PutVertex(size_t loc, const Li::Vertex& vtx,
+                         PD::ptr accessor) = 0;
+  virtual void PutIndex(size_t loc, u16 idx, PD::ptr accessor) = 0;
+  virtual const Li::Vertex& GetVertex(size_t loc) const = 0;
+  virtual const u16& GetIndex(size_t loc) const = 0;
+  virtual void ResetPools() = 0;
+
+ protected:
+  virtual void SysDeinit() {}
+  virtual void SysInit() {}
+  virtual void SysReset() {}
+  virtual void Submit(size_t count, size_t start) {}
+  virtual void UploadPools() {}  // not every driver requires it
+  void RegisterTexture(const Li::Texture& tex);
+  void UnregisterTexture(const Li::Texture& tex);
+
+  // Counters
+  size_t CountDrawcalls = 0;
+  size_t CountCommands = 0;
+  size_t CountVertices = 0;
+  size_t CountIndices = 0;
+  size_t CurrentIndex = 0;
+  size_t CurrentVertex = 0;
+  size_t pCountDrawcalls = 0;
+  size_t pCountCommands = 0;
+  // State Variables oder so
+  TextureID CurrentTex = 0;
+  bool CurrentTexIsSDF = false;
+  Mat4 Projection;
+  ivec2 ViewPort;
+  std::unordered_map<TextureID, Li::Texture> pTextureRegestry;
+  Li::Texture pWhite;
+  PDGfxBackendFlags Flags = 0;
+};
+
+struct DefaultGfxConfig {
+  // Vertex Allocator
+  template <typename T>
+  using VertexAlloc = std::allocator<T>;
+  // Index Allocator
+  template <typename T>
+  using IndexAlloc = std::allocator<T>;
+};
+
+template <typename Config = DefaultGfxConfig>
+class GfxDriverBase : public GfxDriver {
+ public:
+  using VtxPool =
+      Pool<Li::Vertex, typename Config::template VertexAlloc<Li::Vertex>>;
+  using IdxPool = Pool<u16, typename Config::template VertexAlloc<u16>>;
+  GfxDriverBase(std::string_view name = "Default") : GfxDriver(name) {}
+  virtual ~GfxDriverBase() {}
+
+  void Init() override {
+    SysInit();
+    std::vector<u8> img(16 * 16 * 4, 0xff);
+    pWhite = LoadTexture(img, 16, 16);
+  }
+
+  void Draw(const Li::Drawlist& dl) override {
+    const auto& commands = dl.Data();
+    if (commands.size() == 0) return;
+    pCountCommands += commands.size();
+
+    size_t vtotal = dl.GetNumVertices();
+    size_t itotal = dl.GetNumIndices();
+
+    size_t start_vtx = pVtxPool.size();
+    pVtxPool.Allocate(vtotal);
+    CurrentVertex += vtotal;
+
+    size_t start_idx = pIdxPool.size();
+    pIdxPool.Allocate(itotal);
+    CurrentIndex += itotal;
+
+    size_t current_vtx = start_vtx;
+    size_t current_idx = start_idx;
+
+    const auto& vpool = Li::GetVertexPool();
+    const auto& ipool = Li::GetIndexPool();
+    /** Build Pools */
+    for (size_t i = 0; i < commands.size(); i++) {
+      const auto& cmd = commands[i];
+      if (cmd.VertexCount > 0) {
+        std::memcpy(pVtxPool.begin() + current_vtx,
+                    vpool.begin() + cmd.FirstVertex,
+                    cmd.VertexCount * sizeof(Li::Vertex));
+      }
+      for (size_t idx = 0; idx < cmd.IndexCount; idx++) {
+        u16 local_idx = ipool[cmd.FirstIndex + idx];
+        pIdxPool[current_idx + idx] = static_cast<u16>(current_vtx + local_idx);
+      }
+      current_vtx += cmd.VertexCount;
+      current_idx += cmd.IndexCount;
+    }
+
+    UploadPools();
+
+    size_t index = 0;
+    size_t ioff = start_idx;
+
+    while (index < commands.size()) {
+      CurrentTex = commands[index].Tex;
+      CurrentTexIsSDF = commands[index].SDF;
+      if (!CurrentTex) {
+        CurrentTex = pWhite.GetID();
+      }
+      size_t num_indices = 0;
+      while (index < commands.size() &&
+             CurrentTexIsSDF == commands[index].SDF &&
+             (CurrentTex == commands[index].Tex ||
+              (CurrentTex == pWhite.GetID() && commands[index].Tex == 0))) {
+        num_indices += commands[index].IndexCount;
+        index++;
+      }
+      if (num_indices > 0) {
+        Submit(num_indices, ioff);
+        ioff += num_indices;
+        pCountDrawcalls++;
+      }
+    }
+  }
+
+  size_t AllocateVertices(size_t count, PD::ptr accessor) override {
+    pVertexAccessor = accessor;
+    size_t loc = pVtxPool.size();
+    pVtxPool.Allocate(count);
+    return loc;
+  }
+
+  size_t AllocateIndices(size_t count, PD::ptr accessor) override {
+    pIndexAccessor = accessor;
+    size_t loc = pIdxPool.size();
+    pIdxPool.Allocate(count);
+    return loc;
+  }
+
+  bool ExpandVertices(size_t count, PD::ptr accessor) override {
+    if (pVertexAccessor != accessor) return false;
+    pVtxPool.Allocate(count);
+    return true;
+  }
+
+  bool ExpandIndices(size_t count, PD::ptr accessor) override {
+    if (pIndexAccessor != accessor) return false;
+    pIdxPool.Allocate(count);
+    return true;
+  }
+
+  void PutVertex(size_t loc, const Li::Vertex& vtx, PD::ptr accessor) override {
+    if (pVertexAccessor != accessor) return;
+    pVtxPool.Put(loc, vtx);
+  }
+
+  void PutIndex(size_t loc, u16 idx, PD::ptr accessor) override {
+    if (pIndexAccessor != accessor) return;
+    pIdxPool.Put(loc, idx);
+  }
+
+  const Li::Vertex& GetVertex(size_t loc) const override {
+    return pVtxPool[loc];
+  }
+
+  const u16& GetIndex(size_t loc) const override { return pIdxPool[loc]; }
+
+  void ResetPools() override {
+    pVtxPool.NoReset();
+    pIdxPool.NoReset();
+  }
+
+ protected:
+  u16* GetIndexBufPtr(size_t start) { return &pIdxPool[start]; }
+  Li::Vertex* GetVertexBufPtr(size_t start) { return &pVtxPool[start]; }
+  size_t GetVertexPoolSize() const { return pVtxPool.size(); }
+  size_t GetIndexPoolSize() const { return pIdxPool.size(); }
+
+ private:
+  VtxPool pVtxPool;
+  IdxPool pIdxPool;
+  PD::ptr pVertexAccessor = 0;
+  PD::ptr pIndexAccessor = 0;
+};
+
+class PD_API Gfx {
+ public:
+  Gfx() = default;
+  ~Gfx() = default;
+
+  template <typename T, typename... Args>
+  static void UseDriver(Args&&... args) {
+    // assert(driver == nullptr && "OS Driver already set");
+    driver = std::make_unique<T>(std::forward<Args>(args)...);
+  }
+
+  static void Init() { driver->Init(); }
+  static void Deinit() { driver->Deinit(); }
+  static void SetViewPort(const ivec2& vp) { driver->SetViewPort(vp); }
+  static void SetViewPort(int w, int h) { driver->SetViewPort(w, h); }
+  static void Reset() { driver->Reset(); }
+  static void Draw(const Li::Drawlist& dl) { driver->Draw(dl); }
+  static Li::Texture LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                 int h,
+                                 TextureFormat type = TextureFormat::RGBA32,
+                                 TextureFilter filter = TextureFilter::Linear) {
+    return driver->LoadTexture(pixels, w, h, type, filter);
+  }
+  static void DeleteTexture(const Li::Texture& tex) {
+    driver->DeleteTexture(tex);
+  }
+  static Li::Texture::Ptr GetWhiteTexture() {
+    return driver->GetWhiteTexture();
+  }
+
+  static PDGfxBackendFlags GetFlags() { return driver->GetFlags(); }
+
+  static const char* GetDriverName() { return driver->GetName(); }
+
+  static size_t GetNumVertices() { return driver->GetNumVertices(); }
+  static size_t GetNumIndices() { return driver->GetNumIndices(); }
+  static size_t GetNumDrawcalls() { return driver->GetNumDrawcalls(); }
+  static size_t GetNumCommands() { return driver->GetNumCommands(); }
+
+  // Gloabal Pool Interface
+  static size_t AllocateVertices(size_t count, PD::ptr accessor) {
+    return driver->AllocateVertices(count, accessor);
+  }
+
+  static size_t AllocateIndices(size_t count, PD::ptr accessor) {
+    return driver->AllocateIndices(count, accessor);
+  }
+
+  static bool ExpandVertices(size_t count, PD::ptr accessor) {
+    return driver->ExpandVertices(count, accessor);
+  }
+
+  static bool ExpandIndices(size_t count, PD::ptr accessor) {
+    return driver->ExpandIndices(count, accessor);
+  }
+
+  static void PutVertex(size_t loc, const Li::Vertex& vtx, PD::ptr accessor) {
+    driver->PutVertex(loc, vtx, accessor);
+  }
+
+  static void PutIndex(size_t loc, u16 idx, PD::ptr accessor) {
+    driver->PutIndex(loc, idx, accessor);
+  }
+
+  static const Li::Vertex& GetVertex(size_t loc) {
+    return driver->GetVertex(loc);
+  }
+
+  static const u16& GetIndex(size_t loc) { return driver->GetIndex(loc); }
+
+  static void NewFrame() { driver->ResetPools(); }
+
+ private:
+  static std::unique_ptr<GfxDriver> driver;
+};
+}  // namespace PD

include/pd/drivers/hid.hpp

@@ -1,38 +1,80 @@
 #pragma once
 
-/*
+#include <pd/core/core.hpp>
-MIT License
+#include <pd/drivers/interface.hpp>
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+using PDHidBackendFlags = PD::u32;
-of this software and associated documentation files (the "Software"), to deal
+enum PDHidBackendFlags_ {
-in the Software without restriction, including without limitation the rights
+  PDHidBackendFlags_None = 0,
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  PDHidBackendFlags_HasTouch = 1 << 1,
-copies of the Software, and to permit persons to whom the Software is
+  PDHidBackendFlags_HasGamepad = 1 << 2,
-furnished to do so, subject to the following conditions:
+  PDHidBackendFlags_HasMouse = 1 << 3,
-
+  PDHidBackendFlags_HasKeyboard = 1 << 4,
-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/vec.hpp>
 
 namespace PD {
-/** Input Driver Template class */
+namespace HidInternal {
-class Hid : public SmartCtor<Hid> {
+class Keyboard {
  public:
-  /** Key [Controller] */
+  Keyboard() = default;
-  enum Key : u32 {
+  virtual ~Keyboard() = default;
-    No = 0,                    ///< No Key
+  using Key = u128;
+  constexpr static Key No = 0;
+  constexpr static Key Escape = Key::Flag(0);
+  constexpr static Key Q = Key::Flag(1);
+  constexpr static Key W = Key::Flag(2);
+  constexpr static Key E = Key::Flag(3);
+  constexpr static Key R = Key::Flag(4);
+  constexpr static Key T = Key::Flag(5);
+  constexpr static Key Z = Key::Flag(6);
+  constexpr static Key U = Key::Flag(7);
+  constexpr static Key I = Key::Flag(8);
+  constexpr static Key O = Key::Flag(9);
+  constexpr static Key P = Key::Flag(10);
+  constexpr static Key A = Key::Flag(11);
+  constexpr static Key S = Key::Flag(12);
+  constexpr static Key D = Key::Flag(13);
+  constexpr static Key F = Key::Flag(14);
+  constexpr static Key G = Key::Flag(15);
+  constexpr static Key H = Key::Flag(16);
+  constexpr static Key J = Key::Flag(17);
+  constexpr static Key K = Key::Flag(18);
+  constexpr static Key L = Key::Flag(19);
+  constexpr static Key Y = Key::Flag(20);
+  constexpr static Key X = Key::Flag(21);
+  constexpr static Key C = Key::Flag(22);
+  constexpr static Key V = Key::Flag(23);
+  constexpr static Key B = Key::Flag(24);
+  constexpr static Key N = Key::Flag(25);
+  constexpr static Key M = Key::Flag(26);
+  constexpr static Key _1 = Key::Flag(27);
+  constexpr static Key _2 = Key::Flag(28);
+  constexpr static Key _3 = Key::Flag(29);
+  constexpr static Key _4 = Key::Flag(30);
+  constexpr static Key _5 = Key::Flag(31);
+  constexpr static Key _6 = Key::Flag(32);
+  constexpr static Key _7 = Key::Flag(33);
+  constexpr static Key _8 = Key::Flag(34);
+  constexpr static Key _9 = Key::Flag(35);
+  constexpr static Key _0 = Key::Flag(36);
+  constexpr static Key F1 = Key::Flag(37);
+  constexpr static Key F2 = Key::Flag(38);
+  constexpr static Key F3 = Key::Flag(39);
+  constexpr static Key F4 = Key::Flag(40);
+  constexpr static Key F5 = Key::Flag(41);
+  constexpr static Key F6 = Key::Flag(42);
+  constexpr static Key F7 = Key::Flag(43);
+  constexpr static Key F8 = Key::Flag(44);
+  constexpr static Key F9 = Key::Flag(45);
+  constexpr static Key F10 = Key::Flag(46);
+  constexpr static Key F11 = Key::Flag(47);
+  constexpr static Key F12 = Key::Flag(48);
+  constexpr static Key MouseLeft = Key::Flag(120);
+};
+
+using GamepadKey = u32;
+enum Gamepad : GamepadKey {
+  None = 0,                  ///< No Key
   A = 1 << 0,                ///< A
   B = 1 << 1,                ///< B
   X = 1 << 2,                ///< X
@@ -56,117 +98,86 @@ class Hid : public SmartCtor<Hid> {
   ZL = 1 << 20,              ///< ZL
   ZR = 1 << 21,              ///< ZR
   Touch = 1 << 22,           ///< Touch
+  LStick = 1 << 23,          ///< Left Stick
+  RStick = 1 << 24,          ///< Right Stick
   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
+};
+}  // namespace HidInternal
+// Pre interface class
+class PD_API HidDriver : public DriverInterface {
+ public:
+  enum class Event {
+    Null,  ///< Nothing happended
+    Down,  ///< Key Pressed
+    Held,  ///< Key held
+    Up,    ///< Key released
   };
-  /** Event */
+  HidDriver(std::string_view name = "HidNull");
-  enum Event {
+  virtual ~HidDriver();
-    Event_Down,  ///< Key Pressed
+
-    Event_Held,  ///< Key Held
+  virtual void Init() {}
-    Event_Up,    ///< Key released
+  virtual void Deinit() {}
-  };
+  virtual const fvec2& MousePos() const { return pMouse[0]; }
+  virtual const fvec2& MousePosLast() const { return pMouse[1]; }
+  virtual const fvec2& TouchPos() const { return pMouse[0]; }
+  virtual const fvec2& TouchPosLast() const { return pMouse[1]; }
+  virtual void Update();
+  virtual bool IsEvent(Event e, HidInternal::GamepadKey keys);
+  virtual bool IsEvent(Event e, HidInternal::Keyboard::Key keys);
+  virtual const fvec2& GetLeftStick() const { return pLStick[0]; }
+  virtual const fvec2& GetRightStick() const { return pRStick[0]; }
+
+  PDHidBackendFlags GetFlags() const { return pFlags; }
+
+ protected:
+  void SwapTab();
+  PDHidBackendFlags pFlags = PDHidBackendFlags_None;
+  fvec2 pMouse[2];  // Current And last pos
+  fvec2 pLStick[2];
+  fvec2 pRStick[2];
+  std::unordered_map<u32, u32> pGamepad;
+  std::unordered_map<u128, u128> pKeyboard;
+  std::unordered_map<Event, u32> pGamepadEvents[2];
+  std::unordered_map<Event, u128> pKeyboardEvents[2];
+};
+
+class PD_API Hid {
+ public:
+  using Gamepad = HidInternal::Gamepad;
+  using Keyboard = HidInternal::Keyboard;
+  using Event = HidDriver::Event;
   Hid() = default;
   ~Hid() = default;
 
-  /**
+  template <typename T, typename... Args>
-   * Get TOuch Position
+  static void UseDriver(Args&&... args) {
-   * @return touch pos
+    // assert(driver == nullptr && "OS Driver already set");
-   */
+    driver = std::make_unique<T>(std::forward<Args>(args)...);
-  vec2 TouchPos() const { return touch[0]; }
-  /**
-   * Get Last Touch Position (from last frame)
-   * @return touch pos
-   */
-  vec2 TouchPosLast() const { return touch[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 key_events[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 key_events[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 key_events[0].at(Event_Up) & keys; }
-
-  /**
-   * Sett all keyevents to 0
-   */
-  void Clear() {
-    for (int i = 0; i < 2; i++) {
-      key_events[i][Event_Down] = 0;
-      key_events[i][Event_Up] = 0;
-      key_events[i][Event_Held] = 0;
-    }
   }
 
-  /**
+  static void Init() { driver->Init(); }
-   * Lock input driver
+  static void Deinit() { driver->Deinit(); }
-   * @param v lock or not lock
+  static const fvec2& MousePos() { return driver->MousePos(); }
-   */
+  static const fvec2& MousePosLast() { return driver->MousePosLast(); }
-  void Lock(bool v) {
+  static const fvec2& TouchPos() { return driver->TouchPos(); }
-    if (v != locked) {
+  static const fvec2& TouchPosLast() { return driver->TouchPosLast(); }
-      SwappyTable();
+  static void Update() { driver->Update(); }
+  static bool IsEvent(Event e, HidInternal::GamepadKey keys) {
+    return driver->IsEvent(e, keys);
   }
-    locked = v;
+  static bool IsEvent(Event e, HidInternal::Keyboard::Key keys) {
-  }
+    return driver->IsEvent(e, keys);
-  /**
-   * Check if Driver is locked
-   * @return true if locked
-   */
-  bool Locked() const { return locked; }
-  /**
-   * Lock Input Driver
-   */
-  void Lock() {
-    if (!locked) {
-      SwappyTable();
-    }
-    locked = true;
-  }
-  /**
-   * Unlock Input Driver
-   */
-  void Unlock() {
-    if (locked) {
-      SwappyTable();
-    }
-    locked = false;
   }
+  static PDHidBackendFlags GetFlags() { return driver->GetFlags(); }
+  static const fvec2& GetLeftStick() { return driver->GetLeftStick(); }
+  static const fvec2& GetRightStick() { return driver->GetRightStick(); }
 
-  /**
+  static const char* GetDriverName() { return driver->GetName(); }
-   * Template Update Function for a device specific driver
-   */
-  virtual void Update() {}
 
- protected:
+ private:
-  /** Key binds map */
+  static std::unique_ptr<HidDriver> driver;
-  std::unordered_map<u32, u32> binds;
-  /** Function to swap around the Table */
-  void SwappyTable();
-  /** Using 2 Touch positions for current and last frame */
-  vec2 touch[2];
-  /** locked state */
-  bool locked = false;
-  /** Key event tables */
-  std::unordered_map<Event, u32> key_events[2];
 };
 }  // namespace PD

include/pd/drivers/interface.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <pd/common.hpp>
+
+namespace PD {
+class DriverInterface {
+ public:
+  DriverInterface(const std::string_view& name) : pName(name) {}
+  virtual ~DriverInterface() {}
+
+  const char* GetName() const { return pName.data(); }
+
+ private:
+  std::string_view pName;
+};
+}  // namespace PD

include/pd/drivers/os.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <pd/drivers/interface.hpp>
+
+namespace PD {
+class PD_API OsDriver : public DriverInterface {
+ public:
+  OsDriver(std::string_view name = "Default") : DriverInterface(name) {}
+  virtual ~OsDriver() {}
+
+  virtual u64 GetTime() const;
+  virtual u64 GetTimeNano() const;
+};
+
+class PD_API Os {
+ public:
+  Os() = default;
+  ~Os() = default;
+
+  template <typename T, typename... Args>
+  static void UseDriver(Args&&... args) {
+    // assert(driver == nullptr && "OS Driver already set");
+    driver = std::make_unique<T>(std::forward<Args>(args)...);
+  }
+
+  static u64 GetTime() { return driver->GetTime(); }
+  static u64 GetTimeNano() { return driver->GetTimeNano(); }
+
+  static const char* GetDriverName() { return driver->GetName(); }
+
+ private:
+  static std::unique_ptr<OsDriver> driver;
+};
+}  // namespace PD

include/pd/image/convert.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (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
@@ -24,7 +23,9 @@ 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/core.hpp>
+#include <pd/image/image.hpp>
+#include <pd/pd_p_api.hpp>
 
 namespace PD {
 /**
@@ -39,14 +40,19 @@ namespace ImgConvert {
  * @param w width of the image
  * @param h height of the image
  */
-void RGB24toRGBA32(std::vector<u8> &out, const std::vector<u8> &in,
+PD_API
-                   const int &w, const int &h);
+void RGB24toRGBA32(std::vector<PD::u8>& out, const std::vector<u8>& in,
+                   const int& w, const int& h);
+PD_API
+void RGB32toRGBA24(std::vector<u8>& out, const std::vector<u8>& in,
+                   const int& w, const int& h);
 /**
  * Reverse 32 (RGBA -> ABGR || ABGR -> RGBA)
  * @param buf Buffer to convert
  * @param w width
  * @param h height
  */
-void Reverse32(std::vector<u8> &buf, const int &w, const int &h);
+PD_API void Reverse32(std::vector<u8>& buf, const int& w, const int& h);
+PD_API void ReverseBuf(std::vector<u8>& buf, size_t bpp, int w, int h);
 }  // namespace ImgConvert
 }  // namespace PD

include/pd/image/image.hpp

@@ -1,64 +1,50 @@
 #pragma once
 
-/*
+#include <pd/core/core.hpp>
-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 Image {
+class PD_API Image {
  public:
-  Image() = default;
+  enum class Format {
-  Image(const std::string& path) { this->Load(path); }
+    RGBA,    // bpp == 4
-  Image(const std::vector<u8>& buf) { this->Load(buf); }
+    RGB,     // bpp == 3
-  Image(const std::vector<u8>& buf, int w, int h, int fmt = 4) {
+    RGB565,  // bpp == 2 (not supported in laoding)
-    this->Copy(buf, w, h, fmt);
+    BGR,     // bpp == 3
-  }
+    ABGR,    // bpp == 4
-  ~Image() = default;
+    BGRA,    // bpp == 4
+  };
+  Image();
+  Image(const std::string& path);
+  Image(const std::vector<u8>& buf);
+  Image(const std::vector<u8>& pixels, int w, int h, int bpp = 4);
+  ~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 fmt = 4);
+  void Load(const u8* buf, size_t size);
+  void Copy(const std::vector<u8>& pixels, int w, int h, int bpp = 4);
 
-  std::vector<u8>& GetBuffer() { return buffer; }
+  const int& Width() const { return pSize.x; }
-  std::vector<u8> GetBuffer() const { return buffer; }
+  const int& Height() const { return pSize.y; }
+  const ivec2& Size() const { return pSize; }
 
-  int Width() const { return w; }
+  const std::vector<u8>& data() const { return pData; }
-  int Height() const { return h; }
+  std::vector<u8>& data() { return pData; }
+  operator const std::vector<u8>&() const { return pData; }
+  operator std::vector<u8>&() { return pData; }
+  operator const ivec2&() const { return pSize; }
+  operator const Format&() const { return pFormat; }
 
-  u8& operator[](int idx) { return buffer[idx]; }
+  void Flip(bool horizontal = true, bool vertical = true);
-  u8 operator[](int idx) const { return buffer[idx]; }
 
-  // Probably these make th eabove ones useless
+  static int Format2Bpp(Format fmt);
+  static Format GuessFmtFromBpp(int bpp);
 
-  operator std::vector<u8>&() { return buffer; }
+  void Convert(Format dst);
-  operator std::vector<u8>() const { return buffer; }
 
  private:
-  std::vector<u8> buffer;
+  std::vector<u8> pData;
-  int w = 0;
+  ivec2 pSize;
-  int h = 0;
+  Format pFormat = Format::RGBA;
-  int fmt = 0;
 };
 }  // namespace PD

include/pd/image/img_blur.hpp

@@ -1,72 +0,0 @@
-#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/vec.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
- */
-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
- */
-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
- */
-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

include/pd/lib3ds/gamepad_icons.hpp

@@ -1,73 +0,0 @@
-#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/drivers/hid.hpp>
-
-namespace PD {
-/**
- * Simple Table Containing the codepoint references
- * for the Controller Icons on the 3ds
- */
-namespace GamePadIcons {
-/**
- * Icon ID
- */
-enum ID {
-  A,
-  B,
-  X,
-  Y,
-  L,
-  R,
-  Dpad,
-  Start,
-  Select,
-  Home,
-  Steps,
-  PlayCoin,
-  AnalogStick,
-  Power3DS,
-  DpadUp,
-  DpadDown,
-  DpadLeft,
-  DpadRight,
-  DpadHorizontal,
-  DpadVertical,
-};
-/**
- * Get Icon by ID
- * @param id ID to Get
- * @return codepoint
- */
-std::string GetIcon(ID id);
-/**
- * Get Icon By Input Driver Key
- * @param key Key to find
- * @return codepoint
- */
-std::string GetIcon(Hid::Key key);
-}  // namespace GamePadIcons
-}  // namespace PD

include/pd/lib3ds/hwinfo.hpp

@@ -1,57 +0,0 @@
-#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 {
-/**
- * static Namespace containing Access to some 3ds Hardware Info
- */
-namespace HwInfo {
-/**
- * Init connecttion to required sys modules
- */
-void Init();
-/**
- * Deinit connection to sys modules
- */
-void Deinit();
-/**
- * Check if the Console is Charging
- * @return true if the console is charging
- */
-bool IsCharging();
-/**
- * Get the Current Battery Percentage
- * @return Battery Percentage (from 0 to 100)
- */
-int GetBatteryPercentage();
-/**
- * Get Current Wifi Level
- * @return wifi level (0 to 4)
- */
-int GetWifiLevel();
-}  // namespace HwInfo
-}  // namespace PD

include/pd/lithium/atlas.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/texture.hpp>
+
+namespace PD {
+namespace Li {
+enum class AtlasState {
+  Invalid,
+  ReqCreate,
+  ReqUpdate,
+  ReqDestroy,
+};
+
+class Atlas {
+ public:
+  Atlas() {}
+  ~Atlas() {}
+
+ private:
+  AtlasState pState = AtlasState::Invalid;
+  TextureID pID;
+};
+}  // namespace Li
+}  // namespace PD

include/pd/lithium/command.hpp

@@ -1,215 +1,33 @@
 #pragma once
 
-/*
+#include <cstddef>
-MIT License
+#include <pd/core/pool.hpp>
-
-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/vec.hpp>
-#include <pd/lithium/flags.hpp>
-#include <pd/lithium/texture.hpp>
 #include <pd/lithium/vertex.hpp>
 
 namespace PD {
-namespace LI {
+namespace Li {
-/**
+class Command {
- * Lithium Draw Command (containing a list of vertex and index data
- * only for this specific command itself)
- */
-class Command : public SmartCtor<Command> {
  public:
-  Command() = default;
+  Command() { Reset(); }
-  ~Command() = default;
+  ~Command() {}
 
-  /**
+  void Reserve(size_t vtx, size_t idx);
-   * Copy Constructor [to Copy the Data of a Command Reference]
+  void Reset();
-   */
-  Command(Command::Ref v) {
-    this->index = v->index;
-    this->index_buf = v->index_buf;
-    this->layer = v->layer;
-    this->mode = v->mode;
-    this->tex = v->tex;
-    this->vertex_buf = v->vertex_buf;
-  }
 
-  /**
+  Command& Add(const Vertex& vtx);
-   * Setter for the Commands layer
+  Command& Add(u16 idx);
-   * @param v layer value
+  Command& Add(u16 a, u16 b, u16 c);
-   * @return command reference
-   */
-  Command& Layer(int v) {
-    layer = v;
-    return *this;
-  }
 
-  /**
+  int Layer = 0;
-   * Getter for the Layer
+  ptr Tex = 0;
-   * @return layer value
+  bool SDF = false;
-   */
+  size_t FirstVertex = 0;
-  int Layer() const { return layer; }
+  size_t FirstIndex = 0;
-
+  size_t VertexCount = 0;
-  /**
+  size_t IndexCount = 0;
-   * Setter for the Commands Index [used in sorting]
+  // Todo: implement
-   * @param v index value
+  size_t VertexCountMax = 0;
-   * @return command reference
+  size_t IndexCountMax = 0;
-   */
-  Command& Index(int v) {
-    index = v;
-    return *this;
-  }
-  /**
-   * Getter for the Index
-   * @return index value
-   */
-  int Index() const { return index; }
-
-  /**
-   * Setter for the Commands Texture
-   * @param v Texture reference
-   * @return command reference
-   */
-  Command& Tex(Texture::Ref v) {
-    tex = v;
-    return *this;
-  }
-  /**
-   * Getter for the Texture reference
-   * @return Texture reference
-   */
-  Texture::Ref Tex() const { return tex; }
-
-  /**
-   * Function to Push a Vertex to the vertexbuffer
-   * @param v Vertex to push
-   * @return command reference
-   */
-  Command& PushVertex(const Vertex& v) {
-    vertex_buf.push_back(v);
-    return *this;
-  }
-
-  /**
-   * Access to the Index list [used to write index data
-   * to the real indexbuffer]
-   * @return const reference to commands idx buffer
-   */
-  const std::vector<u16>& IndexList() const { return index_buf; }
-  /**
-   * Access to the Vertex list [used to write vertices
-   * data to the real vertexbuffer]
-   * @return const reference to commands vertex buffer
-   */
-  const std::vector<Vertex>& VertexList() const { return vertex_buf; }
-
-  // ADVANCED
-
-  /**
-   * Advanced function to access index list
-   *
-   * - This function is UNSAFE to use cause it allows to modify index data
-   * @return reference to index list
-   */
-  std::vector<u16>& IndexList() { return index_buf; }
-  /**
-   * Advanced function to access vertex list
-   *
-   * - This function is UNSAFE to use cause it allows to modify index data
-   * - Using this in StaticText to change Position color and stuff after it is
-   *   rendered into commands
-   * @return reference to vertex list
-   */
-  std::vector<Vertex>& VertexList() { return vertex_buf; }
-
-  /**
-   * Function to Push an index value to indexbuffer
-   * @param v Index value
-   * @return command reference
-   */
-  Command& PushIndex(u16 v) {
-    index_buf.push_back(vertex_buf.size() + v);
-    return *this;
-  }
-
-  /**
-   * Setter for the Commands RenderMode
-   * @param v RenderMode
-   * @return command reference
-   */
-  Command& Rendermode(const RenderMode& v) {
-    mode = v;
-    return *this;
-  }
-
-  /**
-   * Getter for the Commands RenderMode
-   * @return RenderMode
-   */
-  RenderMode Rendermode() const { return mode; }
-
-  /** Setter for Scissor Mode */
-  Command& SetScissorMode(ScissorMode mode) {
-    scissor = mode;
-    return *this;
-  }
-
-  /** Getter for Scissor Mode */
-  ScissorMode GetScissorMode() const { return scissor; }
-
-  /** Setter for Scissor Area */
-  Command& ScissorRect(const vec4& v) {
-    scissor_area = v;
-    return *this;
-  }
-
-  /** Getter for Scissor Area */
-  vec4 ScissorRect() const { return scissor_area; }
-
- private:
-  /**
-   * Vertex Buffer
-   *
-   * - Using default vector here as its data will be copied later
-   */
-  std::vector<Vertex> vertex_buf;
-  /**
-   * Index Buffer
-   *
-   * - Using default vector here as its data will be copied later
-   */
-  std::vector<u16> index_buf;
-  /** Layer */
-  int layer;
-  /** Texture Reference */
-  Texture::Ref tex;
-  /** Index */
-  int index;
-  /** RenderMode (Default to RenderMode_RGBA) */
-  RenderMode mode = RenderMode_RGBA;
-  /** Scissor Mode (for defined area to render) */
-  ScissorMode scissor = ScissorMode_None;
-  /** scissor box (top left and bottom right) */
-  vec4 scissor_area;
 };
-}  // namespace LI
+}  // namespace Li
 }  // namespace PD

include/pd/lithium/drawlist.hpp

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <pd/lithium/command.hpp>
+#include <pd/lithium/font.hpp>
+#include <pd/lithium/texture.hpp>
+
+using LiPathRectFlags = PD::u32;
+
+enum LiPathRectFlags_ : PD::u32 {
+  LiPathRectFlags_None = 0,
+  LiPathRectFlags_KeepTopLeft = 1 << 0,
+  LiPathRectFlags_KeepTopRight = 1 << 1,
+  LiPathRectFlags_KeepBotRight = 1 << 2,
+  LiPathRectFlags_KeepBotLeft = 1 << 3,
+  LiPathRectFlags_KeepTop =
+      LiPathRectFlags_KeepTopLeft | LiPathRectFlags_KeepTopRight,
+  LiPathRectFlags_KeepBot =
+      LiPathRectFlags_KeepBotLeft | LiPathRectFlags_KeepBotRight,
+  LiPathRectFlags_KeepLeft =
+      LiPathRectFlags_KeepTopLeft | LiPathRectFlags_KeepBotLeft,
+  LiPathRectFlags_KeepRight =
+      LiPathRectFlags_KeepTopRight | LiPathRectFlags_KeepBotRight,
+};
+
+using LiDrawFlags = PD::u32;
+enum LiDrawFlags_ : PD::u32 {
+  LiDrawFlags_None = 0,
+  LiDrawFlags_Close = 1 << 0,
+  LiDrawFlags_AA = 1 << 1,
+};
+
+namespace PD {
+namespace Li {
+class PD_API Drawlist {
+ public:
+  Drawlist();
+  ~Drawlist();
+
+  /** Baisc */
+
+  void Merge(Drawlist& other);
+  void Copy(Drawlist& other);
+  void Optimize();
+  void Clear();
+  void SetLayer(int layer) { pCurrentLayer = layer; }
+  void LayerUp() { pCurrentLayer++; }
+  void LayerDown() { pCurrentLayer--; }
+  int GetLayer() const { return pCurrentLayer; }
+
+  size_t GetNumVertices() const {
+    size_t count = 0;
+    for (const auto& cmd : pCommands) count += cmd.VertexCount;
+    return count;
+  }
+
+  size_t GetNumIndices() const {
+    size_t count = 0;
+    for (const auto& cmd : pCommands) count += cmd.IndexCount;
+    return count;
+  }
+
+  /** Command Allocation */
+  Command& NewCommand();
+  bool HasCommands() { return pCommands.size() > 0; }
+  Command& GetLastCommand() { return pCommands[pCommands.size() - 1]; }
+
+  /** Path API */
+  void PathAdd(const fvec2& point) { pPath.Push(point); }
+  void PathAdd(float x, float y) { pPath.Push(fvec2(x, y)); }
+  void PathClear() { pPath.Reset(); }
+  /**
+   * @brief Reserve memory for the next PathAdd uses
+   * @note As path will autoexpant and keep the size this func is
+   *       only for special use cases
+   */
+  void PathReserve(size_t num) { pPath.ExpandIf(num); }
+  void PathStroke(const PD::Color& color, int t = 1,
+                  LiDrawFlags flags = LiDrawFlags_None);
+  void PathFill(const PD::Color& color);
+  void PathFillGradient(const PD::Color& a, const PD::Color& b,
+                        float rad = 0.f);
+  void PathArcToN(const fvec2& c, float r, float amin, float amax, int s);
+  void PathFastArcToN(const fvec2& c, float r, float amin, float amax, int s);
+  void PathRect(const fvec2& tl, const fvec2& br, float r = 0.f);
+  void PathRectEx(const fvec2& tl, const fvec2& br, float r = 0.f,
+                  LiPathRectFlags flags = LiPathRectFlags_None);
+
+  /** Texture Handling */
+  void BindTexture(const Texture& tex);
+  void UnbindTexture() { pCurrentTexture = Texture(); }
+
+  /** Font Handling */
+  void SetFont(Font* font) { pFont = font; }
+  void SetFontscale(float fontscale = 1.f) { pFontScale = fontscale; }
+  const float& GetFontScale() const { return pFontScale; }
+
+  /** Data geters */
+  const Pool<Command>& Data() const { return pCommands; }
+  operator const Pool<Command>&() const { return pCommands; }
+
+  /** Drawing functions */
+  void DrawRect(const fvec2& pos, const fvec2& size, const PD::Color& color,
+                int t = 1);
+  void DrawRectFilled(const fvec2& pos, const fvec2& size,
+                      const PD::Color& color);
+  void DrawTriangle(const fvec2& a, const fvec2& b, const fvec2& c,
+                    const PD::Color& color, int t = 1);
+  void DrawTriangleFilled(const fvec2& a, const fvec2& b, const fvec2& c,
+                          const PD::Color& color);
+  void DrawCircle(const fvec2& center, float rad, const PD::Color& color,
+                  int num_segments, int t = 1);
+  void DrawCircleFilled(const fvec2& center, float rad, const PD::Color& color,
+                        int num_segments);
+  void DrawText(const fvec2& p, const char* text, const PD::Color& color);
+  void DrawTextEx(const fvec2& p, const char* text, const PD::Color& color,
+                  LiTextFlags flags, const fvec2& box = fvec2(0.f));
+  void DrawLine(const fvec2& a, const fvec2& b, const PD::Color& color,
+                int thickness = 1);
+
+  void DrawPolyLine(const Pool<fvec2>& points, const PD::Color& color,
+                    LiDrawFlags flags = LiDrawFlags_None, int t = 1);
+  void DrawConvexPolyFilled(const Pool<fvec2>& points, const PD::Color& color);
+  void DrawConvexPolyFilled(const Pool<fvec2>& points, const PD::Color& a,
+                            const PD::Color b, float rad = 0.f);
+
+  void PrimQuad(Command& cmd, const Rect& quad, const Rect& uv,
+                const PD::Color& color);
+  void PrimTriangle(Command& cmd, const fvec2& a, const fvec2& b,
+                    const fvec2& c, const PD::Color& color);
+
+ private:
+  Texture pCurrentTexture;
+  int pCurrentLayer = 0;
+  Pool<Command> pCommands;
+  Pool<fvec2> pPath;
+  Pool<Vertex> pVertices;
+  Pool<u16> pIndices;
+  Font* pFont = nullptr;
+  float pFontScale = 1.f;
+};
+}  // namespace Li
+}  // namespace PD

include/pd/lithium/flags.hpp

@@ -1,71 +0,0 @@
-#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>
-
-/** Alias for Lithium Text Flags */
-using LITextFlags = PD::u32;
-
-/** LITextFlags */
-enum LITextFlags_ {
-  LITextFlags_None = 0,             ///< Do nothing
-  LITextFlags_AlignRight = 1 << 0,  ///< Align Right of position
-  LITextFlags_AlignMid = 1 << 1,    ///< Align in the middle of pos and box
-  LITextFlags_Shaddow = 1 << 2,     ///< Draws the text twice to create shaddow
-  LITextFlags_Wrap = 1 << 3,        ///< Wrap Text: May be runs better with TMS
-  LITextFlags_Short = 1 << 4,       ///< Short Text: May be runs better with TMS
-  LITextFlags_Scroll = 1 << 5,      ///< Not implemented [scoll text if to long]
-  LITextFlags_RenderOOS = 1 << 6    ///< Render Out of Screen
-};
-
-/** Aliad for Lithium Render Flags */
-using LIRenderFlags = PD::u32;
-/** LIRenderFlags */
-enum LIRenderFlags_ {
-  LIRenderFlags_None = 0,      ///< Nothing
-  LIRenderFlags_TMS = 1 << 0,  ///< Text Map System
-  LIRenderFlags_LRS = 1 << 1,  ///< Layer Render System
-  LIRenderFlags_AST = 1 << 2,  ///< Auto Static Text
-  /** Default Enables all of them */
-  LIRenderFlags_Default =
-      LIRenderFlags_TMS | LIRenderFlags_LRS | LIRenderFlags_AST,
-};
-
-namespace PD {
-namespace LI {
-/** RenderMode [Required to modify TexENV] */
-enum RenderMode {
-  RenderMode_RGBA,  ///< RGBA [for textures or solid colors]
-  RenderMode_Font,  ///< A8 [for textures only crated by 1 color channel]
-};
-/** Scissor Mode (for ClipRect related rendering) */
-enum ScissorMode {
-  ScissorMode_None = 0,      ///< No Scissor
-  ScissorMode_Inverted = 1,  ///< Render Pixels outside the box
-  ScissorMode_Normal = 3,    ///< Only render pixels inside the box
-};
-}  // namespace LI
-}  // namespace PD

include/pd/lithium/font.hpp

@@ -1,181 +1,125 @@
 #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/vec.hpp>
-#include <pd/lithium/rect.hpp>
 #include <pd/lithium/texture.hpp>
 
+using LiTextFlags = PD::u32;
+enum LiTextFlags_ : PD::u32 {
+  LiTextFlags_None = 0,             ///< Do nothing
+  LiTextFlags_AlignRight = 1 << 0,  ///< Align Right of position
+  LiTextFlags_AlignMid = 1 << 1,    ///< Align in the middle of pos and box
+  LiTextFlags_Shaddow = 1 << 2,     ///< Draws the text twice to create shaddow
+  LiTextFlags_Wrap = 1 << 3,        ///< Wrap Text: May be runs better with TMS
+  LiTextFlags_Short = 1 << 4,       ///< Short Text: May be runs better with TMS
+  LiTextFlags_Scroll = 1 << 5,      ///< Not implemented [scoll text if to long]
+  LiTextFlags_NoOOS = 1 << 6,       ///< No Out of Screen Rendering
+};
+
+using LiFontFlags = PD::u32;
+enum LiFontFlags_ : PD::u32 {
+  LiFontFlags_None = 0,            ///< Not special (bitmap font)
+  LiFontFlags_SDF = 1 << 0,        ///< SDF Texture (and mode)
+  LiFontFlags_Monospace = 1 << 1,  ///< Monospace Rendering
+};
+
 namespace PD {
-namespace LI {
+namespace Li {
-/** Font Loader for Lithium */
+class Drawlist;
-class Font : public SmartCtor<Font> {
+class PD_API Font {
  public:
-  /** Codepoint Data holder */
+  struct Codepoint {
-  class Codepoint {
+    u32 pCodepoint = 0;
-   public:
+    fvec4 SimpleUV;
-    Codepoint() = default;
+    size_t Tex = 0;
-    ~Codepoint() = default;
+    fvec2 Size;
-
+    fvec2 Offset;
-    /**
+    // float Offset = 0.f;
-     * Codepoint ID Getter
+    float AdvanceX = 0.f;
-     * @return 32Bit codepoint value
+    bool pInvalid = false;
-     */
-    u32 cp() const { return m_cp; }
-    /**
-     * Codepoint ID Setter
-     * @param v codepoint id
-     * @return DataHolder reference
-     */
-    Codepoint& cp(u32 v) {
-      m_cp = v;
-      return *this;
-    }
-    /**
-     * Getter for the UV Coords
-     * @return uv coords
-     */
-    vec4 uv() const { return m_uv; }
-    /**
-     * Setter for the UV Coords
-     * @param v uv coords
-     * @return DataHolder Reference
-     */
-    Codepoint& uv(const vec4& v) {
-      m_uv = v;
-      return *this;
-    }
-    /**
-     * Getter for the Texture reference
-     * @return Texture Reference
-     */
-    Texture::Ref tex() const { return m_tex; }
-    /**
-     * Setter for the Texture Reference
-     * @param v Texture Reference
-     * @return DataHolder Reference
-     */
-    Codepoint& tex(Texture::Ref v) {
-      m_tex = v;
-      return *this;
-    }
-    /**
-     * Getter for the size
-     * @return Size
-     */
-    vec2 size() const { return m_size; }
-    /**
-     * Setter for the Size
-     * @param v size
-     * @return DataHolder Reference
-     */
-    Codepoint& size(const vec2& v) {
-      m_size = v;
-      return *this;
-    }
-    /**
-     * Getter for the Position offset
-     * @return offset
-     */
-    float off() const { return m_off; }
-    /**
-     * Setter for the Render Offset
-     * @param v offset
-     * @return DataHolder Reference
-     */
-    Codepoint& off(float v) {
-      m_off = v;
-      return *this;
-    }
-    /**
-     * Getter to check if Codepoint is invalid
-     * @return true if invalid
-     */
-    bool invalid() const { return m_invalid; }
-    /**
-     * Setter for invald state
-     * @param v true or false
-     * @return DataHolder Reference
-     */
-    Codepoint& invalid(bool v) {
-      m_invalid = v;
-      return *this;
-    }
-
-   private:
-    /** 32Bit Codepoint ID */
-    u32 m_cp = 0;
-    /** UvMap */
-    vec4 m_uv;
-    /** Texture Reference */
-    Texture::Ref m_tex = nullptr;
-    /** Codepoint Size */
-    vec2 m_size;
-    /** Render Position Offset */
-    float m_off = 0;
-    /** Invalid check (for skip in renderer) */
-    bool m_invalid = false;
   };
-  Font() = default;
+  Font() {}
-  ~Font() = default;
+  ~Font() {}
+
+  bool IsMonospace() { return pFlags & LiFontFlags_Monospace; }
+  bool IsSDF() { return pFlags & LiFontFlags_SDF; }
+
   /**
    * Load a TTF File
    * @param path Path to the TTF file
    * @param px_height Pixelheight of the codepoints (limit by 64)
    */
-  void LoadTTF(const std::string& path, int px_height = 32);
+  void LoadTTF(const std::string& path, int px_height = 32,
+               LiFontFlags flags = LiFontFlags_None);
   /**
-   * Load 3DS System Font
+   * Load a TTF File from Memory
+   * @param data File data
+   * @param px_height Pixelheight of the codepoints (limit by 64)
    */
-  void LoadSystemFont();
+  void LoadTTF(const std::vector<u8>& data, int px_height = 32,
+               LiFontFlags flags = LiFontFlags_None);
   /**
-   * Getter for PixelHeight
+   * Function that loads a default integrated font...
-   * @return pixelheigt
+   * This will only work if PD_LI_INCLUDE_FONTS was set
+   * on lithium build cause otherwise the font data is not included
    */
-  int PixelHeight() const { return pixel_height; }
+  void LoadDefaultFont(int id = 0, int pixel_height = 32);
   /**
    * Getter for Codepoint reference
    * @return codepoint dataholder reference
    */
   Codepoint& GetCodepoint(u32 c);
+
   /**
-   * Check if Systemfont is used
+   * Get Text Bounding Box
-   * @return true if is system font
    */
-  bool SystemFont() const { return sysfont; }
+  fvec2 GetTextBounds(const char* text, float scale);
+  /**
+   * Extended Draw Text Function that vreates a Command List
+   */
+  void CmdTextEx(Drawlist& dl, const fvec2& pos, u32 color, float scale,
+                 const char* text, LiTextFlags flags = 0, const fvec2& box = 0);
+
+  /**
+   * Cleanup Font and unload Textures
+   */
+  void Delete();
+
+  /**
+   * Garbage collection for TextMapSystem
+   */
+  void CleanupTMS();
+  /**
+   * Utility function to create a font atlas
+   * During TTF loading (Internal and should not be called)
+   */
+  void BakeAndPush(bool final, std::vector<u8>& font_tex, int texszs);
+  std::string pWrapText(const std::string& txt, float scale,
+                        const PD::fvec2& max, PD::fvec2& dim);
+  std::string pShortText(const std::string& txt, float scale,
+                         const PD::fvec2& max, PD::fvec2& dim);
+
+  /** Data Section */
+  int PixelHeight = 0;
+  int DefaultPixelHeight = 32;
+  std::vector<TextureID> Textures;
+  /**
+   * 32Bit Codepoint Dataholder reference map
+   * **Now using unordered map**
+   */
+  std::unordered_map<u32, Codepoint> CodeMap;
+  /** need some performance tweaks */
+  std::array<Codepoint, 128> pAsciiCache;
+  /** TMS */
+  struct TMELEM {
+    PD::u32 ID;
+    PD::fvec2 Size;
+    std::string Text;
+    u64 TimeStamp;
+  };
+  std::unordered_map<u32, TMELEM> pTMS;
 
  private:
-  /** sysfont set to true if LoadSystemFont got called */
+  size_t pCurrentTex = 0;
-  bool sysfont;
+  LiFontFlags pFlags = 0;
-  /** Pixelheight */
-  int pixel_height;
-  /** List of textures (codepoints are using) */
-  std::vector<Texture::Ref> textures;
-  /** 32Bit Codepoint Dataholder Reference Map */
-  std::map<u32, Codepoint> cpmap;
 };
-}  // namespace LI
+}  // namespace Li
 }  // namespace PD

include/pd/lithium/formatters.hpp

@@ -0,0 +1,122 @@
+#pragma once
+
+#include <pd/lithium/atlas.hpp>
+#include <pd/lithium/command.hpp>
+#include <pd/lithium/rect.hpp>
+#include <pd/lithium/texture.hpp>
+#include <pd/lithium/vertex.hpp>
+
+template <>
+struct std::formatter<PD::TextureFilter> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const PD::TextureFilter& value, FormatContext& ctx) const {
+    std::string_view ret = "Unknown";
+    switch (value) {
+      case PD::TextureFilter::Linear:
+        ret = "Linear";
+        break;
+      case PD::TextureFilter::Nearest:
+        ret = "Nearest";
+        break;
+    }
+    return std::format_to(ctx.out(), "{}", ret);
+  }
+};
+
+template <>
+struct std::formatter<PD::TextureFormat> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const PD::TextureFormat& value, FormatContext& ctx) const {
+    std::string_view ret = "Unknown";
+    switch (value) {
+      case PD::TextureFormat::RGBA32:
+        ret = "RGBA32";
+        break;
+      case PD::TextureFormat::RGB24:
+        ret = "RGB24";
+        break;
+      case PD::TextureFormat::A8:
+        ret = "A8";
+        break;
+    }
+    return std::format_to(ctx.out(), "{}", ret);
+  }
+};
+
+template <>
+struct std::formatter<PD::Li::Rect> : std::formatter<std::string> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const PD::Li::Rect& value, FormatContext& ctx) const {
+    // {l, t, r, t, l, b, r, b}
+    return std::format_to(ctx.out(), "{}, {}, {}, {}, {}, {}, {}, {}",
+                          value.Top.x, value.Top.y, value.Top.z, value.Top.w,
+                          value.Bot.x, value.Bot.y, value.Bot.z, value.Bot.w);
+  }
+};
+
+template <>
+struct std::formatter<PD::Li::Texture> : std::formatter<std::string> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const PD::Li::Texture& value, FormatContext& ctx) const {
+    // {ID, [w, h], [l, t, r, t, l, b, r, b]}
+    return std::format_to(ctx.out(), "{}, [{}], [{}]", value.GetID(),
+                          value.GetSize(), value.GetUV());
+  }
+};
+
+template <>
+struct std::formatter<PD::Li::Vertex> : std::formatter<std::string> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const PD::Li::Vertex& value, FormatContext& ctx) const {
+    // { [x, y], [u, v], colorhex }
+    return std::format_to(ctx.out(), "[{}], [{}], #{:08X}", value.pos, value.uv,
+                          value.color);
+  }
+};
+
+template <>
+struct std::formatter<PD::Li::AtlasState> : std::formatter<std::string> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const PD::Li::AtlasState& value, FormatContext& ctx) const {
+    std::string_view ret = "Unknown";
+    switch (value) {
+      case PD::Li::AtlasState::Invalid:
+        ret = "Invalid";
+        break;
+      case PD::Li::AtlasState::ReqCreate:
+        ret = "RequestCreate";
+        break;
+      case PD::Li::AtlasState::ReqUpdate:
+        ret = "RequestUpdate";
+        break;
+      case PD::Li::AtlasState::ReqDestroy:
+        ret = "RequestDestroy";
+        break;
+    }
+    return std::format_to(ctx.out(), "{}", ret);
+  }
+};
+
+template <>
+struct std::formatter<PD::Li::Command> : std::formatter<std::string> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const PD::Li::Command& value, FormatContext& ctx) const {
+    return std::format_to(ctx.out(), "[0x{:X}, 0x{:X}] [{}, {}] 0x{:X}",
+                          (PD::ptr)value.FirstVertex, (PD::ptr)value.FirstIndex,
+                          value.VertexCount, value.IndexCount, value.Tex);
+  }
+};

include/pd/lithium/li7_shader.hpp

@@ -1,31 +0,0 @@
-// THIS FILE WAS GENERATED BY build_shaders.py!!!
-#pragma once
-
-/*
-MIT License
-
-Copyright (c) 2024 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 <cstddef>
-
-extern unsigned char li7_shader[];
-extern size_t li7_shader_size;

include/pd/lithium/lithium.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <pd/lithium/command.hpp>
+#include <pd/lithium/drawlist.hpp>
+#include <pd/lithium/font.hpp>
+#include <pd/lithium/math.hpp>
+#include <pd/lithium/pools.hpp>
+#include <pd/lithium/vertex.hpp>

include/pd/lithium/math.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/rect.hpp>
+
+namespace PD {
+namespace Li {
+namespace Math {
+PD_API bool InBounds(const fvec2& pos, const fvec2& size, const fvec4& rect);
+PD_API bool InBounds(const fvec2& pos, const fvec4& rect);
+PD_API bool InBounds(const fvec2& a, const fvec2& b, const fvec2& c,
+                     const fvec4& rect);
+PD_API bool InSpace(const PD::fvec2& pos, const Rect& rect);
+PD_API void RotateCorner(fvec2& pos, float sinus, float cosinus);
+PD_API Rect PrimRect(const fvec2& pos, const fvec2& size, float angle = 0.f);
+PD_API Rect PrimLine(const fvec2& a, const fvec2& b, int t = 1);
+}  // namespace Math
+}  // namespace Li
+}  // namespace PD

include/pd/lithium/objects.hpp

@@ -1,349 +0,0 @@
-#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/vec.hpp>
-#include <pd/lithium/command.hpp>
-#include <pd/lithium/flags.hpp>
-#include <pd/lithium/font.hpp>
-#include <pd/lithium/texture.hpp>
-#include <pd/lithium/vertex.hpp>
-
-namespace PD {
-namespace LI {
-class Renderer;
-/**
- * Prerendered Object that can be edidet at runtime
- * and supports diffrent textures as well
- */
-class StaticObject : public SmartCtor<StaticObject> {
- public:
-  StaticObject() = default;
-  ~StaticObject() = default;
-
-  /**
-   * Push a Draw Command to the Static Object
-   * @param v Command to add
-   */
-  void PushCommand(Command::Ref v) { cmds.push_back(v); }
-
-  /**
-   * Copy the root Object to a copy buffer for modification
-   */
-  void ReCopy() {
-    cpy.clear();
-    for (auto it : cmds) {
-      cpy.push_back(Command::New(it));
-    }
-  }
-
-  /**
-   * Modify the Color of a specific Command in the List
-   * @param idx Index of the Command
-   * @param col new COlor to replace with
-   */
-  void ReColorQuad(int idx, u32 col) {
-    if (idx > (int)cpy.size()) {
-      return;
-    }
-    for (auto& it : cpy[idx]->VertexList()) {
-      it.Color(col);
-    }
-  }
-
-  /**
-   * Move the every Command in the Object by a specific offset
-   * @param off offset position to apply
-   */
-  void MoveIt(vec2 off) {
-    for (auto& it : cpy) {
-      for (auto& jt : it->VertexList()) {
-        jt.pos += off;
-      }
-    }
-  }
-
-  /**
-   * Change Color of all Commands in the List
-   * @param col new Color to use
-   */
-  void ReColor(u32 col) {
-    for (auto& it : cpy) {
-      for (auto& jt : it->VertexList()) {
-        jt.Color(col);
-      }
-    }
-  }
-
-  /**
-   * Assign a New Layer to all Objects
-   * @param layer new layer to set to all its commands
-   */
-  void ReLayer(int layer) {
-    for (auto& it : cpy) {
-      it->Layer(layer);
-    }
-  }
-
-  /**
-   * Change the Commands Index by setting a start index
-   * @param start Start index position
-   */
-  void ReIndex(int start) {
-    for (int i = 0; i < (int)cpy.size(); i++) {
-      cpy[i]->Index(start + i);
-    }
-  }
-
-  /**
-   *  Set a Custom Scissor Mode for Object Copy List
-   * @param m New Mode to Set
-   */
-  void ReSetScissorMode(ScissorMode m) {
-    for (auto& i : cpy) {
-      i->SetScissorMode(m);
-    }
-  }
-
-  /**
-   * Set Custom Scissor Rect to All Objects
-   * @param v Scissor Rect to set
-   */
-  void ReScissorRect(const vec4& v) {
-    for (auto& i : cpy) {
-      i->ScissorRect(v);
-    }
-  }
-
-  /**
-   * Get a Reference to the Copy Commands List
-   * @return command list reference
-   */
-  std::vector<Command::Ref>& List() {
-    if (cpy.size() != 0) {
-      return cpy;
-    }
-    return cmds;
-  }
-
- private:
-  /** Copy Buffer */
-  std::vector<Command::Ref> cpy;
-  /** Source Buffer */
-  std::vector<Command::Ref> cmds;
-};
-/**
- * Text Box container for TMS and AST
- */
-class TextBox {
- public:
-  TextBox() = default;
-  /**
-   * Baisc Constructor
-   * @param s Size of the text
-   * @param time creation time
-   */
-  TextBox(const vec2& s, float time) {
-    size = s;
-    time_created = time;
-    optional = false;
-  }
-  ~TextBox() = default;
-
-  /**
-   * Setter for Time created
-   * @param v time
-   */
-  void TimeCreated(float v) { time_created = v; }
-  /**
-   * Setter for Size
-   * @param v size
-   */
-  void Size(const vec2& v) { size = v; }
-  /**
-   * Setter for is optional
-   *
-   * - optional text contains the result string of wrap/short
-   * @param v optional
-   */
-  void Optional(bool v) { optional = v; }
-  /**
-   * set Result of Short Text or Wrap Text
-   * @param v text
-   */
-  void Text(const std::string& v) { text = v; }
-
-  /**
-   * Get Size
-   * @return size
-   */
-  vec2 Size() const { return size; }
-  /**
-   * Get Time Created / Updated
-   * @param time created/updated
-   */
-  float TimeCreated() const { return time_created; }
-  /**
-   * Check if Optional or not
-   * @return is optional
-   */
-  bool Optional() const { return optional; }
-  /**
-   * Get Optional Text
-   * @return text
-   */
-  std::string Text() const { return text; }
-
- private:
-  /** Text Size */
-  vec2 size;
-  /** Time Created / Updated */
-  float time_created;
-  /** Is Optional */
-  bool optional;
-  /** Text Wrap / Short */
-  std::string text;
-};
-/**
- * Static Text [abillity to Prerender Texts into a list of Commands]
- */
-class StaticText : public SmartCtor<StaticText> {
- public:
-  StaticText() = default;
-  /**
-   * Wrap Constructor to Setup
-   * @param ren Renderer direct pointer reference
-   * @param pos Position
-   * @param clr Color
-   * @param text Text to Render
-   * @param flags Text Flags
-   * @param box Additional textbox for specific flags
-   */
-  StaticText(Renderer* ren, const vec2& pos, u32 clr, const std::string& text,
-             LITextFlags flags = 0, const vec2& box = 0) {
-    Setup(ren, pos, clr, text, flags, box);
-  }
-  ~StaticText() = default;
-  /**
-   * Function that Sets Up the Rendering
-   * @param ren Renderer direct pointer reference
-   * @param pos Position
-   * @param clr Color
-   * @param text Text to Render
-   * @param flags Text Flags
-   * @param box Additional textbox for specific flags
-   */
-  void Setup(Renderer* ren, const vec2& pos, u32 clr, const std::string& text,
-             LITextFlags flags = 0, const vec2& box = 0);
-
-  /**
-   * Get Text Size
-   * @return size
-   */
-  vec2 GetDim() const { return tdim; }
-  /**
-   * Get Text Posiotion
-   * @return position
-   */
-  vec2 GetPos() const { return pos; }
-  /**
-   * Setter to Update Color
-   * @param col color
-   */
-  void SetColor(u32 col);
-  /**
-   * Setter to raplace the texts Commands Position
-   * @param pos new position
-   */
-  void SetPos(const vec2& pos);
-  /**
-   * Set Layer of the Text
-   * @param l layer
-   */
-  void SetLayer(int l);
-
-  /**
-   * Function to unset the used variable
-   */
-  void SetUnused() { used = false; }
-  /**
-   * Function to check if the text got rendered
-   * @return is used
-   */
-  bool Used() const { return used; }
-  /**
-   * Function to check if the text got setup
-   * @return is setup
-   */
-  bool IsSetup() { return text != nullptr; }
-
-  /**
-   * Draw the Text
-   */
-  void Draw();
-
-  /** Get the Raw Object for Custom API's */
-  StaticObject::Ref GetRawObject() { return text; }
-
-  /**
-   * Set Font used by the static Text
-   * @param fnt Font used
-   */
-  void Font(Font::Ref fnt) { font = fnt; }
-  /**
-   * Get Font used by the Text
-   * @return Font Reference
-   */
-  Font::Ref Font() { return font; }
-
-  /**
-   *  Set a Custom Scissor Mode Static Text
-   * @param m New Mode to Set
-   */
-  void SetScissorMode(ScissorMode m) { text->ReSetScissorMode(m); }
-
-  /**
-   * Set Custom Scissor Rect to Static Text
-   * @param v Scissor Rect to set
-   */
-  void ScissorRect(const vec4& v) { text->ReScissorRect(v); }
-
- private:
-  /** Font */
-  Font::Ref font;
-  /** Text got Rendered */
-  bool used;
-  /** Renderer pointer Reference */
-  Renderer* ren;
-  /** Text Size */
-  vec2 tdim;
-  /** Text Position */
-  vec2 pos;
-  /** Static Text Object */
-  StaticObject::Ref text;
-};
-}  // namespace LI
-}  // namespace PD

include/pd/lithium/pools.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/vertex.hpp>
+
+namespace PD {
+namespace Li {
+PD_API PD::Pool<Vertex>& GetVertexPool();
+PD_API PD::Pool<u16>& GetIndexPool();
+PD_API void ResetPools();
+}  // namespace Li
+}  // namespace PD

include/pd/lithium/rect.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 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
@@ -23,28 +23,23 @@ 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/core.hpp>
-#include <pd/core/vec.hpp>
 
 namespace PD {
-namespace LI {
+namespace Li {
-/**
- * Container that holds position of a rectangle's corners.
- */
 class Rect {
  public:
-  Rect() = default;
+  constexpr Rect() : Top(0), Bot(0) {}
-
+  ~Rect() = default;
   /**
    * Constructor that initializes the rectangle using top and bottom positions.
    * @param t Top left and right corner positions.
    * @param b Bottom left and right corner positions.
    */
-  Rect(const vec4& t, const vec4& b) {
+  constexpr Rect(const fvec4& t, const fvec4& b) {
-    top = t;
+    Top = t;
-    bot = b;
+    Bot = b;
   }
-
   /**
    * Constructor that initializes the rectangle using individual corner
    * positions.
@@ -53,9 +48,10 @@ class Rect {
    * @param bl Bottom left corner position.
    * @param br Bottom right corner position.
    */
-  Rect(const vec2& tl, const vec2& tr, const vec2& bl, const vec2& br) {
+  constexpr Rect(const fvec2& tl, const fvec2& tr, const fvec2& bl,
-    top = vec4(tl, tr);
+                 const fvec2& br) {
-    bot = vec4(bl, br);
+    Top = fvec4(tl, tr);
+    Bot = fvec4(bl, br);
   }
 
   /**
@@ -66,77 +62,40 @@ class Rect {
    *
    * @param uv Vec4 UV map.
    */
-  Rect(const vec4& uv) {
+  constexpr Rect(const fvec4& uv) {
-    top = vec4(uv.x(), uv.y(), uv.z(), uv.y());
+    Top = vec4(uv.x, uv.y, uv.z, uv.y);
-    bot = vec4(uv.x(), uv.w(), uv.z(), uv.w());
+    Bot = vec4(uv.x, uv.w, uv.z, uv.w);
-  }
-
-  ~Rect() = default;
-
-  /**
-   * Get the top left and right corner positions.
-   * @return Top positions.
-   */
-  vec4 Top() const { return top; }
-
-  /**
-   * Get the bottom left and right corner positions.
-   * @return Bottom positions.
-   */
-  vec4 Bot() const { return bot; }
-
-  /**
-   * Set the top left and right corner positions.
-   * @param v New top positions.
-   * @return Reference to the updated Rect.
-   */
-  Rect& Top(const vec4& v) {
-    top = v;
-    return *this;
-  }
-
-  /**
-   * Set the bottom left and right corner positions.
-   * @param v New bottom positions.
-   * @return Reference to the updated Rect.
-   */
-  Rect& Bot(const vec4& v) {
-    bot = v;
-    return *this;
   }
 
   /**
    * Get the top-left corner position.
    * @return Top-left position as vec2.
    */
-  vec2 TopLeft() const { return vec2(top[0], top[1]); }
+  constexpr fvec2 TopLeft() const { return fvec2(Top.x, Top.y); }
-
   /**
    * Get the top-right corner position.
    * @return Top-right position as vec2.
    */
-  vec2 TopRight() const { return vec2(top[2], top[3]); }
+  constexpr fvec2 TopRight() const { return fvec2(Top.z, Top.w); }
-
   /**
    * Get the bottom-left corner position.
    * @return Bottom-left position as vec2.
    */
-  vec2 BotLeft() const { return vec2(bot[0], bot[1]); }
+  constexpr fvec2 BotLeft() const { return fvec2(Bot.x, Bot.y); }
-
   /**
    * Get the bottom-right corner position.
    * @return Bottom-right position as vec2.
    */
-  vec2 BotRight() const { return vec2(bot[2], bot[3]); }
+  constexpr fvec2 BotRight() const { return fvec2(Bot.z, Bot.w); }
 
   /**
    * Set the top-left corner position.
    * @param v New top-left position.
    * @return Reference to the updated Rect.
    */
-  Rect& TopLeft(const vec2& v) {
+  constexpr Rect& TopLeft(const fvec2& v) {
-    top[0] = v[0];
+    Top.x = v.x;
-    top[1] = v[1];
+    Top.y = v.y;
     return *this;
   }
 
@@ -145,9 +104,9 @@ class Rect {
    * @param v New top-right position.
    * @return Reference to the updated Rect.
    */
-  Rect& TopRight(const vec2& v) {
+  constexpr Rect& TopRight(const fvec2& v) {
-    top[2] = v[0];
+    Top.z = v.x;
-    top[3] = v[1];
+    Top.w = v.y;
     return *this;
   }
 
@@ -156,9 +115,9 @@ class Rect {
    * @param v New bottom-left position.
    * @return Reference to the updated Rect.
    */
-  Rect& BotLeft(const vec2& v) {
+  constexpr Rect& BotLeft(const fvec2& v) {
-    bot[0] = v[0];
+    Bot.x = v.x;
-    bot[1] = v[1];
+    Bot.y = v.y;
     return *this;
   }
 
@@ -167,31 +126,27 @@ class Rect {
    * @param v New bottom-right position.
    * @return Reference to the updated Rect.
    */
-  Rect& BotRight(const vec2& v) {
+  constexpr Rect& BotRight(const fvec2& v) {
-    bot[2] = v[0];
+    Bot.z = v.x;
-    bot[3] = v[1];
+    Bot.w = v.y;
     return *this;
   }
 
-  /**
+  constexpr bool operator==(const Rect& r) const {
-   * Swap X and Y coordinates for all corners.
+    return Top == r.Top && Bot == r.Bot;
-   *
-   * - Used in SpiteSheet for the rotated images.
-   */
-  void SwapVec2XY() {
-    for (int i = 0; i < 4; i += 2) {
-      float t = top[i];
-      top[i] = top[i + 1];
-      top[i + 1] = t;
-      t = bot[i];
-      bot[i] = bot[i + 1];
-      bot[i + 1] = t;
-    }
   }
 
- private:
+  constexpr void SwapVec2XY() {
-  vec4 top;  ///< Top left and right corner positions.
+    Top.SwapXY();
-  vec4 bot;  ///< Bottom left and right corner positions.
+    Top.SwapZW();
+    Bot.SwapXY();
+    Bot.SwapZW();
+  }
+
+  /** Data Section */
+
+  fvec4 Top;
+  fvec4 Bot;
 };
-}  // namespace LI
+}  // namespace Li
 }  // namespace PD

include/pd/lithium/renderer.hpp

@@ -1,382 +0,0 @@
-#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/vec.hpp>
-#include <pd/lib3ds/memory.hpp>
-#include <pd/lithium/command.hpp>
-#include <pd/lithium/flags.hpp>
-#include <pd/lithium/font.hpp>
-#include <pd/lithium/objects.hpp>
-#include <pd/lithium/screen.hpp>
-#include <pd/lithium/texture.hpp>
-#include <pd/lithium/vertex.hpp>
-
-namespace PD {
-namespace LI {
-/**
- * Lithium base renderer Class.
- */
-class Renderer : public SmartCtor<Renderer> {
- public:
-  /**
-   * Constructor setting up the 2d Rendering Engine
-   * @param flags Flags to use [can be changed at runtime].
-   */
-  Renderer(LIRenderFlags flags = LIRenderFlags_Default);
-  /**
-   * Deconstructor that unloads all the renderer data
-   */
-  ~Renderer();
-
-  /**
-   * Prepare render stage for rendering.
-   */
-  void PrepareRender();
-  /**
-   * Render a screens Command list.
-   * @param s Screen to Draw its list on.
-   */
-  void Render(Screen::Ref s);
-  /**
-   * Finalize rendering stage.
-   */
-  void FinalizeRender();
-
-  /**
-   * Register Screens (For UI7, probably move this).
-   * @param bottom set if you register bottom ot top screen.
-   * @param s Screen to register.
-   */
-  void RegisterScreen(bool bottom, Screen::Ref s) { screens[bottom] = s; }
-  /**
-   * Set the Screen next commands will be add to
-   * @param s Screen of choice
-   */
-  void OnScreen(Screen::Ref s) {
-    if (!s) {
-      return;
-    }
-    this->screen = s;
-    area_size = screen->GetSize();
-  }
-
-  /**
-   * Get cobst reference to active screen.
-   * @return current screen.
-   */
-  Screen::Ref CurrentScreen() const { return screen; }
-  /**
-   * Get Screen of screen regestry.
-   * @param bottom bottom ot top screen.
-   * @return screen reference
-   */
-  Screen::Ref GetScreen(bool bottom) {
-    auto res = screens[bottom];
-    Assert(res.get(), "Screen is not registered!");
-    return res;
-  }
-
-  void Rotation(float v) { rot = v; }
-  float Rotation() const { return rot; }
-  void TextScale(float v) { text_size = v; }
-  void DefaultTextScale() { text_size = default_text_size; }
-  float TextScale() const { return text_size; }
-  void Layer(int v) { current_layer = v; }
-  int Layer() const { return current_layer; }
-  LIRenderFlags& GetFlags() { return flags; }
-  void Font(Font::Ref v) {
-    font = v;
-    font_update = true;
-  }
-  Font::Ref Font() const { return font; }
-
-  /**
-   * Use a specific Texture for Next Rectangle.
-   * @param v texture reference to use.
-   */
-  void UseTex(Texture::Ref v = nullptr) {
-    if (v == nullptr) {
-      current_tex = white;
-      return;
-    }
-    current_tex = v;
-  }
-
-  /**
-   * Draws a Rect based on current Texture
-   * @param pos Position of the Rect
-   * @param size Size of the Rect
-   * @param color Color of the Rect [0xffffffff]
-   * for full visible texture
-   * @param uv UV Map (if texture needs a custom uv)
-   * @note This function is part of Simple Draw API.
-   */
-  void DrawRect(const vec2& pos, const vec2& size, u32 color,
-                const Rect& uv = vec4(0.f, 1.f, 1.f, 0.f));
-  /**
-   *  Draw a Solid Rect (uses white tex)
-   * @note
-   * - acts as a simplified Draw rect Wrapper
-   * - This function is part of Simple Draw API.
-   * @param pos Position of the rect
-   * @param size Size of the rect
-   * @param color Color of the rect
-   */
-  void DrawRectSolid(const vec2& pos, const vec2& size, u32 color);
-  /**
-   *  Render a Triangle
-   * @param a Position A
-   * @param b Position B
-   * @param c Position C
-   * @param color Color of the triangle
-   * @note
-   * - Uses Solid color [white tex]
-   * - This function is part of Simple Draw API.
-   */
-  void DrawTriangle(const vec2& a, const vec2& b, const vec2& c, u32 color);
-  /**
-   *  Draw a Circle (Supports Textures)
-   * @param center_pos Center Position
-   * @param r Radius of the circle
-   * @param color Color of the circle
-   * @param segments Segments to use
-   * @note
-   * - Textures could look a bit janky due to uv mapping
-   * - This function is part of Simple Draw API.
-   */
-  void DrawCircle(const vec2& center_pos, float r, u32 color, int segments);
-  /**
-   * Draw a Line between to Positions
-   * @param a Position A
-   * @param b Position B
-   * @param color Color of the line
-   * @param t Thickness
-   * @note This function is part of Simple Draw API.
-   */
-  void DrawLine(const vec2& a, const vec2& b, u32 color, int t);
-  /**
-   * Render a Text
-   * @param pos Position of the text
-   * @param color Color of the Text
-   * @param text Text to Render
-   * @param flags flags to use
-   * @param ap optional size for specific flags
-   * @note This function is part of Simple Draw API.
-   */
-  void DrawText(const vec2& pos, u32 color, const std::string& text,
-                u32 flags = 0, const vec2& ap = vec2());
-  /**
-   * Draw a Texture as 2D Image
-   * @param pos Position
-   * @param tex Texture reference
-   * @param scale Scale (cause maybe wants to be resized)
-   * @note
-   * - Acts as a Simplified wrapper to DrawRect
-   * - This function is part of Simple Draw API.
-   */
-  void DrawImage(const vec2& pos, Texture::Ref tex,
-                 const vec2& scale = vec2(1.f));
-
-  // Debug STUFF
-
-  /** DEBUG Get the Number of Vertices of last Frame */
-  u32 Vertices() const { return vertices; }
-  /** DEBUG Get the Number of Indices of last frame */
-  u32 Indices() const { return indices; }
-  /** DEBUG Get the Number of Commands of last frame */
-  u32 Commands() const { return commands; }
-  /** DEBUG Get the Number of Drawcalls of last frame */
-  u32 DrawCalls() const { return drawcalls; }
-  /** Auto Static Text Number of Texts */
-  u32 AstUsage() const { return ast.size(); }
-  /** Text Map System number of texts */
-  u32 TmsUsage() const { return tms.size(); }
-
-  // TOOLS
-
-  /** Rotate a rect corner position by sine and cosine value */
-  static void RotateCorner(vec2& v, float s, float c);
-  /** Create a Rect by Position, Size and rotation angle */
-  static Rect CreateRect(const vec2& pos, const vec2& size, float angle);
-  /** Create a Line Rect by 2 Position and a thickness value */
-  static Rect CreateLine(const vec2& a, const vec2& b, int t);
-  /** Check if a pos and size are inside a vec4 rect */
-  static bool InBox(const vec2& pos, const vec2& size, const vec4& rect);
-  /** Check if a pos is inside a vec4 rect */
-  static bool InBox(const vec2& pos, const vec4& rect);
-  /** Check if one or all of three positions are somehow inside a vec4 rect */
-  static bool InBox(const vec2& alpha, const vec2& bravo, const vec2& charlie,
-                    const vec4& rect);
-  /**
-   * Get The Address of a Screen
-   * @note **IMPORTANT** THIS IS FOR 32Bit System
-   *
-   * Should find a better way to do this for porting this lib
-   */
-  static u32 Screen32(Screen::Ref s) { return (u32)s.get(); }
-  /** Function to optimize command order for rendering */
-  static void OptiCommandList(std::vector<Command::Ref>& list);
-  /** Returns Viewport with xy */
-  vec4 GetViewport();
-  /** Push a Self Created command */
-  void PushCommand(Command::Ref cmd) {
-    cmd->Index(cmd_idx++);  // Indexing
-    draw_list[Screen32(screen)].push_back(cmd);
-  }
-  /** Automatically sets up a command */
-  void SetupCommand(Command::Ref cmd);
-  /** Creates a default Quad Render Command */
-  void QuadCommand(Command::Ref cmd, const Rect& quad, const Rect& uv, u32 col);
-  /** Create a Default Triangle */
-  void TriangleCommand(Command::Ref cmd, const vec2& a, const vec2& b,
-                       const vec2& c, u32 col);
-  /**
-   * Create List of a Text Commands
-   * @param cmds Link to a command List
-   * @param pos Position
-   * @param color Color
-   * @param text Text
-   * @param flags Flags
-   * @param box (Size for wrapping / Offset for Centered Text)
-   */
-  void TextCommand(std::vector<Command::Ref>& cmds, const vec2& pos, u32 color,
-                   const std::string& text, LITextFlags flags, const vec2& box);
-  vec2 GetTextDimensions(const std::string& text);
-  /**
-   * Function to short a text and replace the rest by ...
-   * @param text Text to short
-   * @param maxlen Maximum width
-   * @param newsize New Textbox size
-   * @return shorted text
-   */
-  std::string ShortText(const std::string& text, int maxlen, vec2& newsize);
-  /**
-   * Function to Wrap Text by specific width
-   *
-   * **NOT IMPLEMENTED YET**
-   * @param text text to wrap
-   * @param maxlen maximum width per line
-   * @param newsize new textbox size
-   * @return wrapped text
-   */
-  std::string WrapText(const std::string& text, int maxlen, vec2& newsize);
-
- private:
-  // Helper Funcitons
-
-  /**
-   * Update the 3DS citro3d texenv for specific RenderMode
-   * @param mode RenderMode to use.
-   */
-  void UpdateRenderMode(const RenderMode& mode);
-
-  /** Current Screen */
-  Screen::Ref screen;
-  /** Screen Regestry */
-  Screen::Ref screens[2];
-
-  // Context Related
-
-  /** Renderer flags */
-  LIRenderFlags flags = LIRenderFlags_Default;
-  /** Area Size */
-  vec2 area_size;
-  /** Current Layer */
-  int current_layer = 0;
-  /** Current Texture */
-  Texture::Ref current_tex = nullptr;
-  /** Single Color Texture (for solid color objs) */
-  Texture::Ref white = nullptr;
-  /** Current Font Reference */
-  Font::Ref font = nullptr;
-  /** Font updated */
-  bool font_update;
-  /** Current Rendermode */
-  RenderMode mode = RenderMode_RGBA;
-  /** Text Map System */
-  std::map<std::string, TextBox> tms;
-  /** (Auto) Static Text */
-  std::unordered_map<u32, StaticText::Ref> ast;
-
-  // Text Rendering
-
-  /** Default FOnt height */
-  const float default_font_h = 24.f;
-  /** Default Text Scale */
-  const float default_text_size = 0.7f;
-  /** Current Text Scale */
-  float text_size = 0.7f;
-  // Special
-
-  /** Current Rotation (RECTS) */
-  float rot = 0.f;
-  // Rendering
-
-  /** Map of drawlist by 32Bit memory Address of their Screen */
-  std::unordered_map<u32, std::vector<Command::Ref>> draw_list;
-  /** Vertex Buffer in linear Ram */
-  std::vector<Vertex, LinearAllocator<Vertex>> vertex_buf;
-  /** 16Bit index buffer in linear Ram */
-  std::vector<u16, LinearAllocator<u16>> index_buf;
-  /** vertex index (render stage) */
-  u32 vertex_idx = 0;
-  /** index buf index (render stage) */
-  u32 index_idx = 0;
-  /** command index (used for debug count) */
-  u32 cmd_idx = 0;
-
-  // Debug
-
-  /** Num of Vertices */
-  u32 vertices = 0;
-  /** Num of indices */
-  u32 indices = 0;
-  /** Num of Commands */
-  u32 commands = 0;
-  /** Num of Drawcalls */
-  u32 drawcalls = 0;
-
-  // Shader
-
-  /** Shader code */
-  DVLB_s* dvlb = nullptr;
-  /** Shader program */
-  shaderProgram_s shader;
-  /** Shader Attribute info */
-  C3D_AttrInfo attr;
-  /** projection matrix location */
-  int uLoc_projection = 0;
-
-  // Matrix
-
-  /** Precalculated Projectrion Matrix for top screen */
-  C3D_Mtx top_proj;
-  /** Precalculated Projectrion Matrix for bottom screen */
-  C3D_Mtx bot_proj;
-};
-}  // namespace LI
-}  // namespace PD

include/pd/lithium/screen.hpp

@@ -1,98 +0,0 @@
-#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 <3ds.h>
-#include <citro3d.h>
-
-#include <pd/core/common.hpp>
-#include <pd/core/vec.hpp>
-
-namespace PD {
-/**
- * 3DS Screen (RenderTarget)
- */
-class Screen : public SmartCtor<Screen> {
- public:
-  /** Screens */
-  enum Screen_ {
-    Top,      ///< Top Screen
-    Bottom,   ///< Bottom Screen
-    TopRight  ///< Top Right Screen area
-  };
-  /**
-   * Constructor to create Screen by Screen Type
-   * @param screen Screen to grab default init values for
-   */
-  Screen(Screen_ screen) : type(screen) {
-    if (screen == Top) {
-      target = C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8,
-                                      GPU_RB_DEPTH24_STENCIL8);
-      C3D_RenderTargetSetOutput(target, GFX_TOP, GFX_LEFT,
-                                DisplayTransferFlags);
-    } else if (screen == Bottom) {
-      target = C3D_RenderTargetCreate(240, 320, GPU_RB_RGBA8,
-                                      GPU_RB_DEPTH24_STENCIL8);
-      C3D_RenderTargetSetOutput(target, GFX_BOTTOM, GFX_LEFT,
-                                DisplayTransferFlags);
-    } else if (screen == TopRight) {
-      target = C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8,
-                                      GPU_RB_DEPTH24_STENCIL8);
-      C3D_RenderTargetSetOutput(target, GFX_TOP, GFX_RIGHT,
-                                DisplayTransferFlags);
-    }
-  }
-  ~Screen() = default;
-
-  /** Clear the Screen */
-  void Clear() { C3D_RenderTargetClear(target, C3D_CLEAR_ALL, 0x00000000, 0); }
-  /** Set the Screen active for Rendering */
-  void Use() { C3D_FrameDrawOn(target); }
-
-  /** Get the Screens Size */
-  vec2 GetSize() const {
-    return vec2(target->frameBuf.height, target->frameBuf.width);
-  }
-
-  /** Get the Screen Type */
-  Screen_ ScreenType() const { return type; }
-
-  /** Get the Raw Rendertarget object */
-  C3D_RenderTarget* Get() const { return target; }
-  /** Operartor to get the raw RenderTarget */
-  operator C3D_RenderTarget*() const { return target; }
-
- private:
-  /** Screen Type */
-  Screen_ type;
-  /** Default Init Flags */
-  const u32 DisplayTransferFlags =
-      (GX_TRANSFER_FLIP_VERT(0) | GX_TRANSFER_OUT_TILED(0) |
-       GX_TRANSFER_RAW_COPY(0) | GX_TRANSFER_IN_FORMAT(GX_TRANSFER_FMT_RGBA8) |
-       GX_TRANSFER_OUT_FORMAT(GX_TRANSFER_FMT_RGB8) |
-       GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_NO));
-  /** RenderTarget */
-  C3D_RenderTarget* target;
-};
-}  // namespace PD

include/pd/lithium/spritesheet.hpp

@@ -1,66 +0,0 @@
-#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 <citro3d.h>
-#include <tex3ds.h>
-
-#include <pd/core/common.hpp>
-#include <pd/lithium/texture.hpp>
-
-namespace PD {
-/**
- * Tex 3DS Spritesheet integration to Lithium
- */
-class SpriteSheet : public SmartCtor<SpriteSheet> {
- public:
-  SpriteSheet() = default;
-  /**
-   * Constructor to directly load a spritesheet
-   * @param path Path to spritesheet
-   */
-  SpriteSheet(const std::string& path) { this->LoadFile(path); }
-  /**
-   * Deconstructor to unload the Spritesheet
-   */
-  ~SpriteSheet();
-
-  /**
-   * Function to load a Spritesheet
-   * @param path Path to the file
-   */
-  void LoadFile(const std::string& path);
-  /** Get a Textures Reference */
-  Texture::Ref Get(int idx);
-  /** Get Number of Textures in spritesheet */
-  int NumTextures() const;
-
-  /** Operator to get Texture reference */
-  Texture::Ref operator[](int idx) { return Get(idx); }
-
- private:
-  /** Storage of the Spritesheets textures */
-  std::vector<Texture::Ref> textures;
-};
-}  // namespace PD

include/pd/lithium/texture.hpp

@@ -1,153 +1,59 @@
 #pragma once
 
-/*
+#include <pd/core/core.hpp>
-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 <citro3d.h>
-
-#include <pd/core/common.hpp>
-#include <pd/core/vec.hpp>
 #include <pd/lithium/rect.hpp>
 
 namespace PD {
-/**
+using TextureID = ptr;
- * Lithium Texture Loader / DataHolder
+enum class TextureFilter {
- */
+  Linear,
-class Texture : public SmartCtor<Texture> {
+  Nearest,
+};
+
+enum class TextureFormat {
+  RGBA32,
+  RGB24,
+  A8,
+};
+namespace Li {
+inline int TextureFormat2Bpp(TextureFormat fmt) {
+  switch (fmt) {
+    case PD::TextureFormat::A8:
+      return 1;
+    case PD::TextureFormat::RGB24:
+      return 3;
+    case PD::TextureFormat::RGBA32:
+      return 4;
+    default:
+      return 0;
+  }
+}
+class Texture {
  public:
-  /** Texture Type */
+  using Ptr = Texture*;
-  enum Type {
+  Texture() : pID(0), pSize(0, 0), pUV(fvec4(0, 0, 1, 1)) {}
-    RGBA32,  ///< RGBA 32
+  Texture(TextureID id, ivec2 size)
-    RGB24,   ///< RGB24
+      : pID(id), pSize(size), pUV(fvec4(0, 0, 1, 1)) {}
-    A8,      ///< A8
-  };
-  /** Texture Filters */
-  enum Filter {
-    NEAREST,  ///< Nearest
-    LINEAR,   ///< Linear
-  };
-  /** Default constructor */
-  Texture() : uv(0.f, 1.f, 1.f, 0.f) {}
-  /**
-   * Load file Constructor
-   * @param path path to file
-   * @param t3x set true if file is a t3x file
-   */
-  Texture(const std::string& path, bool t3x = false) : uv(0.f, 1.f, 1.f, 0.f) {
-    if (t3x) {
-      this->LoadT3X(path);
-    } else {
-      this->LoadFile(path);
-    }
-  }
-  /**
-   * Load Memory constructor
-   * @param data File Data reference
-   */
-  Texture(const std::vector<u8>& data) : uv(0.f, 1.f, 1.f, 0.f) {
-    this->LoadMemory(data);
-  }
-  /**
-   * Load Pixels constructor
-   * @param data Pixel Buffer reference
-   * @param w width
-   * @param h height
-   * @param type Buffer Type [Default RGBA32]
-   * @param filter Filter [DEFAULT NEAREST]
-   */
-  Texture(const std::vector<u8>& data, int w, int h, Type type = RGBA32,
-          Filter filter = NEAREST)
-      : uv(0.f, 1.f, 1.f, 0.f) {
-    this->LoadPixels(data, w, h, type, filter);
-  }
-  /** Deconstructor (aka auto delete) */
-  ~Texture() {
-    if (autounload) {
-      Delete();
-    }
-  }
 
-  /// @brief Deletes image (if not already unloaded)
+  const ivec2& GetSize() const { return pSize; }
-  void Delete();
+  TextureID GetID() { return pID; }
+  const TextureID& GetID() const { return pID; }
+  const Rect& GetUV() const { return pUV; }
 
-  /// @brief Load a png/jpg/bmp from fs into a gpu tex
+  void SetSize(int x, int y) {
-  /// @param path path to image file
+    pSize.x = x;
-  void LoadFile(const std::string& path);
+    pSize.y = y;
-  /// @brief Load a png/jpg/bmp from memory
-  /// @param data reference to data buffer of the file
-  void LoadMemory(const std::vector<u8>& data);
-  /// @brief Create Texture out of Pixel Data
-  /// @param data Data reference
-  /// @param w width
-  /// @param h heigt
-  /// @param type Type of the databuffer
-  /// @param filter Filter (NEAREST OR LINEAR)
-  void LoadPixels(const std::vector<u8>& data, int w, int h, Type type = RGBA32,
-                  Filter filter = NEAREST);
-
-  /// @brief Load a texture of a T3X File
-  /// @note This is used for single texture T3X
-  /// Not for SpriteSheets
-  /// @param path path to .t3x file
-  void LoadT3X(const std::string& path);
-
-  /// @brief Input a Texture that you had set up on your own
-  /// @param tex Texture reference (deletes itself)
-  /// @param rszs The size of the source image
-  /// @param uvs Your uv Setup
-  void LoadExternal(C3D_Tex* tex, vec2 rszs, LI::Rect uvs) {
-    this->Delete();
-    this->tex = tex;
-    this->size = rszs;
-    this->uv = uvs;
   }
-
+  void SetSize(const ivec2& size) { pSize = size; }
-  vec2 GetRealSize() {
+  void SetID(TextureID id) { pID = id; }
-    if (!tex) {
+  void SetUV(const Rect& uv) { pUV = uv; }
-      return vec2();
+  void SetUV(const fvec4& uv) { pUV = uv; }
-    }
+  void SetUV(float t, float l, float b, float r) { SetUV(fvec4(t, l, b, r)); }
-    return vec2(tex->width, tex->height);
-  }
-  vec2 GetSize() const { return size; }
-  C3D_Tex* GetTex() const { return tex; }
-  LI::Rect GetUV() const { return uv; }
-  bool IsValid() const { return tex != 0; }
-
-  bool AutoUnLoad() const { return autounload; }
-  void AutoUnLoad(bool v) { autounload = v; }
-
-  operator C3D_Tex*() const { return tex; }
-  operator vec2() const { return size; }
-  operator LI::Rect() const { return uv; }
-  operator bool() const { return tex != 0; }
 
  private:
-  void MakeTex(std::vector<u8>& buf, int w, int h, Type type = RGBA32,
+  TextureID pID;
-               Filter filter = NEAREST);
+  ivec2 pSize;
-  vec2 size;
+  Rect pUV;
-  LI::Rect uv;
-  C3D_Tex* tex = nullptr;
-  bool autounload = true;
 };
+}  // namespace Li
 }  // namespace PD