Fix

- Add WIP HidNX Driver (clangd not working with devkitpro for switch on windows)
- Add default-release as default search path for compile_commands.json
- remove mingw preset (casue its exactly the default target)
- Move Mouse pos cycle into HidDriver::Update
- Test around with HidGlfw on Nintendo switch

.clang-format

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

.clangd

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

.gitattributes

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

.gitignore

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

.gitmodules

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

CMakeLists.txt

@@ -1,36 +1,164 @@
 cmake_minimum_required(VERSION 3.22)
 
+include(GNUInstallDirs)
+
 # Set Project
-project(palladium LANGUAGES C CXX VERSION 0.5.1)
+project(palladium LANGUAGES C CXX VERSION 0.7.0)
 
 # Required to add this Variable
 set(PD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 include(cmake/palladium.cmake)
 
 option(PD_BUILD_TESTS "Sets if TestApp and TestBench get build" OFF)
-option(PD_BUILD_SHARED "Build Shared Libraries" OFF)
+option(PD_BUILD_SHARED "Build Shared Library" OFF)
 option(PD_BUILD_TOOLS "Build Palladium Tools" OFF)
+option(PD_INCLUDE_STB_IMAGE "Inlude stb image symbols in palladium" ON)
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
+    add_compile_options(-Wno-psabi)
+endif()
 
 if(${PD_BUILD_TOOLS})
     add_subdirectory(tools)
 endif()
 
-## Include Library Source
+add_subdirectory(vendor)
 
-add_subdirectory(pd/drivers)
-add_subdirectory(pd/core)
-add_subdirectory(pd/image)
-add_subdirectory(pd/external)
-add_subdirectory(pd/lithium)
-add_subdirectory(pd/ui7)
+# # Include Library Source
+set(PD_SOURCES
+    # Common
+    source/common.cpp
 
-add_library(palladium INTERFACE)
-target_link_libraries(palladium INTERFACE
-    pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
+    # Core
+    source/core/bits.cpp
+    source/core/color.cpp
+    source/core/io.cpp
+    source/core/mat.cpp
+    source/core/strings.cpp
+    source/core/timer.cpp
+    source/core/timetrace.cpp
+
+    # Image
+    source/image/image.cpp
+
+    # Drivers
+    source/drivers/os.cpp
+    source/drivers/gfx.cpp
+    source/drivers/hid.cpp
+
+    # Lithium
+    source/lithium/drawlist.cpp
+    source/lithium/font.cpp
+    source/lithium/math.cpp
+    source/lithium/pools.cpp
+
+    # Ultra
+    source/ultra/canvas.cpp
+    source/ultra/layout.cpp
+    source/ultra/elems/element.cpp
+    source/ultra/elems/rect.cpp
+    source/ultra/elems/text.cpp
+    source/ultra/elems/image.cpp
+    source/ultra/elems/button.cpp
 )
 
-add_dependencies(palladium
-    pd-drivers pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
+if(${PD_BUILD_SHARED})
+    add_library(palladium SHARED ${PD_SOURCES})
+    target_compile_definitions(palladium PRIVATE PD_BUILD_SHARED)
+else()
+    add_library(palladium STATIC ${PD_SOURCES})
+    target_compile_definitions(palladium PUBLIC PD_BUILD_STATIC)
+endif()
+
+target_link_libraries(palladium
+    PUBLIC stb
 )
 
-install(DIRECTORY include DESTINATION ".")
+target_compile_definitions(palladium
+    PUBLIC
+    PD_DEBUG
+    $<$<OR:$<BOOL:${PD_INCLUDE_STB_IMAGE}>,$<BOOL:${PD_BUILD_SHARED}>>:PD_INCLUDE_STB_IMAGE> # Always on in shared build
+)
+target_compile_options(palladium
+    PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
+    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/source=source
+    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/include=include
+    >
+)
+
+add_library(palladium::palladium ALIAS palladium)
+
+target_include_directories(palladium
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_compile_options(palladium
+    PRIVATE
+    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:GNU,Clang>>:-O0 -g>
+    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU,Clang>>:-O3>
+
+    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:MSVC>>:/Od /Zi>
+    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:MSVC>>:/O2>
+)
+
+install(
+    TARGETS palladium
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+install(
+    DIRECTORY include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+install(EXPORT palladiumTargets
+    FILE palladiumTargets.cmake
+    NAMESPACE palladium::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+    cmake/palladiumConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    INSTALL_DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    VERSION
+    ${PROJECT_VERSION}
+    COMPATIBILITY
+    SameMajorVersion
+)
+
+install(
+    FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+find_program(CLANG_FORMAT clang-format)
+
+file(GLOB_RECURSE PD_FMTFILES
+    CONFIGURE_DEPENDS
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/core/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/gfx/source/*.cpp
+)
+
+add_custom_target(pd-clang-format
+    COMMAND ${CLANG_FORMAT} --style=file -i ${PD_FMTFILES}
+    COMMENT "Formatting Project Sources"
+)
+
+add_subdirectory(backends)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tests)

CMakePresets.json

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

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 - 2025 tobid7
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

backends/3ds/CMakeLists.txt

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

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

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

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

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

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

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

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

@@ -1,251 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd-3ds/bknd-gfx.hpp>
-
-/// @brief Shader Code (Unused as i dont want to use libpicasso here (yet))
-/// Update: Picasso breaks the linearRam or ram for somereason
-/// as far as i found out loading anything into linear ram after
-/// using libpicasso to compile a shader leads into a system freeze
-const char* LIShaderCTR = R"(
-; LI7 Shader
-; Constants
-.constf myconst(0.0, 1.0, 0.00392156862745, 0.0)
-.alias  ones  	myconst.yyyy ; Vector full of ones
-
-; Uniforms
-.fvec projection[4]
-
-; Outputs
-.out out_position		position
-.out out_color			color
-.out out_uv				texcoord0
-
-; Inputs
-.alias in_xy		v0
-.alias in_uvc 		v1
-.alias in_col	    v2
-
-.entry vmain
-.proc vmain
-	mov r0.xy, in_xy.xy
-	mov r0.w, ones
-
-	dp4 out_position.x, projection[0], r0
-	dp4 out_position.y, projection[1], r0
-	dp4 out_position.z, projection[2], r0
-	dp4 out_position.w, projection[3], r0
-
-	mov out_uv, in_uvc.xy
-
-	mul r1, myconst.zzzz, in_col
-	mov out_color, r1
-	end
-.end
-)";
-
-// clang-format off
-unsigned char li_shader[] = {
-  0x44, 0x56, 0x4c, 0x42, 0x1, 0x0, 0x0, 0x0, 0xa4, 0x0, 0x0, 0x0, 0x44, 0x56, 0x4c, 0x50, 0x0, 0x0, 0x0, 0x0, 0x28, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x50, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x98, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4e, 0x1, 0xf0, 0x7, 0x4e, 0x2, 0x8, 0x2, 0x8, 0x3, 0x18, 0x2, 0x8, 0x4, 0x28, 0x2, 0x8, 0x5, 0x38, 0x2, 0x8, 0x6, 0x10, 0x40, 0x4c, 0x7, 0xf1, 0x27, 0x22, 0x8, 0x10, 0x21, 0x4c, 0x0, 0x0, 0x0, 0x88, 0xac, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa1, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x68, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x62, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x61, 0xc3, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4f, 0xd5, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6f, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x44, 0x56, 0x4c, 0x45, 0x2, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x54, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x54, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x6c, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x74, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x2, 0x0, 0x5f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f, 0x0, 0x1, 0x1, 0x37, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x2, 0x0, 0x1, 0x0, 0xf, 0x0, 0x0, 0x0, 0x3, 0x0, 0x2, 0x0, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x13, 0x0, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0, 0x0, 
-  };
-// clang-format on
-size_t li_shader_size = 0x124;
-
-namespace PD {
-GPU_TEXCOLOR GetTexFmt(Li::Texture::Type type) {
-  if (type == Li::Texture::RGBA32)
-    return GPU_RGBA8;
-  else if (type == Li::Texture::RGB24)
-    return GPU_RGB8;
-  else if (type == Li::Texture::A8)
-    return GPU_A8;
-  return GPU_RGBA8;  // Default
-}
-int GetBPP(Li::Texture::Type type) {
-  if (type == Li::Texture::RGBA32)
-    return 4;
-  else if (type == Li::Texture::RGB24)
-    return 3;
-  else if (type == Li::Texture::A8)
-    return 1;
-  return 0;  // Error
-}
-
-void GfxC3D::Init() {
-  VertexBuffer.Resize(4 * 8192);
-  IndexBuffer.Resize(6 * 8192);
-
-  Flags |= LiBackendFlags_FlipUV_Y;
-
-  ShaderCode = DVLB_ParseFile((uint32_t*)li_shader, li_shader_size);
-  shaderProgramInit(&Shader);
-  shaderProgramSetVsh(&Shader, &ShaderCode->DVLE[0]);
-  pLocProjection =
-      shaderInstanceGetUniformLocation(Shader.vertexShader, "projection");
-
-  AttrInfo_Init(&ShaderInfo);
-  AttrInfo_AddLoader(&ShaderInfo, 0, GPU_FLOAT, 2);
-  AttrInfo_AddLoader(&ShaderInfo, 1, GPU_FLOAT, 2);
-  AttrInfo_AddLoader(&ShaderInfo, 2, GPU_UNSIGNED_BYTE, 4);
-}
-
-void GfxC3D::Deinit() {
-  shaderProgramFree(&Shader);
-  DVLB_Free(ShaderCode);
-}
-
-void GfxC3D::NewFrame() {
-  C3D_BindProgram(&Shader);
-  C3D_SetAttrInfo(&ShaderInfo);
-  CurrentIndex = 0;
-  CurrentVertex = 0;
-  FrameCounter++;
-  /** Probably completly incorrect but just do it like that */
-  VertexCounter = CurrentVertex;
-  IndexCounter = CurrentIndex;
-}
-
-void GfxC3D::BindTex(PD::Li::TexAddress addr) {
-  C3D_TexBind(0, reinterpret_cast<C3D_Tex*>(addr));
-}
-
-void GfxC3D::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
-  // C3D_BindProgram(&Shader);
-  shaderProgramUse(&Shader);
-  C3D_SetAttrInfo(&ShaderInfo);
-  C3D_Mtx proj;
-  Mtx_OrthoTilt(&proj, 0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f, false);
-  C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, pLocProjection, &proj);
-  // Mat4 proj = Mat4::Ortho(0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f);
-  // C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, pLocProjection, (C3D_Mtx*)&proj);
-  C3D_DepthTest(false, GPU_GREATER, GPU_WRITE_ALL);
-  C3D_TexEnv* env = C3D_GetTexEnv(0);
-  C3D_TexEnvInit(env);
-  C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0);
-  C3D_TexEnvFunc(env, C3D_Both, GPU_MODULATE);
-  size_t index = 0;
-  while (index < Commands.size()) {
-    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
-    if (!Tex) {
-      index++;
-      continue;
-    }
-    bool ScissorEnabled = Commands[index]->ScissorOn;
-    ivec4 ScissorRect = Commands[index]->ScissorRect;
-    size_t StartIndex = CurrentIndex;
-
-    while (index < Commands.size() && Commands[index]->Tex == Tex &&
-           Commands[index]->ScissorOn == ScissorEnabled &&
-           Commands[index]->ScissorRect == ScissorRect) {
-      auto c = Commands[index].get();
-      for (size_t i = 0; i < c->IndexBuffer.Size(); i++) {
-        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.At(i);
-      }
-      for (size_t i = 0; i < c->VertexBuffer.Size(); i++) {
-        VertexBuffer[CurrentVertex++] = c->VertexBuffer.At(i);
-      }
-      index++;
-    }
-    if (ScissorEnabled) {
-      // Figure out this setup was pain
-      C3D_SetScissor(GPU_SCISSOR_NORMAL,
-                     ViewPort.y - (ScissorRect.y + ScissorRect.w),
-                     ViewPort.x - (ScissorRect.x + ScissorRect.z),
-                     ViewPort.y - ScissorRect.y, ViewPort.x - ScissorRect.x);
-    } else {
-      C3D_SetScissor(GPU_SCISSOR_DISABLE, 0, 0, 0, 0);
-    }
-    BindTex(Tex->Address);
-    auto bufInfo = C3D_GetBufInfo();
-    BufInfo_Init(bufInfo);
-    BufInfo_Add(bufInfo, VertexBuffer.Data(), sizeof(Li::Vertex), 3, 0x210);
-
-    C3D_DrawElements(GPU_TRIANGLES, CurrentIndex - StartIndex,
-                     C3D_UNSIGNED_SHORT, IndexBuffer.Data() + StartIndex);
-  }
-  C3D_DepthTest(true, GPU_GREATER, GPU_WRITE_ALL);
-}
-
-PD::Li::Texture::Ref GfxC3D::LoadTex(const std::vector<PD::u8>& pixels, int w,
-                                     int h, PD::Li::Texture::Type type,
-                                     PD::Li::Texture::Filter filter) {
-  if (w > 1024 || h > 1024) {
-    return nullptr;
-  }
-  // Don't check here as check done before
-  PD::Li::Texture::Ref res = PD::Li::Texture::New();
-  int bpp = GetBPP(type);
-  ivec2 tex_size(w, h);
-  // Pow2
-  if (!PD::BitUtil::IsSingleBit(w)) {
-    tex_size.x = PD::BitUtil::GetPow2((unsigned int)w);
-  }
-  if (!PD::BitUtil::IsSingleBit(h)) {
-    tex_size.y = PD::BitUtil::GetPow2((unsigned int)h);
-  }
-  res->Size.x = w;
-  res->Size.y = h;
-  res->UV = fvec4(0.f, 1.f, ((float)w / (float)tex_size.x),
-                  1.0 - ((float)h / (float)tex_size.y));
-
-  // Texture Setup
-  auto fltr = (filter == Li::Texture::NEAREST ? GPU_NEAREST : GPU_LINEAR);
-  auto tex_fmt = GetTexFmt(type);
-  auto tex = new C3D_Tex;
-  C3D_TexInit(tex, (u16)tex_size.x, (u16)tex_size.y, tex_fmt);
-  C3D_TexSetFilter(tex, fltr, fltr);
-
-  // Using std::fill_n instead cause i hate this error lines
-  // under the memset func in my editor
-  std::fill_n((PD::u8*)tex->data, tex->size, 0);
-  // memset(tex->data, 0, tex->size);s
-
-  /// Probably Remove this if statement in future
-  /// This are the things confirmed as working
-  if (bpp == 3 || bpp == 4 || bpp == 1) {
-    for (int x = 0; x < w; x++) {
-      for (int y = 0; y < h; y++) {
-        int dst_pos = ((((y >> 3) * ((int)tex_size.x >> 3) + (x >> 3)) << 6) +
-                       ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
-                        ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
-                      bpp;
-        int src_pos = (y * w + x) * bpp;
-        /// Best idea i had
-        for (int i = 0; i < bpp; i++) {
-          ((u8*)tex->data)[dst_pos + bpp - 1 - i] = pixels[src_pos + i];
-        }
-      }
-    }
-    C3D_TexFlush(tex);
-  }
-
-  tex->border = 0x00000000;
-  C3D_TexSetWrap(tex, GPU_REPEAT, GPU_REPEAT);
-  res->Address = (Li::TexAddress)tex;
-  std::cout << std::format("Tex {:#08x} Addr {:#08X}",
-                           (Li::TexAddress)res.get(), res->Address)
-            << std::endl;
-  return res;
-}
-}  // namespace PD

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

@@ -1,87 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <3ds.h>
-
-#include <pd-3ds/bknd-hid.hpp>
-
-namespace PD {
-Hid3DS::Hid3DS() : HidDriver("Hid3DS") {
-  this->Flags |= Flags_HasTouch;
-  this->Flags |= FLags_HasGamepad;
-  pBinds[KEY_A] = A;
-  pBinds[KEY_B] = B;
-  pBinds[KEY_X] = X;
-  pBinds[KEY_Y] = Y;
-  pBinds[KEY_START] = Start;
-  pBinds[KEY_SELECT] = Select;
-  pBinds[KEY_L] = L;
-  pBinds[KEY_R] = R;
-  pBinds[KEY_DUP] = DUp;
-  pBinds[KEY_DDOWN] = DDown;
-  pBinds[KEY_DLEFT] = DLeft;
-  pBinds[KEY_DRIGHT] = DRight;
-  pBinds[KEY_CPAD_UP] = CPUp;
-  pBinds[KEY_CPAD_DOWN] = CPDown;
-  pBinds[KEY_CPAD_LEFT] = CPLeft;
-  pBinds[KEY_CPAD_RIGHT] = CPRight;
-  pBinds[KEY_CSTICK_UP] = CSUp;
-  pBinds[KEY_CSTICK_DOWN] = CSDown;
-  pBinds[KEY_CSTICK_LEFT] = CSLeft;
-  pBinds[KEY_CSTICK_RIGHT] = CSRight;
-  pBinds[KEY_ZL] = ZL;
-  pBinds[KEY_ZR] = ZR;
-  pBinds[KEY_TOUCH] = Touch;
-}
-
-void Hid3DS::Update() {
-  hidScanInput();
-  for (int i = 0; i < 2; i++) {
-    KeyEvents[i][Event_Down] = 0;
-    KeyEvents[i][Event_Held] = 0;
-    KeyEvents[i][Event_Up] = 0;
-  }
-  u32 kd = hidKeysDown();
-  u32 kh = hidKeysHeld();
-  u32 ku = hidKeysUp();
-  for (auto &b : pBinds) {
-    if (b.first & kd) {
-      KeyEvents[0][Event_Down] |= b.second;
-    }
-    if (b.first & kh) {
-      KeyEvents[0][Event_Held] |= b.second;
-    }
-    if (b.first & ku) {
-      KeyEvents[0][Event_Up] |= b.second;
-    }
-  }
-  if (pLocked) {
-    SwapTab();
-  }
-  touchPosition t;
-  hidTouchRead(&t);
-  pMouse[1] = pMouse[0];  // Cycle pMouse pos
-  pMouse[0] = fvec2(t.px, t.py);
-}
-}  // namespace PD

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

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

backends/CMakeLists.txt

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

backends/README.md

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

backends/desktop/CMakeLists.txt

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

backends/desktop/glad/CMakeLists.txt

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

backends/desktop/include/pd-desktop.hpp

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

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

@@ -1,62 +0,0 @@
-#pragma once
-
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <glad/glad.h>
-
-/** SEPARATOR */
-#include <GLFW/glfw3.h>
-/** SEPARATOR */
-
-#include <pd/lithium/lithium.hpp>
-
-namespace PD {
-class GfxGL2 : public GfxDriver {
- public:
-  GfxGL2() : GfxDriver("OpenGL2") {}
-  ~GfxGL2() = default;
-
-  PD_SHARED(GfxGL2);
-
-  void Init() override;
-  void Deinit() override;
-  void NewFrame() override;
-  void BindTex(PD::Li::TexAddress addr) override;
-  void RenderDrawData(
-      const std::vector<PD::Li::Command::Ref>& Commands) override;
-  PD::Li::Texture::Ref LoadTex(
-      const std::vector<PD::u8>& pixels, int w, int h,
-      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
-      PD::Li::Texture::Filter filter =
-          PD::Li::Texture::Filter::LINEAR) override;
-
-  PD::Vec<Li::Vertex> VertexBuffer;
-  PD::Vec<PD::u16> IndexBuffer;
-  GLuint Shader;
-  GLuint pLocProjection;
-  GLuint pLocTex;
-  GLuint VBO, IBO;
-};
-}  // namespace PD

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

@@ -1,72 +0,0 @@
-#pragma once
-
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <GLFW/glfw3.h>
-
-#include <pd/drivers/drivers.hpp>
-
-namespace PD {
-class HidGLFW : public HidDriver {
- public:
-  HidGLFW(GLFWwindow* win);
-  ~HidGLFW() = default;
-
-  PD_SHARED(HidGLFW);
-
-  void Update() override;
-  void GetInputStr(std::string& str) override;
-  void HandleTextOps();
-  bool pTimedHeld(KbKey k) {
-    if (pTimings.count(k)) {
-      if (IsEvent(Event_Up, k)) {
-        pTimings.erase(k);
-        return false;
-      }
-      return (PD::OS::GetTime() - pTimings[k]) > 50;
-    }
-    if (!IsEvent(Event_Held, k)) {
-      if (pTimings.count(k)) {
-        pTimings.erase(k);
-        return false;
-      }
-    }
-    if (IsEvent(Event_Held, k)) {
-      pTimings[k] = PD::OS::GetTime();
-      return true;
-    }
-    return false;
-  }
-
-  /** Data section */
-  GLFWwindow* Window;
-  int PrevState;
-  std::unordered_map<int, int> PrevStates;
-  static std::string* pText;
-  bool pInTextMode = false;
-  PD::u64 pLastUpdate = 0;
-  std::unordered_map<KbKey, u64> pTimings;
-};
-}  // namespace PD

backends/desktop/source/bknd-gfx.cpp

@@ -1,256 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd-desktop/bknd-gfx.hpp>
-
-namespace PD {
-const char* vertex_shader = R"(
-  #version 120
-  
-  attribute vec2 pos;
-  attribute vec2 uv;
-  attribute vec4 color;
-  
-  varying vec2 oUV;
-  varying vec4 oColor;
-  
-  // Probably forgot about this matrix and
-  // searched hours for why the rendering isn't working :/
-  uniform mat4 projection;
-  
-  void main() {
-      gl_Position = projection*vec4(pos, 0.0, 1.0);
-      oUV = uv;
-      oColor = color;
-  }
-  )";
-
-const char* frag_shader = R"(
-  #version 120
-      
-  varying vec2 oUV;
-  varying vec4 oColor;
-  
-  uniform sampler2D tex;
-      
-  void main() {
-      vec4 tc = texture2D(tex, oUV);
-      gl_FragColor = tc*oColor;
-  }
-  )";
-
-GLuint compileShader(const std::string& source, GLenum type) {
-  GLuint shader = glCreateShader(type);
-  const char* src = source.c_str();
-  glShaderSource(shader, 1, &src, nullptr);
-  glCompileShader(shader);
-
-  GLint success;
-  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
-  if (!success) {
-    char infoLog[512];
-    glGetShaderInfoLog(shader, 512, nullptr, infoLog);
-    std::cerr << "Shader Compilation Error: " << infoLog << std::endl;
-  }
-
-  return shader;
-}
-
-GLuint createShaderProgram(const std::string& vertexShaderSource,
-                           const std::string& fragmentShaderSource) {
-  GLuint vertexShader = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
-  GLuint fragmentShader =
-      compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
-
-  GLuint shaderProgram = glCreateProgram();
-  glAttachShader(shaderProgram, vertexShader);
-  glAttachShader(shaderProgram, fragmentShader);
-  glLinkProgram(shaderProgram);
-
-  GLint success;
-  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
-  if (!success) {
-    char infoLog[512];
-    glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
-    std::cerr << "Shader Program Linking Error: " << infoLog << std::endl;
-  }
-
-  glDeleteShader(vertexShader);
-  glDeleteShader(fragmentShader);
-
-  return shaderProgram;
-}
-
-void SetupShaderAttribs(GLuint Shader) {
-  GLint _pos = glGetAttribLocation(Shader, "pos");
-  GLint _uv = glGetAttribLocation(Shader, "uv");
-  GLint _color = glGetAttribLocation(Shader, "color");
-  glVertexAttribPointer(_pos, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
-                        (void*)offsetof(PD::Li::Vertex, Pos));
-  glEnableVertexAttribArray(_pos);
-
-  glVertexAttribPointer(_uv, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
-                        (void*)offsetof(PD::Li::Vertex, UV));
-  glEnableVertexAttribArray(_uv);
-
-  glVertexAttribPointer(_color, 4, GL_UNSIGNED_BYTE, GL_TRUE,
-                        sizeof(PD::Li::Vertex),
-                        (void*)offsetof(PD::Li::Vertex, Color));
-  glEnableVertexAttribArray(_color);
-}
-
-/** Actual Backend */
-
-void GfxGL2::Init() {
-  VertexBuffer.Resize(4 * 8192);
-  IndexBuffer.Resize(6 * 8192);
-  Shader = createShaderProgram(vertex_shader, frag_shader);
-  glUseProgram(Shader);
-
-  glGenBuffers(1, &VBO);
-  glBindBuffer(GL_ARRAY_BUFFER, VBO);
-
-  // Attribs Setup
-  SetupShaderAttribs(Shader);
-
-  glGenBuffers(1, &IBO);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
-
-  pLocTex = glGetUniformLocation(Shader, "tex");
-  pLocProjection = glGetUniformLocation(Shader, "projection");
-
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-}
-
-void GfxGL2::Deinit() {
-  glDeleteBuffers(1, &VBO);
-  glDeleteBuffers(1, &IBO);
-}
-
-void GfxGL2::NewFrame() {
-  /*
-  glViewport(0, 0, ViewPort.x, ViewPort.y);
-  glClearColor(ClearColor.x, ClearColor.y, ClearColor.z, ClearColor.w);
-  glClear(GL_COLOR_BUFFER_BIT);
-  */
-  Projection = Mat4::Ortho(0.f, ViewPort.x, ViewPort.y, 0.f, -1.f, 1.f);
-  glUseProgram(Shader);
-  glUniformMatrix4fv(pLocProjection, 1, GL_FALSE, Projection.m.data());
-  glEnable(GL_BLEND);
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-  FrameCounter++;
-  VertexCounter = CurrentVertex;
-  IndexCounter = CurrentIndex;
-  CurrentVertex = 0;
-  CurrentIndex = 0;
-}
-
-void GfxGL2::BindTex(PD::Li::TexAddress addr) {
-  // Actually not using the Address as Address
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, (GLuint)addr);
-  glUniform1i(pLocTex, 0);
-}
-
-void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
-  size_t index = 0;
-  while (index < Commands.size()) {
-    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
-    if (!Tex) {
-      index++;
-      continue;
-    }
-    size_t StartIndex = CurrentIndex;
-    bool ScissorOn = Commands[index]->ScissorOn;
-    ivec4 ScissorRect = Commands[index]->ScissorRect;
-
-    while (index < Commands.size() && Commands[index]->Tex == Tex &&
-           Commands[index]->ScissorOn == ScissorOn &&
-           Commands[index]->ScissorRect == ScissorRect) {
-      auto c = Commands[index].get();
-      for (size_t i = 0; i < c->IndexBuffer.Size(); i++) {
-        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.At(i);
-      }
-      for (size_t i = 0; i < c->VertexBuffer.Size(); i++) {
-        VertexBuffer[CurrentVertex++] = c->VertexBuffer.At(i);
-      }
-      index++;
-    }
-    if (ScissorOn) {
-      glScissor(ScissorRect.x, ViewPort.y - (ScissorRect.y + ScissorRect.w),
-                ScissorRect.z, ScissorRect.w);
-      glEnable(GL_SCISSOR_TEST);
-    } else {
-      glDisable(GL_SCISSOR_TEST);
-    }
-    BindTex(Tex->Address);
-    glBindBuffer(GL_ARRAY_BUFFER, VBO);
-    glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
-                 &VertexBuffer[0], GL_DYNAMIC_DRAW);
-    // For some reason we need to set these every frame for every buffer
-    // Found that out when creating My 3d Engine
-    SetupShaderAttribs(Shader);
-
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
-                 &IndexBuffer[0], GL_DYNAMIC_DRAW);
-
-    glDrawElements(GL_TRIANGLES, CurrentIndex - StartIndex, GL_UNSIGNED_SHORT,
-                   (void*)(StartIndex * sizeof(PD::u16)));
-
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-    BindTex(0);
-  }
-}
-
-PD::Li::Texture::Ref GfxGL2::LoadTex(const std::vector<PD::u8>& pixels, int w,
-                                     int h, PD::Li::Texture::Type type,
-                                     PD::Li::Texture::Filter filter) {
-  GLuint texID;
-  glGenTextures(1, &texID);
-  glBindTexture(GL_TEXTURE_2D, texID);
-
-  // Set base format (Always using RGBA as base)
-  GLenum fmt = GL_RGBA;
-  if (type == PD::Li::Texture::Type::RGB24) {
-    fmt = GL_RGB;
-  } else if (type == PD::Li::Texture::Type::A8) {
-    fmt = GL_ALPHA;
-  }
-  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
-               pixels.data());
-  if (filter == PD::Li::Texture::Filter::LINEAR) {
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  } else if (filter == PD::Li::Texture::Filter::NEAREST) {
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  }
-  glBindTexture(GL_TEXTURE_2D, 0);
-  auto res = PD::Li::Texture::New(texID, PD::ivec2(w, h));
-  return res;
-}
-}  // namespace PD

