small fix for shaders

.clang-format

@@ -1,334 +0,0 @@
----
-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
-...
-

.gitattributes

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

.gitignore

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

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "vendor/stb"]
+[submodule "backends/desktop/glfw"]
-	path = vendor/stb
+	path = backends/desktop/glfw
-	url = https://github.com/nothings/stb.git
-[submodule "vendor/glfw"]
-	path = vendor/glfw
 	url = https://github.com/glfw/glfw.git

.vscode/c_cpp_properties.json

@@ -0,0 +1,37 @@
+{
+    "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",
+                "__3DS__"
+            ],
+            "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

@@ -0,0 +1,21 @@
+{
+    "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

@@ -0,0 +1,120 @@
+{
+    "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,129 +1,158 @@
-cmake_minimum_required(VERSION 3.22)
+cmake_minimum_required(VERSION 3.18)
 
-include(GNUInstallDirs)
+### Helper Function to Build Librarys without have always
+### These includes and definition defines
+function(add_pd_lib TARGET_NAME)
+set(opts "BUILD_SHARED")
+set(one_val_args "")
+set(multi_val_args SRC_FILES DEPENDS)
+cmake_parse_arguments(ARG "${opts}" "${one_val_args}" "${multi_val_args}" ${ARGN})
+
+string(REPLACE "-" "_" FLAG_NAME_T ${TARGET_NAME})
+string(TOUPPER ${FLAG_NAME_T} FLAG_NAME_F)
+
+if(ARG_BUILD_SHARED)
+    add_library(${TARGET_NAME} SHARED ${ARG_SRC_FILES})
+    target_compile_definitions(${TARGET_NAME} PUBLIC -D${FLAG_NAME_F}_BUILD_SHARED=1)
+    message("Building SHARED library: ${FLAG_NAME_F}_BUILD_SHARED=1")
+else()
+    add_library(${TARGET_NAME} STATIC ${ARG_SRC_FILES})
+    target_compile_definitions(${TARGET_NAME} PUBLIC -D${FLAG_NAME_F}_BUILD_SHARED=0)
+    message("Building STATIC library: ${FLAG_NAME_F}_BUILD_SHARED=0")
+endif()
+target_include_directories(${TARGET_NAME} PUBLIC
+    include
+    ${DEVKITPRO}/portlibs/3ds/include
+    backends)
+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()
+
+## 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.7.0)
+project(palladium LANGUAGES C CXX VERSION 0.4.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_SHARED "Build Shared Libraries" OFF)
-option(PD_BUILD_TOOLS "Build Palladium Tools" OFF)
 
-if(${PD_BUILD_TOOLS})
+message("Var: ${PD_BUILD_SHARED}")
-    add_subdirectory(tools)
-endif()
 
-add_subdirectory(vendor)
+# Enable Compile Command Export
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-# # Include Library Source
+# Force C++ 20
-set(PD_SOURCES
+set(CMAKE_CXX_STANDARD 20)
-    # Common
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
-    source/common.cpp
-
-    # Core
-    source/core/bits.cpp
-    source/core/color.cpp
-    source/core/mat.cpp
-    source/core/strings.cpp
-
-    # Drivers
-    source/drivers/os.cpp
-    source/drivers/gfx.cpp
-
-    # Lithium
-    source/lithium/pools.cpp
-)
 
+# Set Special C and CXX flags for 3ds
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
 if(${PD_BUILD_SHARED})
-    add_library(palladium SHARED ${PD_SOURCES})
+message(ERROR "3DS Only supports Static libraries")
-    target_compile_definitions(palladium PRIVATE PD_BUILD_SHARED)
+endif()
+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")
+endif()
+#include_directories(include)
+
+## 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/hid_driver.cpp
+source/core/mat.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)
+
+## Lithiu, Source Code
+set(LI_SRC
+source/lithium/font.cpp
+source/lithium/drawlist.cpp
+source/lithium/renderer.cpp)
+
+## Net Source Code
+set(NET_SRC
+source/net/socket.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/remenu.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/dynobj.cpp
+source/ui7/container/image.cpp
+source/ui7/container/label.cpp)
+
+#### Creating the Libraries ####
+if(PD_BUILD_SHARED)
+add_pd_lib(pd-core BUILD_SHARED TRUE SRC_FILES ${CORE_SRC})
+add_pd_lib(pd-image BUILD_SHARED TRUE SRC_FILES ${IMAGE_SRC} DEPENDS pd-core)
+add_pd_lib(pd-external SRC_FILES ${EXTERNAL_SRC})
+add_pd_lib(pd-lithium BUILD_SHARED TRUE SRC_FILES ${LI_SRC} DEPENDS pd-core)
+add_pd_lib(pd-net BUILD_SHARED TRUE SRC_FILES ${NET_SRC} DEPENDS pd-core)
+add_pd_lib(pd-ui7 BUILD_SHARED TRUE SRC_FILES ${UI7_SRC} DEPENDS pd-core pd-lithium)
 else()
-    add_library(palladium STATIC ${PD_SOURCES})
+add_pd_lib(pd-core SRC_FILES ${CORE_SRC})
-    target_compile_definitions(palladium PUBLIC PD_BUILD_STATIC)
+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-lithium SRC_FILES ${LI_SRC} DEPENDS pd-core)
+add_pd_lib(pd-net SRC_FILES ${NET_SRC} DEPENDS pd-core)
+add_pd_lib(pd-ui7 SRC_FILES ${UI7_SRC} DEPENDS pd-core pd-lithium)
 endif()
 