backends/desktop/source/bknd-hid.cpp

@@ -1,166 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd-desktop/bknd-hid.hpp>
-namespace PD {
-std::string* HidGLFW::pText;
-// Default Call back (If no Text input is requsted)
-void NullTextCB(GLFWwindow* win, unsigned int c) {}
-// Text callback if requested
-void TextCB(GLFWwindow* win, unsigned int c) {
-  if (!HidGLFW::pText) {
-    return;
-  }
-  *HidGLFW::pText += (char)c;
-}
-HidGLFW::HidGLFW(GLFWwindow* win) : HidDriver("HidGLFW") {
-  Window = win;
-  glfwSetCharCallback(Window, NullTextCB);
-  Flags |= Flags_HasKeyboard;
-  Flags |= Flags_HasMouse;
-  pBinds[GLFW_MOUSE_BUTTON_LEFT] = Touch;
-  /*pBinds[GLFW_KEY_F3] = Kb_3;
-  pBinds[GLFW_KEY_ESCAPE] = Kb_Escape;
-  pBinds[GLFW_KEY_F11] = Kb_F11;
-  pBinds[GLFW_KEY_ESCAPE] = Kb_Escape;
-  pBinds[GLFW_KEY_Q] = Kb_Q;
-  pBinds[GLFW_KEY_W] = Kb_W;
-  pBinds[GLFW_KEY_E] = Kb_E;
-  pBinds[GLFW_KEY_R] = Kb_R;
-  pBinds[GLFW_KEY_T] = Kb_T;
-  pBinds[GLFW_KEY_Z] = Kb_Z;
-  pBinds[GLFW_KEY_U] = Kb_U;
-  pBinds[GLFW_KEY_I] = Kb_I;
-  pBinds[GLFW_KEY_O] = Kb_O;
-  pBinds[GLFW_KEY_P] = Kb_P;
-  pBinds[GLFW_KEY_A] = Kb_A;
-  pBinds[GLFW_KEY_S] = Kb_S;
-  pBinds[GLFW_KEY_D] = Kb_D;
-  pBinds[GLFW_KEY_F] = Kb_F;
-  pBinds[GLFW_KEY_G] = Kb_G;
-  pBinds[GLFW_KEY_H] = Kb_H;
-  pBinds[GLFW_KEY_J] = Kb_J;
-  pBinds[GLFW_KEY_K] = Kb_K;
-  pBinds[GLFW_KEY_L] = Kb_L;
-  pBinds[GLFW_KEY_Y] = Kb_Y;
-  pBinds[GLFW_KEY_X] = Kb_X;
-  pBinds[GLFW_KEY_C] = Kb_C;
-  pBinds[GLFW_KEY_V] = Kb_V;
-  pBinds[GLFW_KEY_B] = Kb_B;
-  pBinds[GLFW_KEY_N] = Kb_N;
-  pBinds[GLFW_KEY_M] = Kb_M;
-  pBinds[GLFW_KEY_LEFT_SHIFT] = Kb_LShift;
-  pBinds[GLFW_KEY_F1] = Kb_F1;
-  pBinds[GLFW_KEY_F2] = Kb_F2;
-  pBinds[GLFW_KEY_F3] = Kb_F3;
-  pBinds[GLFW_KEY_F4] = Kb_F4;
-  pBinds[GLFW_KEY_F5] = Kb_F5;
-  pBinds[GLFW_KEY_F6] = Kb_F6;
-  pBinds[GLFW_KEY_F7] = Kb_F7;
-  pBinds[GLFW_KEY_F8] = Kb_F8;
-  pBinds[GLFW_KEY_F9] = Kb_F9;
-  pBinds[GLFW_KEY_F10] = Kb_F10;
-  pBinds[GLFW_KEY_F11] = Kb_F11;
-  pBinds[GLFW_KEY_F12] = Kb_F12;
-  pBinds[GLFW_KEY_1] = Kb_1;
-  pBinds[GLFW_KEY_2] = Kb_2;
-  pBinds[GLFW_KEY_3] = Kb_3;
-  pBinds[GLFW_KEY_4] = Kb_4;
-  pBinds[GLFW_KEY_5] = Kb_5;
-  pBinds[GLFW_KEY_6] = Kb_6;
-  pBinds[GLFW_KEY_7] = Kb_7;
-  pBinds[GLFW_KEY_8] = Kb_8;
-  pBinds[GLFW_KEY_9] = Kb_9;
-  pBinds[GLFW_KEY_0] = Kb_0;
-  pBinds[GLFW_KEY_BACKSPACE] = Kb_Backspace;
-  pBinds[GLFW_KEY_ENTER] = Kb_Enter;*/
-}
-
-void HidGLFW::Update() {
-  // Clear States
-  for (int i = 0; i < 2; i++) {
-    KeyEvents[i][Event_Down] = 0;
-    KeyEvents[i][Event_Held] = 0;
-    KeyEvents[i][Event_Up] = 0;
-    for (auto& it : KbKeyEvents[i]) {
-      it.second = Event_Null;
-    }
-  }
-  // Keyboard Logic
-  /*for (auto& it : pBinds) {
-    int kbstate = glfwGetKey(Window, it.first);
-    if (kbstate == GLFW_PRESS) {
-      if (PrevStates[it.first] == GLFW_RELEASE) {
-        KbKeyEvents[0][it.second] = Event_Down;
-      }
-      KbKeyEvents[0][it.second] = Event_Held;
-    } else if (kbstate == GLFW_RELEASE && PrevStates[it.first] == GLFW_PRESS) {
-      KbKeyEvents[0][it.second] = Event_Up;
-    }
-    PrevStates[it.first] = kbstate;
-  }*/
-  // Mouse Logic (Todo: Support all mouse buttons)
-  int state = glfwGetMouseButton(Window, GLFW_MOUSE_BUTTON_LEFT);
-  if (state == GLFW_PRESS) {
-    if (PrevState == GLFW_RELEASE) {
-      KeyEvents[0][Event_Down] |= Touch;
-    }
-    KeyEvents[0][Event_Held] |= Touch;
-  } else if (state == GLFW_RELEASE && PrevState == GLFW_PRESS) {
-    KeyEvents[0][Event_Up] |= Touch;
-  }
-
-  PrevState = state;
-  if (pLocked) {
-    SwapTab();
-  }
-  double x, y;
-  glfwGetCursorPos(Window, &x, &y);
-  pMouse[1] = pMouse[0];  // Cycle pMouse pos
-  pMouse[0] = fvec2(x, y);
-  if (pInTextMode && (PD::OS::GetTime() - pLastUpdate) > 50) {
-    pLastUpdate = PD::OS::GetTime();
-    HandleTextOps();
-  }
-}
-
-void HidGLFW::GetInputStr(std::string& str) {
-  pText = &str;
-  glfwSetCharCallback(Window, TextCB);
-  pInTextMode = true;
-}
-
-void HidGLFW::HandleTextOps() {
-  if (!pText) {
-    return;
-  }
-  /*if (pTimedHeld(Kb_Backspace)) {
-    if (!pText->empty()) {
-      pText->pop_back();
-    }
-  } else if (pTimedHeld(Kb_Enter)) {
-    *pText += '\n';
-  }*/
-}
-}  // namespace PD

backends/desktop/source/pd-desktop.cpp

@@ -1,43 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <palladium>
-#include <pd-desktop.hpp>
-
-namespace PD {
-void Init(void* data) {
-  if (!data) {
-    std::cout << "[PD-DRIVERS] Error: pd-desktop requires GLFWwindow* "
-                 "reference as data "
-                 "input!"
-              << std::endl;
-    abort();
-  }
-  // Dekstop Init Stage
-  // First use default OS Driver
-  PD::OS::Init();
-  PD::Gfx::Init(PD::GfxGL2::New());
-  PD::Hid::Init(PD::HidGLFW::New(reinterpret_cast<GLFWwindow*>(data)));
-}
-}  // namespace PD

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

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

backends/include/pd_system/gfx_citro3d.hpp

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

backends/include/pd_system/gfx_directx9.hpp

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