-target_compile_definitions(palladium PUBLIC PD_DEBUG)
+add_library(palladium INTERFACE)
-target_compile_options(palladium
+target_link_libraries(palladium INTERFACE
-    PUBLIC
+pd-core pd-image pd-external pd-lithium pd-net pd-ui7
-    $<$<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)
+add_dependencies(palladium
-
+pd-core pd-image pd-external pd-lithium pd-net pd-ui7
-target_include_directories(palladium
-    PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:include>
 )
 
-target_compile_options(palladium
+install(DIRECTORY include DESTINATION ".")
-    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
-)
-
-add_custom_target(pd-clang-format
-    COMMAND ${CLANG_FORMAT} --style=file -i ${PD_FMTFILES}
-    COMMENT "Formatting Project Sources"
-)
-
-add_subdirectory(backends)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tests)

LICENSE

@@ -1,6 +1,6 @@
 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

README.md

@@ -23,11 +23,27 @@ make
 make install
 ```
 
+## Libraries
+
+| Name | Last Updated | Platform | Depends |
+|---|---|---|---|
+| pd-core | 0.3.3 | multi | none |
+| pd-external | 0.1.0 | multi | none |
+| pd-image | 0.3.3 | 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.3.3 | multi | pd-core |
+| 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.3 | multi | pd-core, 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/3ds/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.22)
+
+# Make sure to use 3ds toolschain for 3ds build :)
+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()
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-psabi -O3")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_C_FLAGS} -fno-rtti -fno-exceptions")
+
+add_library(pd-backend-3ds STATIC
+source/li_backend_c3d.cpp
+source/pd_hid_3ds.cpp)
+target_include_directories(pd-backend-3ds PUBLIC include)
+target_link_libraries(pd-backend-3ds PUBLIC palladium)

backends/3ds/include/li_backend_c3d.hpp

@@ -0,0 +1,84 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#pragma once
+
+#include <3ds.h>
+#include <citro3d.h>
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/backend.hpp>
+
+namespace PD {
+template <typename T>
+class LinearAlloc : public Allocator<T> {
+ public:
+  LinearAlloc() = default;
+  ~LinearAlloc() = default;
+
+  /** Never forget the sizeof(T) again (most painful bug i created) */
+  T* Allocate(size_t n) override { return (T*)linearAlloc(n * sizeof(T)); }
+  void Deallocate(T* ptr) { linearFree(ptr); }
+};
+namespace LI {
+class Backend_C3D : public PD::LI::Backend {
+ public:
+  Backend_C3D() : LI::Backend("Citro3D") {}
+  ~Backend_C3D() {}
+  PD_SMART_CTOR(Backend_C3D)
+
+  void Init() override;
+
+  void Deinit() override;
+
+  void NewFrame() override;
+
+  void BindTexture(PD::LI::TexAddress addr) override;
+
+  void RenderDrawData(const PD::Vec<PD::LI::Command::Ref>& Commands) override;
+
+  PD::LI::Texture::Ref LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::LI::Texture::Type type = PD::LI::Texture::Type::RGBA32,
+      PD::LI::Texture::Filter filter =
+          PD::LI::Texture::Filter::LINEAR) override;
+
+ private:
+  Vec<Vertex, LinearAlloc<Vertex>> VertexBuffer;
+  Vec<u16, LinearAlloc<u16>> IndexBuffer;
+  size_t CurrentVertex = 0;
+  size_t CurrentIndex = 0;
+  Mat4 Projection;
+  int pLocProjection = 0;
+  DVLB_s* ShaderCode;
+  shaderProgram_s Shader;
+  C3D_AttrInfo ShaderInfo;
+  // For Stats
+  PD::u32 num_vtx = 0;
+  PD::u32 num_idx = 0;
+};
+}  // namespace LI
+}  // namespace PD

backends/3ds/include/pd_hid_3ds.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,32 +23,21 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/hid_driver.hpp>
 
 namespace PD {
-namespace Std {
+class Hid3DS : public Hid {
-template <typename T>
-class Vector {
  public:
-  // for c++ std stuff
+  /**
-  using value_type = T;
+   * Constructor to setup Key binds
-  using iterator = value_type*;
+   */
-  using const_iterator = const value_type*;
+  Hid3DS();
+  ~Hid3DS() = default;
+  PD_SMART_CTOR(Hid3DS)
 
-  Vector() {
+  /**
-    Size = 0;
+   * Overrideing the Update Function for Input Checking etc
-    Cap = 0;
+   */
-    Data = nullptr;
+  void Update() override;
-  }
-  ~Vector() {
-    if (Data) {
-      delete Data;
-    }
-  }
-
-  T* Data = nullptr;
-  size_t Size = 0;
-  size_t Cap = 0;
 };
-}  // namespace Std
 }  // namespace PD

backends/3ds/include/pd_net_3ds.hpp

@@ -0,0 +1,117 @@
+#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 <arpa/inet.h>
+#include <malloc.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#include <pd/net/backend.hpp>
+
+namespace PD {
+class NetBackend3DS : public Net::Backend {
+ public:
+  NetBackend3DS() : Net::Backend("3DS") {}
+  ~NetBackend3DS() = default;
+  PD_SMART_CTOR(NetBackend3DS)
+
+  bool Init() override {
+    pSocBuffer = (uint32_t*)memalign(pSocAlign, pSocBufferSize);
+    Result ret = 0;
+    if (pSocBuffer == NULL) {
+      return false;
+    }
+
+    if ((ret = socInit(pSocBuffer, pSocBufferSize)) != 0) {
+      return false;
+    }
+    return true;
+  }
+
+  void Deinit() override { socExit(); }
+  int NewSocket() override { return socket(AF_INET, SOCK_STREAM, 0); }
+  void Close(int sock_id) override { close(sock_id); }
+  int GetInvalidRef() const override { return -1; }
+
+  bool Bind(int sock_id, u16 port) {
+    sockaddr_in addr{};
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = INADDR_ANY;
+    return bind(sock_id, (sockaddr*)&addr, sizeof(addr)) != -1;
+  }
+  bool Listen(int sock_id, int backlog = 5) {
+    return listen(sock_id, backlog) != -1;
+  }
+
+  bool WaitForRead(int sock_id, int timeout_ms) override {
+    fd_set set;
+    FD_ZERO(&set);
+    FD_SET(sock_id, &set);
+
+    timeval timeout{};
+    timeout.tv_sec = timeout_ms / 1000;
+    timeout.tv_usec = (timeout_ms % 1000) * 1000;
+
+    int result = select(sock_id + 1, &set, nullptr, nullptr, &timeout);
+    return (result > 0 && FD_ISSET(sock_id, &set));
+  }
+
+  bool Accept(int sock_id, Net::Socket::Ref client) {
+    int client_soc = accept(sock_id, nullptr, nullptr);
+    if (client_soc == -1) {
+      return false;
+    }
+    client->pSocket = client_soc;
+    return true;
+  }
+  bool Connect(int sock_id, const std::string& ip, u16 port) {
+    sockaddr_in addr{};
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    inet_pton(AF_INET, ip.c_str(), &addr.sin_addr);
+    return connect(sock_id, (sockaddr*)&addr, sizeof(addr)) != -1;
+  }
+  int Send(int sock_id, const std::string& data) {
+    return send(sock_id, data.c_str(), static_cast<int>(data.size()), 0);
+  }
+  int Receive(int sock_id, std::string& data, int size = 1024) {
+    char* tmp = new char[size];
+    int res = recv(sock_id, tmp, size, 0);
+    if (res > 0) {
+      data.assign(tmp, res);
+    }
+    delete[] tmp;
+    return res;
+  }
+
+ private:
+  /** using libctru u32 here */
+  const uint32_t pSocAlign = 0x1000;
+  const uint32_t pSocBufferSize = 0x100000;
+  uint32_t* pSocBuffer = nullptr;
+};
+}  // namespace PD

backends/3ds/source/li_backend_c3d.cpp

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

backends/3ds/source/pd_hid_3ds.cpp

@@ -0,0 +1,60 @@
+#include <3ds.h>
+
+#include <pd_hid_3ds.hpp>
+
+namespace PD {
+Hid3DS::Hid3DS() : Hid("3DS") {
+  binds[KEY_A] = A;
+  binds[KEY_B] = B;
+  binds[KEY_X] = X;
+  binds[KEY_Y] = Y;
+  binds[KEY_START] = Start;
+  binds[KEY_SELECT] = Select;
+  binds[KEY_L] = L;
+  binds[KEY_R] = R;
+  binds[KEY_DUP] = DUp;
+  binds[KEY_DDOWN] = DDown;
+  binds[KEY_DLEFT] = DLeft;
+  binds[KEY_DRIGHT] = DRight;
+  binds[KEY_CPAD_UP] = CPUp;
+  binds[KEY_CPAD_DOWN] = CPDown;
+  binds[KEY_CPAD_LEFT] = CPLeft;
+  binds[KEY_CPAD_RIGHT] = CPRight;
+  binds[KEY_CSTICK_UP] = CSUp;
+  binds[KEY_CSTICK_DOWN] = CSDown;
+  binds[KEY_CSTICK_LEFT] = CSLeft;
+  binds[KEY_CSTICK_RIGHT] = CSRight;
+  binds[KEY_ZL] = ZL;
+  binds[KEY_ZR] = ZR;
+  binds[KEY_TOUCH] = Touch;
+}
+void Hid3DS::Update() {
+  hidScanInput();
+  for (int i = 0; i < 2; i++) {
+    key_events[i][Event_Down] = 0;
+    key_events[i][Event_Held] = 0;
+    key_events[i][Event_Up] = 0;
+  }
+  u32 kd = hidKeysDown();
+  u32 kh = hidKeysHeld();
+  u32 ku = hidKeysUp();
+  for (auto &b : binds) {
+    if (b.first & kd) {
+      key_events[0][Event_Down] |= b.second;
+    }
+    if (b.first & kh) {
+      key_events[0][Event_Held] |= b.second;
+    }
+    if (b.first & ku) {
+      key_events[0][Event_Up] |= b.second;
+    }
+  }
+  if (locked) {
+    SwappyTable();
+  }
+  touchPosition t;
+  hidTouchRead(&t);
+  touch[1] = touch[0];  // Cycle touch pos
+  touch[0] = fvec2(t.px, t.py);
+}
+}  // namespace PD

backends/CMakeLists.txt

@@ -1,63 +0,0 @@
-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)
-
-if(NOT WIN32) # cause we are not on windows...
-    set(PD_ENABLE_DIRECTX9 OFF)
-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
-)
-
-target_include_directories(pd-system
-    PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE: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>
-)
-
-# Palladium
-target_link_libraries(pd-system PUBLIC palladium::palladium)
-
-# glad (if we have any OpenGL version included)
-if(PD_ENABLE_OPENGL2 OR PD_ENABLE_OPENGL3)
-    target_link_libraries(pd-system
-        PUBLIC
-        glad
-    )
-endif()
-
-# DirectX9
-if(PD_ENABLE_DIRECTX9)
-    target_link_libraries(pd-system
-        PUBLIC
-        d3d9
-        d3dcompiler
-    )
-endif()

backends/desktop/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.22)
+
+if(WIN32)
+set(EXTRA_LIBS ws2_32)
+else()
+set(EXTRA_LIBS)
+endif()
+
+add_subdirectory(glfw)
+add_subdirectory(glad)
+
+# if(PD_BUILD_SHARED)
+# add_library(pd-backend-desktop SHARED
+# source/li_backend_gl2.cpp
+# source/pd_hid_glfw.cpp)
+# target_compile_definitions(pd-backend-desktop PUBLIC
+#     -DPD_BKND_DESKTOP_BUILD_SHARED=1)
+# else()
+add_library(pd-backend-desktop STATIC
+source/li_backend_gl2.cpp
+source/pd_hid_glfw.cpp)
+#endif()
+
+target_compile_definitions(pd-backend-desktop PUBLIC
+     -DPD_BKND_DESKTOP_STATIC=1)
+target_include_directories(pd-backend-desktop PUBLIC include)
+target_link_libraries(pd-backend-desktop PUBLIC glad glfw palladium ${EXTRA_LIBS})

backends/desktop/glad/CMakeLists.txt

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

backends/desktop/include/li_backend_gl2.hpp

@@ -0,0 +1,46 @@
+#include <glad/glad.h>
+
+/** SEPARATOR */
+#include <GLFW/glfw3.h>
+/** SEPARATOR */
+#include <pd/core/core.hpp>
+#include <pd/lithium/backend.hpp>
+#include <pd_p_bknd_api.hpp>
+
+namespace PD {
+namespace LI {
+class PD_BKND_DESKTOP_API Backend_GL2 : public PD::LI::Backend {
+ public:
+  Backend_GL2() : LI::Backend("OpenGL2") {}
+  ~Backend_GL2() {}
+
+  PD_SMART_CTOR(Backend_GL2)
+
+  void Init() override;
+  void Deinit() override;
+  void NewFrame() override;
+  void BindTexture(PD::LI::TexAddress addr) override;
+  void RenderDrawData(const PD::Vec<PD::LI::Command::Ref>& Commands) override;
+  PD::LI::Texture::Ref LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::LI::Texture::Type type = PD::LI::Texture::Type::RGBA32,
+      PD::LI::Texture::Filter filter =
+          PD::LI::Texture::Filter::LINEAR) override;
+
+ private:
+  PD::Vec<PD::LI::Vertex> VertexBuffer;
+  PD::Vec<PD::u16> IndexBuffer;
+  size_t CurrentVertex = 0;
+  size_t CurrentIndex = 0;
+  GLuint Shader;
+  GLuint pLocProjection;
+  GLuint pLocTex;
+  Mat4 Projection;
+  GLuint VBO, IBO;
+  // For Stats
+  PD::u32 num_vtx = 0;
+  PD::u32 num_idx = 0;
+};
+
+}  // namespace LI
+}  // namespace PD

backends/desktop/include/pd_hid_glfw.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,20 +23,28 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-/** Header for all source file functions */
+#include <GLFW/glfw3.h>
 
-#include <format>  // yes this tool requires at least c++ 20
+#include <pd/core/hid_driver.hpp>
-#include <fstream>
+#include <pd_p_bknd_api.hpp>
-#include <sstream>
-#include <string>
-#include <vector>
 
-namespace LVec {
+namespace PD {
-const std::vector<std::string> elems = {"x", "y", "z", "w"};
+class PD_BKND_DESKTOP_API HidGLFW : public Hid {
-std::string GenerateHeader(int n);
+ public:
-std::string MakeOperationFor(char op, int n);
+  /**
-std::string GenericOperations(int n);
+   * Constructor to setup Key binds
-std::string MakeFunctions(int n);
+   */
-std::string MakeSwap(int n);
+  HidGLFW(GLFWwindow* win);
-std::string MakeConstructors(int n);
+  ~HidGLFW() = default;
-}  // namespace LVec
+  PD_SMART_CTOR(HidGLFW)
+
+  /**
+   * Overrideing the Update Function for Input Checking etc
+   */
+  void Update() override;
+
+ private:
+  GLFWwindow* Window;
+  int PrevState;
+};
+}  // namespace PD

backends/desktop/include/pd_net_desktop.hpp

@@ -0,0 +1,132 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#ifdef _MSVC
+#pragma comment(lib, "ws2_32.lib")
+#endif
+#else
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#endif
+
+#include <pd/net/backend.hpp>
+namespace PD {
+class NetBackendDesktop : public PD::Net::Backend {
+ public:
+#ifdef _WIN32
+  NetBackendDesktop() : Net::Backend("Desktop (Windows)") {
+#else
+  NetBackendDesktop() : Net::Backend("Desktop (Unix)") {
+#endif
+  }
+  ~NetBackendDesktop() = default;
+  PD_SMART_CTOR(NetBackendDesktop)
+  bool Init() override {
+#ifdef _WIN32
+    WSADATA wsa_data;
+    return (WSAStartup(MAKEWORD(2, 2), &wsa_data) == 0);
+#else
+    return true;
+#endif
+  }
+  void Deinit() override {
+#ifdef _WIN32
+    WSACleanup();
+#endif
+  }
+  int NewSocket() override { return socket(AF_INET, SOCK_STREAM, 0); }
+  void Close(int sock_id) override {
+#ifdef _WIN32
+    closesocket(sock_id);
+#else
+    close(sock_id);
+#endif
+  }
+  int GetInvalidRef() const override {
+#ifdef _WIN32
+    return INVALID_SOCKET;
+#else
+    return -1;
+#endif
+  }
+
+  bool Bind(int sock_id, u16 port) override {
+    sockaddr_in addr{};
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = INADDR_ANY;
+    return bind(sock_id, (sockaddr*)&addr, sizeof(addr)) != -1;
+  }
+  bool Listen(int sock_id, int backlog = 5) override {
+    return listen(sock_id, backlog) != -1;
+  }
+
+  bool WaitForRead(int sock_id, int timeout_ms) override {
+    fd_set set;
+    FD_ZERO(&set);
+    FD_SET(sock_id, &set);
+
+    timeval timeout{};
+    timeout.tv_sec = timeout_ms / 1000;
+    timeout.tv_usec = (timeout_ms % 1000) * 1000;
+
+    int result = select(sock_id + 1, &set, nullptr, nullptr, &timeout);
+    return (result > 0 && FD_ISSET(sock_id, &set));
+  }
+
+  bool Accept(int sock_id, Net::Socket::Ref client) override {
+    int client_soc = accept(sock_id, nullptr, nullptr);
+    if (client_soc == GetInvalidRef()) {
+      return false;
+    }
+    client->pSocket = client_soc;
+    return true;
+  }
+  bool Connect(int sock_id, const std::string& ip, u16 port) override {
+    sockaddr_in addr{};
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    inet_pton(AF_INET, ip.c_str(), &addr.sin_addr);
+    return connect(sock_id, (sockaddr*)&addr, sizeof(addr)) != -1;
+  }
+  int Send(int sock_id, const std::string& data) override {
+    return send(sock_id, data.c_str(), static_cast<int>(data.size()), 0);
+  }
+  int Receive(int sock_id, std::string& data, int size = 1024) override {
+    char* tmp = new char[size];
+    int res = recv(sock_id, tmp, size, 0);
+    if (res > 0) {
+      data.assign(tmp, res);
+    }
+    delete[] tmp;
+    return res;
+  }
+};
+}  // namespace PD

backends/desktop/include/pd_p_bknd_api.hpp

@@ -0,0 +1,58 @@
+#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.
+*/
+
+#pragma once
+
+#ifdef PD_BKND_DESKTOP_STATIC
+#if defined(__3DS__)  // 3ds Specific
+#error "Desktop backend is not supported on the 3ds!"
+#endif
+#define PD_BKND_DESKTOP_API
+#else
+#ifdef _WIN32  // Windows (MSVC Tested)
+#ifdef PD_BKND_DESKTOP_BUILD_SHARED
+#define PD_BKND_DESKTOP_API __declspec(dllexport)
+#else
+#define PD_BKND_DESKTOP_API __declspec(dllimport)
+#endif
+#elif defined(__APPLE__)  // macOS (untested yet)
+#ifdef PD_BKND_DESKTOP_BUILD_SHARED
+#define PD_BKND_DESKTOP_API __attribute__((visibility("default")))
+#else
+#define PD_BKND_DESKTOP_API
+#endif
+#elif defined(__linux__)  // Linux (untested yet)
+#ifdef PD_BKND_DESKTOP_BUILD_SHARED
+#define PD_BKND_DESKTOP_API __attribute__((visibility("default")))
+#else
+#define PD_BKND_DESKTOP_API
+#endif
+#elif defined(__3DS__)  // 3ds Specific
+#error "Desktop backend is not supported on the 3ds!"
+#else
+#define PD_BKND_DESKTOP_API
+#endif
+#endif

backends/desktop/source/li_backend_gl2.cpp

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

backends/desktop/source/pd_hid_glfw.cpp

@@ -0,0 +1,33 @@
+#include <pd_hid_glfw.hpp>
+
+namespace PD {
+PD_BKND_DESKTOP_API HidGLFW::HidGLFW(GLFWwindow* win) : Hid("GLFW") {
+  Window = win;
+  binds[GLFW_MOUSE_BUTTON_LEFT] = Touch;
+}
+PD_BKND_DESKTOP_API void HidGLFW::Update() {
+  for (int i = 0; i < 2; i++) {
+    key_events[i][Event_Down] = 0;
+    key_events[i][Event_Held] = 0;
+    key_events[i][Event_Up] = 0;
+  }
+  int state = glfwGetMouseButton(Window, GLFW_MOUSE_BUTTON_LEFT);
+  if (state == GLFW_PRESS) {
+    if (PrevState == GLFW_RELEASE) {
+      key_events[0][Event_Down] |= Touch;
+    }
+    key_events[0][Event_Held] |= Touch;
+  } else if (state == GLFW_RELEASE && PrevState == GLFW_PRESS) {
+    key_events[0][Event_Up] |= Touch;
+  }
+
+  PrevState = state;
+  if (locked) {
+    SwappyTable();
+  }
+  double x, y;
+  glfwGetCursorPos(Window, &x, &y);
+  touch[1] = touch[0];  // Cycle touch pos
+  touch[0] = fvec2(x, y);
+}
+}  // namespace PD

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

@@ -1,67 +0,0 @@
-#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

@@ -1,38 +0,0 @@
-#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>;
-
-  static constexpr size_t NumVertices = 32768;  // 8192*4
-  static constexpr size_t NumIndices = 49152;   // 8192*6
-};
-
-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;
-  TextureID LoadTexture(const std::vector<PD::u8>& pixels, int w, int h,
-                        TextureFormat type = TextureFormat::RGBA32,
-                        TextureFilter filter = TextureFilter::Linear) override;
-  void DeleteTexture(const TextureID& tex) override;
-
- private:
-  struct Impl;
-  Impl* impl = nullptr;
-};
-}  // namespace PD

backends/include/pd_system/gfx_directx9.hpp

@@ -1,39 +0,0 @@
-#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>;
-
-  static constexpr size_t NumVertices = 32768;  // 8192*4
-  static constexpr size_t NumIndices = 49152;   // 8192*6
-};
-
-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;
-  TextureID LoadTexture(const std::vector<PD::u8>& pixels, int w, int h,
-                        TextureFormat type = TextureFormat::RGBA32,
-                        TextureFilter filter = TextureFilter::Linear) override;
-  void DeleteTexture(const TextureID& tex) override;
-
- private:
-  struct Impl;
-  Impl* impl = nullptr;
-  void* pDevice = nullptr;
-};
-}  // namespace PD

backends/include/pd_system/gfx_opengl2.hpp

@@ -1,44 +0,0 @@
-#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>;
-
-  static constexpr size_t NumVertices = 32768;  // 8192*4
-  static constexpr size_t NumIndices = 49152;   // 8192*6
-};
-
-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;
-  TextureID LoadTexture(const std::vector<PD::u8>& pixels, int w, int h,
-                        TextureFormat type = TextureFormat::RGBA32,
-                        TextureFilter filter = TextureFilter::Linear) override;
-  void DeleteTexture(const TextureID& tex) override;
-
- private:
-  void pSetupShaderAttribs(u32 shader);
-  u32 pShader = 0;
-  u32 VBO = 0;
-  u32 IBO = 0;
-  int pLocTex = 0;
-  int pLocAlfa = 0;
-  int pLocProjection = 0;
-  static const char* pVertCode;
-  static const char* pFragCode;
-};
-}  // namespace PD

backends/include/pd_system/gfx_opengl3.hpp

@@ -1,44 +0,0 @@
-#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>;
-
-  static constexpr size_t NumVertices = 32768;  // 8192*4
-  static constexpr size_t NumIndices = 49152;   // 8192*6
-};
-
-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;
-  TextureID LoadTexture(const std::vector<PD::u8>& pixels, int w, int h,
-                        TextureFormat type = TextureFormat::RGBA32,
-                        TextureFilter filter = TextureFilter::Linear) override;
-  void DeleteTexture(const TextureID& tex) override;
-
- private:
-  u32 pShader = 0;
-  u32 VBO = 0;
-  u32 IBO = 0;
-  u32 VAO = 0;
-  int pLocTex = 0;
-  int pLocAlfa = 0;
-  int pLocProjection = 0;
-  static const char* pVertCode;
-  static const char* pFragCode;
-};
-}  // namespace PD

backends/include/pd_system/gl-helper.hpp

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

backends/include/pdsystem

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <pd_system/gfx_citro3d.hpp>
-#include <pd_system/gfx_directx9.hpp>
-#include <pd_system/gfx_opengl2.hpp>
-#include <pd_system/gfx_opengl3.hpp>

backends/source/gfx_citro3d.cpp

@@ -1,69 +0,0 @@
-// Well yes, i finally try it
-
-#include <pd_system/gfx_citro3d.hpp>
-
-#if defined(PD_ENABLE_CITRO3D)  // && defined(__3DS__)
-
-#include <3ds.h>
-#include <citro3d.h>
-
-#include <pd/drivers/drivers.hpp>
-
-namespace PD {
-struct GfxCitro3D::Impl {};
-
-void GfxCitro3D::SysInit() {
-  if (impl) return;
-  PDLOG("GfxCitro3D::SysInit();");
-  impl = new Impl();
-}
-
-void GfxCitro3D::SysDeinit() {
-  if (!impl) return;
-  delete impl;
-  impl = nullptr;
-  PDLOG("GfxCitro3D::SysDeinit()");
-}
-
-void GfxCitro3D::Submit(size_t count, size_t start) {
-  if (!impl) return;
-}
-
-void GfxCitro3D::BindTexture(TextureID id) {
-  if (!impl) return;
-}
-
-void GfxCitro3D::SysReset() {
-  if (!impl) return;
-}
-
-TextureID GfxCitro3D::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                  int h, TextureFormat type,
-                                  TextureFilter filter) {
-  if (!impl) return 0;
-  return 0;
-}
-
-void GfxCitro3D::DeleteTexture(const TextureID& tex) {
-  if (!tex) return;
-}
-}  // namespace PD
-#else
-namespace PD {
-void GfxCitro3D::SysInit() {
-  PDLOG(
-      "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() {}
-TextureID GfxCitro3D::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                  int h, TextureFormat type,
-                                  TextureFilter filter) {
-  return 0;
-}
-void GfxCitro3D::DeleteTexture(const TextureID& tex) {}
-}  // namespace PD
-#endif

backends/source/gfx_directx9.cpp

@@ -1,267 +0,0 @@
-// Well yes, i finally try it
-
-#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;
-    return o;
-}
-)";
-
-static const char* g_psCode = R"(
-sampler2D tex : register(s0);
-bool alfa;
-
-struct PS_IN {
-    float2 uv  : TEXCOORD0;
-    float4 col : COLOR0;
-};
-
-float4 main(PS_IN input) : COLOR0 {
-    float4 tc = tex2D(tex, input.uv);
-    if (alfa)
-        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;
-};
-
-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);
-    impl->Device->CreateVertexBuffer(
-        GfxDirectX9Config::NumVertices * sizeof(PD::Li::Vertex),
-        D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &impl->VBO,
-        nullptr);
-    impl->Device->CreateIndexBuffer(GfxDirectX9Config::NumIndices * sizeof(u16),
-                                    D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
-                                    D3DFMT_INDEX16, D3DPOOL_DEFAULT, &impl->IBO,
-                                    nullptr);
-    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)) {
-      PDLOG("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 {
-    PDLOG(
-        "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;
-
-  impl->Device->SetVertexShaderConstantF(
-      0, reinterpret_cast<const float*>(&Projection), 4);
-
-  void* vptr;
-  impl->VBO->Lock(0, 0, &vptr, D3DLOCK_DISCARD);
-  memcpy(vptr, GetVertexBufPtr(0), CurrentVertex * sizeof(PD::Li::Vertex));
-  impl->VBO->Unlock();
-
-  void* iptr;
-  impl->IBO->Lock(0, 0, &iptr, D3DLOCK_DISCARD);
-  memcpy(iptr, GetIndexBufPtr(0), CurrentIndex * sizeof(u16));
-  impl->IBO->Unlock();
-
-  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, CurrentVertex,
-                                     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);
-}
-
-void GfxDirectX9::SysReset() {
-  if (!impl || !impl->Device) return;
-
-  impl->Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
-  impl->Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
-  impl->Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
-}
-
-TextureID GfxDirectX9::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                   int h, TextureFormat type,
-                                   TextureFilter filter) {
-  if (!impl || !impl->Device) return 0;
-  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 0;
-
-  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;  // X8R8G8B8
-      }
-      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;  // A8R8G8B8
-      }
-      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);
-
-  PDLOG("GfxDirectX9::LoadTexture -> [{}] 0x{:X}, [{}, {}]", PD::ivec2(w, h),
-        (TextureID)tex, type, filter);
-  return (TextureID)tex;
-}
-
-void GfxDirectX9::DeleteTexture(const TextureID& tex) {
-  if (!tex) return;
-  IDirect3DTexture9* t = (IDirect3DTexture9*)tex;
-  t->Release();
-}
-}  // namespace PD
-#else
-namespace PD {
-void GfxDirectX9::SysInit() {
-  PDLOG(
-      "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() {}
-TextureID GfxDirectX9::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                   int h, TextureFormat type,
-                                   TextureFilter filter) {
-  return 0;
-}
-void GfxDirectX9::DeleteTexture(const TextureID& tex) {}
-}  // namespace PD
-#endif

backends/source/gfx_opengl2.cpp

@@ -1,184 +0,0 @@
-#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;
-      
-  void main() {
-    vec4 tc = texture2D(tex, oUV);
-    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");
-  pLocProjection = glGetUniformLocation(pShader, "projection");
-
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-  PDLOG(
-      "GfxOpenGL2::SysInit():\n  pShader = {}\n  pLocTex = {}\n  pLocAlfa = "
-      "{}\n  pLocProjection = {}\n  VBO = {}\n  IBO = {}",
-      pShader, pLocTex, pLocAlfa, pLocProjection, VBO, IBO);
-}
-
-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);
-  glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
-               GetVertexBufPtr(0), GL_DYNAMIC_DRAW);
-
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
-  glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
-               GetIndexBufPtr(0), GL_DYNAMIC_DRAW);
-
-  pSetupShaderAttribs(pShader);
-  GLint ibo = 0;
-  glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &ibo);
-  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);
-}
-
-void GfxOpenGL2::SysReset() {
-  glEnable(GL_BLEND);
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-}
-
-TextureID GfxOpenGL2::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                  int h, TextureFormat type,
-                                  TextureFilter filter) {
-  GLuint texID;
-  glGenTextures(1, &texID);
-  glBindTexture(GL_TEXTURE_2D, texID);
-
-  // Set base format (Always using RGBA as base)
-  GLenum fmt = GL_RGBA;
-  if (type == 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);
-  PDLOG("GfxOpenGL2::LoadTexture -> [{}] {}, [{}, {}]", PD::ivec2(w, h), texID,
-        type, filter);
-  return texID;
-}
-
-void GfxOpenGL2::DeleteTexture(const TextureID& tex) {
-  GLuint tex_ = tex;
-  glDeleteTextures(1, &tex_);
-}
-}  // namespace PD
-#else
-namespace PD {
-void GfxOpenGL2::SysInit() {
-  PDLOG(
-      "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() {}
-TextureID GfxOpenGL2::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                  int h, TextureFormat type,
-                                  TextureFilter filter) {
-  return 0;
-}
-void GfxOpenGL2::DeleteTexture(const TextureID& tex) {}
-void GfxOpenGL2::pSetupShaderAttribs(u32 shader) {}
-}  // namespace PD
-#endif

backends/source/gfx_opengl3.cpp

@@ -1,180 +0,0 @@
-#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>
-
-namespace PD {
-const char* GfxOpenGL3::pVertCode = R"(
-  #version 330 core
-  
-  layout(location = 0) in vec2 pos;
-  layout(location = 1) in vec2 uv;
-  layout(location = 2) in vec4 color;
-  
-  out vec2 oUV;
-  out 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* GfxOpenGL3::pFragCode = R"(
-  #version 330 core
-      
-  in vec2 oUV;
-  in vec4 oColor;
-  
-  uniform sampler2D tex;
-  uniform bool alfa;
-
-  out vec4 FragColor;
-      
-  void main() {
-    vec4 tc = texture(tex, oUV);
-    if (alfa) {
-      FragColor = vec4(oColor.rgb, tc.a * oColor.a);
-    } else {
-      FragColor = tc * oColor;
-    }
-  }
-  )";
-
-void GfxOpenGL3::SysInit() {
-  pShader = CreateShaderProgram(pVertCode, pFragCode);
-  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, "alfa");
-  pLocProjection = glGetUniformLocation(pShader, "projection");
-
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-  glBindVertexArray(0);
-  PDLOG(
-      "GfxOpenGL3::SysInit():\n  pShader = {}\n  pLocTex = {}\n  pLocAlfa = "
-      "{}\n  pLocProjection = {}\n  VBO = {}\n  IBO = {}, VAO = {}",
-      pShader, pLocTex, pLocAlfa, pLocProjection, VBO, IBO, VAO);
-}
-
-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);
-  glBindBuffer(GL_ARRAY_BUFFER, VBO);
-  glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
-               GetVertexBufPtr(0), GL_DYNAMIC_DRAW);
-
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
-  glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(u16),
-               GetIndexBufPtr(0), GL_DYNAMIC_DRAW);
-
-  glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT,
-                 reinterpret_cast<void*>(start * sizeof(u16)));
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-  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_ALPHA);
-}
-
-void GfxOpenGL3::SysReset() {
-  glEnable(GL_BLEND);
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-}
-
-TextureID GfxOpenGL3::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                  int h, TextureFormat type,
-                                  TextureFilter filter) {
-  GLuint texID;
-  glGenTextures(1, &texID);
-  glBindTexture(GL_TEXTURE_2D, texID);
-
-  // Set base format (Always using RGBA as base)
-  GLenum fmt = GL_RGBA;
-  if (type == 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);
-  PDLOG("GfxOpenGL3::LoadTexture -> [{}] {}, [{}, {}]", PD::ivec2(w, h), texID,
-        type, filter);
-  return texID;
-}
-
-void GfxOpenGL3::DeleteTexture(const TextureID& tex) {
-  GLuint tex_ = tex;
-  glDeleteTextures(1, &tex_);
-}
-}  // namespace PD
-#else
-namespace PD {
-void GfxOpenGL3::SysInit() {
-  PDLOG(
-      "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() {}
-TextureID GfxOpenGL3::LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                  int h, TextureFormat type,
-                                  TextureFilter filter) {
-  return 0;
-}
-void GfxOpenGL3::DeleteTexture(const TextureID& tex) {}
-void GfxOpenGL3::pSetupShaderAttribs(u32 shader) {}
-}  // namespace PD
-#endif

backends/source/gl-helper.cpp

@@ -1,46 +0,0 @@
-#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

cmake/palladium.cmake

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

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

docs/javascripts/mathjax.js

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

docs/javascripts/tablesort.js

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

docs/overrides/partials/copyright.html

@@ -0,0 +1,22 @@
+<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

@@ -0,0 +1,58 @@
+: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

@@ -0,0 +1,15 @@
+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/pd.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+// Core
+#include <pd/core/core.hpp>
+// Image
+#include <pd/image/image.hpp>
+#include <pd/image/img_blur.hpp>
+#include <pd/image/img_convert.hpp>
+#include <pd/ui7/ui7.hpp>
+// Net
+#include <pd/net/backend.hpp>
+#include <pd/net/socket.hpp>
+
+/// Setup these as non Namespaced access by default
+#ifndef PD_MATH_NAMESPACED
+using fvec2 = PD::fvec2;
+using fvec3 = PD::fvec3;
+using fvec4 = PD::fvec4;
+using dvec2 = PD::dvec2;
+using dvec3 = PD::dvec3;
+using dvec4 = PD::dvec4;
+using ivec2 = PD::ivec2;
+using ivec3 = PD::ivec3;
+using ivec4 = PD::ivec4;
+#endif
+
+// namespace Palladium = PD;

include/pd/core/bit_util.hpp

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

include/pd/core/color.hpp

@@ -2,7 +2,8 @@
 
 /*
 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
@@ -23,26 +24,45 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/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 PD_CORE_API Color {
+ private:
+  /** Red Value */
+  u8 m_r;
+  /** Green Value */
+  u8 m_g;
+  /** Blue Value */
+  u8 m_b;
+  /** Alpha Value */
+  u8 m_a;
+
  public:
   /**
    * Default Constructor (all variables are set to 0)
    */
-  constexpr Color() : r(0), g(0), b(0), a(0) {}
+  // Color() : m_r(0), m_g(0), m_b(0), m_a(0) {}
+  constexpr Color() : m_r(0), m_g(0), m_b(0), m_a(0) {}
   constexpr ~Color() {}
   /**
    * Constructor for 32Bit Color Input
    * @param color 32Bit Color value
    */
-  constexpr Color(u32 clr) {
+  constexpr Color(u32 color) {
-    a = (clr >> 24) & 0xff;
+    m_a = (color >> 24) & 0xff;
-    b = (clr >> 16) & 0xff;
+    m_b = (color >> 16) & 0xff;
-    g = (clr >> 8) & 0xff;
+    m_g = (color >> 8) & 0xff;
-    r = clr & 0xff;
+    m_r = color & 0xff;
   }
   /**
    * Constructor for 8Bit Input
@@ -51,7 +71,12 @@ class PD_API Color {
    * @param b Blue Value
    * @param a Optional Alpha Value (Defaults to 255)
    */
-  constexpr Color(int r, int g, int b, int a = 255) : r(r), g(g), b(b), a(a) {}
+  constexpr Color(int r, int g, int b, int a = 255) {
+    m_r = r;
+    m_g = g;
+    m_b = b;
+    m_a = a;
+  }
   /**
    * Constructor for float Input
    * @param r Red Value
@@ -60,40 +85,28 @@ class PD_API 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
    */
-  constexpr Color(float r, float g, float b, float a = 1.f)
+  constexpr Color(float r, float g, float b, float a = 1.f) {
-      : r(static_cast<u8>(255.f * r)),
+    m_r = static_cast<u8>(255.f * r);
-        g(static_cast<u8>(255.f * g)),
+    m_g = static_cast<u8>(255.f * g);
-        b(static_cast<u8>(255.f * b)),
+    m_b = static_cast<u8>(255.f * b);
-        a(static_cast<u8>(255.f * a)) {}
+    m_a = static_cast<u8>(255.f * a);
+  }
   /**
-   * Constructor for Hex Input (is abel to run at compile time xD)
+   * Constructor for Hex Input
    * @param hex Hex String in `#ffffff` or `#ffffffff` format
    */
-  constexpr Color(const std::string_view& hex) { Hex(hex); }
+  Color(const std::string& hex) { Hex(hex); }
+  /**
+   * Unused Deconstructor
+   */
+  // ~Color() {}
 
   /**
-   * Create Color Object by Hex String (at compile time btw)
+   * Create Color Object by Hex String
    * @param hex Hex String in `#ffffff` or `#ffffffff` format
    * @return Color class itself
    */
-  constexpr Color& Hex(const std::string_view& hex) {
+  Color& Hex(const std::string& 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
@@ -101,54 +114,118 @@ class PD_API 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_g; }
+  /**
+   * 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_b; }
+  /**
+   * 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_a; }
+
   /**
    * Fade from Current to another Color
    * @param color Color to fade to
    * @param p Amount (supports -1.0 to 1.0 for use of sine)
    * @return Class Reference
    */
-  constexpr Color& Fade(const Color& color, float p) {
+  Color& Fade(const Color& color, float p) {
-    a = static_cast<u8>((color.a - a) * ((p + 1.f) / 2));
+    m_a = static_cast<u8>((color.a() - m_a) * ((p + 1.f) / 2));
-    b = static_cast<u8>((color.b - b) * ((p + 1.f) / 2));
+    m_b = static_cast<u8>((color.b() - m_b) * ((p + 1.f) / 2));
-    g = static_cast<u8>((color.g - g) * ((p + 1.f) / 2));
+    m_g = static_cast<u8>((color.g() - m_g) * ((p + 1.f) / 2));
-    r = static_cast<u8>((color.r - r) * ((p + 1.f) / 2));
+    m_r = static_cast<u8>((color.r() - m_r) * ((p + 1.f) / 2));
     return *this;
   }
-
   /**
    * Get 32Bit Color Value
-   * @return 32Bit Color Value (ABGR iirc)
+   * @return 32Bit Color Value
    */
-  constexpr u32 Get() const { return (a << 24) | (b << 16) | (g << 8) | r; }
+  u32 Get() const { return (m_a << 24) | (m_b << 16) | (m_g << 8) | m_r; }
   /**
    * Get The Luminance of the Color
    * @return luminance (from 0.0 to 1.0)
    */
-  constexpr float Luminance() const {
+  float Luminance() const {
     // For Reference https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness
-    return (0.3 * (r / 255.f) + 0.59 * (g / 255.f) + 0.11 * (b / 255.f));
+    return (0.3 * (m_r / 255.f) + 0.59 * (m_g / 255.f) + 0.11 * (m_b / 255.f));
   }
   /**
    * Check if the Color is Light or Dark
    * @return true if light
    */
-  constexpr bool IsLight() const { return (Luminance() >= 0.5); }
+  bool IsLight() const { return (Luminance() >= 0.5); }
 
   /**
    * Operator to cast Color to 32Bit Value
    * @return 32Bit Color Value
    */
-  constexpr operator u32() const { return Get(); }
+  operator u32() const { return Get(); }
-
-  const float rf() const { return static_cast<float>(r) / 255.f; }
-  const float gf() const { return static_cast<float>(g) / 255.f; }
-  const float bf() const { return static_cast<float>(b) / 255.f; }
-  const float af() const { return static_cast<float>(a) / 255.f; }
-
-  /** Public Access Data section */
-  u8 r;
-  u8 g;
-  u8 b;
-  u8 a;
 };
+namespace Colors {
+constexpr Color White = Color(1.f, 1.f, 1.f, 1.f);
+constexpr Color Black = Color(0.f, 0.f, 0.f, 1.f);
+constexpr Color Red = Color(1.f, 0.f, 0.f, 1.f);
+constexpr Color Green = Color(0.f, 1.f, 0.f, 1.f);
+constexpr Color Blue = Color(0.f, 0.f, 1.f, 1.f);
+constexpr Color Yellow = Color(1.f, 1.f, 0.f, 1.f);
+constexpr Color Cyan = Color(0.f, 1.f, 1.f, 1.f);
+constexpr Color Magenta = Color(1.f, 0.f, 1.f, 1.f);
+constexpr Color Gray = Color(0.5f, 0.5f, 0.5f, 1.f);
+constexpr Color LightGray = Color(0.75f, 0.75f, 0.75f, 1.f);
+constexpr Color DarkGray = Color(0.25f, 0.25f, 0.25f, 1.f);
+constexpr Color Orange = Color(1.f, 0.65f, 0.f, 1.f);
+constexpr Color Pink = Color(1.f, 0.75f, 0.8f, 1.f);
+constexpr Color Brown = Color(0.6f, 0.4f, 0.2f, 1.f);
+constexpr Color Purple = Color(0.5f, 0.f, 0.5f, 1.f);
+constexpr Color Teal = Color(0.f, 0.5f, 0.5f, 1.f);
+constexpr Color Transparent = Color(0.f, 0.f, 0.f, 0.f);
+}  // namespace Colors
 }  // namespace PD

include/pd/core/common.hpp

@@ -0,0 +1,131 @@
+#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>
+
+// Platform API
+#include <pd/core/pd_p_api.hpp>
+
+// Legacy Smart Pointer
+#define PD_SMART_CTOR(x)                                      \
+  using Ref = std::shared_ptr<x>;                             \
+  template <typename... args>                                 \
+  static Ref New(args&&... cargs) {                           \
+    return std::make_shared<x>(std::forward<args>(cargs)...); \
+  }
+
+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
+ */
+PD_CORE_API const std::string CompiledWith();
+/**
+ * Get the C++ Version used to compile the lib
+ * @return C++ Version (__cplusplus)
+ */
+PD_CORE_API const std::string CxxVersion();
+/**
+ * Get the Buildtime of the Library
+ * @return Build Time
+ */
+PD_CORE_API const std::string BuildTime();
+/**
+ * Get the Library Version
+ * @return Library Version String
+ */
+PD_CORE_API const std::string Version();
+/**
+ * Get the Git Commit the Lib got compiled in
+ * @return Git Commit 7digit short hash
+ */
+PD_CORE_API const std::string Commit();
+/**
+ * Get the Git Branch which was active when compiling the lib
+ * @return Git Branch
+ */
+PD_CORE_API const std::string Branch();
+}  // namespace LibInfo
+}  // namespace PD

include/pd/core/core.hpp

@@ -2,7 +2,8 @@
 
 /*
 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
@@ -21,20 +22,18 @@ 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/bit_util.hpp>
 #include <pd/core/color.hpp>
-#include <pd/core/fnv.hpp>
+#include <pd/core/common.hpp>
-#include <pd/core/formatters.hpp>
+#include <pd/core/hid_driver.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/sl/sl.hpp>
 #include <pd/core/strings.hpp>
+#include <pd/core/sys.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

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

@@ -1,98 +0,0 @@
-#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/hashid.hpp

@@ -1,50 +0,0 @@
-#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/hid_driver.hpp

@@ -0,0 +1,175 @@
+#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/vec.hpp>
+
+namespace PD {
+/** Input Driver Template class */
+class PD_CORE_API Hid : public SmartCtor<Hid> {
+ public:
+  /** Key [Controller] */
+  enum Key : u32 {
+    No = 0,                    ///< No Key
+    A = 1 << 0,                ///< A
+    B = 1 << 1,                ///< B
+    X = 1 << 2,                ///< X
+    Y = 1 << 3,                ///< Y
+    Start = 1 << 4,            ///< Start
+    Select = 1 << 5,           ///< Select
+    L = 1 << 6,                ///< L
+    R = 1 << 7,                ///< R
+    DUp = 1 << 8,              ///< Dpad Up
+    DDown = 1 << 9,            ///< Dpad down
+    DLeft = 1 << 10,           ///< Dpad left
+    DRight = 1 << 11,          ///< Dpad right
+    CPUp = 1 << 12,            ///< Cpad up
+    CPDown = 1 << 13,          ///< cpad down
+    CPLeft = 1 << 14,          ///< cpad left
+    CPRight = 1 << 15,         ///< Cpad right
+    CSUp = 1 << 16,            ///< Cstick up
+    CSDown = 1 << 17,          ///< cstick down
+    CSLeft = 1 << 18,          ///< cstick left
+    CSRight = 1 << 19,         ///< cstick right
+    ZL = 1 << 20,              ///< ZL
+    ZR = 1 << 21,              ///< ZR
+    Touch = 1 << 22,           ///< Touch
+    Up = DUp | CPUp,           ///< DPad or CPad Up
+    Down = DDown | CPDown,     ///< DPad or CPad Down
+    Left = DLeft | CPLeft,     ///< DPad or CPad Left
+    Right = DRight | CPRight,  ///< DPad or CPad Right
+  };
+  /** Event */
+  enum Event {
+    Event_Down,  ///< Key Pressed
+    Event_Held,  ///< Key Held
+    Event_Up,    ///< Key released
+  };
+  Hid(const std::string& name = "NullBackend") : pName(name) {}
+  ~Hid() = default;
+
+  /**
+   * Get TOuch Position
+   * @return touch pos
+   */
+  fvec2 TouchPos() const { return touch[0]; }
+  /**
+   * Get Last Touch Position (from last frame)
+   * @return touch pos
+   */
+  fvec2 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;
+    }
+  }
+
+  /**
+   * Lock input driver
+   * @param v lock or not lock
+   */
+  void Lock(bool v) {
+    if (v != locked) {
+      SwappyTable();
+    }
+    locked = v;
+  }
+  /**
+   * 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;
+  }
+
+  /**
+   * Template Update Function for a device specific driver
+   */
+  virtual void Update() {}
+
+  /** Backend Identification Name */
+  const std::string pName;
+
+ protected:
+  /** Key binds map */
+  std::unordered_map<u32, u32> binds;
+  /** Function to swap around the Table */
+  void SwappyTable();
+  /** Using 2 Touch positions for current and last frame */
+  fvec2 touch[2];
+  /** locked state */
+  bool locked = false;
+  /** Key event tables */
+  std::unordered_map<Event, u32> key_events[2];
+};
+}  // namespace PD