backends/include/pd_system/gfx_opengl2.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <pd/drivers/gfx.hpp>
+
+namespace PD {
+struct GfxOpenGL2Config {
+  // Vertex Allocator
+  template <typename T>
+  using VertexAlloc = std::allocator<T>;
+  // Index Allocator
+  template <typename T>
+  using IndexAlloc = std::allocator<T>;
+};
+
+class GfxOpenGL2 : public GfxDriverBase<GfxOpenGL2Config> {
+ public:
+  GfxOpenGL2() : GfxDriverBase("OpenGL2") {}
+  ~GfxOpenGL2() {}
+
+  void SysInit() override;
+  void SysDeinit() override;
+  void Submit(size_t count, size_t start) override;
+  void BindTexture(TextureID id) override;
+  void SysReset() override;
+  Li::Texture LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      TextureFormat type = TextureFormat::RGBA32,
+      TextureFilter filter = TextureFilter::Linear) override;
+  void DeleteTexture(const Li::Texture& tex) override;
+
+ 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

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

backends/include/pd_system/gl-helper.hpp

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

backends/include/pd_system/hid_glfw.hpp

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

backends/include/pd_system/hid_nx.hpp

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

backends/include/pd_system/shaders.hpp

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

backends/include/pdsystem

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

backends/source/gfx_citro3d.cpp

@@ -0,0 +1,262 @@
+// Well yes, i finally try it
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/formatters.hpp>
+#include <pd_system/gfx_citro3d.hpp>
+
+#if defined(PD_ENABLE_CITRO3D) && defined(__3DS__)
+
+#include <3ds.h>
+#include <citro3d.h>
+
+#include <pd/drivers/drivers.hpp>
+#include <pica.hpp>
+
+namespace PD {
+const char* LIShaderCTR = R"(
+; LI7 Shader
+; Constants
+.constf myconst(0.0, 1.0, 0.00392156862745, 0.0)
+.alias  ones  	myconst.yyyy ; Vector full of ones
+
+; Uniforms
+.fvec projection[4]
+
+; Outputs
+.out out_position		position
+.out out_color			color
+.out out_uv				texcoord0
+
+; Inputs
+.alias in_xy		v0
+.alias in_uvc 		v1
+.alias in_col	    v2
+
+.entry vmain
+.proc vmain
+	mov r0.xy, in_xy.xy
+	mov r0.w, ones
+
+	dp4 out_position.x, projection[0], r0
+	dp4 out_position.y, projection[1], r0
+	dp4 out_position.z, projection[2], r0
+	dp4 out_position.w, projection[3], r0
+
+	mov out_uv, in_uvc.xy
+
+	mul r1, myconst.zzzz, in_col
+	mov out_color, r1
+	end
+.end
+)";
+
+struct GfxCitro3D::Impl {
+  C3D_AttrInfo pAttr;
+  shaderProgram_s pShader;
+  DVLB_s* pCode;
+  int uLocProjection = 0;
+  C3D_Tex* CurrentTex = nullptr;
+  std::vector<u8> pShaderRaw;
+
+  GPU_TEXCOLOR TextureTranslateFormat(TextureFormat fmt) {
+    switch (fmt) {
+      case PD::TextureFormat::A8:
+        return GPU_A8;
+      case PD::TextureFormat::RGB24:
+        return GPU_RGB8;
+      case PD::TextureFormat::RGBA32:
+        return GPU_RGBA8;
+      default:
+        return GPU_RGBA8;
+    }
+  }
+
+  int TextureFormat2Bpp(TextureFormat fmt) {
+    switch (fmt) {
+      case PD::TextureFormat::A8:
+        return 1;
+      case PD::TextureFormat::RGB24:
+        return 3;
+      case PD::TextureFormat::RGBA32:
+        return 4;
+      default:
+        return 0;
+    }
+  }
+
+  void SetupPixelStage() {
+    shaderProgramUse(&pShader);
+    C3D_BindProgram(&pShader);
+    C3D_SetAttrInfo(&pAttr);
+    C3D_DepthTest(false, GPU_GREATER, GPU_WRITE_ALL);
+    if (!CurrentTex) return;
+    C3D_TexEnv* env = C3D_GetTexEnv(0);
+    C3D_TexEnvInit(env);
+    switch (CurrentTex->fmt) {
+      case GPU_A4:
+      case GPU_A8:
+      case GPU_L4:
+      case GPU_L8:
+        C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE0);
+        C3D_TexEnvFunc(env, C3D_RGB, GPU_REPLACE);
+        C3D_TexEnvFunc(env, C3D_Alpha, GPU_MODULATE);
+        break;
+      case GPU_RGB565:
+        C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE0);
+        C3D_TexEnvFunc(env, C3D_RGB, GPU_MODULATE);
+        C3D_TexEnvFunc(env, C3D_Alpha, GPU_REPLACE);
+        break;
+
+      default:
+        C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0);
+        C3D_TexEnvFunc(env, C3D_Both, GPU_MODULATE);
+        break;
+    }
+  }
+};
+
+void GfxCitro3D::SysInit() {
+  if (impl) return;
+  PDLOG("GfxCitro3D::SysInit();");
+  impl = new Impl();
+  Flags |= PDGfxBackendFlags_FlipUV_Y;
+  impl->pShaderRaw = Pica::AssembleCode(LIShaderCTR);
+  impl->pCode = DVLB_ParseFile((uint32_t*)impl->pShaderRaw.data(),
+                               impl->pShaderRaw.size());
+  shaderProgramInit(&impl->pShader);
+  shaderProgramSetVsh(&impl->pShader, &impl->pCode->DVLE[0]);
+  impl->uLocProjection = shaderInstanceGetUniformLocation(
+      impl->pShader.vertexShader, "projection");
+
+  AttrInfo_Init(&impl->pAttr);
+  AttrInfo_AddLoader(&impl->pAttr, 0, GPU_FLOAT, 2);
+  AttrInfo_AddLoader(&impl->pAttr, 1, GPU_FLOAT, 2);
+  AttrInfo_AddLoader(&impl->pAttr, 2, GPU_UNSIGNED_BYTE, 4);
+}
+
+void GfxCitro3D::SysDeinit() {
+  if (!impl) return;
+  shaderProgramFree(&impl->pShader);
+  DVLB_Free(impl->pCode);
+  delete impl;
+  impl = nullptr;
+  PDLOG("GfxCitro3D::SysDeinit()");
+}
+
+void GfxCitro3D::Submit(size_t count, size_t start) {
+  if (!impl) return;
+  BindTexture(CurrentTex);
+  impl->SetupPixelStage();  // needs to be called after
+  C3D_Mtx proj;
+  Mtx_OrthoTilt(&proj, 0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f, false);
+  C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, impl->uLocProjection, &proj);
+  // C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, impl->uLocProjection,
+  //                  (C3D_Mtx*)&Projection);
+  auto buf = C3D_GetBufInfo();
+  BufInfo_Init(buf);
+  BufInfo_Add(buf, GetVertexBufPtr(0), sizeof(Li::Vertex), 3, 0x210);
+  C3D_DrawElements(GPU_TRIANGLES, count, C3D_UNSIGNED_SHORT,
+                   GetIndexBufPtr(start));
+  impl->CurrentTex = nullptr;
+}
+
+void GfxCitro3D::BindTexture(TextureID id) {
+  if (!impl || !id) return;
+  impl->CurrentTex = (C3D_Tex*)id;
+  C3D_TexBind(0, (C3D_Tex*)id);
+}
+
+void GfxCitro3D::SysReset() {
+  if (!impl) return;
+  C3D_CullFace(GPU_CULL_NONE);
+}
+
+Li::Texture GfxCitro3D::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  if (!impl || w > 1024 || h > 1024) return Li::Texture();
+  if (pixels.size() !=
+      static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type))) {
+    PDERR("Failed to load Texture due to Size mismatch: {} != {}",
+          pixels.size(),
+          static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type)));
+    return Li::Texture();
+  }
+  // Don't check here as check done before
+  PD::Li::Texture res;
+  int bpp = impl->TextureFormat2Bpp(type);
+  ivec2 tex_size(w, h);
+  // Pow2
+  if (!PD::Bits::IsSingleBit(w)) {
+    tex_size.x = PD::Bits::GetPow2((unsigned int)w);
+  }
+  if (!PD::Bits::IsSingleBit(h)) {
+    tex_size.y = PD::Bits::GetPow2((unsigned int)h);
+  }
+  res.SetSize(w, h);
+  res.SetUV(0.f, 1.f, ((float)w / (float)tex_size.x),
+            1.0 - ((float)h / (float)tex_size.y));
+
+  // Texture Setup
+  auto fltr = (filter == TextureFilter::Linear ? GPU_NEAREST : GPU_LINEAR);
+  auto tex_fmt = impl->TextureTranslateFormat(type);
+  auto tex = new C3D_Tex;
+  C3D_TexInit(tex, (u16)tex_size.x, (u16)tex_size.y, tex_fmt);
+  C3D_TexSetFilter(tex, fltr, fltr);
+
+  std::memset((PD::u8*)tex->data, 0x0, tex->size);
+
+  /// Probably Remove this if statement in future
+  /// This are the things confirmed as working
+  if (bpp == 3 || bpp == 4 || bpp == 1) {
+    for (int x = 0; x < w; x++) {
+      for (int y = 0; y < h; y++) {
+        int dst_pos = ((((y >> 3) * ((int)tex_size.x >> 3) + (x >> 3)) << 6) +
+                       ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
+                        ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
+                      bpp;
+        int src_pos = (y * w + x) * bpp;
+        /// Best idea i had
+        for (int i = 0; i < bpp; i++) {
+          ((u8*)tex->data)[dst_pos + bpp - 1 - i] = pixels[src_pos + i];
+        }
+      }
+    }
+    C3D_TexFlush(tex);
+  }
+
+  tex->border = 0x00000000;
+  C3D_TexSetWrap(tex, GPU_REPEAT, GPU_REPEAT);
+  res.SetID((TextureID)tex);
+  RegisterTexture(res);
+  PDLOG("GfxCitro3D::LoadTexture -> {{ {} }}, [{}, {}]", res, type, filter);
+  return res;
+}
+
+void GfxCitro3D::DeleteTexture(const Li::Texture& tex) {
+  if (!tex.GetID()) return;
+  UnregisterTexture(tex);
+  C3D_Tex* t = reinterpret_cast<C3D_Tex*>(tex.GetID());
+  C3D_TexDelete(t);
+  delete t;
+}
+}  // namespace PD
+#else
+namespace PD {
+void GfxCitro3D::SysInit() {
+  PDERR(
+      "GfxCitro3D::SysInit: Citro3D Driver is not included in "
+      "palladium-system");
+}
+void GfxCitro3D::SysDeinit() {}
+void GfxCitro3D::Submit(size_t count, size_t start) {}
+void GfxCitro3D::BindTexture(TextureID id) {}
+void GfxCitro3D::SysReset() {}
+Li::Texture GfxCitro3D::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  return Li::Texture();
+}
+void GfxCitro3D::DeleteTexture(const Li::Texture& tex) {}
+}  // namespace PD
+#endif

backends/source/gfx_directx9.cpp

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

backends/source/gfx_opengl2.cpp

@@ -0,0 +1,194 @@
+#include <pd/lithium/formatters.hpp>
+#include <pd_system/gfx_opengl2.hpp>
+
+#if defined(PD_ENABLE_OPENGL2)
+#include <glad/glad.h>
+
+#include <pd/drivers/drivers.hpp>
+#include <pd_system/gl-helper.hpp>
+
+namespace PD {
+
+const char* GfxOpenGL2::pVertCode = R"(
+  #version 120
+  
+  attribute vec2 pos;
+  attribute vec2 uv;
+  attribute vec4 color;
+  
+  varying vec2 oUV;
+  varying vec4 oColor;
+  
+  // Probably forgot about this matrix and
+  // searched hours for why the rendering isn't working :/
+  uniform mat4 projection;
+  
+  void main() {
+      gl_Position = projection*vec4(pos, 0.0, 1.0);
+      oUV = uv;
+      oColor = color;
+  }
+  )";
+
+const char* GfxOpenGL2::pFragCode = R"(
+  #version 120
+      
+  varying vec2 oUV;
+  varying vec4 oColor;
+  
+  uniform sampler2D tex;
+  uniform bool alfa;
+      
+  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);
+}
+
+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);
+}
+
+Li::Texture GfxOpenGL2::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  if (pixels.size() !=
+      static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type))) {
+    PDERR("Failed to load Texture due to Size mismatch: {} != {}",
+          pixels.size(),
+          static_cast<size_t>(w * h * Li::TextureFormat2Bpp(type)));
+    return Li::Texture();
+  }
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  if (type == TextureFormat::RGB24) {
+    fmt = GL_RGB;
+  } else if (type == TextureFormat::A8) {
+    fmt = GL_ALPHA;
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+  if (filter == TextureFilter::Linear) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == TextureFilter::Nearest) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  }
+  glBindTexture(GL_TEXTURE_2D, 0);
+  Li::Texture res;
+  res.SetID(texID);
+  res.SetSize(w, h);
+  res.SetUV(0.f, 0.f, 1.f, 1.f);
+  RegisterTexture(res);
+  PDLOG("GfxOpenGL2::LoadTexture -> {{ {} }}, [{}, {}]", res, type, filter);
+  return res;
+}
+
+void GfxOpenGL2::DeleteTexture(const Li::Texture& tex) {
+  UnregisterTexture(tex);
+  GLuint tex_ = tex.GetID();
+  glDeleteTextures(1, &tex_);
+}
+}  // namespace PD
+#else
+namespace PD {
+void GfxOpenGL2::SysInit() {
+  PDERR(
+      "GfxOpenGL2::SysInit: OpenGL2 Driver is not included in "
+      "palladium-system");
+}
+void GfxOpenGL2::SysDeinit() {}
+void GfxOpenGL2::Submit(size_t count, size_t start) {}
+void GfxOpenGL2::BindTexture(TextureID id) {}
+void GfxOpenGL2::SysReset() {}
+Li::Texture GfxOpenGL2::LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                    int h, TextureFormat type,
+                                    TextureFilter filter) {
+  return Li::Texture();
+}
+void GfxOpenGL2::DeleteTexture(const Li::Texture& tex) {}
+void GfxOpenGL2::pSetupShaderAttribs(u32 shader) {}
+}  // namespace PD
+#endif

backends/source/gfx_opengl3.cpp

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

backends/source/gl-helper.cpp

@@ -0,0 +1,48 @@
+#if defined(PD_ENABLE_OPENGL2) || defined(PD_ENABLE_OPENGL3)
+#include <glad/glad.h>
+
+#include <iostream>
+#include <pd_system/gl-helper.hpp>
+
+namespace PD {
+GLuint compileShader(const char* src, GLenum type) {
+  GLuint shader = glCreateShader(type);
+  glShaderSource(shader, 1, &src, nullptr);
+  glCompileShader(shader);
+
+  GLint success;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetShaderInfoLog(shader, 512, nullptr, infoLog);
+    std::cerr << "Shader Compilation Error: " << infoLog << std::endl;
+  }
+
+  return shader;
+}
+u32 CreateShaderProgram(const char* vert, const char* frag) {
+  GLuint vertexShader = compileShader(vert, GL_VERTEX_SHADER);
+  GLuint fragmentShader = compileShader(frag, GL_FRAGMENT_SHADER);
+
+  GLuint shaderProgram = glCreateProgram();
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+  glLinkProgram(shaderProgram);
+
+  GLint success;
+  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
+    std::cerr << "Shader Program Linking Error: " << infoLog << std::endl;
+  }
+
+  glDeleteShader(vertexShader);
+  glDeleteShader(fragmentShader);
+
+  if (success) PDLOG("Shader [{}] compiled sucessfully", shaderProgram);
+
+  return shaderProgram;
+}
+}  // namespace PD
+#endif

backends/source/hid_glfw.cpp

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

backends/source/hid_nx.cpp

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

cmake/palladium.cmake

@@ -11,51 +11,6 @@ set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 # Enable Compile Command Export
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-option(PD_INCLUDE_DIR "")
-
-### Helper Function to Build Librarys without have always
-### These includes and definition defines
-function(pd_add_lib TARGET_NAME)
-    set(opts "BUILD_SHARED")
-    set(one_val_args "")
-    set(multi_val_args SRC_FILES DEPENDS)
-    cmake_parse_arguments(ARG "${opts}" "${one_val_args}" "${multi_val_args}" ${ARGN})
-
-    string(REPLACE "-" "_" FLAG_NAME_T ${TARGET_NAME})
-    string(TOUPPER ${FLAG_NAME_T} FLAG_NAME_F)
-
-    if(ARG_BUILD_SHARED)
-        add_library(${TARGET_NAME} SHARED ${ARG_SRC_FILES})
-        target_compile_definitions(${TARGET_NAME} PUBLIC -D${FLAG_NAME_F}_BUILD_SHARED=1)
-        message("Building SHARED library: ${FLAG_NAME_F}_BUILD_SHARED=1")
-    else()
-        add_library(${TARGET_NAME} STATIC ${ARG_SRC_FILES})
-        target_compile_definitions(${TARGET_NAME} PUBLIC -D${FLAG_NAME_F}_BUILD_SHARED=0)
-        message("Building STATIC library: ${FLAG_NAME_F}_BUILD_SHARED=0")
-    endif()
-    target_include_directories(${TARGET_NAME} PUBLIC
-        ${PD_INCLUDE_DIR}
-        ${DEVKITPRO}/portlibs/3ds/include
-    )
-    target_compile_definitions(${TARGET_NAME} PRIVATE
-        -D_GNU_SOURCE=1
-        -DPALLADIUM_VERSION="${PROJECT_VERSION}"
-        -DPALLADIUM_GIT_COMMIT="${GIT_SHORT_HASH}"
-        -DPALLADIUM_GIT_BRANCH="${GIT_BRANCH}"
-        -DBUILD_CTR=1
-    )
-    if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
-        target_compile_options(${TARGET_NAME} PRIVATE
-            -Wno-abi
-        )
-    endif()
-    ### For the libs that depend on another
-    if(ARG_DEPENDS)
-        target_link_libraries(${TARGET_NAME} PUBLIC ${ARG_DEPENDS})
-    endif()
-    install(TARGETS ${TARGET_NAME})
-endfunction()
-
 ### GIT HELPER ###
 
 function(pd_git_get_hash ret)

cmake/palladiumConfig.cmake.in

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

cmake/presets/3ds.json

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

cmake/presets/default.json

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

cmake/presets/msvc.json

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

cmake/presets/switch.json

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

include/palladium

@@ -1,8 +1,29 @@
 #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/core.hpp>
 #include <pd/drivers/drivers.hpp>
-#include <pd/external/json.hpp>
 #include <pd/image/image.hpp>
-#include <pd/lithium/lithium.hpp>
-#include <pd/ui7/ui7.hpp>
+#include <pd/lithium/lithium.hpp>

include/pd/common.hpp

@@ -0,0 +1,105 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#if defined(__GNUG__) && !defined(_MSC_VER)
+#include <cxxabi.h>
+#endif
+
+#include <array>
+#include <chrono>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <exception>
+#include <format>
+#include <fstream>
+#include <numbers>
+#include <pd/pd_p_api.hpp>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace PD {
+enum class LogLevel {
+  None,
+  Info,
+  Warning,
+  Error,
+};
+[[noreturn]] inline void Throw(const std::string& msg) {
+  throw std::runtime_error(msg);
+}
+using u8 = unsigned char;
+using u16 = unsigned short;
+using u32 = unsigned int;
+using u64 = unsigned long long;
+using ptr = uintptr_t;
+PD_API void LogFilter(LogLevel minimum);
+PD_API void Log(const std::string& txt, LogLevel lvl = LogLevel::Info);
+template <typename... Args>
+void Log(std::format_string<Args...> fmt, Args&&... args) {
+  std::string msg = std::format(fmt, std::forward<Args>(args)...);
+  Log(msg, LogLevel::Info);
+}
+template <typename... Args>
+void Log(LogLevel lvl, std::format_string<Args...> fmt, Args&&... args) {
+  std::string msg = std::format(fmt, std::forward<Args>(args)...);
+  Log(msg, lvl);
+}
+template <typename T>
+std::string TypeName() {
+#if defined(__GNUG__) && !defined(_MSC_VER)
+  int res = 0;
+  std::unique_ptr<char, void (*)(void*)> up{
+      abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &res), std::free};
+  return (res == 0) ? up.get() : typeid(T).name();
+#else
+  return typeid(T).name();  // no demangler available :/
+#endif
+}
+}  // namespace PD
+
+#if defined(__GNUC__) || defined(__clang__)
+#define PDPRETTYFUNC __PRETTY_FUNCTION__
+#elif defined(_MSC_VER)
+#define PDPRETTYFUNC __FUNCSIG__
+#else
+#define PDPRETTYFUNC __FUNCTION__
+#endif
+#ifdef PD_DEBUG
+#define PDLOG(fmt, ...) \
+  PD::Log("[{}:{}]: " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
+#define PDWARN(fmt, ...)                                              \
+  PD::Log(PD::LogLevel::Warning, "[{}:{}]: " fmt, __FILE__, __LINE__, \
+          ##__VA_ARGS__)
+#define PDERR(fmt, ...)                                             \
+  PD::Log(PD::LogLevel::Error, "[{}:{}]: " fmt, __FILE__, __LINE__, \
+          ##__VA_ARGS__)
+#else
+#define PDLOG(fmt, ...)
+#define PDWARN(fmt, ...)
+#define PDERR(fmt, ...)
+#endif

include/pd/core/bits.hpp

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

include/pd/core/color.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,10 +23,11 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
+#include <pd/core/strings.hpp>
 
 namespace PD {
-class PD_CORE_API Color {
+class PD_API Color {
  public:
   /**
    * Default Constructor (all variables are set to 0)
@@ -65,17 +66,40 @@ class PD_CORE_API Color {
         b(static_cast<u8>(255.f * b)),
         a(static_cast<u8>(255.f * a)) {}
   /**
-   * Constructor for Hex Input
+   * Constructor for Hex Input (is abel to run at compile time xD)
    * @param hex Hex String in `#ffffff` or `#ffffffff` format
    */
-  Color(const std::string& hex) { Hex(hex); }
+  constexpr Color(const std::string_view& hex) { Hex(hex); }
 
   /**
-   * Create Color Object by Hex String
+   * Constructor for Hex Input (is abel to run at compile time xD)
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   */
+  constexpr Color(const char* hex) { Hex(std::string_view{hex}); }
+
+  /**
+   * Create Color Object by Hex String (at compile time btw)
    * @param hex Hex String in `#ffffff` or `#ffffffff` format
    * @return Color class itself
    */
-  Color& Hex(const std::string& hex);
+  constexpr Color& Hex(const std::string_view& hex) {
+    if (!(hex.length() == 7 || hex.length() == 9)) {
+      PD::Throw("[PD] Color: hex string is not rgb or rgba!");
+    }
+    r = PD::Strings::HexChar2Int(hex[1]) * 16 +
+        PD::Strings::HexChar2Int(hex[2]);
+    g = PD::Strings::HexChar2Int(hex[3]) * 16 +
+        PD::Strings::HexChar2Int(hex[4]);
+    b = PD::Strings::HexChar2Int(hex[5]) * 16 +
+        PD::Strings::HexChar2Int(hex[6]);
+    if (hex.length() == 9) {
+      a = PD::Strings::HexChar2Int(hex[7]) * 16 +
+          PD::Strings::HexChar2Int(hex[8]);
+    } else {
+      a = 255;
+    }
+    return *this;
+  }
   /**
    * Convert this Color Object to Hex string
    * @param rgba [default false] sets if 8 or 6 digit color should be returned
@@ -89,7 +113,7 @@ class PD_CORE_API Color {
    * @param p Amount (supports -1.0 to 1.0 for use of sine)
    * @return Class Reference
    */
-  Color& Fade(const Color& color, float p) {
+  constexpr Color& Fade(const Color& color, float p) {
     a = static_cast<u8>((color.a - a) * ((p + 1.f) / 2));
     b = static_cast<u8>((color.b - b) * ((p + 1.f) / 2));
     g = static_cast<u8>((color.g - g) * ((p + 1.f) / 2));
@@ -97,16 +121,30 @@ class PD_CORE_API Color {
     return *this;
   }
 
+  /**
+   * Lerp
+   * @param v Target color
+   * @param t interpolation factor
+   * @return Class Reference
+   */
+  constexpr Color& Lerp(const Color& v, float t) {
+    a = static_cast<u8>(a + (v.a - a) * t);
+    b = static_cast<u8>(b + (v.b - b) * t);
+    g = static_cast<u8>(g + (v.g - g) * t);
+    r = static_cast<u8>(r + (v.r - r) * t);
+    return *this;
+  }
+
   /**
    * Get 32Bit Color Value
    * @return 32Bit Color Value (ABGR iirc)
    */
-  u32 Get() const { return (a << 24) | (b << 16) | (g << 8) | r; }
+  constexpr u32 Get() const { return (a << 24) | (b << 16) | (g << 8) | r; }
   /**
    * Get The Luminance of the Color
    * @return luminance (from 0.0 to 1.0)
    */
-  float Luminance() const {
+  constexpr float Luminance() const {
     // For Reference https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness
     return (0.3 * (r / 255.f) + 0.59 * (g / 255.f) + 0.11 * (b / 255.f));
   }
@@ -114,13 +152,18 @@ class PD_CORE_API Color {
    * Check if the Color is Light or Dark
    * @return true if light
    */
-  bool IsLight() const { return (Luminance() >= 0.5); }
+  constexpr bool IsLight() const { return (Luminance() >= 0.5); }
 
   /**
    * Operator to cast Color to 32Bit Value
    * @return 32Bit Color Value
    */
-  operator u32() const { return Get(); }
+  constexpr operator u32() const { return Get(); }
+
+  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;

include/pd/core/common.hpp

@@ -1,70 +0,0 @@
-#pragma once
-
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <array>
-#include <chrono>
-#include <cinttypes>
-#include <cmath>
-#include <filesystem>  // Requires C++ 17 or later
-#include <format>      // Requires C++ 20 or later
-#include <fstream>
-#include <functional>
-#include <iostream>
-#include <map>
-#include <memory>
-#include <numbers>
-#include <sstream>
-#include <stack>
-#include <string>
-#include <vector>
-
-/** Dynamic Lib loading */
-#include <pd/core/pd_p_api.hpp>
-
-/** Memory Management */
-
-#define PD_SHARED(x)                                         \
-  using Ref = std::shared_ptr<x>;                            \
-  template <typename... Args>                                \
-  static Ref New(Args&&... args) {                           \
-    return std::make_shared<x>(std::forward<Args>(args)...); \
-  }
-
-#define PD_UNIQUE(x)                                         \
-  using Ref = std::unique_ptr<x>;                            \
-  template <typename... Args>                                \
-  static Ref New(Args&&... args) {                           \
-    return std::make_unique<x>(std::forward<Args>(args)...); \
-  }
-
-#define PD_BIT(x) (1 << x)
-
-namespace PD {
-/** Types */
-using u8 = unsigned char;
-using u16 = unsigned short;
-using u32 = unsigned int;
-using u64 = unsigned long long;
-}  // namespace PD

include/pd/core/core.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,13 +23,18 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/bit_util.hpp>
+#include <pd/core/bits.hpp>
 #include <pd/core/color.hpp>
+#include <pd/core/fnv.hpp>
+#include <pd/core/formatters.hpp>
+#include <pd/core/fquat.hpp>
+#include <pd/core/hashid.hpp>
 #include <pd/core/io.hpp>
 #include <pd/core/mat.hpp>
-#include <pd/core/sl/sl.hpp>
+#include <pd/core/pool.hpp>
 #include <pd/core/strings.hpp>
 #include <pd/core/timer.hpp>
 #include <pd/core/timetrace.hpp>
 #include <pd/core/tween.hpp>
-#include <pd/core/vec.hpp>
+#include <pd/core/u128.hpp>
+#include <pd/core/vec.hpp>

include/pd/core/fnv.hpp

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

@@ -0,0 +1,98 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/color.hpp>
+
+template <>
+struct std::formatter<PD::Color> : std::formatter<std::string> {
+  enum class ColorFmt {
+    Hex,
+    Rgbf,
+    Rgb,
+    Rgba,
+    Rgbaf,
+  };
+  ColorFmt mode = ColorFmt::Hex;
+  constexpr auto parse(std::format_parse_context& ctx) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+
+    if (it == end || *it == '}') return it;
+
+    if (check(it, end, 5, "rgbaf")) {
+      mode = ColorFmt::Rgbaf;
+      it += 5;
+    } else if (check(it, end, 4, "rgba")) {
+      mode = ColorFmt::Rgba;
+      it += 4;
+    } else if (check(it, end, 4, "rgbf")) {
+      mode = ColorFmt::Rgbf;
+      it += 4;
+    } else if (check(it, end, 3, "rgb")) {
+      mode = ColorFmt::Rgb;
+      it += 3;
+    } else if (check(it, end, 3, "hex")) {
+      mode = ColorFmt::Hex;
+      it += 3;
+    } else {
+      throw std::format_error("invalid format for PD::Color");
+    }
+
+    if (it == end || *it != '}')
+      throw std::format_error("invalid format for PD::Color");
+
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(const PD::Color& value, FormatContext& ctx) const {
+    switch (mode) {
+      case ColorFmt::Hex:
+        return std::format_to(ctx.out(), "#{:02X}{:02X}{:02X}{:02X}", value.r,
+                              value.g, value.b, value.a);
+      case ColorFmt::Rgb:
+        return std::format_to(ctx.out(), "{}, {}, {}", value.r, value.g,
+                              value.b);
+      case ColorFmt::Rgba:
+        return std::format_to(ctx.out(), "{}, {}, {}, {}", value.r, value.g,
+                              value.b, value.a);
+      case ColorFmt::Rgbf:
+        return std::format_to(ctx.out(), "{}, {}, {}", value.rf(), value.gf(),
+                              value.bf());
+      case ColorFmt::Rgbaf:
+        return std::format_to(ctx.out(), "{}, {}, {}, {}", value.rf(),
+                              value.gf(), value.bf(), value.af());
+      default:
+        return ctx.out();
+    }
+  }
+
+  constexpr bool check(std::format_parse_context::const_iterator it,
+                       std::format_parse_context::const_iterator end,
+                       size_t len, const char* what) {
+    return (end - it >= static_cast<std::ptrdiff_t>(len) &&
+            std::string_view(&*it, len) == what);  // msvc things...
+  }
+};

include/pd/core/fquat.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,7 +25,7 @@ SOFTWARE.
 
 // This file is based on fvec4
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 #include <pd/core/vec4.hpp>
 
 namespace PD {

include/pd/core/hashid.hpp

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

include/pd/core/io.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
@@ -35,28 +35,28 @@ namespace IO {
  * @param path Path to the File
  * @return 8Bit FileBuffer
  */
-PD_CORE_API std::vector<u8> LoadFile2Mem(const std::string& path);
+PD_API std::vector<u8> LoadFile2Mem(const std::string& path);
 /**
  * Load a File into a std::string
  * @param path Path to the File
  * @return std::string file content
  */
-PD_CORE_API std::string LoadFile2Str(const std::string& path);
+PD_API std::string LoadFile2Str(const std::string& path);
 /**
  * Hash a 8Bit Memory Buffer
  * @param data 8Bit input Buffer
  * @return 32Bit Hash
  */
-PD_CORE_API u32 HashMemory(const std::vector<u8>& data);
+PD_API u32 HashMemory(const std::vector<u8>& data);
 /**
  * Function to decrompress RLE buffer
  * @param data Data buffer to decompress
  */
-PD_CORE_API void DecompressRLE(std::vector<u8>& data);
+PD_API void DecompressRLE(std::vector<u8>& data);
 /**
  * Function to compress data with RLE Algorithm
  * @param data Data buf
  */
-PD_CORE_API void CompressRLE(std::vector<u8>& data);
+PD_API void CompressRLE(std::vector<u8>& data);
 }  // namespace IO
 }  // namespace PD

include/pd/core/mat.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
-Copyright (c) 2024 - 2025 tobid7
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 #include <pd/core/vec3.hpp>
 
 namespace PD {
@@ -41,7 +40,7 @@ constexpr float Radians(float v) { return v * (Numbers::Tau / 360.0f); }
  * @note That this is not a full Matrix Library
  */
 
-struct PD_CORE_API Mat4 {
+struct PD_API Mat4 {
   std::array<float, 16> m;
   constexpr Mat4() : m{} {}
   constexpr static Mat4 Diagonal(float x, float y, float z, float w) {
@@ -110,6 +109,16 @@ struct PD_CORE_API Mat4 {
     return ret;
   }
 
+  constexpr Mat4 Transpose() const {
+    Mat4 ret;
+    for (int i = 0; i < 4; ++i) {
+      for (int j = 0; j < 4; ++j) {
+        ret(i, j) = (*this)(j, i);
+      }
+    }
+    return ret;
+  }
+
   constexpr static Mat4 Ortho(float l, float r, float b, float t, float n,
                               float f) {
     Mat4 ret;

include/pd/core/pd_p_api.hpp

@@ -1,51 +0,0 @@
-#pragma once
-
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-/** Generated with ppam */
-
-#ifdef _WIN32  // Windows (MSVC Tested)
-#ifdef PD_CORE_BUILD_SHARED
-#define PD_CORE_API __declspec(dllexport)
-#else
-#define PD_CORE_API __declspec(dllimport)
-#endif
-#elif defined(__APPLE__)  // macOS (untested yet)
-#ifdef PD_CORE_BUILD_SHARED
-#define PD_CORE_API __attribute__((visibility("default")))
-#else
-#define PD_CORE_API
-#endif
-#elif defined(__linux__)  // Linux (untested yet)
-#ifdef PD_CORE_BUILD_SHARED
-#define PD_CORE_API __attribute__((visibility("default")))
-#else
-#define PD_CORE_API
-#endif
-#elif defined(__3DS__)  // 3ds Specific
-// Only Static supported
-#define PD_CORE_API
-#else
-#define PD_CORE_API
-#endif

include/pd/core/pool.hpp

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

include/pd/core/sl/hashmap.hpp

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

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

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

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

include/pd/core/sl/stack.hpp

@@ -1,70 +0,0 @@
-#pragma once
-
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-#include <pd/core/common.hpp>
-#include <pd/core/sl/vector.hpp>
-
-namespace PD {
-/**
- * Custom Stack class (caus std::stack ofsten lead to memory coruption)
- */
-template <typename T, typename Alloc = Allocator<T>>
-class Stack {
- public:
-  Stack() = default;
-  explicit Stack(size_t cap) : pVec(cap) {}
-
-  void Push(const T& val) { pVec.Add(val); }
-
-  void Pop() {
-    if (pVec.Size() == 0) {
-      exit(1);
-    }
-    pVec.PopBack();
-  }
-
-  T& Top() {
-    if (pVec.Size() == 0) {
-      exit(1);
-    }
-    return pVec[pVec.Size() - 1];
-  }
-
-  const T& Top() const {
-    if (pVec.Size() == 0) {
-      exit(1);
-    }
-    return pVec[pVec.Size() - 1];
-  }
-
-  bool IsEmpty() const { return pVec.Size() == 0; }
-  size_t Size() const { return pVec.Size(); }
-  void Clear() { pVec.Clear(); }
-
- private:
-  Vec<T, Alloc> pVec;
-};
-}  // namespace PD

include/pd/core/sl/tools.hpp

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

@@ -1,165 +0,0 @@
-#pragma once
-
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd/core/common.hpp>
-#include <pd/core/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 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,60 +23,67 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
  * Set of String Utillity Functions
  */
 namespace Strings {
+constexpr int HexChar2Int(char c) {
+  /** Imagine man hat ne lookup table dafür verwendet :/ */
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
+  if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
+  return -1;  // Error
+}
 /**
  * Check if a String ends with a specific extension
  * @param str Input string
  * @param exts List of Extensions to check for
  * @return true if one of the extensions is found in the String
  */
-PD_CORE_API bool StringEndsWith(const std::string& str,
-                                const std::vector<std::string>& exts);
+PD_API bool StringEndsWith(const std::string& str,
+                           const std::vector<std::string>& exts);
 /**
  * Function to Create a wstring of a string
  * @param s Input String to Convert
  * @return Result wstring
  * @note Returns Empty if it has an error
  */
-PD_CORE_API std::wstring MakeWstring(const std::string& s);
+PD_API std::wstring MakeWstring(const std::string& s);
 /**
  * Generate a Formatted String by an Nanoseconds Input
  * @param nanos Nanoseconds Input
  * @return Result String
  */
-PD_CORE_API const std::string FormatNanos(unsigned long long nanos);
+PD_API const std::string FormatNanos(unsigned long long nanos);
 /**
  * Generate a Formatted String by an Milliseconds Input
  * @param millis Milliseconds Input
  * @return Result String
  */
-PD_CORE_API const std::string FormatMillis(unsigned long long millis);
+PD_API const std::string FormatMillis(unsigned long long millis);
 /**
  * Create a formatted String by an input bytes value
  * @param bytes value in bytes
  * @result Formatted String for example `2.5MB`
  */
-PD_CORE_API const std::string FormatBytes(unsigned long long bytes);
+PD_API const std::string FormatBytes(unsigned long long bytes);
 /**
  * Extract the Filename out of a Path
  * @param path Path to extract from
  * @param saperators Path Split Chars
  * @return extracted filename
  */
-PD_CORE_API const std::string GetFileName(
-    const std::string& path, const std::string& saperators = "/\\");
+PD_API const std::string GetFileName(const std::string& path,
+                                     const std::string& saperators = "/\\");
 /**
  * Remove Extension from a Path / Filename
  * @param path Input Path
  * @return Path without Extension
  */
-PD_CORE_API const std::string PathRemoveExtension(const std::string& path);
+PD_API const std::string PathRemoveExtension(const std::string& path);
 /**
  * Function to Convert a Type to a hex value
  * @tparam T Type
@@ -85,39 +92,79 @@ PD_CORE_API const std::string PathRemoveExtension(const std::string& path);
  */
 template <typename T>
 inline const std::string ToHex(const T& v) {
-  std::stringstream s;
-  s << "0x" << std::setfill('0') << std::setw(sizeof(v) * 2) << std::hex << v;
-  return s.str();
+  return std::format("{0:0{1}X}", v, sizeof(v) * 2);
 }
 /**
  * Generate a Hash out of a string
  * @param s String to hash
  * @return 32Bit Hash
  */
-PD_CORE_API u32 FastHash(const std::string& s);
+PD_API u32 FastHash(const std::string& s);
 /**
  * Function to Generate a Compiler Name and Version String
  * Based on their Macros
  * @return CompilerName: Version
  */
-inline const std::string GetCompilerVersion() {
-  /// As the function looks like this Project is meant to
-  /// Be ported to other systems as well
-  std::stringstream res;
+inline const char* GetCompilerVersion() {
+/// As the function looks like this Project is meant to
+/// Be ported to other systems as well
+#define __mks(x) #x
+#define mkstring(x) __mks(x)
 #ifdef __clang__  // Check clang first
-  res << "Clang: " << __clang_major__ << ".";
-  res << __clang_minor__ << ".";
-  res << __clang_patchlevel__;
+  return "Clang: " mkstring(__clang_major__) "." mkstring(
+      __clang_minor__) "." mkstring(__clang_patchlevel__);
 #elif __GNUC__
-  res << "GCC: " << __GNUC__;
-  res << "." << __GNUC_MINOR__ << ".";
-  res << __GNUC_PATCHLEVEL__;
+  return "GCC: " mkstring(__GNUC__) "." mkstring(__GNUC_MINOR__) "." mkstring(
+      __GNUC_PATCHLEVEL__);
 #elif _MSC_VER
-  res << "MSVC: " << _MSC_VER;
+  return "MSVC; " mkstring(_MSC_VER);
 #else
-  res << "Unknown Compiler";
+  return "Unknown Compiler";
 #endif
-  return res.str();
 }
 }  // namespace Strings
+class U8Iterator {
+ public:
+  explicit U8Iterator(const char* s) : ptr(reinterpret_cast<const u8*>(s)) {}
+  ~U8Iterator() = default;
+
+  bool Decode32(u32& ret) {
+    if (ptr == nullptr || *ptr == 0) return false;
+    u8 c = *ptr;
+    if (c < 0x80) {
+      ret = c;
+      ptr += 1;
+    } else if ((c >> 5) == 0x6) {
+      ret = ((c & 0x1F) << 6) | (ptr[1] & 0x3F);
+      ptr += 2;
+    } else if ((c >> 4) == 0xE) {
+      ret = ((c & 0x0F) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
+      ptr += 3;
+    } else {
+      ret = ((c & 0x07) << 18) | ((ptr[1] & 0x3F) << 12) |
+            ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
+      ptr += 4;
+    }
+    return true;
+  }
+
+  bool PeekNext32(u32& ret) {
+    if (ptr == nullptr || *(ptr + 1) == 0) return false;
+    u8 c = *ptr;
+    if (c < 0x80) {
+      ret = c;
+    } else if ((c >> 5) == 0x6) {
+      ret = ((c & 0x1F) << 6) | (ptr[1] & 0x3F);
+    } else if ((c >> 4) == 0xE) {
+      ret = ((c & 0x0F) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
+    } else {
+      ret = ((c & 0x07) << 18) | ((ptr[1] & 0x3F) << 12) |
+            ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
+    }
+    return true;
+  }
+
+ private:
+  const u8* ptr = nullptr;
+};
 }  // namespace PD

include/pd/core/timer.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,13 +23,13 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
  * Timer class
  */
-class PD_CORE_API Timer {
+class PD_API Timer {
  public:
   /**
    * Constructor
@@ -41,8 +41,6 @@ class PD_CORE_API Timer {
    */
   ~Timer() {}
 
-  PD_SHARED(Timer);
-
   /**
    * Resume Timer if Paused
    */

include/pd/core/timetrace.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
@@ -38,8 +38,6 @@ class TimeStats {
   TimeStats(int l) : len(l), val(l, 0) {}
   ~TimeStats() = default;
 
-  PD_SHARED(TimeStats);
-
   /**
    * Add a New Value to the list
    * @param v value to add
@@ -102,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
@@ -151,16 +149,14 @@ namespace TT {
 class Res {
  public:
   /** Constructore that Inits a protocol at size of 60 frames */
-  Res(): start(0), end(0) { protocol = TimeStats::New(60); }
+  Res() : start(0), end(0), protocol(60) {}
   ~Res() = default;
 
-  PD_SHARED(Res);
-
   /**
    * Setter for the ID (Name)
    * @param v ID of the Trace
    */
-  void SetID(const std::string &v) { id = v; }
+  void SetID(const std::string& v) { id = v; }
   /**
    * Getter for the traces ID
    * @return Trace ID
@@ -182,7 +178,8 @@ class Res {
    */
   void SetEnd(u64 v) {
     end = v;
-    protocol->Add(GetLastDiff());
+    diff = end - start;
+    protocol.Add(GetLastDiff());
   }
   /**
    * Getter for the End Time
@@ -194,12 +191,12 @@ class Res {
    * Get Last Diffrence between end and start
    * @return end - start
    */
-  u64 GetLastDiff() { return end - start; }
+  u64 GetLastDiff() { return diff; }
   /**
    * Get Protcol Reference
    * @return Protocol Ref
    */
-  TimeStats::Ref GetProtocol() { return protocol; }
+  TimeStats& GetProtocol() { return protocol; }
 
  private:
   /** Trace ID */
@@ -208,19 +205,21 @@ class Res {
   u64 start;
   /** End Time */
   u64 end;
+  /** Last Diff */
+  u64 diff;
   /** Protocol */
-  TimeStats::Ref protocol;
+  TimeStats protocol;
 };
 /**
  * Begin a Trace
  * @param id Name of the Trace
  */
-PD_CORE_API void Beg(const std::string &id);
+PD_API void Beg(const std::string& id);
 /**
  * End a Trace
  * @param id Name of the Trace
  */
-PD_CORE_API void End(const std::string &id);
+PD_API void End(const std::string& id);
 /**
  * Collect Start end end of the trace by tracking
  * when the Scope object goes out of scope
@@ -242,7 +241,7 @@ 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;
     Beg(id);
   }

include/pd/core/tween.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
@@ -60,7 +60,7 @@ class Tween {
    * @param delta deltatime
    */
   void Update(float delta) {
-    time += delta / 1000.f;
+    time += delta * 0.001f;
     if (time > tend) {
       finished = true;
       time = tend;
@@ -162,10 +162,10 @@ class Tween {
         return -(end - start) * t * (t - 2) + start;
         break;
       case EaseInOutQuad:
-        t = time / (tend / 2);
-        if (t < 1) return (end - start) / 2 * t * t + start;
+        t = time / (tend * 0.5f);
+        if (t < 1) return (end - start) * 0.5f * t * t + start;
         t--;
-        return -(end - start) / 2 * (t * (t - 2) - 1) + start;
+        return -(end - start) * 0.5f * (t * (t - 2) - 1) + start;
         break;
       case EaseInCubic:
         t = time / tend;
@@ -177,20 +177,20 @@ class Tween {
         return (end - start) * (t * t * t + 1) + start;
         break;
       // case EaseInOutCubic:
-      //   t = time / (tend / 2);
-      //   if (t < 1) return (end - start) / 2 * t * t * t + start;
+      //   t = time / (tend *0.5f);
+      //   if (t < 1) return (end - start) *0.5f * t * t * t + start;
       //   t--;
-      //   return (end - start) / 2 * (t * t * t * 2) + start;
+      //   return (end - start) *0.5f * (t * t * t * 2) + start;
       //   break;
       case EaseInSine:
-        return -(end - start) * cos(time / tend * (M_PI / 2)) + (end - start) +
-               start;
+        return -(end - start) * cos(time / tend * (M_PI * 0.5f)) +
+               (end - start) + start;
         break;
       case EaseOutSine:
-        return (end - start) * sin(time / tend * (M_PI / 2)) + start;
+        return (end - start) * sin(time / tend * (M_PI * 0.5f)) + start;
         break;
       case EaseInOutSine:
-        return -(end - start) / 2 * (cos(M_PI * time / tend) - 1) + start;
+        return -(end - start) * 0.5f * (cos(M_PI * time / tend) - 1) + start;
         break;
 
       default:  // Linear

include/pd/core/u128.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 /**
@@ -28,18 +28,18 @@ class u128 {
     return u128();
   }
 
-  u128 operator+(const u128& v) const {
+  constexpr u128 operator+(const u128& v) const {
     u128 ret;
     ret.pLow = pLow + v.pLow;
     ret.pHigh = pHigh + v.pHigh + (ret.pLow < pLow);
     return ret;
   }
 
-  u128 operator&(const u128& v) const {
+  constexpr u128 operator&(const u128& v) const {
     return u128(pLow & v.pLow, pHigh & v.pHigh);
   }
 
-  u128 operator<<(u32 s) const {
+  constexpr u128 operator<<(u32 s) const {
     if (s == 0) {
       return *this;
     }
@@ -52,7 +52,7 @@ class u128 {
     return u128(pLow << s, (pHigh << s) | (pLow >> (64 - s)));
   }
 
-  u128 operator>>(u32 s) const {
+  constexpr u128 operator>>(u32 s) const {
     if (s == 0) {
       return *this;
     }
@@ -65,23 +65,23 @@ class u128 {
     return u128((pLow >> s) | (pHigh << (64 - s)), pHigh >> s);
   }
 
-  u128& operator|=(const u128& v) {
+  constexpr u128& operator|=(const u128& v) {
     pLow |= v.pLow;
     pHigh |= v.pHigh;
     return *this;
   }
 
-  u128 operator|(const u128& v) const {
+  constexpr u128 operator|(const u128& v) const {
     return u128(pLow | v.pLow, pHigh | v.pHigh);
   }
 
-  u128& operator&=(const u128& v) {
+  constexpr u128& operator&=(const u128& v) {
     pLow &= v.pLow;
     pHigh &= v.pHigh;
     return *this;
   }
 
-  u128 operator~() const { return u128(~pLow, ~pHigh); }
+  constexpr u128 operator~() const { return u128(~pLow, ~pHigh); }
 
   /**
    * Old why to make if checks possible
@@ -92,7 +92,7 @@ class u128 {
   //   return pLow & v.pLow || pHigh & v.pHigh;
   // }
 
-  bool operator==(const u128& v) const {
+  constexpr bool operator==(const u128& v) const {
     return pLow == v.pLow && pHigh == v.pHigh;
   }
 
@@ -100,12 +100,14 @@ class u128 {
    * Use explicit here to make sure it is only for checking and not for
    * some error leading implicit bool assignments...
    */
-  explicit operator bool() const { return pLow != 0 || pHigh != 0; }
+  constexpr explicit operator bool() const { return pLow != 0 || pHigh != 0; }
 
   /** Deprecated way to handle `flag & SomeFlag` */
-  bool Has(const u128& v) const { return pLow & v.pLow || pHigh & v.pHigh; }
+  constexpr bool Has(const u128& v) const {
+    return pLow & v.pLow || pHigh & v.pHigh;
+  }
 
-  bool operator!=(const u128& v) const { return !(*this == v); }
+  constexpr bool operator!=(const u128& v) const { return !(*this == v); }
 };
 }  // namespace PD
 

include/pd/core/vec.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
-Copyright (c) 2024 - 2025 tobid7
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 #include <pd/core/vec2.hpp>
 #include <pd/core/vec3.hpp>
 #include <pd/core/vec4.hpp>

include/pd/core/vec2.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,9 +23,9 @@ 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
+// This file is generated by lazyvec 2.1.0
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 
 namespace PD {
 template <typename T>
@@ -54,117 +54,117 @@ class vec2 {
   // Operations
 
   template <typename T1>
-  vec2<T>& operator+=(T1 v) {
+  constexpr vec2<T>& operator+=(T1 v) {
     x += (T)v;
     y += (T)v;
     return *this;
   }
 
   template <typename T1>
-  vec2<T>& operator+=(const vec2<T1>& v) {
+  constexpr vec2<T>& operator+=(const vec2<T1>& v) {
     x += (T)v.x;
     y += (T)v.y;
     return *this;
   }
 
   template <typename T1>
-  vec2<T> operator+(T1 v) const {
+  constexpr 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 {
+  constexpr vec2<T> operator+(const vec2<T1>& v) const {
     return vec2<T>(x + (T)v.x, y + (T)v.y);
   }
 
   template <typename T1>
-  vec2<T>& operator-=(T1 v) {
+  constexpr vec2<T>& operator-=(T1 v) {
     x -= (T)v;
     y -= (T)v;
     return *this;
   }
 
   template <typename T1>
-  vec2<T>& operator-=(const vec2<T1>& v) {
+  constexpr vec2<T>& operator-=(const vec2<T1>& v) {
     x -= (T)v.x;
     y -= (T)v.y;
     return *this;
   }
 
   template <typename T1>
-  vec2<T> operator-(T1 v) const {
+  constexpr 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 {
+  constexpr vec2<T> operator-(const vec2<T1>& v) const {
     return vec2<T>(x - (T)v.x, y - (T)v.y);
   }
 
   template <typename T1>
-  vec2<T>& operator*=(T1 v) {
+  constexpr vec2<T>& operator*=(T1 v) {
     x *= (T)v;
     y *= (T)v;
     return *this;
   }
 
   template <typename T1>
-  vec2<T>& operator*=(const vec2<T1>& v) {
+  constexpr vec2<T>& operator*=(const vec2<T1>& v) {
     x *= (T)v.x;
     y *= (T)v.y;
     return *this;
   }
 
   template <typename T1>
-  vec2<T> operator*(T1 v) const {
+  constexpr 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 {
+  constexpr vec2<T> operator*(const vec2<T1>& v) const {
     return vec2<T>(x * (T)v.x, y * (T)v.y);
   }
 
   template <typename T1>
-  vec2<T>& operator/=(T1 v) {
+  constexpr vec2<T>& operator/=(T1 v) {
     x /= (T)v;
     y /= (T)v;
     return *this;
   }
 
   template <typename T1>
-  vec2<T>& operator/=(const vec2<T1>& v) {
+  constexpr vec2<T>& operator/=(const vec2<T1>& v) {
     x /= (T)v.x;
     y /= (T)v.y;
     return *this;
   }
 
   template <typename T1>
-  vec2<T> operator/(T1 v) const {
+  constexpr 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 {
+  constexpr 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); }
+  constexpr vec2 operator-() const { return vec2(-x, -y); }
   template <typename T1>
-  bool operator==(const vec2<T1>& v) const {
+  constexpr 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 {
+  constexpr bool operator!=(const vec2<T1>& v) const {
     return !(*this == v);
   }
 
   // Functions
 
   double Len() const { return std::sqrt(SqLen()); }
-  double SqLen() const { return x * x + y * y; }
+  constexpr double SqLen() const { return x * x + y * y; }
 
   template <typename T1>
   double Distance(const vec2<T1>& v) const {
@@ -180,12 +180,12 @@ class vec2 {
   }
 
   template <typename T1>
-  T Dot(const vec2<T1>& v) const {
+  constexpr T Dot(const vec2<T1>& v) const {
     return x * (T)v.x + y * (T)v.y;
   }
 
   // Swap Functions
-  void SwapXY() {
+  constexpr void SwapXY() {
     T t = x;
     x = y;
     y = t;

include/pd/core/vec3.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,9 +23,9 @@ 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
+// This file is generated by lazyvec 2.1.0
 
-#include <pd/core/common.hpp>
+#include <pd/common.hpp>
 // Extended includes (rename if you use other filenames/paths)
 #include <pd/core/vec2.hpp>
 
@@ -69,7 +69,7 @@ class vec3 {
   // Operations
 
   template <typename T1>
-  vec3<T>& operator+=(T1 v) {
+  constexpr vec3<T>& operator+=(T1 v) {
     x += (T)v;
     y += (T)v;
     z += (T)v;
@@ -77,7 +77,7 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T>& operator+=(const vec3<T1>& v) {
+  constexpr vec3<T>& operator+=(const vec3<T1>& v) {
     x += (T)v.x;
     y += (T)v.y;
     z += (T)v.z;
@@ -85,17 +85,17 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T> operator+(T1 v) const {
+  constexpr 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 {
+  constexpr vec3<T> operator+(const vec3<T1>& v) const {
     return vec3<T>(x + (T)v.x, y + (T)v.y, z + (T)v.z);
   }
 
   template <typename T1>
-  vec3<T>& operator-=(T1 v) {
+  constexpr vec3<T>& operator-=(T1 v) {
     x -= (T)v;
     y -= (T)v;
     z -= (T)v;
@@ -103,7 +103,7 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T>& operator-=(const vec3<T1>& v) {
+  constexpr vec3<T>& operator-=(const vec3<T1>& v) {
     x -= (T)v.x;
     y -= (T)v.y;
     z -= (T)v.z;
@@ -111,17 +111,17 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T> operator-(T1 v) const {
+  constexpr 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 {
+  constexpr vec3<T> operator-(const vec3<T1>& v) const {
     return vec3<T>(x - (T)v.x, y - (T)v.y, z - (T)v.z);
   }
 
   template <typename T1>
-  vec3<T>& operator*=(T1 v) {
+  constexpr vec3<T>& operator*=(T1 v) {
     x *= (T)v;
     y *= (T)v;
     z *= (T)v;
@@ -129,7 +129,7 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T>& operator*=(const vec3<T1>& v) {
+  constexpr vec3<T>& operator*=(const vec3<T1>& v) {
     x *= (T)v.x;
     y *= (T)v.y;
     z *= (T)v.z;
@@ -137,17 +137,17 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T> operator*(T1 v) const {
+  constexpr 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 {
+  constexpr vec3<T> operator*(const vec3<T1>& v) const {
     return vec3<T>(x * (T)v.x, y * (T)v.y, z * (T)v.z);
   }
 
   template <typename T1>
-  vec3<T>& operator/=(T1 v) {
+  constexpr vec3<T>& operator/=(T1 v) {
     x /= (T)v;
     y /= (T)v;
     z /= (T)v;
@@ -155,7 +155,7 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T>& operator/=(const vec3<T1>& v) {
+  constexpr vec3<T>& operator/=(const vec3<T1>& v) {
     x /= (T)v.x;
     y /= (T)v.y;
     z /= (T)v.z;
@@ -163,31 +163,31 @@ class vec3 {
   }
 
   template <typename T1>
-  vec3<T> operator/(T1 v) const {
+  constexpr 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 {
+  constexpr vec3<T> operator/(const vec3<T1>& v) const {
     return vec3<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z);
   }
 
   // Generic Operations
 
-  vec3 operator-() const { return vec3(-x, -y, -z); }
+  constexpr vec3 operator-() const { return vec3(-x, -y, -z); }
   template <typename T1>
-  bool operator==(const vec3<T1>& v) const {
+  constexpr bool operator==(const vec3<T1>& v) const {
     return x == (T)v.x && y == (T)v.y && z == (T)v.z;
   }
   template <typename T1>
-  bool operator!=(const vec3<T1>& v) const {
+  constexpr bool operator!=(const vec3<T1>& v) const {
     return !(*this == v);
   }
 
   // Functions
 
   double Len() const { return std::sqrt(SqLen()); }
-  double SqLen() const { return x * x + y * y + z * z; }
+  constexpr double SqLen() const { return x * x + y * y + z * z; }
 
   template <typename T1>
   double Distance(const vec3<T1>& v) const {
@@ -203,27 +203,27 @@ class vec3 {
   }
 
   template <typename T1>
-  T Dot(const vec3<T1>& v) const {
+  constexpr 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 {
+  constexpr vec3<T> Cross(const vec3<T1>& v) const {
     return vec3<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
   }
 
   // Swap Functions
-  void SwapXY() {
+  constexpr void SwapXY() {
     T t = x;
     x = y;
     y = t;
   }
-  void SwapXZ() {
+  constexpr void SwapXZ() {
     T t = x;
     x = z;
     z = t;
   }
-  void SwapYZ() {
+  constexpr void SwapYZ() {
     T t = y;
     y = z;
     z = t;

include/pd/core/vec4.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,9 +23,9 @@ 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
+// This file is generated by lazyvec 2.1.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>
@@ -84,7 +84,7 @@ class vec4 {
   // Operations
 
   template <typename T1>
-  vec4<T>& operator+=(T1 v) {
+  constexpr vec4<T>& operator+=(T1 v) {
     x += (T)v;
     y += (T)v;
     z += (T)v;
@@ -93,7 +93,7 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T>& operator+=(const vec4<T1>& v) {
+  constexpr vec4<T>& operator+=(const vec4<T1>& v) {
     x += (T)v.x;
     y += (T)v.y;
     z += (T)v.z;
@@ -102,17 +102,17 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T> operator+(T1 v) const {
+  constexpr vec4<T> operator+(T1 v) const {
     return vec4<T>(x + (T)v, y + (T)v, z + (T)v, w + (T)v);
   }
 
   template <typename T1>
-  vec4<T> operator+(const vec4<T1>& v) const {
+  constexpr vec4<T> operator+(const vec4<T1>& v) const {
     return vec4<T>(x + (T)v.x, y + (T)v.y, z + (T)v.z, w + (T)v.w);
   }
 
   template <typename T1>
-  vec4<T>& operator-=(T1 v) {
+  constexpr vec4<T>& operator-=(T1 v) {
     x -= (T)v;
     y -= (T)v;
     z -= (T)v;
@@ -121,7 +121,7 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T>& operator-=(const vec4<T1>& v) {
+  constexpr vec4<T>& operator-=(const vec4<T1>& v) {
     x -= (T)v.x;
     y -= (T)v.y;
     z -= (T)v.z;
@@ -130,17 +130,17 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T> operator-(T1 v) const {
+  constexpr vec4<T> operator-(T1 v) const {
     return vec4<T>(x - (T)v, y - (T)v, z - (T)v, w - (T)v);
   }
 
   template <typename T1>
-  vec4<T> operator-(const vec4<T1>& v) const {
+  constexpr vec4<T> operator-(const vec4<T1>& v) const {
     return vec4<T>(x - (T)v.x, y - (T)v.y, z - (T)v.z, w - (T)v.w);
   }
 
   template <typename T1>
-  vec4<T>& operator*=(T1 v) {
+  constexpr vec4<T>& operator*=(T1 v) {
     x *= (T)v;
     y *= (T)v;
     z *= (T)v;
@@ -149,7 +149,7 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T>& operator*=(const vec4<T1>& v) {
+  constexpr vec4<T>& operator*=(const vec4<T1>& v) {
     x *= (T)v.x;
     y *= (T)v.y;
     z *= (T)v.z;
@@ -158,17 +158,17 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T> operator*(T1 v) const {
+  constexpr vec4<T> operator*(T1 v) const {
     return vec4<T>(x * (T)v, y * (T)v, z * (T)v, w * (T)v);
   }
 
   template <typename T1>
-  vec4<T> operator*(const vec4<T1>& v) const {
+  constexpr vec4<T> operator*(const vec4<T1>& v) const {
     return vec4<T>(x * (T)v.x, y * (T)v.y, z * (T)v.z, w * (T)v.w);
   }
 
   template <typename T1>
-  vec4<T>& operator/=(T1 v) {
+  constexpr vec4<T>& operator/=(T1 v) {
     x /= (T)v;
     y /= (T)v;
     z /= (T)v;
@@ -177,7 +177,7 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T>& operator/=(const vec4<T1>& v) {
+  constexpr vec4<T>& operator/=(const vec4<T1>& v) {
     x /= (T)v.x;
     y /= (T)v.y;
     z /= (T)v.z;
@@ -186,31 +186,31 @@ class vec4 {
   }
 
   template <typename T1>
-  vec4<T> operator/(T1 v) const {
+  constexpr vec4<T> operator/(T1 v) const {
     return vec4<T>(x / (T)v, y / (T)v, z / (T)v, w / (T)v);
   }
 
   template <typename T1>
-  vec4<T> operator/(const vec4<T1>& v) const {
+  constexpr vec4<T> operator/(const vec4<T1>& v) const {
     return vec4<T>(x / (T)v.x, y / (T)v.y, z / (T)v.z, w / (T)v.w);
   }
 
   // Generic Operations
 
-  vec4 operator-() const { return vec4(-x, -y, -z, -w); }
+  constexpr vec4 operator-() const { return vec4(-x, -y, -z, -w); }
   template <typename T1>
-  bool operator==(const vec4<T1>& v) const {
+  constexpr bool operator==(const vec4<T1>& v) const {
     return x == (T)v.x && y == (T)v.y && z == (T)v.z && w == (T)v.w;
   }
   template <typename T1>
-  bool operator!=(const vec4<T1>& v) const {
+  constexpr bool operator!=(const vec4<T1>& v) const {
     return !(*this == v);
   }
 
   // Functions
 
   double Len() const { return std::sqrt(SqLen()); }
-  double SqLen() const { return x * x + y * y + z * z + w * w; }
+  constexpr double SqLen() const { return x * x + y * y + z * z + w * w; }
 
   template <typename T1>
   double Distance(const vec4<T1>& v) const {
@@ -226,37 +226,37 @@ class vec4 {
   }
 
   template <typename T1>
-  T Dot(const vec4<T1>& v) const {
+  constexpr T Dot(const vec4<T1>& v) const {
     return x * (T)v.x + y * (T)v.y + z * (T)v.z + w * (T)v.w;
   }
 
   // Swap Functions
-  void SwapXY() {
+  constexpr void SwapXY() {
     T t = x;
     x = y;
     y = t;
   }
-  void SwapXZ() {
+  constexpr void SwapXZ() {
     T t = x;
     x = z;
     z = t;
   }
-  void SwapXW() {
+  constexpr void SwapXW() {
     T t = x;
     x = w;
     w = t;
   }
-  void SwapYZ() {
+  constexpr void SwapYZ() {
     T t = y;
     y = z;
     z = t;
   }
-  void SwapYW() {
+  constexpr void SwapYW() {
     T t = y;
     y = w;
     w = t;
   }
-  void SwapZW() {
+  constexpr void SwapZW() {
     T t = z;
     z = w;
     w = t;

include/pd/drivers/drivers.hpp

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

include/pd/drivers/gfx.hpp

@@ -1,114 +1,189 @@
 #pragma once
 
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd/core/core.hpp>
+#include <pd/core/mat.hpp>
+#include <pd/drivers/interface.hpp>
 #include <pd/lithium/command.hpp>
+#include <pd/lithium/pools.hpp>
 #include <pd/lithium/texture.hpp>
 
-using LiBackendFlags = PD::u32;
-enum LiBackendFlags_ {
-  LiBackendFlags_None = 0,
-  LiBackendFlags_FlipUV_Y = PD_BIT(0),  // Essential for font loading
+using PDGfxBackendFlags = PD::u32;
+enum PDGfxBackendFlags_ {
+  PDGfxBackendFlags_None = 0,
+  PDGfxBackendFlags_FlipUV_Y = 1 << 0,   // Essential for font loading
+  PDGfxBackendFlags_WindingCW = 1 << 0,  // Use CW instead of CCW winding
 };
 
 namespace PD {
-class GfxDriver {
+
+// Pre interface class
+class PD_API GfxDriver : public DriverInterface {
  public:
-  GfxDriver(const std::string& name = "NullGfx") : pName(name) {};
-  ~GfxDriver() = default;
-
-  PD_SHARED(GfxDriver);
-
-  void PostInit();
+  GfxDriver(std::string_view name);
+  virtual ~GfxDriver();
 
   virtual void Init() {}
-  virtual void Deinit() {}
-  virtual void NewFrame() {}
-
-  virtual void BindTex(Li::TexAddress addr) {}
-
-  virtual void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {}
-
-  void SetViewPort(const ivec2& vp) { ViewPort = vp; }
-
-  virtual Li::Texture::Ref LoadTex(
-      const std::vector<u8>& pixels, int w, int h,
-      Li::Texture::Type type = Li::Texture::Type::RGBA32,
-      Li::Texture::Filter filter = Li::Texture::Filter::LINEAR) {
-    // Texture loading not supported (when this func not get override)
-    return nullptr;
+  virtual void Deinit() {
+    DeleteTexture(pWhite);
+    SysDeinit();
   }
 
-  Li::Texture::Ref GetSolidTex() { return pSolid; }
+  void SetViewPort(const ivec2& size);
+  void SetViewPort(int x, int y);
+  virtual void BindTexture(TextureID id) {}
+  void Reset();
+  virtual Li::Texture LoadTexture(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      TextureFormat type = TextureFormat::RGBA32,
+      TextureFilter filter = TextureFilter::Linear) {
+    return Li::Texture();
+  }
+  virtual void DeleteTexture(const Li::Texture& tex) {}
+  virtual void Draw(const Pool<Li::Command>& commands) {}
+  Li::Texture::Ptr GetWhiteTexture() { return &pWhite; }
+  PDGfxBackendFlags GetFlags() { return Flags; }
 
-  const std::string pName = "NullGfx";
-  LiBackendFlags Flags = 0;
-  ivec2 ViewPort;
-  Mat4 Projection;
-  Li::Texture::Ref pSolid;
-  size_t CurrentVertex = 0;
+  size_t GetNumVertices() const { return CountVertices; }
+  size_t GetNumIndices() const { return CountIndices; }
+  size_t GetNumDrawcalls() const { return CountDrawcalls; }
+  size_t GetNumCommands() const { return CountCommands; }
+
+ protected:
+  virtual void SysDeinit() {}
+  virtual void SysInit() {}
+  virtual void SysReset() {}
+  virtual void Submit(size_t count, size_t start) {}
+  virtual void ResetPools() = 0;
+  void RegisterTexture(const Li::Texture& tex);
+  void UnregisterTexture(const Li::Texture& tex);
+
+  // Counters
+  size_t CountDrawcalls = 0;
+  size_t CountCommands = 0;
+  size_t CountVertices = 0;
+  size_t CountIndices = 0;
   size_t CurrentIndex = 0;
-
-  /** Debug Variables */
-
-  // Optional Index counter
-  u32 IndexCounter;
-  // Optional Vertex counter
-  u32 VertexCounter;
-  // Optional Frame Counter
-  u64 FrameCounter;
+  size_t CurrentVertex = 0;
+  size_t pCountDrawcalls = 0;
+  size_t pCountCommands = 0;
+  TextureID CurrentTex = 0;
+  Mat4 Projection;
+  ivec2 ViewPort;
+  std::unordered_map<TextureID, Li::Texture> pTextureRegestry;
+  Li::Texture pWhite;
+  PDGfxBackendFlags Flags = 0;
 };
 
-/** Static Gfx Controller */
-class Gfx {
+struct DefaultGfxConfig {
+  // Vertex Allocator
+  template <typename T>
+  using VertexAlloc = std::allocator<T>;
+  // Index Allocator
+  template <typename T>
+  using IndexAlloc = std::allocator<T>;
+};
+
+template <typename Config = DefaultGfxConfig>
+class GfxDriverBase : public GfxDriver {
+ public:
+  using VtxPool =
+      Pool<Li::Vertex, typename Config::template VertexAlloc<Li::Vertex>>;
+  using IdxPool = Pool<u16, typename Config::template VertexAlloc<u16>>;
+  GfxDriverBase(std::string_view name = "Default") : GfxDriver(name) {}
+  virtual ~GfxDriverBase() {}
+
+  void Init() override {
+    SysInit();
+    std::vector<u8> img(16 * 16 * 4, 0xff);
+    pWhite = LoadTexture(img, 16, 16);
+  }
+
+  void Draw(const Pool<Li::Command>& commands) override {
+    pCountCommands += commands.size();
+    size_t index = 0;
+    while (index < commands.size()) {
+      CurrentTex = commands[index].Tex;
+      if (!CurrentTex) {
+        CurrentTex = pWhite.GetID();
+      }
+      size_t startidx = CurrentIndex;
+      while (index < commands.size() &&
+             (CurrentTex == commands[index].Tex ||
+              (CurrentTex == pWhite.GetID() && commands[index].Tex == 0))) {
+        const auto& c = commands[index];
+        auto pIdx = pIdxPool.Allocate(c.IndexCount);
+        auto pVtx = pVtxPool.Allocate(c.VertexCount);
+        for (size_t i = 0; i < c.IndexCount; i++) {
+          pIdx[i] = CurrentVertex + Li::GetIndex(c.FirstIndex + i);
+        }
+        CurrentIndex += c.IndexCount;
+        CurrentVertex += c.VertexCount;
+        for (size_t i = 0; i < c.VertexCount; i++) {
+          pVtx[i] = Li::GetVertex(c.FirstVertex + i);
+        }
+        index++;
+      }
+      Submit(CurrentIndex - startidx, startidx);
+      pCountDrawcalls++;
+    }
+  }
+
+ protected:
+  u16* GetIndexBufPtr(size_t start) { return &pIdxPool[start]; }
+  Li::Vertex* GetVertexBufPtr(size_t start) { return &pVtxPool[start]; }
+  size_t GetVertexPoolSize() const { return pVtxPool.size(); }
+  size_t GetIndexPoolSize() const { return pIdxPool.size(); }
+  void ResetPools() override {
+    pVtxPool.ResetFast();
+    pIdxPool.ResetFast();
+  }
+
+ private:
+  VtxPool pVtxPool;
+  IdxPool pIdxPool;
+};
+
+class PD_API Gfx {
  public:
   Gfx() = default;
   ~Gfx() = default;
 
-  static void Init(GfxDriver::Ref d);
-
-  static void Deinit() { pGfx->Deinit(); }
-  static void NewFrame() { pGfx->NewFrame(); }
-
-  static void BindTex(Li::TexAddress addr) { pGfx->BindTex(addr); }
-  static void SetViewPort(const ivec2& vp) { pGfx->SetViewPort(vp); }
-
-  static void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {
-    pGfx->RenderDrawData(Commands);
+  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 LiBackendFlags Flags() { return pGfx->Flags; }
-  static Li::Texture::Ref LoadTex(
-      const std::vector<u8>& pixels, int w, int h,
-      Li::Texture::Type type = Li::Texture::Type::RGBA32,
-      Li::Texture::Filter filter = Li::Texture::Filter::LINEAR) {
-    return pGfx->LoadTex(pixels, w, h, type, filter);
+  static 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 Li::Texture LoadTexture(const std::vector<PD::u8>& pixels, int w,
+                                 int h,
+                                 TextureFormat type = TextureFormat::RGBA32,
+                                 TextureFilter filter = TextureFilter::Linear) {
+    return driver->LoadTexture(pixels, w, h, type, filter);
+  }
+  static void DeleteTexture(const Li::Texture& tex) {
+    driver->DeleteTexture(tex);
+  }
+  static Li::Texture::Ptr GetWhiteTexture() {
+    return driver->GetWhiteTexture();
   }
 
-  static Li::Texture::Ref GetSolidTex() { return pGfx->GetSolidTex(); }
+  static PDGfxBackendFlags GetFlags() { return driver->GetFlags(); }
 
-  static GfxDriver::Ref pGfx;
+  static const char* GetDriverName() { return driver->GetName(); }
+
+  static size_t GetNumVertices() { return driver->GetNumVertices(); }
+  static size_t GetNumIndices() { return driver->GetNumIndices(); }
+  static size_t GetNumDrawcalls() { return driver->GetNumDrawcalls(); }
+  static size_t GetNumCommands() { return driver->GetNumCommands(); }
+
+ private:
+  static std::unique_ptr<GfxDriver> driver;
 };
 }  // namespace PD

include/pd/drivers/hid.hpp

@@ -1,296 +1,183 @@
-#pragma once
-
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPHidE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd/core/core.hpp>
-
-namespace PD {
-/** Did not found a better solution yet sadly */
-namespace HidKb {
-// Lets use u128 here
-using KbKey = u128;
-constexpr static KbKey Kb_No = 0;
-constexpr static KbKey Kb_Escape = KbKey::Flag(0);
-constexpr static KbKey Kb_Q = KbKey::Flag(1);
-constexpr static KbKey Kb_W = KbKey::Flag(2);
-constexpr static KbKey Kb_E = KbKey::Flag(3);
-constexpr static KbKey Kb_R = KbKey::Flag(4);
-constexpr static KbKey Kb_T = KbKey::Flag(5);
-constexpr static KbKey Kb_Z = KbKey::Flag(6);
-constexpr static KbKey Kb_U = KbKey::Flag(7);
-constexpr static KbKey Kb_I = KbKey::Flag(8);
-constexpr static KbKey Kb_O = KbKey::Flag(9);
-constexpr static KbKey Kb_P = KbKey::Flag(10);
-constexpr static KbKey Kb_A = KbKey::Flag(11);
-constexpr static KbKey Kb_S = KbKey::Flag(12);
-constexpr static KbKey Kb_D = KbKey::Flag(13);
-constexpr static KbKey Kb_F = KbKey::Flag(14);
-constexpr static KbKey Kb_G = KbKey::Flag(15);
-constexpr static KbKey Kb_H = KbKey::Flag(16);
-constexpr static KbKey Kb_J = KbKey::Flag(17);
-constexpr static KbKey Kb_K = KbKey::Flag(18);
-constexpr static KbKey Kb_L = KbKey::Flag(19);
-constexpr static KbKey Kb_Y = KbKey::Flag(20);
-constexpr static KbKey Kb_X = KbKey::Flag(21);
-constexpr static KbKey Kb_C = KbKey::Flag(22);
-constexpr static KbKey Kb_V = KbKey::Flag(23);
-constexpr static KbKey Kb_B = KbKey::Flag(24);
-constexpr static KbKey Kb_N = KbKey::Flag(25);
-constexpr static KbKey Kb_M = KbKey::Flag(26);
-constexpr static KbKey Kb_1 = KbKey::Flag(27);
-constexpr static KbKey Kb_2 = KbKey::Flag(28);
-constexpr static KbKey Kb_3 = KbKey::Flag(29);
-constexpr static KbKey Kb_4 = KbKey::Flag(30);
-constexpr static KbKey Kb_5 = KbKey::Flag(31);
-constexpr static KbKey Kb_6 = KbKey::Flag(32);
-constexpr static KbKey Kb_7 = KbKey::Flag(33);
-constexpr static KbKey Kb_8 = KbKey::Flag(34);
-constexpr static KbKey Kb_9 = KbKey::Flag(35);
-constexpr static KbKey Kb_0 = KbKey::Flag(36);
-constexpr static KbKey Kb_F1 = KbKey::Flag(37);
-constexpr static KbKey Kb_F2 = KbKey::Flag(38);
-constexpr static KbKey Kb_F3 = KbKey::Flag(39);
-constexpr static KbKey Kb_F4 = KbKey::Flag(40);
-constexpr static KbKey Kb_F5 = KbKey::Flag(41);
-constexpr static KbKey Kb_F6 = KbKey::Flag(42);
-constexpr static KbKey Kb_F7 = KbKey::Flag(43);
-constexpr static KbKey Kb_F8 = KbKey::Flag(44);
-constexpr static KbKey Kb_F9 = KbKey::Flag(45);
-constexpr static KbKey Kb_F10 = KbKey::Flag(46);
-constexpr static KbKey Kb_F11 = KbKey::Flag(47);
-constexpr static KbKey Kb_F12 = KbKey::Flag(48);
-constexpr static KbKey Kb_MouseLeft = KbKey::Flag(120);
-}  // namespace HidKb
-class HidDriver {
- public:
-  enum Flags : u32 {
-    Flags_None = 0,
-    FLags_HasGamepad = 1 << 0,
-    Flags_HasKeyboard = 1 << 1,
-    Flags_HasTouch = 1 << 2,
-    Flags_HasMouse = 1 << 3,
-  };
-  // Todo: Name to GpKey (GamepadKey)
-  /** Key [Controller] */
-  enum Key : u32 {
-    No = 0,                    ///< No Key
-    A = 1 << 0,                ///< A
-    B = 1 << 1,                ///< B
-    X = 1 << 2,                ///< X
-    Y = 1 << 3,                ///< Y
-    Start = 1 << 4,            ///< Start
-    Select = 1 << 5,           ///< Select
-    L = 1 << 6,                ///< L
-    R = 1 << 7,                ///< R
-    DUp = 1 << 8,              ///< Dpad Up
-    DDown = 1 << 9,            ///< Dpad down
-    DLeft = 1 << 10,           ///< Dpad left
-    DRight = 1 << 11,          ///< Dpad right
-    CPUp = 1 << 12,            ///< Cpad up
-    CPDown = 1 << 13,          ///< cpad down
-    CPLeft = 1 << 14,          ///< cpad left
-    CPRight = 1 << 15,         ///< Cpad right
-    CSUp = 1 << 16,            ///< Cstick up
-    CSDown = 1 << 17,          ///< cstick down
-    CSLeft = 1 << 18,          ///< cstick left
-    CSRight = 1 << 19,         ///< cstick right
-    ZL = 1 << 20,              ///< ZL
-    ZR = 1 << 21,              ///< ZR
-    Touch = 1 << 22,           ///< Touch
-    Up = DUp | CPUp,           ///< DPad or CPad Up
-    Down = DDown | CPDown,     ///< DPad or CPad Down
-    Left = DLeft | CPLeft,     ///< DPad or CPad Left
-    Right = DRight | CPRight,  ///< DPad or CPad Right
-  };
-
-  using KbKey = HidKb::KbKey;
-
-  /** Event */
-  enum Event {
-    Event_Null,
-    Event_Down,  ///< Key Pressed
-    Event_Held,  ///< Key Held
-    Event_Up,    ///< Key released
-  };
-
-  HidDriver(const std::string& name = "NullHid") : pName(name) {};
-  virtual ~HidDriver() = default;
-  PD_SHARED(HidDriver);
-
-  /**
-   * Get Mouse Position
-   * @return Mouse pos
-   */
-  fvec2 MousePos() const {
-    return pMouse[0];
-  } /**
-     * Get Last Mouse Position (from last frame)
-     * @return Mouse pos
-     */
-  fvec2 MousePosLast() const { return pMouse[1]; }
-
-  /**
-   * Check for a Button Event
-   * @param e Event Type
-   * @param keys Keys to check for
-   * @return if key(s) doing the requiested event
-   */
-  bool IsEvent(Event e, Key keys);
-  bool IsEvent(Event e, KbKey key);
-  /**
-   * Check for Key Press Event
-   * @param keys set of keys
-   * @return true if key is pressed
-   */
-  bool IsDown(Key keys) const { return KeyEvents[0].at(Event_Down) & keys; }
-  /**
-   * Check for Key Held Event
-   * @param keys set of keys
-   * @return true if key is held
-   */
-  bool IsHeld(Key keys) const { return KeyEvents[0].at(Event_Held) & keys; }
-  /**
-   * Check for Key Release Event
-   * @param keys set of keys
-   * @return true if key is released
-   */
-  bool IsUp(Key keys) const { return KeyEvents[0].at(Event_Up) & keys; }
-
-  /**
-   * Sett all keyevents to 0
-   */
-  void Clear() {
-    for (int i = 0; i < 2; i++) {
-      KeyEvents[i][Event_Down] = 0;
-      KeyEvents[i][Event_Up] = 0;
-      KeyEvents[i][Event_Held] = 0;
-    }
-  }
-
-  /**
-   * Lock input driver
-   * @param v lock or not lock
-   */
-  void Lock(bool v) {
-    if (v != pLocked) {
-      SwapTab();
-    }
-    pLocked = v;
-  }
-
-  /**
-   * Check if Driver is locked
-   * @return true if locked
-   */
-  bool Locked() const { return pLocked; }
-
-  /**
-   * Lock Input Driver
-   */
-  void Lock() {
-    if (!pLocked) {
-      SwapTab();
-    }
-    pLocked = true;
-  }
-  /**
-   * Unlock Input Driver
-   */
-  void Unlock() {
-    if (pLocked) {
-      SwapTab();
-    }
-    pLocked = false;
-  }
-
-  /**
-   * Template Update Function for a device specific driver
-   */
-  virtual void Update();
-  /**
-   * Get Text from Keyboard
-   */
-  virtual void GetInputStr(std::string& str) {}
-
-  /** Data Section */
-
-  /** Backend Identification Name */
-  const std::string pName;
-
-  /** Flags */
-  u32 Flags = 0;
-
-  /** Key Binds Map */
-  std::unordered_map<u32, u32> pBinds;
-  std::unordered_map<u128, u128> pKbBinds;
-  /** Swap Tabe Function */
-  void SwapTab();
-  /** Using 2 Positions for Current and Last */
-  fvec2 pMouse[2];
-  /** Lock State */
-  bool pLocked = false;
-  /** Key Event Table Setup */
-  std::unordered_map<Event, u32> KeyEvents[2];
-  /** Keyboard Key Event Table Setup */
-  std::unordered_map<Event, u128> KbKeyEvents[2];
-};
-
-/** Static Hid Controller */
-class Hid {
- public:
-  Hid() = default;
-  ~Hid() = default;
-
-  /** Referenec to Drivers enums */
-  using Key = HidDriver::Key;
-  using KbKey = HidKb::KbKey;
-  using Event = HidDriver::Event;
-
-  static void Init(HidDriver::Ref v = nullptr) {
-    if (v) {
-      pHid = v;
-    } else {
-      pHid = HidDriver::New();
-    }
-  }
-
-  static bool IsEvent(Event e, Key keys) { return pHid->IsEvent(e, keys); }
-  static bool IsEvent(Event e, KbKey key) { return pHid->IsEvent(e, key); }
-  static bool IsDown(Key keys) { return pHid->IsDown(keys); }
-  static bool IsUp(Key keys) { return pHid->IsUp(keys); }
-  static bool IsHeld(Key keys) { return pHid->IsHeld(keys); }
-  static fvec2 MousePos() { return pHid->MousePos(); }
-  static fvec2 MousePosLast() { return pHid->MousePosLast(); }
-  static void Clear() { pHid->Clear(); }
-  static void Lock() { pHid->Lock(); }
-  static void Lock(bool v) { pHid->Lock(v); }
-  static void Unlock() { pHid->Unlock(); }
-  static bool Locked() { return pHid->Locked(); }
-  static void Update() { pHid->Update(); }
-  static u32 GetFlags() { return pHid->Flags; }
-  static void GetStrInput(std::string& str) { pHid->GetInputStr(str); }
-
-  static HidDriver::Ref pHid;
-};
+#pragma once
+
+#include <pd/core/core.hpp>
+#include <pd/drivers/interface.hpp>
+
+using PDHidBackendFlags = PD::u32;
+enum PDHidBackendFlags_ {
+  PDHidBackendFlags_None = 0,
+  PDHidBackendFlags_HasTouch = 1 << 1,
+  PDHidBackendFlags_HasGamepad = 1 << 2,
+  PDHidBackendFlags_HasMouse = 1 << 3,
+  PDHidBackendFlags_HasKeyboard = 1 << 4,
+};
+
+namespace PD {
+namespace HidInternal {
+class Keyboard {
+ public:
+  Keyboard() = default;
+  virtual ~Keyboard() = default;
+  using Key = u128;
+  constexpr static Key No = 0;
+  constexpr static Key Escape = Key::Flag(0);
+  constexpr static Key Q = Key::Flag(1);
+  constexpr static Key W = Key::Flag(2);
+  constexpr static Key E = Key::Flag(3);
+  constexpr static Key R = Key::Flag(4);
+  constexpr static Key T = Key::Flag(5);
+  constexpr static Key Z = Key::Flag(6);
+  constexpr static Key U = Key::Flag(7);
+  constexpr static Key I = Key::Flag(8);
+  constexpr static Key O = Key::Flag(9);
+  constexpr static Key P = Key::Flag(10);
+  constexpr static Key A = Key::Flag(11);
+  constexpr static Key S = Key::Flag(12);
+  constexpr static Key D = Key::Flag(13);
+  constexpr static Key F = Key::Flag(14);
+  constexpr static Key G = Key::Flag(15);
+  constexpr static Key H = Key::Flag(16);
+  constexpr static Key J = Key::Flag(17);
+  constexpr static Key K = Key::Flag(18);
+  constexpr static Key L = Key::Flag(19);
+  constexpr static Key Y = Key::Flag(20);
+  constexpr static Key X = Key::Flag(21);
+  constexpr static Key C = Key::Flag(22);
+  constexpr static Key V = Key::Flag(23);
+  constexpr static Key B = Key::Flag(24);
+  constexpr static Key N = Key::Flag(25);
+  constexpr static Key M = Key::Flag(26);
+  constexpr static Key _1 = Key::Flag(27);
+  constexpr static Key _2 = Key::Flag(28);
+  constexpr static Key _3 = Key::Flag(29);
+  constexpr static Key _4 = Key::Flag(30);
+  constexpr static Key _5 = Key::Flag(31);
+  constexpr static Key _6 = Key::Flag(32);
+  constexpr static Key _7 = Key::Flag(33);
+  constexpr static Key _8 = Key::Flag(34);
+  constexpr static Key _9 = Key::Flag(35);
+  constexpr static Key _0 = Key::Flag(36);
+  constexpr static Key F1 = Key::Flag(37);
+  constexpr static Key F2 = Key::Flag(38);
+  constexpr static Key F3 = Key::Flag(39);
+  constexpr static Key F4 = Key::Flag(40);
+  constexpr static Key F5 = Key::Flag(41);
+  constexpr static Key F6 = Key::Flag(42);
+  constexpr static Key F7 = Key::Flag(43);
+  constexpr static Key F8 = Key::Flag(44);
+  constexpr static Key F9 = Key::Flag(45);
+  constexpr static Key F10 = Key::Flag(46);
+  constexpr static Key F11 = Key::Flag(47);
+  constexpr static Key F12 = Key::Flag(48);
+  constexpr static Key MouseLeft = Key::Flag(120);
+};
+
+using GamepadKey = u32;
+enum Gamepad : GamepadKey {
+  None = 0,                  ///< No Key
+  A = 1 << 0,                ///< A
+  B = 1 << 1,                ///< B
+  X = 1 << 2,                ///< X
+  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
+  LStick = 1 << 23,          ///< Left Stick
+  RStick = 1 << 24,          ///< Right Stick
+  Up = DUp | CPUp,           ///< DPad or CPad Up
+  Down = DDown | CPDown,     ///< DPad or CPad Down
+  Left = DLeft | CPLeft,     ///< DPad or CPad Left
+  Right = DRight | CPRight,  ///< DPad or CPad Right
+};
+}  // namespace HidInternal
+// Pre interface class
+class PD_API HidDriver : public DriverInterface {
+ public:
+  enum class Event {
+    Null,  ///< Nothing happended
+    Down,  ///< Key Pressed
+    Held,  ///< Key held
+    Up,    ///< Key released
+  };
+  HidDriver(std::string_view name = "HidNull");
+  virtual ~HidDriver();
+
+  virtual void Init() {}
+  virtual void Deinit() {}
+  virtual const fvec2& MousePos() const { return pMouse[0]; }
+  virtual const fvec2& MousePosLast() const { return pMouse[1]; }
+  virtual const fvec2& TouchPos() const { return pMouse[0]; }
+  virtual const fvec2& TouchPosLast() const { return pMouse[1]; }
+  virtual void Update();
+  virtual bool IsEvent(Event e, HidInternal::GamepadKey keys);
+  virtual bool IsEvent(Event e, HidInternal::Keyboard::Key keys);
+  virtual const fvec2& GetLeftStick() const { return pLStick[0]; }
+  virtual const fvec2& GetRightStick() const { return pRStick[0]; }
+
+  PDHidBackendFlags GetFlags() const { return pFlags; }
+
+ protected:
+  void SwapTab();
+  PDHidBackendFlags pFlags = PDHidBackendFlags_None;
+  fvec2 pMouse[2];  // Current And last pos
+  fvec2 pLStick[2];
+  fvec2 pRStick[2];
+  std::unordered_map<u32, u32> pGamepad;
+  std::unordered_map<u128, u128> pKeyboard;
+  std::unordered_map<Event, u32> pGamepadEvents[2];
+  std::unordered_map<Event, u128> pKeyboardEvents[2];
+};
+
+class PD_API Hid {
+ public:
+  using Gamepad = HidInternal::Gamepad;
+  using Keyboard = HidInternal::Keyboard;
+  using Event = HidDriver::Event;
+  Hid() = default;
+  ~Hid() = default;
+
+  template <typename T, typename... Args>
+  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 const fvec2& MousePos() { return driver->MousePos(); }
+  static const fvec2& MousePosLast() { return driver->MousePosLast(); }
+  static const fvec2& TouchPos() { return driver->TouchPos(); }
+  static const fvec2& TouchPosLast() { return driver->TouchPosLast(); }
+  static void Update() { driver->Update(); }
+  static bool IsEvent(Event e, HidInternal::GamepadKey keys) {
+    return driver->IsEvent(e, keys);
+  }
+  static bool IsEvent(Event e, HidInternal::Keyboard::Key keys) {
+    return driver->IsEvent(e, keys);
+  }
+  static PDHidBackendFlags GetFlags() { return driver->GetFlags(); }
+  static const fvec2& GetLeftStick() { return driver->GetLeftStick(); }
+  static const fvec2& GetRightStick() { return driver->GetRightStick(); }
+
+  static const char* GetDriverName() { return driver->GetName(); }
+
+ private:
+  static std::unique_ptr<HidDriver> driver;
+};
 }  // namespace PD

include/pd/drivers/interface.hpp

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

include/pd/drivers/os.hpp

@@ -1,71 +1,32 @@
 #pragma once
 
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd/core/common.hpp>
-#include <pd/core/timetrace.hpp>
+#include <pd/drivers/interface.hpp>
 
 namespace PD {
-using TraceMap = std::map<std::string, TT::Res::Ref>;
-
-class OsDriver {
+class PD_API OsDriver : public DriverInterface {
  public:
-  OsDriver() = default;
-  virtual ~OsDriver() = default;
-  PD_SHARED(OsDriver);
+  OsDriver(std::string_view name = "Default") : DriverInterface(name) {}
+  virtual ~OsDriver() {}
 
-  virtual u64 GetTime();
-  virtual u64 GetNanoTime();
-  TraceMap& GetTraceMap();
-  TT::Res::Ref& GetTraceRef(const std::string& id);
-  bool TraceExist(const std::string& id);
-
-  TraceMap pTraces;
+  virtual u64 GetTime() const;
+  virtual u64 GetTimeNano() const;
 };
 
-/** Static Os Controller */
-class OS {
+class PD_API Os {
  public:
-  OS() = default;
-  ~OS() = default;
+  Os() = default;
+  ~Os() = default;
 
-  static void Init(OsDriver::Ref v = nullptr) {
-    if (v) {
-      pOs = v;
-    } else {
-      pOs = OsDriver::New();
-    }
+  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 pOs->GetTime(); }
-  static u64 GetNanoTime() { return pOs->GetNanoTime(); }
-  static TraceMap& GetTraceMap() { return pOs->GetTraceMap(); }
-  static TT::Res::Ref& GetTraceRef(const std::string& id) {
-    return pOs->GetTraceRef(id);
-  }
-  static bool TraceExist(const std::string& id) { return pOs->TraceExist(id); }
+  static u64 GetTime() { return driver->GetTime(); }
+  static u64 GetTimeNano() { return driver->GetTimeNano(); }
 
-  static OsDriver::Ref pOs;
+ private:
+  static std::unique_ptr<OsDriver> driver;
 };
 }  // namespace PD

include/pd/drivers/pd_p_api.hpp

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

include/pd/image/image.hpp

@@ -1,88 +1,48 @@
-#pragma once
-
-/*
-MIT License
-
-Copyright (c) 2024 - 2025 tobid7
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd/core/core.hpp>
-#include <pd/image/pd_p_api.hpp>
-
-namespace PD {
-class PD_IMAGE_API Image {
- public:
-  enum Format {
-    RGBA,    // bpp == 4
-    RGB,     // bpp == 3
-    RGB565,  // bpp == 2 (not supported in laoding)
-    BGR,     // bpp == 3
-    ABGR,    // bpp == 4
-    BGRA,    // bpp == 4
-  };
-  Image() = default;
-  Image(const std::string& path) { this->Load(path); }
-  Image(const std::vector<u8>& buf) { this->Load(buf); }
-  Image(const std::vector<u8>& buf, int w, int h, int bpp = 4) {
-    this->Copy(buf, w, h, bpp);
-  }
-  ~Image() = default;
-
-  PD_SHARED(Image)
-
-  void Load(const std::string& path);
-  void Load(const std::vector<u8>& buf);
-  void Copy(const std::vector<u8>& buf, int w, int h, int bpp = 4);
-
-  std::vector<PD::u8>& GetBuffer() { return pBuffer; }
-  std::vector<PD::u8> GetBuffer() const { return pBuffer; }
-
-  int Width() const { return pWidth; }
-  int Height() const { return pHeight; }
-  Format Fmt() const { return pFmt; }
-
-  void FlipVertical();
-  void FlipHorizontal();
-
-  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;
-};
+#pragma once
+
+#include <pd/core/core.hpp>
+
+namespace PD {
+class PD_API Image {
+ public:
+  enum class Format {
+    RGBA,    // bpp == 4
+    RGB,     // bpp == 3
+    RGB565,  // bpp == 2 (not supported in laoding)
+    BGR,     // bpp == 3
+    ABGR,    // bpp == 4
+    BGRA,    // bpp == 4
+  };
+  Image();
+  Image(const std::string& path);
+  Image(const std::vector<u8>& buf);
+  Image(const std::vector<u8>& pixels, int w, int h, int bpp = 4);
+  ~Image();
+
+  void Load(const std::string& path);
+  void Load(const std::vector<u8>& buf);
+  void Load(const u8* buf, size_t size);
+  void Copy(const std::vector<u8>& pixels, int w, int h, int bpp = 4);
+
+  const int& Width() const { return pSize.x; }
+  const int& Height() const { return pSize.y; }
+  const ivec2& Size() const { return pSize; }
+
+  const std::vector<u8>& data() const { return pData; }
+  std::vector<u8>& data() { return pData; }
+  operator const std::vector<u8>&() const { return pData; }
+  operator std::vector<u8>&() { return pData; }
+  operator const ivec2&() const { return pSize; }
+  operator const Format&() const { return pFormat; }
+
+  void Flip(bool horizontal = true, bool vertical = true);
+
+  static int Format2Bpp(Format fmt);
+  static Format GuessFmtFromBpp(int bpp);
+
+ private:
+  std::vector<u8> pData;
+  ivec2 pSize;
+  Format pFormat = Format::RGBA;
+};
 }  // namespace PD

include/pd/image/img_blur.hpp

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

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

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

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

include/pd/lithium/command.hpp

@@ -1,58 +1,75 @@
 #pragma once
 
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd/core/core.hpp>
-#include <pd/lithium/texture.hpp>
+#include <cstddef>
+#include <pd/core/pool.hpp>
+#include <pd/lithium/pools.hpp>
 #include <pd/lithium/vertex.hpp>
 
 namespace PD {
 namespace Li {
 class Command {
  public:
-  Command() = default;
-  ~Command() = default;
+  Command() { Reset(); }
+  ~Command() {}
 
-  PD_UNIQUE(Command);
+  void Reserve(size_t vtx, size_t idx) {
+    if (!FirstVertex) {
+      FirstVertex = AllocateVertices(vtx, (PD::ptr)this);
+      VertexCountMax = vtx;
+    } else {
+      ExpandVertices(vtx, (PD::ptr)this);
+      VertexCountMax += vtx;
+    }
+    if (!FirstIndex) {
+      FirstIndex = AllocateIndices(idx, (PD::ptr)this);
+      IndexCountMax = idx;
+    } else {
+      ExpandIndices(idx, (PD::ptr)this);
+      IndexCountMax += idx;
+    }
+  }
 
-  Command& AddIdx(const u16& idx) {
-    IndexBuffer.Add(VertexBuffer.Size() + idx);
+  void Reset() {
+    Layer = 0;
+    Tex = 0;
+    FirstIndex = 0;
+    FirstVertex = 0;
+    IndexCount = 0;
+    VertexCount = 0;
+    VertexCountMax = 0;
+    IndexCountMax = 0;
+  }
+
+  Command& Add(const Vertex& vtx) {
+    if (VertexCount <= VertexCountMax)
+      PutVertex(FirstVertex + VertexCount++, vtx, (PD::ptr)this);
+    return *this;
+  }
+  Command& Add(u16 idx) {
+    if (IndexCount <= IndexCountMax)
+      PutIndex(FirstIndex + IndexCount++, VertexCount + idx, (PD::ptr)this);
+    return *this;
+  }
+  Command& Add(u16 a, u16 b, u16 c) {
+    if (IndexCount + 3 <= IndexCountMax) {
+      size_t idx = FirstIndex + IndexCount;
+      PutIndex(idx + 0, VertexCount + a, (PD::ptr)this);
+      PutIndex(idx + 1, VertexCount + b, (PD::ptr)this);
+      PutIndex(idx + 2, VertexCount + c, (PD::ptr)this);
+      IndexCount += 3;
+    }
     return *this;
   }
 
-  Command& AddVtx(const Vertex& v) {
-    VertexBuffer.Add(std::move(v));
-    return *this;
-  }
-
-  PD::Vec<Vertex> VertexBuffer;
-  PD::Vec<u16> IndexBuffer;
-  ivec4 ScissorRect;
-  bool ScissorOn = false;
-  int Layer;
-  int Index;
-  Texture::Ref Tex;
+  int Layer = 0;
+  ptr Tex = 0;
+  size_t FirstVertex = 0;
+  size_t FirstIndex = 0;
+  size_t VertexCount = 0;
+  size_t IndexCount = 0;
+  // Todo: implement
+  size_t VertexCountMax = 0;
+  size_t IndexCountMax = 0;
 };
 }  // namespace Li
 }  // namespace PD

include/pd/lithium/drawlist.hpp

@@ -1,201 +1,121 @@
-#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>
-
-/** Path Rect Flags */
-using LiPathRectFlags = PD::u32;
-
-/** Setup for everything (oder so) */
-enum LiPathRectFlags_ : PD::u32 {
-  LiPathRectFlags_None = 0,
-  LiPathRectFlags_KeepTopLeft = PD_BIT(0),
-  LiPathRectFlags_KeepTopRight = PD_BIT(1),
-  LiPathRectFlags_KeepBotRight = PD_BIT(2),
-  LiPathRectFlags_KeepBotLeft = PD_BIT(3),
-  LiPathRectFlags_KeepTop = PD_BIT(0) | PD_BIT(1),
-  LiPathRectFlags_KeepBot = PD_BIT(2) | PD_BIT(3),
-  LiPathRectFlags_KeepLeft = PD_BIT(0) | PD_BIT(3),
-  LiPathRectFlags_KeepRight = PD_BIT(1) | PD_BIT(2),
-};
-
-namespace PD {
-namespace Li {
-class PD_LITHIUM_API DrawList {
- public:
-  DrawList() { DrawSolid(); }
-  ~DrawList() { pDrawList.clear(); }
-
-  /** Require Copy and Move Constructors */
-
-  DrawList(const DrawList&) = delete;
-  DrawList& operator=(const DrawList&) = delete;
-
-  DrawList(DrawList&&) noexcept = default;
-  DrawList& operator=(DrawList&&) noexcept = default;
-
-  PD_SHARED(DrawList);
-
-  /**
-   * Append an input drawlist on top of this one
-   * This Function will clear the Input list to make sure
-   * THat the moved memory blocks don't get used
-   * @param list DrawList to move into current
-   */
-  void Merge(DrawList::Ref list);
-
-  Command::Ref PreGenerateCmd();
-  void AddCommand(Command::Ref v);
-  void Clear();
-
-  void SetFont(Font::Ref font) { pCurrentFont = font; }
-  void SetFontScale(float scale) { pFontScale = scale; }
-
-  void DrawSolid();
-  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);
-  /**
-   * Extended Draw Text Function
-   */
-  void DrawTextEx(const fvec2& p, const std::string& text, u32 color,
-                  LiTextFlags flags, fvec2 box = fvec2(0.f));
-  void DrawLine(const fvec2& a, const fvec2& b, u32 color, int t = 1);
-  /**
-   * 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);
-  void PathFastArcToN(const fvec2& c, float r, float amin, float amax, int s);
-  /// @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
-  void PathRect(fvec2 a, fvec2 b, float rounding = 0.f);
-  /// @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 PathRectEx(fvec2 a, fvec2 b, float rounding = 0.f, u32 flags = 0);
-
-  void PushClipRect(const fvec4& cr) { pClipRects.Push(cr); }
-  void PopClipRect() {
-    if (pClipRects.IsEmpty()) {
-      return;
-    }
-    pClipRects.Pop();
-  }
-  /** One linear Clip rect Setup */
-  void pClipCmd(Command* cmd);
-
-  /** Data Section */
-
-  Stack<fvec4> pClipRects;
-  int Layer;
-  float pFontScale = 0.7f;
-  Font::Ref pCurrentFont;
-  Texture::Ref CurrentTex;
-  std::vector<Command::Ref> pDrawList;
-  PD::Vec<fvec2> pPath;
-  u32 pNumIndices = 0;
-  u32 pNumVertices = 0;
-};
-}  // namespace Li
-}  // namespace PD
+#pragma once
+
+#include <pd/lithium/command.hpp>
+#include <pd/lithium/font.hpp>
+#include <pd/lithium/texture.hpp>
+
+using LiPathRectFlags = PD::u32;
+
+enum LiPathRectFlags_ : PD::u32 {
+  LiPathRectFlags_None = 0,
+  LiPathRectFlags_KeepTopLeft = 1 << 0,
+  LiPathRectFlags_KeepTopRight = 1 << 1,
+  LiPathRectFlags_KeepBotRight = 1 << 2,
+  LiPathRectFlags_KeepBotLeft = 1 << 3,
+  LiPathRectFlags_KeepTop =
+      LiPathRectFlags_KeepTopLeft | LiPathRectFlags_KeepTopRight,
+  LiPathRectFlags_KeepBot =
+      LiPathRectFlags_KeepBotLeft | LiPathRectFlags_KeepBotRight,
+  LiPathRectFlags_KeepLeft =
+      LiPathRectFlags_KeepTopLeft | LiPathRectFlags_KeepBotLeft,
+  LiPathRectFlags_KeepRight =
+      LiPathRectFlags_KeepTopRight | LiPathRectFlags_KeepBotRight,
+};
+
+using LiDrawFlags = PD::u32;
+enum LiDrawFlags_ : PD::u32 {
+  LiDrawFlags_None = 0,
+  LiDrawFlags_Close = 1 << 0,
+  LiDrawFlags_AA = 1 << 1,
+};
+
+namespace PD {
+namespace Li {
+class PD_API Drawlist {
+ public:
+  Drawlist();
+  ~Drawlist();
+
+  /** Baisc */
+
+  void Merge(Drawlist& other);
+  void Copy(Drawlist& other);
+  void Optimize();
+  void Clear();
+
+  /** Command Allocation */
+  Command& NewCommand();
+
+  /** Path API */
+  void PathAdd(const fvec2& point) { pPath.Push(point); }
+  void PathAdd(float x, float y) { pPath.Push(fvec2(x, y)); }
+  void PathClear() { pPath.Reset(); }
+  /**
+   * @brief Reserve memory for the next PathAdd uses
+   * @note As path will autoexpant and keep the size this func is
+   *       only for special use cases
+   */
+  void PathReserve(size_t num) { pPath.ExpandIf(num); }
+  void PathStroke(const PD::Color& color, int t = 1,
+                  LiDrawFlags flags = LiDrawFlags_None);
+  void PathFill(const PD::Color& color);
+  void PathFillGradient(const PD::Color& a, const PD::Color& b,
+                        float rad = 0.f);
+  void PathArcToN(const fvec2& c, float r, float amin, float amax, int s);
+  void PathFastArcToN(const fvec2& c, float r, float amin, float amax, int s);
+  void PathRect(const fvec2& tl, const fvec2& br, float r = 0.f);
+  void PathRectEx(const fvec2& tl, const fvec2& br, float r = 0.f,
+                  LiPathRectFlags flags = LiPathRectFlags_None);
+
+  /** Texture Handling */
+  void BindTexture(const Texture& tex);
+  void UnbindTexture() { pCurrentTexture = Texture(); }
+
+  /** Font Handling */
+  void SetFont(Font* font) { pFont = font; }
+  void SetFontscale(float fontscale = 1.f) { pFontScale = fontscale; }
+  const float& GetFontScale() const { return pFontScale; }
+
+  /** Data geters */
+  const Pool<Command>& Data() const { return pCommands; }
+  operator const Pool<Command>&() const { return pCommands; }
+
+  /** Drawing functions */
+  void DrawRect(const fvec2& pos, const fvec2& size, const PD::Color& color,
+                int t = 1);
+  void DrawRectFilled(const fvec2& pos, const fvec2& size,
+                      const PD::Color& color);
+  void DrawTriangle(const fvec2& a, const fvec2& b, const fvec2& c,
+                    const PD::Color& color, int t = 1);
+  void DrawTriangleFilled(const fvec2& a, const fvec2& b, const fvec2& c,
+                          const PD::Color& color);
+  void DrawCircle(const fvec2& center, float rad, const PD::Color& color,
+                  int num_segments, int t = 1);
+  void DrawCircleFilled(const fvec2& center, float rad, const PD::Color& color,
+                        int num_segments);
+  void DrawText(const fvec2& p, const char* text, const PD::Color& color);
+  void DrawTextEx(const fvec2& p, const char* text, const PD::Color& color,
+                  LiTextFlags flags, const fvec2& box = fvec2(0.f));
+
+  void DrawPolyLine(const Pool<fvec2>& points, const PD::Color& color,
+                    LiDrawFlags flags = LiDrawFlags_None, int t = 1);
+  void DrawConvexPolyFilled(const Pool<fvec2>& points, const PD::Color& color);
+  void DrawConvexPolyFilled(const Pool<fvec2>& points, const PD::Color& a,
+                            const PD::Color b, float rad = 0.f);
+
+  void PrimQuad(Command& cmd, const Rect& quad, const Rect& uv,
+                const PD::Color& color);
+  void PrimTriangle(Command& cmd, const fvec2& a, const fvec2& b,
+                    const fvec2& c, const PD::Color& color);
+
+ private:
+  Texture pCurrentTexture;
+  Pool<Command> pCommands;
+  Pool<fvec2> pPath;
+  Pool<Vertex> pVertices;
+  Pool<u16> pIndices;
+  Font* pFont = nullptr;
+  float pFontScale = 1.f;
+};
+}  // namespace Li
+}  // namespace PD

include/pd/lithium/font.hpp

@@ -1,116 +1,108 @@
-#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/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 {
-class PD_LITHIUM_API Font {
- public:
-  /** Codepoint Data holder */
-  struct Codepoint {
-    u32 pCodepoint = 0;
-    fvec4 SimpleUV;
-    Texture::Ref Tex;
-    fvec2 Size;
-    float Offset = 0.f;
-    bool pInvalid = false;
-  };
-
-  /** Constructore doesnt need Backand anymore */
-  Font() = default;
-  ~Font() = default;
-
-  PD_SHARED(Font);
-
-  /**
-   * 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);
-  /**
-   * Load a TTF File from Memory
-   * @param data File data
-   * @param px_height Pixelheight of the codepoints (limit by 64)
-   */
-  void LoadTTF(const std::vector<u8>& data, int px_height = 32);
-  /**
-   * Function that loads a default integrated font...
-   * This will only work if PD_LI_INCLUDE_FONTS was set
-   * on lithium build cause otherwise the font data is not included
-   */
-  void LoadDefaultFont(int id = 0, int pixel_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(std::vector<Command::Ref>& cmds, const fvec2& pos, u32 color,
-                 float scale, const std::string& text, LiTextFlags flags = 0,
-                 const fvec2& box = 0);
-  /**
-   * Utility function to create a font atlas
-   * During TTF loading (Internal and should not be called)
-   */
-  void pMakeAtlas(bool final, std::vector<u8>& font_tex, int texszs,
-                  PD::Li::Texture::Ref tex);
-
-  /** Data Section */
-  int PixelHeight;
-  int DefaultPixelHeight = 24;
-  std::vector<Texture::Ref> Textures;
-  /**
-   * 32Bit Codepoint Dataholder reference map
-   * **Now using unordered map**
-   */
-  std::unordered_map<u32, Codepoint> CodeMap;
-};
-}  // namespace Li
+#pragma once
+
+#include <pd/lithium/texture.hpp>
+
+using LiTextFlags = PD::u32;
+enum LiTextFlags_ : PD::u32 {
+  LiTextFlags_None = 0,             ///< Do nothing
+  LiTextFlags_AlignRight = 1 << 0,  ///< Align Right of position
+  LiTextFlags_AlignMid = 1 << 1,    ///< Align in the middle of pos and box
+  LiTextFlags_Shaddow = 1 << 2,     ///< Draws the text twice to create shaddow
+  LiTextFlags_Wrap = 1 << 3,        ///< Wrap Text: May be runs better with TMS
+  LiTextFlags_Short = 1 << 4,       ///< Short Text: May be runs better with TMS
+  LiTextFlags_Scroll = 1 << 5,      ///< Not implemented [scoll text if to long]
+  LiTextFlags_NoOOS = 1 << 6,       ///< No Out of Screen Rendering
+};
+
+namespace PD {
+namespace Li {
+class Drawlist;
+class PD_API Font {
+ public:
+  struct Codepoint {
+    u32 pCodepoint = 0;
+    fvec4 SimpleUV;
+    size_t Tex = 0;
+    fvec2 Size;
+    float Offset = 0.f;
+    bool pInvalid = false;
+  };
+  Font() {}
+  ~Font() {}
+
+  /**
+   * 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);
+  /**
+   * Load a TTF File from Memory
+   * @param data File data
+   * @param px_height Pixelheight of the codepoints (limit by 64)
+   */
+  void LoadTTF(const std::vector<u8>& data, int px_height = 32);
+  /**
+   * Function that loads a default integrated font...
+   * This will only work if PD_LI_INCLUDE_FONTS was set
+   * on lithium build cause otherwise the font data is not included
+   */
+  void LoadDefaultFont(int id = 0, int pixel_height = 32);
+  /**
+   * Getter for Codepoint reference
+   * @return codepoint dataholder reference
+   */
+  Codepoint& GetCodepoint(u32 c);
+
+  /**
+   * Get Text Bounding Box
+   */
+  fvec2 GetTextBounds(const char* text, float scale);
+  /**
+   * Extended Draw Text Function that vreates a Command List
+   */
+  void CmdTextEx(Drawlist& dl, const fvec2& pos, u32 color, float scale,
+                 const char* text, LiTextFlags flags = 0, const fvec2& box = 0);
+
+  /**
+   * Cleanup Font and unload Textures
+   */
+  void Delete();
+
+  /**
+   * Garbage collection for TextMapSystem
+   */
+  void CleanupTMS();
+  /**
+   * Utility function to create a font atlas
+   * During TTF loading (Internal and should not be called)
+   */
+  void BakeAndPush(bool final, std::vector<u8>& font_tex, int texszs);
+  std::string pWrapText(const std::string& txt, float scale,
+                        const PD::fvec2& max, PD::fvec2& dim);
+  std::string pShortText(const std::string& txt, float scale,
+                         const PD::fvec2& max, PD::fvec2& dim);
+
+  /** Data Section */
+  int PixelHeight = 0;
+  int DefaultPixelHeight = 32;
+  std::vector<TextureID> Textures;
+  /**
+   * 32Bit Codepoint Dataholder reference map
+   * **Now using unordered map**
+   */
+  std::unordered_map<u32, Codepoint> CodeMap;
+  /** TMS */
+  struct TMELEM {
+    PD::u32 ID;
+    PD::fvec2 Size;
+    std::string Text;
+    u64 TimeStamp;
+  };
+  std::unordered_map<u32, TMELEM> pTMS;
+
+ private:
+  size_t pCurrentTex = 0;
+};
+}  // namespace Li
 }  // namespace PD

include/pd/lithium/fonts.hpp

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

include/pd/lithium/formatters.hpp

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