include/pd/core/io.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,40 +23,50 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 namespace PD {
 /**
  * Set of File Functions
  */
 namespace IO {
+enum RleFmt {
+  Default = 0,
+  _16 = 1 << 0,
+  _32 = 1 << 1,
+  _64 = 1 << 2,
+};
 /**
  * Load a File into an 8Bit Memory Buffer
  * @param path Path to the File
  * @return 8Bit FileBuffer
  */
-PD_API std::vector<u8> LoadFile2Mem(const std::string& path);
+PD_CORE_API std::vector<u8> LoadFile2Mem(const std::string& path);
-/**
- * Load a File into a std::string
- * @param path Path to the File
- * @return std::string file content
- */
-PD_API std::string LoadFile2Str(const std::string& path);
 /**
  * Hash a 8Bit Memory Buffer
  * @param data 8Bit input Buffer
  * @return 32Bit Hash
  */
-PD_API u32 HashMemory(const std::vector<u8>& data);
+PD_CORE_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);
+PD_CORE_API void DecompressRLE(std::vector<u8>& data);
+/**
+ * Function to decrompress Extended RLE Buffer
+ * @param data Data buffer to decompress
+ */
+PD_CORE_API void DecompressRLE_Ex(std::vector<u8>& data);
 /**
  * Function to compress data with RLE Algorithm
  * @param data Data buf
  */
-PD_API void CompressRLE(std::vector<u8>& data);
+PD_CORE_API void CompressRLE(std::vector<u8>& data);
+/**
+ * Extended RLE Compress function (slower cause searches best format)
+ * @param data Data buf
+ */
+PD_CORE_API void CompressRLE_Ex(std::vector<u8>& data);
 }  // namespace IO
 }  // namespace PD

include/pd/core/mat.hpp

@@ -2,7 +2,8 @@
 
 /*
 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
@@ -23,119 +24,18 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
-#include <pd/core/vec3.hpp>
 
 namespace PD {
-namespace Numbers {
+class PD_CORE_API Mat4 {
-constexpr float Tau = std::numbers::pi * 2.f;
+ public:
-}
+  Mat4() { Zeros(); }
-constexpr float Radians(float v) { return v * (Numbers::Tau / 360.0f); }
+  ~Mat4() = default;
-/**
- * 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 {
+  void Zeros();
-  std::array<float, 16> m;
+  void Ortho(float left, float right, float bottom, float top, float near,
-  constexpr Mat4() : m{} {}
+             float far);
-  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(); }
+  float m[16];
-  constexpr const float* Ptr() const { return m.data(); }
-
-  constexpr float& operator()(int row, int col) {
-#ifdef __3DS__
-    // 3ds is full reverse order iirc
-    return m[row * 4 + (3 - col)];
-#else
-    return m[col * 4 + row];
-#endif
-  }
-  constexpr float operator()(int row, int col) const {
-#ifdef __3DS__
-    // 3ds is full reverse order iirc
-    return m[row * 4 + (3 - col)];
-#else
-    return m[col * 4 + row];
-#endif
-  }
-
-  constexpr Mat4 operator*(const Mat4& v) const {
-    Mat4 ret;
-    for (int i = 0; i < 4; i++) {
-      for (int j = 0; j < 4; j++) {
-        float t = 0.f;
-        for (int k = 0; k < 4; k++) {
-          t += (*this)(i, k) * v(k, j);
-        }
-        ret(i, j) = t;
-      }
-    }
-    return ret;
-  }
-
-  constexpr Mat4& operator*=(const Mat4& v) {
-    *this = *this * v;
-    return *this;
-  }
-
-  constexpr static Mat4 Translate(float x, float y, float z) {
-    Mat4 ret = Identity();
-    ret(0, 3) = x;
-    ret(1, 3) = y;
-    ret(2, 3) = z;
-    return ret;
-  }
-
-  constexpr static Mat4 Scale(float x, float y, float z) {
-    Mat4 ret;
-    ret(0, 0) = x;
-    ret(1, 1) = y;
-    ret(2, 2) = z;
-    ret(3, 3) = 1.f;
-    return ret;
-  }
-
-  constexpr static Mat4 Ortho(float l, float r, float b, float t, float n,
-                              float f) {
-    Mat4 ret;
-#ifdef __3DS__  // Patch to rotate the Matrix correctly
-    ret(0, 1) = 2.f / (t - b);
-    ret(0, 3) = (b + t) / (b - t);
-    ret(1, 0) = 2.f / (l - r);
-    ret(1, 3) = (l + r) / (r - l);
-    ret(2, 2) = 1.f / (n - f);
-    ret(2, 3) = 0.5f * (n + f) / (n - f) - 0.5f;
-#else
-    ret(0, 0) = 2.0f / (r - l);
-    ret(0, 3) = -(r + l) / (r - l);
-    ret(1, 1) = 2.0f / (t - b);
-    ret(1, 3) = -(t + b) / (t - b);
-    ret(2, 2) = -2.0f / (f - n);
-    ret(2, 3) = -(f + n) / (f - n);
-#endif
-    ret(3, 3) = 1.f;
-    return ret;
-  }
-
-  static Mat4 Rotate(fvec3 axis, float a);
-  static Mat4 RotateX(float a);
-  static Mat4 RotateY(float a);
-  static Mat4 RotateZ(float a);
-  static Mat4 Perspective(float fov, float aspect, float n, float f);
-  static Mat4 LookAt(const fvec3& pos, const fvec3& center, const fvec3& up);
 };
 }  // namespace PD

include/pd/core/pd_p_api.hpp

@@ -2,7 +2,8 @@
 
 /*
 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
@@ -21,34 +22,29 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
- */
+*/
 
-/** Generated with ppam */
-#ifndef PD_BUILD_STATIC
 #ifdef _WIN32  // Windows (MSVC Tested)
-#ifdef PD_BUILD_SHARED
+#ifdef PD_CORE_BUILD_SHARED
-#define PD_API __declspec(dllexport)
+#define PD_CORE_API __declspec(dllexport)
 #else
-#define PD_API __declspec(dllimport)
+#define PD_CORE_API __declspec(dllimport)
 #endif
 #elif defined(__APPLE__)  // macOS (untested yet)
-#ifdef PD_BUILD_SHARED
+#ifdef PD_CORE_BUILD_SHARED
-#define PD_API __attribute__((visibility("default")))
+#define PD_CORE_API __attribute__((visibility("default")))
 #else
-#define PD_API
+#define PD_CORE_API
 #endif
 #elif defined(__linux__)  // Linux (untested yet)
-#ifdef PD_BUILD_SHARED
+#ifdef PD_CORE_BUILD_SHARED
-#define PD_API __attribute__((visibility("default")))
+#define PD_CORE_API __attribute__((visibility("default")))
 #else
-#define PD_API
+#define PD_CORE_API
 #endif
 #elif defined(__3DS__)  // 3ds Specific
 // Only Static supported
-#define PD_API
+#define PD_CORE_API
 #else
-#define PD_API
+#define PD_CORE_API
-#endif
-#else
-#define PD_API
 #endif

include/pd/core/pool.hpp

@@ -1,82 +0,0 @@
-#pragma once
-
-#include <iostream>
-#include <memory>
-#include <pd/common.hpp>
-namespace PD {
-template <typename T, typename Alloc = std::allocator<T>>
-class Pool {
- public:
-  using value_type = T;
-  using iterator = T*;
-  using const_iterator = const iterator*;
-
-  Pool() = default;
-  ~Pool() {
-    if (pData) {
-      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) {
-    if (CheckLimits(num)) return nullptr;
-    T* ret = &pData[pPos];
-    pPos += num;
-    return ret;
-  }
-
-  bool CheckLimits(size_t num) {
-    if ((pPos + num) >= pCap) {
-      throw std::runtime_error(
-          std::format("[PD::Pool]: Trying to allocate {} elements but this is "
-                      "going out of range ({}/{})",
-                      num, pPos + num, pCap));
-      return true;
-    }
-    return false;
-  }
-
-  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]);
-    }
-  }
-
-  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]; }
-
-  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) { pData = pAlloc.allocate(size); }
-  size_t pCap = 0;
-  size_t pPos = 0;
-  Alloc pAlloc;
-  T* pData = nullptr;
-};
-}  // namespace PD

include/pd/core/sl/allocator.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <pd/core/common.hpp>
+
+namespace PD {
+/**
+ * Custom Allocator for Custom Vec and probably other stuff in future
+ */
+template <typename T>
+class Allocator {
+ public:
+  Allocator() = default;
+  ~Allocator() = default;
+
+  virtual T* Allocate(size_t n) { return new T[n]; }
+  virtual T* AllocateRaw(size_t n) {
+    return reinterpret_cast<T*>(::operator new(sizeof(T) * n));
+  }
+  virtual void DeallocateRaw(T* ptr) { operator delete(ptr); }
+  virtual void Deallocate(T* ptr) { delete[] ptr; }
+  template <typename... Args>
+  void Construct(T* ptr, Args&&... args) {
+    new (ptr) T(std::forward<Args>(args)...);
+  }
+  void Destroy(T* ptr) { ptr->~T(); }
+};
+}  // namespace PD

include/pd/core/sl/hashmap.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <pd/core/common.hpp>
+#include <pd/core/sl/list.hpp>
+#include <pd/core/sl/pair.hpp>
+
+namespace PD {
+template <typename K, typename V, size_t bucket_count = 10>
+class HashMap {
+ public:
+  HashMap() {}
+  ~HashMap() {}
+
+  void Insert(const K& k, const V& v) {
+    size_t idx = Hash(k);
+    auto& bukket = pBuckets[idx];
+    for (auto& it : bukket) {
+      if (it.First == k) {
+        it.Second = v;
+        return;
+      }
+    }
+    bukket.PushBack(Pair(k, v));
+  }
+
+  bool Contains(const K& k) const {
+    size_t idx = Hash(k);
+    auto& bukket = pBuckets[idx];
+
+    for (auto& it : bukket) {
+      if (it.First == k) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void Clear() {
+    for (size_t i = 0; i < bucket_count; i++) {
+      pBuckets[i].Clear();
+    }
+  }
+
+  size_t Hash(const K& k) const { return std::hash<K>{}(k) % bucket_count; }
+  PD::List<PD::Pair<K, V>> pBuckets[bucket_count];
+};
+}  // namespace PD

include/pd/core/sl/list.hpp

@@ -0,0 +1,210 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <pd/core/common.hpp>
+
+namespace PD {
+template <typename T>
+class List {
+ public:
+  List() {}
+  ~List() {}
+
+  struct Node {
+    Node(const T& v) : Data(v) {}
+    T Data;
+    Node* Prev = nullptr;
+    Node* Next = nullptr;
+  };
+
+  class Iterator {
+   public:
+    Iterator(Node* n) : pNode(n) {}
+    T& operator*() { return pNode->Data; }
+    Iterator& operator++() {
+      pNode = pNode->Next;
+      return *this;
+    }
+    bool operator!=(const Iterator& o) const { return pNode != o.pNode; }
+
+    Node* pNode = nullptr;
+  };
+
+  void PushFront(const T& val) {
+    Node* node = new Node(val);
+    // node->Data = val;
+    node->Prev = nullptr;
+    node->Next = pHead;
+    if (pHead) {
+      pHead->Prev = node;
+    }
+    pHead = node;
+    if (!pTail) {
+      pTail = node;
+    }
+    pSize++;
+  }
+
+  void PushBack(const T& val) {
+    Node* node = new Node(val);
+    // node->Data = val;
+    node->Prev = pTail;
+    node->Next = nullptr;
+    if (pTail) {
+      pTail->Next = node;
+    }
+    pTail = node;
+    if (!pHead) {
+      pHead = node;
+    }
+    pSize++;
+  }
+
+  void PopFront() {
+    if (!pHead) {
+      return;
+    }
+    Node* t = pHead;
+    pHead = pHead->Next;
+    if (pHead) {
+      pHead->Prev = nullptr;
+    } else {
+      pTail = nullptr;
+    }
+    delete t;
+    pSize--;
+  }
+
+  void PopBack() {
+    if (!pTail) {
+      return;
+    }
+    Node* t = pTail;
+    pTail = pTail->Prev;
+    if (pTail) {
+      pTail->Next = nullptr;
+    } else {
+      pHead = nullptr;
+    }
+    delete t;
+    pSize--;
+  }
+
+  void Clear() {
+    while (pHead) {
+      PopFront();
+    }
+  }
+
+  void Remove(const T& v) {
+    Node* s = pHead;
+    while (s) {
+      if (s->Data == v) {
+        if (s->Prev) {
+          s->Prev->Next = s->Next;
+        } else {
+          pHead = s->Next;
+        }
+        if (s->Next) {
+          s->Next->Prev = s->Prev;
+        } else {
+          pTail = s->Prev;
+        }
+        delete s;
+        pSize--;
+        return;
+      }
+      s = s->Next;
+    }
+  }
+
+  void Reverse() {
+    Node* cur = pHead;
+    while (cur) {
+      Node* temp = cur->Prev;
+      cur->Prev = cur->Next;
+      cur->Next = temp;
+      cur = cur->Prev;
+    }
+    Node* temp = pHead;
+    pHead = pTail;
+    pTail = temp;
+  }
+
+  T& Front() {
+    if (pHead) {
+      return pHead->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  const T& Front() const {
+    if (pHead) {
+      return pHead->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  T& Back() {
+    if (pTail) {
+      return pTail->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  const T& Back() const {
+    if (pTail) {
+      return pTail->Data;
+    }
+    // Need a List Empty Error Here (exceptions are disabled on 3ds)
+    exit(1);
+  }
+
+  size_t Size() const { return pSize; }
+
+  Iterator begin() { return Iterator(pHead); }
+  Iterator end() { return Iterator(nullptr); }
+
+ private:
+  Node* Find(const T& v) const {
+    Node* t = pHead;
+    while (t) {
+      if (t->Data == v) {
+        return t;
+      }
+      t = t->Next;
+    }
+    return nullptr;
+  }
+
+  Node* pHead = nullptr;
+  Node* pTail = nullptr;
+  size_t pSize = 0;
+};
+}  // namespace PD

include/pd/core/sl/pair.hpp

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

include/pd/core/sl/sl.hpp

@@ -2,7 +2,8 @@
 
 /*
 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
@@ -21,8 +22,12 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
- */
+*/
 
-#include <pd/core/core.hpp>
+#include <pd/core/sl/allocator.hpp>
-#include <pd/drivers/drivers.hpp>
+#include <pd/core/sl/hashmap.hpp>
-#include <pd/lithium/lithium.hpp>
+#include <pd/core/sl/list.hpp>
+#include <pd/core/sl/pair.hpp>
+#include <pd/core/sl/stack.hpp>
+#include <pd/core/sl/tools.hpp>
+#include <pd/core/sl/vector.hpp>

include/pd/core/sl/stack.hpp

@@ -2,7 +2,8 @@
 
 /*
 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
@@ -21,35 +22,49 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
- */
+*/
 
-// This file is based on fvec4
+#include <pd/core/common.hpp>
-
+#include <pd/core/sl/vector.hpp>
-#include <pd/common.hpp>
-#include <pd/core/vec4.hpp>
 
 namespace PD {
-class fquat : public fvec4 {
+/**
-  constexpr fquat() : fvec4(0.f, 0.f, 0.f, 1.f) {}
+ * Custom Stack class (caus std::stack ofsten lead to memory coruption)
-  constexpr fquat(float x, float y, float z, float w) : fvec4(x, y, z, w) {}
+ */
-  constexpr fquat(const fvec4& v) : fvec4(v) {}
+template <typename T, typename Alloc = Allocator<T>>
+class Stack {
+ public:
+  Stack() = default;
+  explicit Stack(size_t cap) : pVec(cap) {}
 
-  static fquat Identity() { return fquat(0.f, 0.f, 0.f, 1.f); }
+  void Push(const T& val) { pVec.Add(val); }
 
-  constexpr fquat Conjugate() const { return fquat(-x, -y, -z, w); }
+  void Pop() {
-  fquat Inverse() const {
+    if (pVec.Size() == 0) {
-    float len = SqLen();
+      exit(1);
-    if (len == 0.0f) {
-      return fquat();
     }
-    return Conjugate() / len;
+    pVec.PopBack();
   }
 
-  fquat operator*(const fquat& v) const {
+  T& Top() {
-    return fquat(w * v.x + x * v.w + y * v.z - z * v.y,
+    if (pVec.Size() == 0) {
-                 w * v.y - x * v.z + y * v.w + z * v.x,
+      exit(1);
-                 w * v.z + x * v.y - y * v.x + z * v.w,
+    }
-                 w * v.w - x * v.x - y * v.y - z * v.z);
+    return pVec[pVec.Size() - 1];
   }
+
+  const T& Top() const {
+    if (pVec.Size() == 0) {
+      exit(1);
+    }
+    return pVec[pVec.Size() - 1];
+  }
+
+  bool IsEmpty() const { return pVec.Size() == 0; }
+  size_t Size() const { return pVec.Size(); }
+  void Clear() { pVec.Clear(); }
+
+ private:
+  Vec<T, Alloc> pVec;
 };
 }  // namespace PD

include/pd/core/sl/tools.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <pd/core/common.hpp>
+
+namespace PD {
+/**
+ * Function to get Arraysize for any type using modern c++ to
+ * get the size at compiletime instead of runtime
+ * @note this function only works for Arrays declared as
+ * type arr[size] and not for pointer references.
+ * This function will precalculate the size at compile time
+ * while keeping the code clean to not hardcode arraysizes
+ * into functions like std::fill_n
+ */
+template <typename T, size_t N>
+constexpr size_t ArraySize(T (&)[N]) noexcept {
+  return N;
+}
+}  // namespace PD

include/pd/core/sl/vector.hpp

@@ -0,0 +1,165 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/common.hpp>
+#include <pd/core/sl/allocator.hpp>
+
+namespace PD {
+/**
+ * Open Access Vector class (Alternative to std::vector)
+ */
+template <typename T, typename Alloc = Allocator<T>>
+class Vec {
+ public:
+  Vec() {
+    pData = pAllocator.Allocate(2);
+    pCap = 2;
+    Clear();
+    pPos = 0;
+  };
+  Vec(const size_t& Size) {
+    pData = pAllocator.Allocate(Size + 2);
+    pCap = Size + 2;
+    Clear();
+    pPos = Size;
+  }
+  Vec(const size_t& Size, const T& v) {
+    pData = pAllocator.Allocate(Size + 2);
+    pCap = Size + 2;
+    Clear();
+    pPos = Size;
+    std::fill_n(pData, Size, v);
+  }
+  Vec(const T* s, const T* e) {
+    pData = pAllocator.Allocate(2);
+    pCap = 2;
+    Clear();
+    pPos = 0;
+    Resize(e - s);
+    std::copy_n(s, e - s, pData);
+  }
+  Vec(const Vec& v) {
+    pCap = v.pCap;
+    pPos = v.pPos;
+    pData = pAllocator.Allocate(pCap);
+    for (size_t i = 0; i < pPos; i++) {
+      pData[i] = v.pData[i];
+    }
+  }
+  ~Vec() { pAllocator.Deallocate(pData); }
+
+  void Add(const T& v) {
+    if (pPos >= pCap) {
+      Reserve(pCap * 2);
+    }
+    pData[pPos++] = v;
+  }
+
+  void PopBack() {
+    if (pPos == 0) return;
+    pPos--;
+  }
+
+  T Pop() {
+    if (pPos == 0) {
+      // Todo: LOG
+      exit(1);
+    }
+    return pData[pPos--];
+  }
+
+  T& At(const size_t& Idx) {
+    if (Idx >= pPos) {
+      // Log
+      exit(1);
+    }
+    return pData[Idx];
+  }
+
+  const T& At(const size_t& Idx) const {
+    if (Idx >= pPos) {
+      // Log
+      exit(1);
+    }
+    return pData[Idx];
+  }
+
+  T& operator[](const size_t& Idx) { return At(Idx); }
+  const T& operator[](const size_t& Idx) const { return At(Idx); }
+  void operator+=(T v) { Add(v); }
+
+  T* Begin() { return pData; }
+  const T* Begin() const { return pData; }
+  T* End() { return pData + pPos; }
+  const T* End() const { return pData + pPos; }
+
+  // Support: `for(auto& it : Vec)` //
+  T* begin() { return pData; }
+  const T* begin() const { return pData; }
+  T* end() { return pData + pPos; }
+  const T* end() const { return pData + pPos; }
+
+  T* Data() { return pData; }
+  T* Data() const { return pData; }
+  size_t Size() const { return pPos; }
+  size_t Capacity() const { return pCap; }
+  void Clear() {
+    // Avoid memset to support std::string for now
+    // probably revert this decision based if it lacks performance
+    // or make it a setting
+    std::fill(pData, pData + pCap, T());
+    pPos = 0;
+  }
+
+  void Reserve(const size_t& Size) {
+    if (Size <= pCap) return;
+    T* tmp = pAllocator.Allocate(Size);
+    std::fill(tmp, tmp + Size, T());
+    std::copy(pData, pData + pCap, tmp);
+    pAllocator.Deallocate(pData);
+    pData = tmp;
+    pCap = Size;
+  }
+
+  void Resize(size_t Size) {
+    if (Size < pPos) {
+      pPos = Size;
+    } else if (Size > pCap) {
+      Reserve(Size);
+    }
+    std::fill(pData + pPos, pData + Size, T());
+    pPos = Size;
+  }
+
+  // Allocator
+  Alloc pAllocator;
+  // Data Reference Pointer
+  T* pData;
+  // Capacity
+  size_t pCap;
+  // Current Position (Size)
+  size_t pPos;
+};
+}  // namespace PD

include/pd/core/strings.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,67 +23,60 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 namespace PD {
 /**
  * Set of String Utillity Functions
  */
 namespace Strings {
-constexpr int HexChar2Int(char c) {
-  /** Imagine man hat ne lookup table dafür verwendet :/ */
-  if (c >= '0' && c <= '9') return c - '0';
-  if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
-  if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
-  return -1;  // Error
-}
 /**
  * Check if a String ends with a specific extension
  * @param str Input string
  * @param exts List of Extensions to check for
  * @return true if one of the extensions is found in the String
  */
-PD_API bool StringEndsWith(const std::string& str,
+PD_CORE_API bool StringEndsWith(const std::string& str,
-                           const std::vector<std::string>& exts);
+                                const std::vector<std::string>& exts);
 /**
  * Function to Create a wstring of a string
  * @param s Input String to Convert
  * @return Result wstring
  * @note Returns Empty if it has an error
  */
-PD_API std::wstring MakeWstring(const std::string& s);
+PD_CORE_API std::wstring MakeWstring(const std::string& s);
 /**
  * Generate a Formatted String by an Nanoseconds Input
  * @param nanos Nanoseconds Input
  * @return Result String
  */
-PD_API const std::string FormatNanos(unsigned long long nanos);
+PD_CORE_API const std::string FormatNanos(unsigned long long nanos);
 /**
  * Generate a Formatted String by an Milliseconds Input
  * @param millis Milliseconds Input
  * @return Result String
  */
-PD_API const std::string FormatMillis(unsigned long long millis);
+PD_CORE_API const std::string FormatMillis(unsigned long long millis);
 /**
  * Create a formatted String by an input bytes value
  * @param bytes value in bytes
  * @result Formatted String for example `2.5MB`
  */
-PD_API const std::string FormatBytes(unsigned long long bytes);
+PD_CORE_API const std::string FormatBytes(unsigned long long bytes);
 /**
  * Extract the Filename out of a Path
  * @param path Path to extract from
  * @param saperators Path Split Chars
  * @return extracted filename
  */
-PD_API const std::string GetFileName(const std::string& path,
+PD_CORE_API const std::string GetFileName(
-                                     const std::string& saperators = "/\\");
+    const std::string& path, const std::string& saperators = "/\\");
 /**
  * Remove Extension from a Path / Filename
  * @param path Input Path
  * @return Path without Extension
  */
-PD_API const std::string PathRemoveExtension(const std::string& path);
+PD_CORE_API const std::string PathRemoveExtension(const std::string& path);
 /**
  * Function to Convert a Type to a hex value
  * @tparam T Type
@@ -92,79 +85,39 @@ PD_API const std::string PathRemoveExtension(const std::string& path);
  */
 template <typename T>
 inline const std::string ToHex(const T& v) {
-  return std::format("{0:0{1}X}", v, sizeof(v) * 2);
+  std::stringstream s;
+  s << "0x" << std::setfill('0') << std::setw(sizeof(v) * 2) << std::hex << v;
+  return s.str();
 }
 /**
  * Generate a Hash out of a string
  * @param s String to hash
  * @return 32Bit Hash
  */
-PD_API u32 FastHash(const std::string& s);
+PD_CORE_API u32 FastHash(const std::string& s);
 /**
  * Function to Generate a Compiler Name and Version String
  * Based on their Macros
  * @return CompilerName: Version
  */
-inline const char* GetCompilerVersion() {
+inline const std::string 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
-#define __mks(x) #x
+  std::stringstream res;
-#define mkstring(x) __mks(x)
 #ifdef __clang__  // Check clang first
-  return "Clang: " mkstring(__clang_major__) "." mkstring(
+  res << "Clang: " << __clang_major__ << ".";
-      __clang_minor__) "." mkstring(__clang_patchlevel__);
+  res << __clang_minor__ << ".";
+  res << __clang_patchlevel__;
 #elif __GNUC__
-  return "GCC: " mkstring(__GNUC__) "." mkstring(__GNUC_MINOR__) "." mkstring(
+  res << "GCC: " << __GNUC__;
-      __GNUC_PATCHLEVEL__);
+  res << "." << __GNUC_MINOR__ << ".";
+  res << __GNUC_PATCHLEVEL__;
 #elif _MSC_VER
-  return "MSVC; " mkstring(_MSC_VER);
+  res << "MSVC: " << _MSC_VER;
 #else
-  return "Unknown Compiler";
+  res << "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 + 1) == 0 || *(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

@@ -0,0 +1,66 @@
+#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
+ */
+PD_CORE_API u64 GetTime();
+/**
+ * Get Current Time in Nanoseconds
+ * @return 64Bit value of nanos
+ */
+PD_CORE_API u64 GetNanoTime();
+/**
+ * Get a TimeTrace Reference by its string ID
+ * @param id trace name
+ * @return Trace reference or nullptr if not found
+ */
+PD_CORE_API 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
+ */
+PD_CORE_API bool TraceExist(const std::string& id);
+/**
+ * Get TraceMap Reference
+ * @return edidable Reference to the TraceMap
+ */
+PD_CORE_API TraceMap& GetTraceMap();
+}  // namespace Sys
+}  // namespace PD

include/pd/core/timer.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,13 +23,14 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
+#include <pd/core/sys.hpp>
 
 namespace PD {
 /**
  * Timer class
  */
-class PD_API Timer {
+class PD_CORE_API Timer : public SmartCtor<Timer> {
  public:
   /**
    * Constructor
@@ -40,7 +41,6 @@ class PD_API Timer {
    * Unused Deconstructor
    */
   ~Timer() {}
-
   /**
    * Resume Timer if Paused
    */
@@ -73,11 +73,12 @@ class PD_API Timer {
    */
   double GetSeconds();
 
+ private:
   /** Start of the Timer */
-  u64 pStart;
+  u64 start;
   /** Current Time */
-  u64 pNow;
+  u64 now;
   /** Is Running */
-  bool pIsRunning = false;
+  bool is_running = false;
 };
 }  // namespace PD

include/pd/core/timetrace.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,13 +23,13 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 namespace PD {
 /**
  * Class to calculate Maximum/Minimum and Average Timings
  */
-class TimeStats {
+class TimeStats : public SmartCtor<TimeStats> {
  public:
   /**
    * Constructor taking a lengh for the List
@@ -100,12 +100,12 @@ class 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 +146,17 @@ namespace TT {
 /**
  * Data Structure for a TimeTrace Result
  */
-class Res {
+class Res : public SmartCtor<Res> {
  public:
   /** Constructore that Inits a protocol at size of 60 frames */
-  Res() : start(0), end(0), protocol(60) {}
+  Res() { protocol = TimeStats::New(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,8 +178,7 @@ class Res {
    */
   void SetEnd(u64 v) {
     end = v;
-    diff = end - start;
+    protocol->Add(GetLastDiff());
-    protocol.Add(GetLastDiff());
   }
   /**
    * Getter for the End Time
@@ -191,12 +190,12 @@ class Res {
    * Get Last Diffrence between end and start
    * @return end - start
    */
-  u64 GetLastDiff() { return diff; }
+  u64 GetLastDiff() { return end - start; }
   /**
    * Get Protcol Reference
    * @return Protocol Ref
    */
-  TimeStats& GetProtocol() { return protocol; }
+  TimeStats::Ref GetProtocol() { return protocol; }
 
  private:
   /** Trace ID */
@@ -205,21 +204,19 @@ class Res {
   u64 start;
   /** End Time */
   u64 end;
-  /** Last Diff */
-  u64 diff;
   /** Protocol */
-  TimeStats protocol;
+  TimeStats::Ref protocol;
 };
 /**
  * Begin a Trace
  * @param id Name of the Trace
  */
-PD_API void Beg(const std::string& id);
+PD_CORE_API void Beg(const std::string &id);
 /**
  * End a Trace
  * @param id Name of the Trace
  */
-PD_API void End(const std::string& id);
+PD_CORE_API void End(const std::string &id);
 /**
  * Collect Start end end of the trace by tracking
  * when the Scope object goes out of scope
@@ -241,18 +238,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 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
@@ -60,7 +60,7 @@ class Tween {
    * @param delta deltatime
    */
   void Update(float delta) {
-    time += delta * 0.001f;
+    time += delta / 1000.f;
     if (time > tend) {
       finished = true;
       time = tend;
@@ -162,10 +162,10 @@ class Tween {
         return -(end - start) * t * (t - 2) + start;
         break;
       case EaseInOutQuad:
-        t = time / (tend * 0.5f);
+        t = time / (tend / 2);
-        if (t < 1) return (end - start) * 0.5f * t * t + start;
+        if (t < 1) return (end - start) / 2 * t * t + start;
         t--;
-        return -(end - start) * 0.5f * (t * (t - 2) - 1) + start;
+        return -(end - start) / 2 * (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 *0.5f);
+      //   t = time / (tend / 2);
-      //   if (t < 1) return (end - start) *0.5f * t * t * t + start;
+      //   if (t < 1) return (end - start) / 2 * t * t * t + start;
       //   t--;
-      //   return (end - start) *0.5f * (t * t * t * 2) + start;
+      //   return (end - start) / 2 * (t * t * t * 2) + start;
       //   break;
       case EaseInSine:
-        return -(end - start) * cos(time / tend * (M_PI * 0.5f)) +
+        return -(end - start) * cos(time / tend * (M_PI / 2)) + (end - start) +
-               (end - start) + start;
+               start;
         break;
       case EaseOutSine:
-        return (end - start) * sin(time / tend * (M_PI * 0.5f)) + start;
+        return (end - start) * sin(time / tend * (M_PI / 2)) + start;
         break;
       case EaseInOutSine:
-        return -(end - start) * 0.5f * (cos(M_PI * time / tend) - 1) + start;
+        return -(end - start) / 2 * (cos(M_PI * time / tend) - 1) + start;
         break;
 
       default:  // Linear

include/pd/core/u128.hpp

@@ -1,127 +0,0 @@
-#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 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,37 +23,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
 #include <pd/core/vec2.hpp>
 #include <pd/core/vec3.hpp>
 #include <pd/core/vec4.hpp>
-
-/** Define Formatters for C++ 20 */
-
-/**
- * WHY DOES MSVC ALWAYS NEED THESE EXTRA THINGS
- */
-
-template <typename T, typename CharT>
-struct std::formatter<PD::vec2<T>, CharT> : std::formatter<T, CharT> {
-  template <typename FormatContext>
-  auto format(const PD::vec2<T>& v, FormatContext& ctx) const {
-    return std::format_to(ctx.out(), "{}, {}", v.x, v.y);
-  }
-};
-
-template <typename T, typename CharT>
-struct std::formatter<PD::vec3<T>, CharT> : std::formatter<T, CharT> {
-  template <typename FormatContext>
-  auto format(const PD::vec3<T>& v, FormatContext& ctx) const {
-    return std::format_to(ctx.out(), "{}, {}, {}", v.x, v.y, v.z);
-  }
-};
-
-template <typename T, typename CharT>
-struct std::formatter<PD::vec4<T>, CharT> : std::formatter<T, CharT> {
-  template <typename FormatContext>
-  auto format(const PD::vec4<T>& v, FormatContext& ctx) const {
-    return std::format_to(ctx.out(), "{}, {}, {}, {}", v.x, v.y, v.z, v.w);
-  }
-};

include/pd/core/vec2.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,175 +23,113 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-// This file is generated by lazyvec 2.0.0
+#include <pd/core/common.hpp>
-
-#include <pd/common.hpp>
 
 namespace PD {
 template <typename T>
 class vec2 {
  public:
-  T x;
+  // SECTION: Constructors //
-  T y;
 
-  // Constructors
+  vec2() = default;
-
+  vec2(T v) {
-  constexpr vec2() : x(0), y(0) {}
+    x = v;
-  template <typename T1>
+    y = v;
-  constexpr vec2(T1 v) {
+  }
-    x = (T)v;
+  vec2(T x, T y) {
-    y = (T)v;
+    this->x = x;
+    this->y = y;
   }
 
-  template <typename T1>
+  vec2(const vec2<T> &v) {
-  constexpr vec2(const vec2<T1>& v) {
+    x = v.x;
-    x = (T)v.x;
+    y = v.y;
-    y = (T)v.y;
   }
 
-  constexpr explicit vec2(T x, T y) : x(x), y(y) {}
+  // SECTION: Operators //
 
-  // Operations
+  // ADD //
 
-  template <typename T1>
+  vec2 &operator+=(T v) {
-  vec2<T>& operator+=(T1 v) {
+    x += v;
-    x += (T)v;
+    y += v;
-    y += (T)v;
     return *this;
   }
-
+  vec2 &operator+=(const vec2 &v) {
-  template <typename T1>
+    x += v.x;
-  vec2<T>& operator+=(const vec2<T1>& v) {
+    y += v.y;
-    x += (T)v.x;
-    y += (T)v.y;
     return *this;
   }
+  vec2 operator+(T v) const { return vec2(x + v, y + v); }
+  vec2 operator+(vec2 v) const { return vec2(x + v.x, y + v.y); }
 
-  template <typename T1>
+  // SUB //
-  vec2<T> operator+(T1 v) const {
-    return vec2<T>(x + (T)v, y + (T)v);
-  }
 
-  template <typename T1>
+  vec2 &operator-=(T v) {
-  vec2<T> operator+(const vec2<T1>& v) const {
+    x -= v;
-    return vec2<T>(x + (T)v.x, y + (T)v.y);
+    y -= v;
-  }
-
-  template <typename T1>
-  vec2<T>& operator-=(T1 v) {
-    x -= (T)v;
-    y -= (T)v;
     return *this;
   }
-
+  vec2 &operator-=(const vec2 &v) {
-  template <typename T1>
+    x -= v.x;
-  vec2<T>& operator-=(const vec2<T1>& v) {
+    y -= v.y;
-    x -= (T)v.x;
-    y -= (T)v.y;
     return *this;
   }
+  vec2 operator-(T v) const { return vec2(x - v, y - v); }
+  vec2 operator-(vec2 v) const { return vec2(x - v.x, y - v.y); }
 
-  template <typename T1>
+  // MUL //
-  vec2<T> operator-(T1 v) const {
-    return vec2<T>(x - (T)v, y - (T)v);
-  }
 
-  template <typename T1>
+  vec2 &operator*=(T v) {
-  vec2<T> operator-(const vec2<T1>& v) const {
+    x *= v;
-    return vec2<T>(x - (T)v.x, y - (T)v.y);
+    y *= v;
-  }
-
-  template <typename T1>
-  vec2<T>& operator*=(T1 v) {
-    x *= (T)v;
-    y *= (T)v;
     return *this;
   }
-
+  vec2 &operator*=(const vec2 &v) {
-  template <typename T1>
+    x *= v.x;
-  vec2<T>& operator*=(const vec2<T1>& v) {
+    y *= v.y;
-    x *= (T)v.x;
-    y *= (T)v.y;
     return *this;
   }
+  vec2 operator*(T v) const { return vec2(x * v, y * v); }
+  vec2 operator*(vec2 v) const { return vec2(x * v.x, y * v.y); }
 
-  template <typename T1>
+  // DIV //
-  vec2<T> operator*(T1 v) const {
-    return vec2<T>(x * (T)v, y * (T)v);
-  }
 
-  template <typename T1>
+  vec2 &operator/=(T v) {
-  vec2<T> operator*(const vec2<T1>& v) const {
+    x /= v;
-    return vec2<T>(x * (T)v.x, y * (T)v.y);
+    y /= v;
-  }
-
-  template <typename T1>
-  vec2<T>& operator/=(T1 v) {
-    x /= (T)v;
-    y /= (T)v;
     return *this;
   }
-
+  vec2 &operator/=(const vec2 &v) {
-  template <typename T1>
+    x /= v.x;
-  vec2<T>& operator/=(const vec2<T1>& v) {
+    y /= v.y;
-    x /= (T)v.x;
-    y /= (T)v.y;
     return *this;
   }
+  vec2 operator/(T v) const { return vec2(x / v, y / v); }
+  vec2 operator/(vec2 v) const { return vec2(x / v.x, y / v.y); }
 
-  template <typename T1>
+  // Make Negative //
-  vec2<T> operator/(T1 v) const {
-    return vec2<T>(x / (T)v, y / (T)v);
-  }
-
-  template <typename T1>
-  vec2<T> operator/(const vec2<T1>& v) const {
-    return vec2<T>(x / (T)v.x, y / (T)v.y);
-  }
-
-  // Generic Operations
-
   vec2 operator-() const { return vec2(-x, -y); }
-  template <typename T1>
-  bool operator==(const vec2<T1>& v) const {
-    return x == (T)v.x && y == (T)v.y;
-  }
-  template <typename T1>
-  bool operator!=(const vec2<T1>& v) const {
-    return !(*this == v);
-  }
 
-  // Functions
+  bool operator==(const vec2 &v) const { return x == v.x && y == v.y; }
+  bool operator!=(const vec2 &v) const { return !(*this == v); }
 
-  double Len() const { return std::sqrt(SqLen()); }
+  // SECTION: Additional Functions //
-  double SqLen() const { return x * x + y * y; }
 
-  template <typename T1>
+  float Len() const { return sqrt(SqLen()); }
-  double Distance(const vec2<T1>& v) const {
+  float SqLen() const { return x * x + y * y; }
-    return (*this - v).Len();
+  void Swap() {
-  }
-
-  vec2<T> Normalize() const {
-    double l = Len();
-    if (l == 0) {
-      return *this;
-    }
-    return *this / (T)l;
-  }
-
-  template <typename T1>
-  T Dot(const vec2<T1>& v) const {
-    return x * (T)v.x + y * (T)v.y;
-  }
-
-  // Swap Functions
-  void SwapXY() {
     T t = x;
     x = y;
     y = t;
   }
+
+  // SECTION: DATA //
+  T x = 0;
+  T y = 0;
 };
+
+using dvec2 = vec2<double>;
 using fvec2 = vec2<float>;
 using ivec2 = vec2<int>;
-using dvec2 = vec2<double>;
 }  // namespace PD

include/pd/core/vec3.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,213 +23,138 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-// This file is generated by lazyvec 2.0.0
+#include <pd/core/common.hpp>
-
-#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;
+  // SECTION: Constructors //
-  T y;
-  T z;
 
-  // Constructors
+  vec3() = default;
-
+  vec3(T v) {
-  constexpr vec3() : x(0), y(0), z(0) {}
+    x = v;
-  template <typename T1>
+    y = v;
-  constexpr vec3(T1 v) {
+    z = v;
-    x = (T)v;
+  }
-    y = (T)v;
+  vec3(T x, T y, T z) {
-    z = (T)v;
+    this->x = x;
+    this->y = y;
+    this->z = z;
   }
 
-  template <typename T1>
+  vec3(const vec3 &v) {
-  constexpr vec3(const vec3<T1>& v) {
+    x = v.x;
-    x = (T)v.x;
+    y = v.y;
-    y = (T)v.y;
+    z = v.z;
-    z = (T)v.z;
   }
 
-  constexpr explicit vec3(T x, T y, T z) : x(x), y(y), z(z) {}
+  // SECTION: Operators //
 
-  // Extended Constructors
+  // ADD //
-  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
+  vec3 &operator+=(T v) {
-
+    x += v;
-  template <typename T1>
+    y += v;
-  vec3<T>& operator+=(T1 v) {
+    z += v;
-    x += (T)v;
-    y += (T)v;
-    z += (T)v;
     return *this;
   }
-
+  vec3 &operator+=(const vec3 &v) {
-  template <typename T1>
+    x += v.x;
-  vec3<T>& operator+=(const vec3<T1>& v) {
+    y += v.y;
-    x += (T)v.x;
+    z += v.z;
-    y += (T)v.y;
-    z += (T)v.z;
     return *this;
   }
+  vec3 operator+(T v) const { return vec3(x + v, y + v, z + v); }
+  vec3 operator+(vec3 v) const { return vec3(x + v.x, y + v.y, z + v.z); }
 
-  template <typename T1>
+  // SUB //
-  vec3<T> operator+(T1 v) const {
-    return vec3<T>(x + (T)v, y + (T)v, z + (T)v);
-  }
 
-  template <typename T1>
+  vec3 &operator-=(T v) {
-  vec3<T> operator+(const vec3<T1>& v) const {
+    x -= v;
-    return vec3<T>(x + (T)v.x, y + (T)v.y, z + (T)v.z);
+    y -= v;
-  }
+    z -= v;
-
-  template <typename T1>
-  vec3<T>& operator-=(T1 v) {
-    x -= (T)v;
-    y -= (T)v;
-    z -= (T)v;
     return *this;
   }
-
+  vec3 &operator-=(const vec3 &v) {
-  template <typename T1>
+    x -= v.x;
-  vec3<T>& operator-=(const vec3<T1>& v) {
+    y -= v.y;
-    x -= (T)v.x;
+    z -= v.z;
-    y -= (T)v.y;
-    z -= (T)v.z;
     return *this;
   }
+  vec3 operator-(T v) const { return vec3(x - v, y - v, z - v); }
+  vec3 operator-(vec3 v) const { return vec3(x - v.x, y - v.y, z - v.z); }
 
-  template <typename T1>
+  // MUL //
-  vec3<T> operator-(T1 v) const {
-    return vec3<T>(x - (T)v, y - (T)v, z - (T)v);
-  }
 
-  template <typename T1>
+  vec3 &operator*=(T v) {
-  vec3<T> operator-(const vec3<T1>& v) const {
+    x *= v;
-    return vec3<T>(x - (T)v.x, y - (T)v.y, z - (T)v.z);
+    y *= v;
-  }
+    z *= v;
-
-  template <typename T1>
-  vec3<T>& operator*=(T1 v) {
-    x *= (T)v;
-    y *= (T)v;
-    z *= (T)v;
     return *this;
   }
-
+  vec3 &operator*=(const vec3 &v) {
-  template <typename T1>
+    x *= v.x;
-  vec3<T>& operator*=(const vec3<T1>& v) {
+    y *= v.y;
-    x *= (T)v.x;
+    z *= v.z;
-    y *= (T)v.y;
-    z *= (T)v.z;
     return *this;
   }
+  vec3 operator*(T v) const { return vec3(x * v, y * v, z * v); }
+  vec3 operator*(vec3 v) const { return vec3(x * v.x, y * v.y, z * v.z); }
 
-  template <typename T1>
+  // DIV //
-  vec3<T> operator*(T1 v) const {
-    return vec3<T>(x * (T)v, y * (T)v, z * (T)v);
-  }
 
-  template <typename T1>
+  vec3 &operator/=(T v) {
-  vec3<T> operator*(const vec3<T1>& v) const {
+    x /= v;
-    return vec3<T>(x * (T)v.x, y * (T)v.y, z * (T)v.z);
+    y /= v;
-  }
+    z /= v;
-
-  template <typename T1>
-  vec3<T>& operator/=(T1 v) {
-    x /= (T)v;
-    y /= (T)v;
-    z /= (T)v;
     return *this;
   }
-
+  vec3 &operator/=(const vec3 &v) {
-  template <typename T1>
+    x /= v.x;
-  vec3<T>& operator/=(const vec3<T1>& v) {
+    y /= v.y;
-    x /= (T)v.x;
+    z /= v.z;
-    y /= (T)v.y;
-    z /= (T)v.z;
     return *this;
   }
+  vec3 operator/(T v) const { return vec3(x / v, y / v, z / v); }
+  vec3 operator/(vec3 v) const { return vec3(x / v.x, y / v.y, z / v.z); }
 
-  template <typename T1>
+  // Make Negative //
-  vec3<T> operator/(T1 v) const {
-    return vec3<T>(x / (T)v, y / (T)v, z / (T)v);
-  }
-
-  template <typename T1>
-  vec3<T> operator/(const vec3<T1>& v) const {
-    return vec3<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z);
-  }
-
-  // Generic Operations
-
   vec3 operator-() const { return vec3(-x, -y, -z); }
-  template <typename T1>
+
-  bool operator==(const vec3<T1>& v) const {
+  bool operator==(const vec3 &v) const {
-    return x == (T)v.x && y == (T)v.y && z == (T)v.z;
+    return x == v.x && y == v.y && z == v.z;
-  }
-  template <typename T1>
-  bool operator!=(const vec3<T1>& v) const {
-    return !(*this == v);
   }
+  bool operator!=(const vec3 &v) const { return !(*this == v); }
 
-  // Functions
+  // SECTION: Additional Functions //
 
-  double Len() const { return std::sqrt(SqLen()); }
+  float Len() const { return sqrt(SqLen()); }
-  double SqLen() const { return x * x + y * y + z * z; }
+  float SqLen() const { return x * x + y * y + z * z; }
-
-  template <typename T1>
-  double Distance(const vec3<T1>& v) const {
-    return (*this - v).Len();
-  }
-
-  vec3<T> Normalize() const {
-    double l = Len();
-    if (l == 0) {
-      return *this;
-    }
-    return *this / (T)l;
-  }
-
-  template <typename T1>
-  T Dot(const vec3<T1>& v) const {
-    return x * (T)v.x + y * (T)v.y + z * (T)v.z;
-  }
-
-  template <typename T1>
-  vec3<T> Cross(const vec3<T1>& v) const {
-    return vec3<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
-  }
-
-  // Swap Functions
   void SwapXY() {
     T t = x;
     x = y;
     y = t;
   }
-  void SwapXZ() {
-    T t = x;
-    x = z;
-    z = t;
-  }
   void SwapYZ() {
-    T t = y;
+    T t = z;
-    y = z;
+    z = y;
-    z = t;
+    y = t;
   }
+  void SwapXZ() {
+    T t = z;
+    z = x;
+    x = t;
+  }
+
+  // SECTION: DATA //
+  T x = 0;
+  T y = 0;
+  T z = 0;
 };
+
+using dvec3 = vec3<double>;
 using fvec3 = vec3<float>;
 using ivec3 = vec3<int>;
-using dvec3 = vec3<double>;
 }  // namespace PD

include/pd/core/vec4.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,246 +23,171 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-// This file is generated by lazyvec 2.0.0
+#include <pd/core/common.hpp>
-
-#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;
+  // SECTION: Constructors //
-  T y;
-  T z;
-  T w;
 
-  // Constructors
+  vec4() = default;
-
+  vec4(T v) {
-  constexpr vec4() : x(0), y(0), z(0), w(0) {}
+    x = v;
-  template <typename T1>
+    y = v;
-  constexpr vec4(T1 v) {
+    z = v;
-    x = (T)v;
+    w = v;
-    y = (T)v;
+  }
-    z = (T)v;
+  vec4(T x, T y, T z, T w) {
-    w = (T)v;
+    this->x = x;
+    this->y = y;
+    this->z = z;
+    this->w = w;
   }
 
-  template <typename T1>
+  vec4(const vec4 &v) {
-  constexpr vec4(const vec4<T1>& v) {
+    x = v.x;
-    x = (T)v.x;
+    y = v.y;
-    y = (T)v.y;
+    z = v.z;
-    z = (T)v.z;
+    w = v.w;
-    w = (T)v.w;
   }
 
-  constexpr explicit vec4(T x, T y, T z, T w) : x(x), y(y), z(z), w(w) {}
+  vec4(const vec2<T> &xy, const vec2<T> &zw) {
-
+    x = xy.x;
-  // Extended Constructors
+    y = xy.y;
-  template <typename T1>
+    z = zw.x;
-  constexpr explicit vec4(const vec2<T1>& xy, const vec2<T1>& zw) {
+    w = zw.y;
-    {
-      x = (T)xy.x;
-      y = (T)xy.y;
-      z = (T)zw.x;
-      w = (T)zw.y;
-    }
   }
 
-  template <typename T1>
+  // SECTION: Operators //
-  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
+  // ADD //
 
-  template <typename T1>
+  vec4 &operator+=(T v) {
-  vec4<T>& operator+=(T1 v) {
+    x += v;
-    x += (T)v;
+    y += v;
-    y += (T)v;
+    z += v;
-    z += (T)v;
+    w += v;
-    w += (T)v;
     return *this;
   }
-
+  vec4 &operator+=(const vec4<T> &v) {
-  template <typename T1>
+    x += v.x;
-  vec4<T>& operator+=(const vec4<T1>& v) {
+    y += v.y;
-    x += (T)v.x;
+    z += v.z;
-    y += (T)v.y;
+    w += v.w;
-    z += (T)v.z;
-    w += (T)v.w;
     return *this;
   }
-
+  vec4 operator+(T v) const { return vec4<T>(x + v, y + v, z + v, w + v); }
-  template <typename T1>
+  vec4 operator+(vec4 v) const {
-  vec4<T> operator+(T1 v) const {
+    return vec4(x + v.x, y + v.y, z + v.z, w + v.w);
-    return vec4<T>(x + (T)v, y + (T)v, z + (T)v, w + (T)v);
   }
 
-  template <typename T1>
+  // SUB //
-  vec4<T> operator+(const vec4<T1>& v) const {
-    return vec4<T>(x + (T)v.x, y + (T)v.y, z + (T)v.z, w + (T)v.w);
-  }
 
-  template <typename T1>
+  vec4 &operator-=(T v) {
-  vec4<T>& operator-=(T1 v) {
+    x -= v;
-    x -= (T)v;
+    y -= v;
-    y -= (T)v;
+    z -= v;
-    z -= (T)v;
+    w -= v;
-    w -= (T)v;
     return *this;
   }
-
+  vec4 &operator-=(const vec4 &v) {
-  template <typename T1>
+    x -= v.x;
-  vec4<T>& operator-=(const vec4<T1>& v) {
+    y -= v.y;
-    x -= (T)v.x;
+    z -= v.z;
-    y -= (T)v.y;
+    w -= v.w;
-    z -= (T)v.z;
-    w -= (T)v.w;
     return *this;
   }
-
+  vec4 operator-(T v) const { return vec4(x - v, y - v, z - v, w - v); }
-  template <typename T1>
+  vec4 operator-(vec4 v) const {
-  vec4<T> operator-(T1 v) const {
+    return vec4(x - v.x, y - v.y, z - v.z, w - v.w);
-    return vec4<T>(x - (T)v, y - (T)v, z - (T)v, w - (T)v);
   }
 
-  template <typename T1>
+  // MUL //
-  vec4<T> operator-(const vec4<T1>& v) const {
-    return vec4<T>(x - (T)v.x, y - (T)v.y, z - (T)v.z, w - (T)v.w);
-  }
 
-  template <typename T1>
+  vec4 &operator*=(T v) {
-  vec4<T>& operator*=(T1 v) {
+    x *= v;
-    x *= (T)v;
+    y *= v;
-    y *= (T)v;
+    z *= v;
-    z *= (T)v;
+    w *= v;
-    w *= (T)v;
     return *this;
   }
-
+  vec4 &operator*=(const vec4 &v) {
-  template <typename T1>
+    x *= v.x;
-  vec4<T>& operator*=(const vec4<T1>& v) {
+    y *= v.y;
-    x *= (T)v.x;
+    z *= v.z;
-    y *= (T)v.y;
+    w *= v.w;
-    z *= (T)v.z;
-    w *= (T)v.w;
     return *this;
   }
-
+  vec4 operator*(T v) const { return vec4(x * v, y * v, z * v, w * v); }
-  template <typename T1>
+  vec4 operator*(vec4 v) const {
-  vec4<T> operator*(T1 v) const {
+    return vec4(x * v.x, y * v.y, z * v.z, w * v.w);
-    return vec4<T>(x * (T)v, y * (T)v, z * (T)v, w * (T)v);
   }
 
-  template <typename T1>
+  // DIV //
-  vec4<T> operator*(const vec4<T1>& v) const {
-    return vec4<T>(x * (T)v.x, y * (T)v.y, z * (T)v.z, w * (T)v.w);
-  }
 
-  template <typename T1>
+  vec4 &operator/=(T v) {
-  vec4<T>& operator/=(T1 v) {
+    x /= v;
-    x /= (T)v;
+    y /= v;
-    y /= (T)v;
+    z /= v;
-    z /= (T)v;
+    w /= v;
-    w /= (T)v;
     return *this;
   }
-
+  vec4 &operator/=(const vec4 &v) {
-  template <typename T1>
+    x /= v.x;
-  vec4<T>& operator/=(const vec4<T1>& v) {
+    y /= v.y;
-    x /= (T)v.x;
+    z /= v.z;
-    y /= (T)v.y;
+    w /= v.w;
-    z /= (T)v.z;
-    w /= (T)v.w;
     return *this;
   }
-
+  vec4 operator/(T v) const { return vec4(x / v, y / v, z / v, w / v); }
-  template <typename T1>
+  vec4 operator/(vec4 v) const {
-  vec4<T> operator/(T1 v) const {
+    return vec4(x / v.x, y / v.y, z / v.z, w / v.w);
-    return vec4<T>(x / (T)v, y / (T)v, z / (T)v, w / (T)v);
   }
 
-  template <typename T1>
+  // Make Negative //
-  vec4<T> operator/(const vec4<T1>& v) const {
-    return vec4<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z, w / (T)v.w);
-  }
-
-  // Generic Operations
-
   vec4 operator-() const { return vec4(-x, -y, -z, -w); }
-  template <typename T1>
+
-  bool operator==(const vec4<T1>& v) const {
+  bool operator==(const vec4 &v) const {
-    return x == (T)v.x && y == (T)v.y && z == (T)v.z && w == (T)v.w;
+    return x == v.x && y == v.y && z == v.z && w == v.w;
-  }
-  template <typename T1>
-  bool operator!=(const vec4<T1>& v) const {
-    return !(*this == v);
   }
+  bool operator!=(const vec4 &v) const { return !(*this == v); }
 
-  // Functions
+  // SECTION: Additional Functions //
 
-  double Len() const { return std::sqrt(SqLen()); }
+  float Len() const { return sqrt(SqLen()); }
-  double SqLen() const { return x * x + y * y + z * z + w * w; }
+  float SqLen() const { return x * x + y * y + z * z + w * w; }
-
-  template <typename T1>
-  double Distance(const vec4<T1>& v) const {
-    return (*this - v).Len();
-  }
-
-  vec4<T> Normalize() const {
-    double l = Len();
-    if (l == 0) {
-      return *this;
-    }
-    return *this / (T)l;
-  }
-
-  template <typename T1>
-  T Dot(const vec4<T1>& v) const {
-    return x * (T)v.x + y * (T)v.y + z * (T)v.z + w * (T)v.w;
-  }
-
-  // Swap Functions
   void SwapXY() {
     T t = x;
     x = y;
     y = t;
   }
-  void SwapXZ() {
-    T t = x;
-    x = z;
-    z = t;
-  }
-  void SwapXW() {
-    T t = x;
-    x = w;
-    w = t;
-  }
   void SwapYZ() {
-    T t = y;
+    T t = z;
-    y = z;
+    z = y;
+    y = t;
+  }
+  void SwapXZ() {
+    T t = z;
+    z = x;
+    x = t;
+  }
+  // Adding ZW (to lazy to add all of those yet)
+  void SwapZW() {
+    T t = w;
+    w = z;
     z = t;
   }
-  void SwapYW() {
+
-    T t = y;
+  // SECTION: DATA //
-    y = w;
+  T x = 0;
-    w = t;
+  T y = 0;
-  }
+  T z = 0;
-  void SwapZW() {
+  T w = 0;
-    T t = z;
-    z = w;
-    w = t;
-  }
 };
+
+using dvec4 = vec4<double>;
 using fvec4 = vec4<float>;
 using ivec4 = vec4<int>;
-using dvec4 = vec4<double>;
 }  // namespace PD

include/pd/drivers/drivers.hpp

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

include/pd/drivers/formatters.hpp

@@ -1,44 +0,0 @@
-#pragma once
-
-#include <pd/drivers/gfx.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);
-  }
-};

include/pd/drivers/gfx.hpp

@@ -1,166 +0,0 @@
-#pragma once
-
-#include <pd/core/mat.hpp>
-#include <pd/drivers/interface.hpp>
-#include <pd/lithium/command.hpp>
-
-using LiBackendFlags = PD::u32;
-enum LiBackendFlags_ {
-  LiBackendFlags_None = 0,
-  LiBackendFlags_FlipUV_Y = 1 << 0,  // Essential for font loading
-};
-
-namespace PD {
-using TextureID = ptr;
-enum class TextureFilter {
-  Linear,
-  Nearest,
-};
-
-enum class TextureFormat {
-  RGBA32,
-  RGB24,
-  A8,
-};
-
-// Pre interface class
-class PD_API GfxDriver : public DriverInterface {
- public:
-  GfxDriver(std::string_view name);
-  virtual ~GfxDriver() = default;
-
-  virtual void Init() {}
-  virtual void Deinit() { SysDeinit(); }
-
-  void SetViewPort(const ivec2& size);
-  void SetViewPort(int x, int y);
-  virtual void BindTexture(TextureID id) {}
-  void Reset();
-  virtual TextureID LoadTexture(const std::vector<PD::u8>& pixels, int w, int h,
-                                TextureFormat type = TextureFormat::RGBA32,
-                                TextureFilter filter = TextureFilter::Linear) {
-    return 0;
-  }
-  virtual void DeleteTexture(const TextureID& tex) {}
-  virtual void Draw(const Pool<Li::Command>& commands) {}
-
- protected:
-  virtual void SysDeinit() {}
-  virtual void SysInit() {}
-  virtual void SysReset() {}
-  virtual void Submit(size_t count, size_t start) {}
-  virtual void ResetPools() = 0;
-
-  // 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;
-  TextureID CurrentTex = 0;
-  Mat4 Projection;
-  ivec2 ViewPort;
-};
-
-struct DefaultGfxConfig {
-  // Vertex Allocator
-  template <typename T>
-  using VertexAlloc = std::allocator<T>;
-  // Index Allocator
-  template <typename T>
-  using IndexAlloc = std::allocator<T>;
-
-  static constexpr size_t NumVertices = 32768;  // 8192*4
-  static constexpr size_t NumIndices = 49152;   // 8192*6
-};
-
-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 {
-    pVtxPool.Init(Config::NumVertices);
-    pIdxPool.Init(Config::NumIndices);
-    SysInit();
-  }
-
-  void Draw(const Pool<Li::Command>& commands) override {
-    CountCommands += commands.size();
-    size_t index = 0;
-    while (index < commands.size()) {
-      CurrentTex = commands[index].Tex;
-      if (!CurrentTex) {
-        index++;
-        continue;
-      }
-      size_t startidx = CurrentIndex;
-      while (index < commands.size() && CurrentTex == commands[index].Tex) {
-        const auto& c = commands[index];
-        CountVertices += c.VertexCount;
-        CountIndices += c.IndexCount;
-        auto pIdx = pIdxPool.Allocate(c.IndexCount);
-        auto pVtx = pVtxPool.Allocate(c.VertexCount);
-        for (size_t i = 0; i < c.IndexCount; i++) {
-          pIdx[i] = CurrentVertex + c.FirstIndex[i];
-        }
-        CurrentIndex += c.IndexCount;
-        CurrentVertex += c.VertexCount;
-        for (size_t i = 0; i < c.VertexCount; i++) {
-          pVtx[i] = c.FirstVertex[i];
-        }
-        index++;
-      }
-      Submit(CurrentIndex - startidx, startidx);
-    }
-  }
-
- protected:
-  u16* GetIndexBufPtr(size_t start) { return &pIdxPool[start]; }
-  Li::Vertex* GetVertexBufPtr(size_t start) { return &pVtxPool[start]; }
-  void ResetPools() override {
-    pVtxPool.Reset();
-    pIdxPool.Reset();
-  }
-
- private:
-  VtxPool pVtxPool;
-  IdxPool pIdxPool;
-};
-
-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 Pool<Li::Command>& commands) {
-    driver->Draw(commands);
-  }
-  static TextureID 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 const char* GetDriverName() { return driver->GetName(); }
-
- private:
-  static std::unique_ptr<GfxDriver> driver;
-};
-}  // namespace PD

include/pd/drivers/interface.hpp

@@ -1,16 +0,0 @@
-#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

@@ -1,32 +0,0 @@
-#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(); }
-
- private:
-  static std::unique_ptr<OsDriver> driver;
-};
-}  // namespace PD

include/pd/image/image.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+#include <pd/image/pd_p_api.hpp>
+
+namespace PD {
+class PD_IMAGE_API Image : public SmartCtor<Image> {
+ public:
+  enum Format {
+    RGBA,    // bpp == 4
+    RGB,     // bpp == 3
+    RGB565,  // bpp == 2 (not supported in laoding)
+    BGR,     // bpp == 3
+    ABGR     // bpp == 4
+  };
+  Image() = default;
+  Image(const std::string& path) { this->Load(path); }
+  Image(const std::vector<u8>& buf) { this->Load(buf); }
+  Image(const std::vector<u8>& buf, int w, int h, int bpp = 4) {
+    this->Copy(buf, w, h, bpp);
+  }
+  ~Image() = default;
+
+  void Load(const std::string& path);
+  void Load(const std::vector<u8>& buf);
+  void Copy(const std::vector<u8>& buf, int w, int h, int bpp = 4);
+
+  std::vector<PD::u8>& GetBuffer() { return pBuffer; }
+  std::vector<PD::u8> GetBuffer() const { return pBuffer; }
+
+  int Width() const { return pWidth; }
+  int Height() const { return pHeight; }
+  Format Fmt() const { return pFmt; }
+
+  u8& operator[](int idx) { return pBuffer[idx]; }
+  u8 operator[](int idx) const { return pBuffer[idx]; }
+
+  // Probably these make th eabove ones useless
+
+  operator std::vector<PD::u8>&() { return pBuffer; }
+  operator std::vector<PD::u8>() const { return pBuffer; }
+
+  static void Convert(Image::Ref img, Image::Format dst);
+  static void ReTile(Image::Ref img,
+                     std::function<u32(int x, int y, int w)> src,
+                     std::function<u32(int x, int y, int w)> dst);
+  static int Fmt2Bpp(Format fmt);
+
+  std::vector<PD::u8> pBuffer;
+  int pWidth;
+  int pHeight;
+  Format pFmt = Format::RGBA;
+
+ private:
+  /** Leftover variable used for stbi_load */
+  int fmt = 0;
+};
+}  // namespace PD

include/pd/image/img_blur.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+#include <pd/image/pd_p_api.hpp>
+
+namespace PD {
+/**
+ * Namepace containing functions to blur images
+ */
+namespace ImgBlur {
+/**
+ * Function to create Gaussian Kernel List
+ * @param radius Rasius to use
+ * @param si sigma value to use
+ * @return list of kernel values
+ */
+PD_IMAGE_API std::vector<float> GaussianKernel(int radius, float si);
+/**
+ * Gaussian Blur for basic Image Buffer
+ * @param buf Image Buffer (unsigned char)
+ * @param w width of the image
+ * @param h width of the image
+ * @param radius Blur radius
+ * @param si Blur sigma
+ * @param idxfn Indexing function
+ */
+PD_IMAGE_API void GaussianBlur(
+    std::vector<u8> &buf, int w, int h, float radius, float si,
+    std::function<int(int, int, int)> idxfn = [](int x, int y, int w) -> int {
+      return y * w + x;
+    });
+/**
+ * Advanced func to access memory directly
+ * @param buf Referenvce to the buffer
+ * @param w width of the image
+ * @param h width of the image
+ * @param bpp Bytes per Pixels (RGB[A], RGB565, etc)
+ * @param radius Blur radius
+ * @param si Blur sigma
+ * @param idxfn Indexing function
+ */
+PD_IMAGE_API void GaussianBlur(
+    void *buf, int w, int h, int bpp, float radius, float si,
+    std::function<int(int, int, int)> idxfn = [](int x, int y, int w) -> int {
+      return y * w + x;
+    });
+}  // namespace ImgBlur
+}  // namespace PD

include/pd/image/img_convert.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+#include <pd/image/image.hpp>
+#include <pd/image/pd_p_api.hpp>
+
+namespace PD {
+/**
+ * Namespace containing function to convert images
+ */
+namespace ImgConvert {
+/**
+ * Convert RGB24 to RGBA32 by adding a 4th alpha value set to 255
+ * to every pixel
+ * @param out Result List
+ * @param in Input Buffer List (rgb24)
+ * @param w width of the image
+ * @param h height of the image
+ */
+PD_IMAGE_API
+void RGB24toRGBA32(std::vector<PD::u8> &out, const std::vector<u8> &in,
+                   const int &w, const int &h);
+PD_IMAGE_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
+ */
+PD_IMAGE_API void Reverse32(std::vector<u8> &buf, const int &w, const int &h);
+PD_IMAGE_API void ReverseBuf(std::vector<u8> &buf, size_t bpp, int w, int h);
+
+/**
+ * Convert RGB24 to RGBA32 by adding a 4th alpha value set to 255
+ * to every pixel
+ * @param out Result List
+ * @param in Input Buffer List (rgb24)
+ * @param w width of the image
+ * @param h height of the image
+ */
+PD_IMAGE_API
+void RGB24toRGBA32(PD::Vec<u8> &out, const PD::Vec<u8> &in, const int &w,
+                   const int &h);
+PD_IMAGE_API
+void RGB32toRGBA24(PD::Vec<u8> &out, const PD::Vec<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
+ */
+PD_IMAGE_API void Reverse32(PD::Vec<u8> &buf, const int &w, const int &h);
+PD_IMAGE_API void ReverseBuf(PD::Vec<u8> &buf, size_t bpp, int w, int h);
+}  // namespace ImgConvert
+}  // namespace PD

include/pd/image/pd_p_api.hpp

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

include/pd/lithium/backend.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/command.hpp>
+#include <pd/lithium/rect.hpp>
+#include <pd/lithium/texture.hpp>
+
+using LIBackendFlags = PD::u32;
+enum LIBackendFlags_ {
+  LIBackendFlags_None = 0,
+  LIBackendFlags_FlipUV_Y = 1 << 0,  // Essential for Font Loading
+};
+
+namespace PD {
+namespace LI {
+class Backend {
+ public:
+  Backend(const std::string& name = "NullBackend") : pName(name) {}
+  ~Backend() = default;
+  // Using Legacy SmartCTOR API here
+  PD_SMART_CTOR(Backend)
+
+  virtual void Init() {}
+  virtual void Deinit() {}
+  virtual void NewFrame() {}
+
+  virtual void BindTexture(TexAddress addr) {}
+
+  virtual void RenderDrawData(const Vec<Command::Ref>& Commands) {}
+
+  virtual Texture::Ref LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      Texture::Type type = Texture::Type::RGBA32,
+      Texture::Filter filter = Texture::Filter::LINEAR) {
+    // Texture loading not supported (when this func not get override)
+    return nullptr;
+  }
+
+  /** Backend identification name */
+  const std::string pName = "NullBackend";
+  LIBackendFlags Flags = 0;
+  ivec2 ViewPort;
+  fvec4 ClearColor;
+  // Optional Index Counter
+  int IndexCounter = 0;
+  // Optional Vertex Counter
+  int VertexCounter = 0;
+  // Optional Frame Counter
+  int FrameCounter = 0;
+};
+}  // namespace LI
+}  // namespace PD

include/pd/lithium/command.hpp

@@ -1,61 +1,62 @@
 #pragma once
 
-#include <cstddef>
+/*
-#include <pd/core/pool.hpp>
+MIT License
-#include <pd/lithium/pools.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/core.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() { Reset(); }
+  Command() = default;
-  ~Command() {}
+  ~Command() = default;
 
-  void Reserve(size_t vtx, size_t idx) {
+  Command& AppendIndex(u16 idx) {
-    if (!FirstVertex)
+    IndexBuffer.Add(VertexBuffer.Size() + idx);
-      FirstVertex = AllocateVertices(vtx);
-    else
-      AllocateVertices(vtx);
-    if (!FirstIndex)
-      FirstIndex = AllocateIndices(idx);
-    else
-      AllocateIndices(idx);
-  }
-
-  void Reset() {
-    Layer = 0;
-    Tex = 0;
-    FirstIndex = nullptr;
-    FirstVertex = nullptr;
-    IndexCount = 0;
-    VertexCount = 0;
-  }
-
-  Command& Add(const Vertex& vtx) {
-    FirstVertex[VertexCount++] = vtx;
-    return *this;
-  }
-  Command& Add(u16 idx) {
-    FirstIndex[IndexCount++] = VertexCount + idx;
-    return *this;
-  }
-  Command& Add(u16 a, u16 b, u16 c) {
-    FirstIndex[IndexCount++] = VertexCount + a;
-    FirstIndex[IndexCount++] = VertexCount + b;
-    FirstIndex[IndexCount++] = VertexCount + c;
     return *this;
   }
 
-  int Layer = 0;
+  Command& AppendVertex(const Vertex& v) {
-  ptr Tex = 0;
+    VertexBuffer.Add(v);
-  Vertex* FirstVertex = nullptr;
+    return *this;
-  u16* FirstIndex = nullptr;
+  }
-  size_t VertexCount = 0;
+
-  size_t IndexCount = 0;
+  Vec<Vertex> VertexBuffer;
-  // Todo: implement
+  Vec<u16> IndexBuffer;
-  size_t VertexCountMax = 0;
+  ivec4 ScissorRect;
-  size_t IndexCountMax = 0;
+  bool ScissorEnabled = false;
+  int Layer;
+  int Index;
+  Texture::Ref Tex;
 };
-}  // namespace Li
+}  // namespace LI
 }  // namespace PD

include/pd/lithium/drawlist.hpp

@@ -0,0 +1,145 @@
+#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/lithium/command.hpp>
+#include <pd/lithium/font.hpp>
+#include <pd/lithium/pd_p_api.hpp>
+
+namespace PD {
+namespace LI {
+class PD_LITHIUM_API DrawList : public SmartCtor<DrawList> {
+ public:
+  DrawList(Texture::Ref solid) {
+    WhitePixel = solid;
+    CurrentTex = solid;
+  }
+  ~DrawList() {}
+
+  Command::Ref PreGenerateCmd();
+  void AddCommand(Command::Ref v) { pDrawList.Add(v); }
+  void Clear() { pDrawList.Clear(); }
+
+  void SetFont(Font::Ref font) { pCurrentFont = font; }
+  void SetFontScale(float scale) { pFontScale = scale; }
+
+  void DrawSolid() { CurrentTex = WhitePixel; }
+  void DrawTexture(Texture::Ref tex) { CurrentTex = tex; }
+
+  // SECTION: Draw API //
+
+  void DrawRect(const fvec2& pos, const fvec2& size, u32 color,
+                int thickness = 1);
+  void DrawRectFilled(const fvec2& pos, const fvec2& size, u32 color);
+  void DrawTriangle(const fvec2& a, const fvec2& b, const fvec2& c, u32 color,
+                    int thickness = 1);
+  void DrawTriangleFilled(const fvec2& a, const fvec2& b, const fvec2& c,
+                          u32 color);
+  void DrawCircle(const fvec2& center, float rad, u32 color, int num_segments,
+                  int thickness = 1);
+  void DrawCircleFilled(const fvec2& center, float rad, u32 color,
+                        int num_segments);
+  void DrawText(const fvec2& p, const std::string& text, u32 color);
+
+  /**
+   * Take list of points and display it as a line on screen
+   * @param points List of Positions
+   * @param clr Color of the Line
+   * @param flags Additional Flags (Close for go back to starting point)
+   * @param thickness Thickness of the Line
+   */
+  void DrawPolyLine(const Vec<fvec2>& points, u32 clr, u32 flags = 0,
+                    int thickness = 1);
+  /**
+   * Take a List ofpoints and display it as Filled Shape
+   * @note Keep in mind to setup the list of points clockwise
+   * @param points List of Points
+   * @param clr Color of the shape
+   */
+  void DrawConvexPolyFilled(const Vec<fvec2>& points, u32 clr);
+
+  // SECTION: PATH API //
+
+  /**
+   * Function to reserve Memory to prevent overhead on
+   * pusing a lot of points with PathNext
+   * @param num_points Number of Positions you want to add
+   */
+  void PathReserve(size_t num_points) {
+    pPath.Reserve(pPath.Size() + num_points);
+  }
+  /**
+   * Clear current Path
+   * @note PathStroke and PathFill will automatically clear
+   */
+  void PathClear() { pPath.Clear(); }
+  /**
+   * Add a Point to the Path
+   * @note Keep in mind that this function is used for
+   * setting the starting point
+   * @param v Position to add
+   */
+  void PathAdd(const fvec2& v) { pPath.Add(v); }
+  /**
+   * Path Stroke Create Line from point to point
+   * @note For Primitives like Rect or Triangle mak sure to use
+   * UI7DrawFlags_Close to add a line back to the starting point
+   * @param clr Color od the line
+   * @param thickness Thickness of the line
+   * @param flags Additional Drawflags
+   */
+  void PathStroke(u32 clr, int thickness = 1, u32 flags = 0) {
+    DrawPolyLine(pPath, clr, flags, thickness);
+    pPath.Clear();
+  }
+  /**
+   * Fill a Path with a Color
+   * @note **IMPORTANT: ** Paths need to be setup clockwise
+   * to be rendered correctly
+   * @param clr Fill Color
+   */
+  void PathFill(u32 clr) {
+    DrawConvexPolyFilled(pPath, clr);
+    pPath.Clear();
+  }
+  void PathArcToN(const fvec2& c, float radius, float a_min, float a_max,
+                  int segments);
+  /// @brief Create a Path Rect (uses to Positions instead of Pos/Size)
+  /// @param a Top Left Position
+  /// @param b Bottom Right Position
+  /// @param rounding rounding
+  /// @param flags DrawFlags (for special rounding rules)
+  void PathRect(fvec2 a, fvec2 b, float rounding = 0.f, u32 flags = 0);
+
+  int Layer = 0;
+  float pFontScale = 0.7f;
+  Font::Ref pCurrentFont = nullptr;
+  Texture::Ref CurrentTex = nullptr;
+  Texture::Ref WhitePixel = nullptr;
+  PD::Vec<Command::Ref> pDrawList;
+  PD::Vec<fvec2> pPath;
+};
+}  // namespace LI
+}  // namespace PD

include/pd/lithium/font.hpp

@@ -0,0 +1,95 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/backend.hpp>
+#include <pd/lithium/pd_p_api.hpp>
+#include <pd/lithium/rect.hpp>
+#include <pd/lithium/texture.hpp>
+
+using LITextFlags = PD::u32;
+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]
+};
+
+namespace PD {
+namespace LI {
+/** Font Loader for Lithium */
+class PD_LITHIUM_API Font : public SmartCtor<Font> {
+ public:
+  /** Codepoint Data holder */
+  struct Codepoint {
+    u32 pCodepoint = 0;
+    fvec4 SimpleUV;
+    Texture::Ref Tex;
+    fvec2 Size;
+    float Offset = 0.f;
+    bool pInvalid = false;
+  };
+  Font(Backend::Ref backend) { pBackend = backend; };
+  ~Font() = default;
+  /**
+   * 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);
+  /**
+   * Getter for Codepoint reference
+   * @return codepoint dataholder reference
+   */
+  Codepoint& GetCodepoint(u32 c);
+
+  /**
+   * Get Text Bounding Box
+   */
+  fvec2 GetTextBounds(const std::string& text, float scale);
+  /**
+   * Extended Draw Text Function that vreates a Command List
+   */
+  void CmdTextEx(Vec<Command::Ref>& cmds, const fvec2& pos, u32 color,
+                 float scale, const std::string& text, LITextFlags flags = 0,
+                 const fvec2& box = 0);
+
+  /** Pixelheight */
+  int PixelHeight;
+  int DefaultPixelHeight = 24;
+
+ private:
+  /** List of textures (codepoints are using) */
+  std::vector<Texture::Ref> Textures;
+  /** 32Bit Codepoint Dataholder Reference Map */
+  std::map<u32, Codepoint> CodeMap;
+  Backend::Ref pBackend = nullptr;
+};
+}  // namespace LI
+}  // namespace PD

include/pd/lithium/lithium.hpp

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

include/pd/lithium/pd_p_api.hpp

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

include/pd/lithium/pools.hpp

@@ -1,12 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <pd/lithium/vertex.hpp>
-
-namespace PD {
-namespace Li {
-PD_API void InitPools(size_t max_vertices = 32768);
-PD_API Vertex* AllocateVertices(size_t count);
-PD_API u16* AllocateIndices(size_t count);
-}  // namespace Li
-}  // namespace PD

include/pd/lithium/rect.hpp

@@ -0,0 +1,192 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+
+namespace PD {
+namespace LI {
+/**
+ * Container that holds position of a rectangle's corners.
+ */
+class Rect {
+ public:
+  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 fvec4& t, const fvec4& b) {
+    top = t;
+    bot = b;
+  }
+
+  /**
+   * Constructor that initializes the rectangle using individual corner
+   * positions.
+   * @param tl Top left corner position.
+   * @param tr Top right corner position.
+   * @param bl Bottom left corner position.
+   * @param br Bottom right corner position.
+   */
+  Rect(const fvec2& tl, const fvec2& tr, const fvec2& bl, const fvec2& br) {
+    top = fvec4(tl, tr);
+    bot = fvec4(bl, br);
+  }
+
+  /**
+   * Constructor that initializes the rectangle using a UV mapping vector.
+   *
+   * - The old API used vec4 for UV mapping.
+   * - Spritesheets have rotated images, so this was updated to use Rect for UV.
+   *
+   * @param uv Vec4 UV map.
+   */
+  Rect(const fvec4& uv) {
+    top = vec4(uv.x, uv.y, uv.z, uv.y);
+    bot = vec4(uv.x, uv.w, uv.z, uv.w);
+  }
+
+  ~Rect() = default;
+
+  /**
+   * Get the top left and right corner positions.
+   * @return Top positions.
+   */
+  fvec4 Top() const { return top; }
+
+  /**
+   * Get the bottom left and right corner positions.
+   * @return Bottom positions.
+   */
+  fvec4 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 fvec4& 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 fvec4& v) {
+    bot = v;
+    return *this;
+  }
+
+  /**
+   * Get the top-left corner position.
+   * @return Top-left position as vec2.
+   */
+  fvec2 TopLeft() const { return vec2(top.x, top.y); }
+
+  /**
+   * Get the top-right corner position.
+   * @return Top-right position as vec2.
+   */
+  fvec2 TopRight() const { return vec2(top.z, top.w); }
+
+  /**
+   * Get the bottom-left corner position.
+   * @return Bottom-left position as vec2.
+   */
+  fvec2 BotLeft() const { return vec2(bot.x, bot.y); }
+
+  /**
+   * Get the bottom-right corner position.
+   * @return Bottom-right position as vec2.
+   */
+  fvec2 BotRight() const { return vec2(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 fvec2& v) {
+    top.x = v.x;
+    top.y = v.y;
+    return *this;
+  }
+
+  /**
+   * Set the top-right corner position.
+   * @param v New top-right position.
+   * @return Reference to the updated Rect.
+   */
+  Rect& TopRight(const fvec2& v) {
+    top.z = v.x;
+    top.w = v.y;
+    return *this;
+  }
+
+  /**
+   * Set the bottom-left corner position.
+   * @param v New bottom-left position.
+   * @return Reference to the updated Rect.
+   */
+  Rect& BotLeft(const fvec2& v) {
+    bot.x = v.x;
+    bot.y = v.y;
+    return *this;
+  }
+
+  /**
+   * Set the bottom-right corner position.
+   * @param v New bottom-right position.
+   * @return Reference to the updated Rect.
+   */
+  Rect& BotRight(const fvec2& v) {
+    bot.z = v.x;
+    bot.w = v.y;
+    return *this;
+  }
+
+  /**
+   * Swap X and Y coordinates for all corners.
+   *
+   * - Used in SpiteSheet for the rotated images.
+   */
+  void SwapVec2XY() {
+    top.SwapXY();
+    top.SwapZW();
+    bot.SwapXY();
+    bot.SwapZW();
+  }
+
+ private:
+  fvec4 top;  ///< Top left and right corner positions.
+  fvec4 bot;  ///< Bottom left and right corner positions.
+};
+}  // namespace LI
+}  // namespace PD

include/pd/lithium/renderer.hpp

@@ -0,0 +1,79 @@
+#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/lithium/backend.hpp>
+#include <pd/lithium/drawlist.hpp>
+#include <pd/lithium/font.hpp>
+#include <pd/lithium/pd_p_api.hpp>
+
+namespace PD {
+namespace LI {
+class PD_LITHIUM_API Renderer : public SmartCtor<Renderer> {
+ public:
+  Renderer(Backend::Ref backend);
+  ~Renderer() = default;
+
+  void Render();
+
+  // SECTION: ADVANCED API
+
+  void AddCommand(Command::Ref v) { DrawList.Add(v); }
+  void RegisterDrawList(DrawList::Ref list) { pDrawLists.Add(list); }
+  Command::Ref PreGenerateCmd();
+
+  // SECTION: Open Command and Object creation API
+  static void RotateCorner(fvec2& pos, float sinus, float cosinus);
+  static Rect PrimRect(const fvec2& pos, const fvec2& size, float angle = 0.f);
+  static Rect PrimLine(const fvec2& a, const fvec2& b, int thickness = 1);
+  static void CmdQuad(Command::Ref cmd, const Rect& quad, const Rect& uv,
+                      u32 color);
+  static void CmdTriangle(Command::Ref cmd, const fvec2 a, const fvec2 b,
+                          const fvec2 c, u32 clr);
+  static void CmdPolyLine(const Vec<fvec2>& points, u32 clr, u32 flags = 0,
+                          int thickness = 1);
+  static void CmdConvexPolyFilled(Command::Ref cmd, const Vec<fvec2>& points,
+                                  u32 clr, Texture::Ref tex);
+
+  // SECTION: InBounds Checks
+
+  static bool InBox(const fvec2& pos, const fvec2& size, const fvec4& area);
+  static bool InBox(const fvec2& pos, const fvec4& area);
+  static bool InBox(const fvec2& a, const fvec2& b, const fvec2& c,
+                    const fvec4& area);
+
+  // SECTION: Data //
+
+  Texture::Ref WhitePixel = nullptr;
+  Backend::Ref pBackend = nullptr;
+  Texture::Ref CurrentTex = nullptr;
+  int Layer = 0;
+
+ private:
+  PD::Vec<Command::Ref> DrawList;
+  PD::Vec<DrawList::Ref> pDrawLists;
+};
+}  // namespace LI
+}  // namespace PD