Add a Drag Slider to UI7

.clang-format

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

.clangd

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

.gitattributes

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

.gitignore

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

.gitmodules

@@ -1,12 +1,6 @@
-[submodule "vendor/stb"]
+[submodule "backends/desktop/glfw"]
-	path = vendor/stb
+	path = backends/desktop/glfw
-	url = https://github.com/nothings/stb.git
+	url = https://github.com/glfw/glfw
-[submodule "vendor/glfw"]
+[submodule "backends/3ds/libpicasso"]
-	path = vendor/glfw
+	path = backends/3ds/libpicasso
-	url = https://github.com/glfw/glfw.git
+	url = https://github.com/npid7/libpicasso
-[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,184 +1,36 @@
 cmake_minimum_required(VERSION 3.22)
 
-include(GNUInstallDirs)
-
 # Set Project
-project(palladium LANGUAGES C CXX VERSION 0.7.0)
+project(palladium LANGUAGES C CXX VERSION 0.6.0)
 
 # Required to add this Variable
 set(PD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 include(cmake/palladium.cmake)
 
 option(PD_BUILD_TESTS "Sets if TestApp and TestBench get build" OFF)
-option(PD_BUILD_SHARED "Build Shared Library" OFF)
+option(PD_BUILD_SHARED "Build Shared Libraries" 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()
 
-add_subdirectory(vendor)
+## Include Library Source
 
-# # Include Library Source
+add_subdirectory(pd/drivers)
-set(PD_SOURCES
+add_subdirectory(pd/core)
-    # Common
+add_subdirectory(pd/image)
-    source/common.cpp
+add_subdirectory(pd/external)
+add_subdirectory(pd/lithium)
+add_subdirectory(pd/ui7)
 
-    # Core
+add_library(palladium INTERFACE)
-    source/core/bits.cpp
+target_link_libraries(palladium INTERFACE
-    source/core/color.cpp
+    pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
-    source/core/io.cpp
-    source/core/mat.cpp
-    source/core/strings.cpp
-    source/core/timer.cpp
-    source/core/timetrace.cpp
-
-    # Image
-    source/image/convert.cpp
-    source/image/image.cpp
-
-    # Drivers
-    source/drivers/os.cpp
-    source/drivers/gfx.cpp
-    source/drivers/hid.cpp
-
-    # Lithium
-    source/lithium/command.cpp
-    source/lithium/drawlist.cpp
-    source/lithium/font.cpp
-    source/lithium/math.cpp
-    source/lithium/pools.cpp
-
-    # UI7
-    source/ui7/io.cpp
-    source/ui7/layout.cpp
-    source/ui7/menu.cpp
-    source/ui7/theme.cpp
-    source/ui7/ui7.cpp
-    source/ui7/container/button.cpp
-    source/ui7/container/checkbox.cpp
-    source/ui7/container/coloredit.cpp
-    source/ui7/container/container.cpp
-    source/ui7/container/dragdata.cpp
-    source/ui7/container/dynobj.cpp
-    source/ui7/container/image.cpp
-    source/ui7/container/label.cpp
-    source/ui7/container/slider.cpp
-
-    # Ultra
-    source/ultra/canvas.cpp
-    source/ultra/layout.cpp
-    source/ultra/elems/element.cpp
-    source/ultra/elems/rect.cpp
-    source/ultra/elems/text.cpp
-    source/ultra/elems/image.cpp
-    source/ultra/elems/button.cpp
 )
 
-if(${PD_BUILD_SHARED})
+add_dependencies(palladium
-    add_library(palladium SHARED ${PD_SOURCES})
+    pd-drivers pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
-    target_compile_definitions(palladium PRIVATE PD_BUILD_SHARED)
-else()
-    add_library(palladium STATIC ${PD_SOURCES})
-    target_compile_definitions(palladium PUBLIC PD_BUILD_STATIC)
-endif()
-
-target_link_libraries(palladium
-    PUBLIC stb
 )
 
-target_compile_definitions(palladium
+install(DIRECTORY include DESTINATION ".")
-    PUBLIC
-    PD_DEBUG
-    $<$<OR:$<BOOL:${PD_INCLUDE_STB_IMAGE}>,$<BOOL:${PD_BUILD_SHARED}>>:PD_INCLUDE_STB_IMAGE> # Always on in shared build
-)
-target_compile_options(palladium
-    PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
-    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/source=source
-    -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/include=include
-    >
-)
-
-add_library(palladium::palladium ALIAS palladium)
-
-target_include_directories(palladium
-    PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:include>
-)
-
-target_compile_options(palladium
-    PRIVATE
-    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:GNU,Clang>>:-O0 -g>
-    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU,Clang>>:-O3>
-
-    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:MSVC>>:/Od /Zi>
-    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:MSVC>>:/O2>
-)
-
-install(
-    TARGETS palladium
-    EXPORT palladiumTargets
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
-install(
-    DIRECTORY include/
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-)
-install(EXPORT palladiumTargets
-    FILE palladiumTargets.cmake
-    NAMESPACE palladium::
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
-)
-
-include(CMakePackageConfigHelpers)
-configure_package_config_file(
-    cmake/palladiumConfig.cmake.in
-    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
-    INSTALL_DESTINATION
-    ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
-)
-
-write_basic_package_version_file(
-    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
-    VERSION
-    ${PROJECT_VERSION}
-    COMPATIBILITY
-    SameMajorVersion
-)
-
-install(
-    FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
-    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
-)
-
-find_program(CLANG_FORMAT clang-format)
-
-file(GLOB_RECURSE PD_FMTFILES
-    CONFIGURE_DEPENDS
-    ${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/backends/source/*.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/backends/include/*.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/tests/core/source/*.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/tests/gfx/source/*.cpp
-)
-
-add_custom_target(pd-clang-format
-    COMMAND ${CLANG_FORMAT} --style=file -i ${PD_FMTFILES}
-    COMMENT "Formatting Project Sources"
-)
-
-add_subdirectory(backends)
-if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tests)
-endif()

CMakePresets.json

@@ -1,14 +0,0 @@
-{
-    "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 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

backends/3ds/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.22)
+
+project(pd-3ds LANGUAGES CXX VERSION 0.6.0)
+
+set(SRC
+    source/bknd-gfx.cpp
+    source/bknd-hid.cpp
+    source/pd-3ds.cpp
+)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/libpicasso)
+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 pica::pica)

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

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

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

@@ -0,0 +1,61 @@
+#pragma once
+
+/*
+MIT License
+
+Copyright (c) 2024 - 2025 tobid7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <3ds.h>
+#include <citro3d.h>
+
+#include <pd-3ds/linearAllocator.hpp>
+#include <pd/lithium/lithium.hpp>
+
+namespace PD {
+class GfxC3D : public GfxDriver {
+ public:
+  GfxC3D() : GfxDriver("Citro3D") {}
+  ~GfxC3D() = default;
+
+  PD_SHARED(GfxC3D);
+
+  void Init() override;
+  void Deinit() override;
+  void NewFrame() override;
+  void BindTex(PD::Li::TexAddress addr) override;
+  void RenderDrawData(const PD::Li::CmdPool& 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;
+  void DestroyTex(PD::Li::Texture::Ref tex) override;
+
+  std::vector<Li::Vertex, LinearAllocator<Li::Vertex>> VertexBuffer;
+  std::vector<u16, LinearAllocator<u16>> IndexBuffer;
+  int pLocProjection = 0;
+  DVLB_s* ShaderCode;
+  shaderProgram_s Shader;
+  C3D_AttrInfo ShaderInfo;
+  std::vector<u8> pRawShader;
+};
+}  // namespace PD

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

@@ -1,54 +1,39 @@
-#pragma once
+#pragma once
-
+
-/*
+/*
-MIT License
+MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
-
+Copyright (c) 2024 - 2025 tobid7
-Permission is hereby granted, free of charge, to any person obtaining a copy
+
-of this software and associated documentation files (the "Software"), to deal
+Permission is hereby granted, free of charge, to any person obtaining a copy
-in the Software without restriction, including without limitation the rights
+of this software and associated documentation files (the "Software"), to deal
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+in the Software without restriction, including without limitation the rights
-copies of the Software, and to permit persons to whom the Software is
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-furnished to do so, subject to the following conditions:
+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 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,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- */
+SOFTWARE.
-
+ */
-#include <pd/common.hpp>
+
-
+#include <pd/drivers/drivers.hpp>
-namespace PD {
+
-namespace Std {
+namespace PD {
-template <typename T>
+class Hid3DS : public HidDriver {
-class Vector {
+ public:
- public:
+  Hid3DS();
-  // for c++ std stuff
+  ~Hid3DS() = default;
-  using value_type = T;
+
-  using iterator = value_type*;
+  PD_SHARED(Hid3DS);
-  using const_iterator = const value_type*;
+
-
+  void Update() override;
-  Vector() {
+};
-    Size = 0;
-    Cap = 0;
-    Data = nullptr;
-  }
-  ~Vector() {
-    if (Data) {
-      delete Data;
-    }
-  }
-
-  T* Data = nullptr;
-  size_t Size = 0;
-  size_t Cap = 0;
-};
-}  // namespace Std
 }  // namespace PD

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

@@ -1,12 +1,8 @@
 #pragma once
 
-#ifdef __3DS__
 #include <3ds.h>
-#endif
 
-#include <limits>
+#include <pd/core/common.hpp>
-#include <memory>
-#include <stdexcept>
 
 // Custom C++ Allocator class to interface with libctru linear heap memory
 // based on this guide:
@@ -25,17 +21,9 @@ class LinearAllocator {
     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) {
@@ -54,14 +42,8 @@ class 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/3ds/source/bknd-gfx.cpp

@@ -0,0 +1,270 @@
+/*
+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 <pica.hpp>
+
+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
+)";
+
+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 FragCfg(GPU_TEXCOLOR clr) {
+  C3D_DepthTest(false, GPU_GREATER, GPU_WRITE_ALL);
+  C3D_TexEnv* env = C3D_GetTexEnv(0);
+  C3D_TexEnvInit(env);
+  switch (clr) {
+    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 GfxC3D::Init() {
+  VertexBuffer.resize(4 * 8192);
+  IndexBuffer.resize(6 * 8192);
+
+  Flags |= LiBackendFlags_FlipUV_Y;
+
+  pRawShader = Pica::AssembleCode(LIShaderCTR);
+  ShaderCode = DVLB_ParseFile((uint32_t*)&pRawShader[0], pRawShader.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 PD::Li::CmdPool& Commands) {
+  shaderProgramUse(&Shader);
+  C3D_SetAttrInfo(&ShaderInfo);
+  C3D_Mtx proj;
+  Mtx_OrthoTilt(&proj, 0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f, false);
+  C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, pLocProjection, &proj);
+  // 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);
+  size_t index = 0;
+  while (index < Commands.Size()) {
+    PD::Li::Texture::Ref Tex = Commands.GetCmd(index)->Tex;
+    if (!Tex) {
+      index++;
+      continue;
+    }
+    bool ScissorEnabled = Commands.GetCmd(index)->ScissorOn;
+    ivec4 ScissorRect = Commands.GetCmd(index)->ScissorRect;
+    size_t StartIndex = CurrentIndex;
+
+    while (index < Commands.Size() && Commands.GetCmd(index)->Tex == Tex &&
+           Commands.GetCmd(index)->ScissorOn == ScissorEnabled &&
+           Commands.GetCmd(index)->ScissorRect == ScissorRect) {
+      auto c = Commands.GetCmd(index);
+      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);
+    }
+    FragCfg(((C3D_Tex*)Tex->Address)->fmt);
+    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;
+}
+
+void GfxC3D::DestroyTex(PD::Li::Texture::Ref tex) {
+  C3D_Tex* t = reinterpret_cast<C3D_Tex*>(tex->Address);
+  C3D_TexDelete(t);
+  delete t;
+  tex->Address = 0;
+}
+}  // namespace PD

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

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

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

@@ -0,0 +1,132 @@
+/*
+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 <palladium>
+#include <pd-3ds.hpp>
+
+namespace PD {
+PD::Li::Font::Ref LoadSystemFont() {
+  TT::Scope st("LI_SystemFont");  // Trace loading time
+  Li::Font::Ref ret = Li::Font::New();
+  fontEnsureMapped();  // Call this to be sure the font is mapped
+  // Get some const references for system font loading
+  const auto fnt = fontGetSystemFont();
+  const auto fnt_info = fontGetInfo(fnt);
+  const auto glyph_info = fontGetGlyphInfo(fnt);
+  // Resize the Texture list by the num of sysfont textures
+  ret->Textures.resize(glyph_info->nSheets + 1);
+  /// Modify the Pixel Height by 1.1f to fit the
+  /// Size og ttf font Rendering
+  ret->PixelHeight = glyph_info->cellHeight;
+  // Load the Textures and make sure they don't auto unload
+  for (size_t i = 0; i < glyph_info->nSheets; i++) {
+    auto stex = Li::Texture::New();
+    auto tx = new C3D_Tex;
+    tx->data = fontGetGlyphSheetTex(fnt, i);
+    tx->fmt = (GPU_TEXCOLOR)glyph_info->sheetFmt;
+    tx->size = glyph_info->sheetSize;
+    tx->width = glyph_info->sheetWidth;
+    tx->height = glyph_info->sheetHeight;
+    tx->param = GPU_TEXTURE_MAG_FILTER(GPU_LINEAR) |
+                GPU_TEXTURE_MIN_FILTER(GPU_LINEAR) |
+                GPU_TEXTURE_WRAP_S(GPU_REPEAT) | GPU_TEXTURE_WRAP_T(GPU_REPEAT);
+    tx->border = 0xffffffff;
+    tx->lodParam = 0;
+    stex->Address = (Li::TexAddress)tx;
+    stex->Size = fvec2(tx->width, tx->height);
+    stex->UV = fvec4(0, 1, 1, 0);
+    ret->Textures[i] = stex;
+  }
+  std::vector<unsigned int> charSet;
+  // Write the Charset into a vector
+  for (auto cmap = fnt_info->cmap; cmap; cmap = cmap->next) {
+    if (cmap->mappingMethod == CMAP_TYPE_DIRECT) {
+      if (cmap->codeEnd >= cmap->codeBegin) {
+        charSet.reserve(charSet.size() + cmap->codeEnd - cmap->codeBegin + 1);
+        for (auto i = cmap->codeBegin; i <= cmap->codeEnd; ++i) {
+          if (cmap->indexOffset + (i - cmap->codeBegin) == 0xFFFF) break;
+          charSet.emplace_back(i);
+        }
+      }
+    } else if (cmap->mappingMethod == CMAP_TYPE_TABLE) {
+      if (cmap->codeEnd >= cmap->codeBegin) {
+        charSet.reserve(charSet.size() + cmap->codeEnd - cmap->codeBegin + 1);
+        for (auto i = cmap->codeBegin; i <= cmap->codeEnd; ++i) {
+          if (cmap->indexTable[i - cmap->codeBegin] == 0xFFFF) continue;
+          charSet.emplace_back(i);
+        }
+      }
+    } else if (cmap->mappingMethod == CMAP_TYPE_SCAN) {
+      charSet.reserve(charSet.size() + cmap->nScanEntries);
+      for (unsigned i = 0; i < cmap->nScanEntries; ++i) {
+        if (cmap->scanEntries[i].code >= cmap->codeBegin &&
+            cmap->scanEntries[i].code <= cmap->codeEnd) {
+          if (cmap->scanEntries[i].glyphIndex != 0xFFFF) {
+            charSet.emplace_back(cmap->scanEntries[i].code);
+          }
+        }
+      }
+    } else {
+      continue;
+    }
+  }
+
+  // Sort the charset and make sure all values are unique
+  std::sort(charSet.begin(), charSet.end());
+  charSet.erase(std::unique(charSet.begin(), charSet.end()));
+
+  // Setup the Codepoint map by the charset
+  for (auto cp : charSet) {
+    int gidx = fontGlyphIndexFromCodePoint(fnt, cp);
+    if (gidx >= 0xFFFF) continue;
+    Li::Font::Codepoint codepoint;
+    fontGlyphPos_s dat;
+    fontCalcGlyphPos(&dat, fnt, gidx, GLYPH_POS_CALC_VTXCOORD, 1.f, 1.f);
+
+    codepoint.pCodepoint = cp;
+    codepoint.SimpleUV = fvec4(dat.texcoord.left, dat.texcoord.top,
+                               dat.texcoord.right, dat.texcoord.bottom);
+
+    if (dat.sheetIndex < (int)ret->Textures.size()) {
+      codepoint.Tex = ret->Textures[dat.sheetIndex];
+    } else {
+      codepoint.pInvalid = true;
+    }
+    codepoint.Size = fvec2(dat.vtxcoord.right, dat.vtxcoord.bottom);
+    codepoint.Offset = 0;
+    ret->CodeMap[cp] = codepoint;
+  }
+  return ret;
+}
+
+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

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

backends/README.md

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

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

backends/desktop/glad/CMakeLists.txt

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

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

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

backends/desktop/include/pd-desktop.hpp

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

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

@@ -1,6 +1,9 @@
+#pragma once
+
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,32 +24,39 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/core/timer.hpp>
+#include <glad/glad.h>
+
+/** SEPARATOR */
+#include <GLFW/glfw3.h>
+/** SEPARATOR */
+
+#include <pd/lithium/lithium.hpp>
 
 namespace PD {
-PD_API Timer::Timer(bool autostart) {
+class GfxGL2 : public GfxDriver {
-  pIsRunning = autostart;
+ public:
-  Reset();
+  GfxGL2() : GfxDriver("OpenGL2") {}
-}
+  ~GfxGL2() = default;
 
-PD_API void Timer::Reset() {
+  PD_SHARED(GfxGL2);
-  pStart = std::chrono::duration_cast<std::chrono::milliseconds>(
-               std::chrono::steady_clock::now().time_since_epoch())
-               .count();
-  pNow = pStart;
-}
 
-PD_API void Timer::Update() {
+  void Init() override;
-  if (pIsRunning) {
+  void Deinit() override;
-    pNow = std::chrono::duration_cast<std::chrono::milliseconds>(
+  void NewFrame() override;
-               std::chrono::steady_clock::now().time_since_epoch())
+  void BindTex(PD::Li::TexAddress addr) override;
-               .count();
+  void RenderDrawData(const Li::CmdPool& 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_API void Timer::Pause() { pIsRunning = false; }
+  std::vector<Li::Vertex> VertexBuffer;
-PD_API void Timer::Rseume() { pIsRunning = true; }
+  std::vector<PD::u16> IndexBuffer;
-PD_API bool Timer::IsRunning() const { return pIsRunning; }
+  GLuint Shader;
-PD_API u64 Timer::Get() { return pNow - pStart; }
+  GLuint pLocProjection;
-PD_API double Timer::GetSeconds() { return (double)Get() / 1000.0; }
+  GLuint pLocTex;
+  GLuint pLocAlfa;
+  GLuint VBO, IBO;
+};
 }  // namespace PD

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

@@ -0,0 +1,73 @@
+#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 GLFWcharfun pOldTextCB;
+  static std::string* pText;
+  bool pInTextMode = false;
+  PD::u64 pLastUpdate = 0;
+  std::unordered_map<KbKey, u64> pTimings;
+};
+}  // namespace PD

backends/desktop/source/bknd-gfx.cpp

@@ -0,0 +1,265 @@
+/*
+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;
+  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;
+    }
+  }
+  )";
+
+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");
+  pLocAlfa = glGetUniformLocation(Shader, "alfa");
+  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);
+  GLint fmt = 0;
+  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
+  glUniform1i(pLocAlfa, fmt == GL_ALPHA);
+}
+
+void GfxGL2::RenderDrawData(const Li::CmdPool& Commands) {
+  size_t index = 0;
+  while (index < Commands.Size()) {
+    PD::Li::Texture::Ref Tex = Commands.GetCmd(index)->Tex;
+    if (!Tex) {
+      index++;
+      continue;
+    }
+    size_t StartIndex = CurrentIndex;
+    bool ScissorOn = Commands.GetCmd(index)->ScissorOn;
+    ivec4 ScissorRect = Commands.GetCmd(index)->ScissorRect;
+
+    while (index < Commands.Size() && Commands.GetCmd(index)->Tex == Tex &&
+           Commands.GetCmd(index)->ScissorOn == ScissorOn &&
+           Commands.GetCmd(index)->ScissorRect == ScissorRect) {
+      auto c = Commands.GetCmd(index);
+      for (size_t i = 0; i < c->IndexBuffer.size(); i++) {
+        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.at(i);
+      }
+      for (size_t i = 0; i < c->VertexBuffer.size(); i++) {
+        VertexBuffer[CurrentVertex++] = c->VertexBuffer.at(i);
+      }
+      index++;
+    }
+    if (ScissorOn) {
+      glScissor(ScissorRect.x, ViewPort.y - (ScissorRect.y + ScissorRect.w),
+                ScissorRect.z, ScissorRect.w);
+      glEnable(GL_SCISSOR_TEST);
+    } else {
+      glDisable(GL_SCISSOR_TEST);
+    }
+    BindTex(Tex->Address);
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
+                 &VertexBuffer[0], GL_DYNAMIC_DRAW);
+    // For some reason we need to set these every frame for every buffer
+    // Found that out when creating My 3d Engine
+    SetupShaderAttribs(Shader);
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
+                 &IndexBuffer[0], GL_DYNAMIC_DRAW);
+
+    glDrawElements(GL_TRIANGLES, CurrentIndex - StartIndex, GL_UNSIGNED_SHORT,
+                   (void*)(StartIndex * sizeof(PD::u16)));
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    BindTex(0);
+  }
+}
+
+PD::Li::Texture::Ref GfxGL2::LoadTex(const std::vector<PD::u8>& pixels, int w,
+                                     int h, PD::Li::Texture::Type type,
+                                     PD::Li::Texture::Filter filter) {
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  if (type == PD::Li::Texture::Type::RGB24) {
+    fmt = GL_RGB;
+  } else if (type == PD::Li::Texture::Type::A8) {
+    fmt = GL_ALPHA;
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+  if (filter == PD::Li::Texture::Filter::LINEAR) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == PD::Li::Texture::Filter::NEAREST) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  }
+  glBindTexture(GL_TEXTURE_2D, 0);
+  auto res = PD::Li::Texture::New(texID, PD::ivec2(w, h));
+  return res;
+}
+}  // namespace PD

backends/desktop/source/bknd-hid.cpp

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

backends/desktop/source/pd-desktop.cpp

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

backends/include/pd_system/gfx_citro3d.hpp

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

backends/include/pd_system/gfx_directx9.hpp

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

backends/include/pd_system/gfx_opengl2.hpp

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

backends/include/pd_system/gfx_opengl3.hpp

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

backends/include/pd_system/gl-helper.hpp

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

backends/include/pd_system/hid_3ds.hpp

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

backends/include/pd_system/hid_glfw.hpp

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

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

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

backends/include/pdsystem

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

backends/source/gfx_citro3d.cpp

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

backends/source/gfx_directx9.cpp

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

backends/source/gfx_opengl2.cpp

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

backends/source/gfx_opengl3.cpp

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

backends/source/gl-helper.cpp

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

backends/source/hid_3ds.cpp

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

backends/source/hid_glfw.cpp

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

backends/source/hid_nx.cpp

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

cmake/palladium.cmake

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

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

cmake/presets/3ds.json

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

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

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

@@ -1,37 +0,0 @@
-{
-    "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,30 +1,8 @@
 #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/common.hpp

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

include/pd/core/bit_util.hpp

@@ -1,43 +1,47 @@
-#pragma once
+#pragma once
-
+
-/*
+/*
-MIT License
+MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
-
+Copyright (c) 2024 - 2025 tobid7
-Permission is hereby granted, free of charge, to any person obtaining a copy
+
-of this software and associated documentation files (the "Software"), to deal
+Permission is hereby granted, free of charge, to any person obtaining a copy
-in the Software without restriction, including without limitation the rights
+of this software and associated documentation files (the "Software"), to deal
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+in the Software without restriction, including without limitation the rights
-copies of the Software, and to permit persons to whom the Software is
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-furnished to do so, subject to the following conditions:
+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 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,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- */
+SOFTWARE.
-
+ */
-#include <pd/common.hpp>
+
-
+#include <pd/core/common.hpp>
-namespace PD {
+
-namespace Bits {
+namespace PD {
-/**
+/**
- * Check if a 32 Bit number only set a sigle bit to 1
+ * Binary Utillity Functions
- * @param v 32 bit unsigned int
+ */
- * @return true if its a single bit number
+namespace BitUtil {
- */
+/**
-PD_API bool IsSingleBit(u32 v);
+ * Check if a 32 Bit number only set a sigle bit to 1
-/**
+ * @param v 32 bit unsigned int
- * Get the Next Power of two Number
+ * @return true if its a single bit number
- * @param v Current Number
+ */
- * @return Next Number thats a Pow of 2
+PD_CORE_API bool IsSingleBit(u32 v);
- */
+/**
-PD_API u32 GetPow2(u32 v);
+ * Get the Next Power of two Number
-}  // namespace Bits
+ * @param v Current Number
+ * @return Next Number thats a Pow of 2
+ */
+PD_CORE_API u32 GetPow2(u32 v);
+}  // namespace BitUtil
 }  // namespace PD

include/pd/core/color.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,11 +23,11 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 #include <pd/core/strings.hpp>
 
 namespace PD {
-class PD_API Color {
+class PD_CORE_API Color {
  public:
   /**
    * Default Constructor (all variables are set to 0)
@@ -71,12 +71,6 @@ class PD_API Color {
    */
   constexpr Color(const std::string_view& hex) { Hex(hex); }
 
-  /**
-   * 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
@@ -84,7 +78,7 @@ class PD_API Color {
    */
   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!");
+      throw "[PD] Color: hex string is not rgb or rgba!";
     }
     r = PD::Strings::HexChar2Int(hex[1]) * 16 +
         PD::Strings::HexChar2Int(hex[2]);
@@ -121,20 +115,6 @@ class PD_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)
@@ -160,11 +140,6 @@ class PD_API Color {
    */
   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;
   u8 g;

include/pd/core/common.hpp

@@ -0,0 +1,84 @@
+#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 <list>
+#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_RAW(x)                           \
+  using Ref = x*;                           \
+  template <typename... Args>               \
+  static Ref New(Args&&... args) {          \
+    x* v = new x;                           \
+    new (v) x(std::forward<Args>(args)...); \
+    return v;                               \
+  }                                         \
+  static void Delete(Ref ref) { delete ref; }
+
+#define PD_UNIQUE(x)                                         \
+  using Ref = std::unique_ptr<x>;                            \
+  template <typename... Args>                                \
+  static Ref New(Args&&... args) {                           \
+    return std::make_unique<x>(std::forward<Args>(args)...); \
+  }
+
+#define PD_BIT(x) (1 << x)
+
+namespace PD {
+[[noreturn]] inline void Throw(const std::string& str) {
+  throw std::runtime_error("[PD] " + str);
+}
+/** Types */
+using u8 = unsigned char;
+using u16 = unsigned short;
+using u32 = unsigned int;
+using u64 = unsigned long long;
+}  // namespace PD

include/pd/core/core.hpp

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

include/pd/core/fnv.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 namespace PD {
 /**
@@ -50,21 +50,4 @@ constexpr u64 FNV1A64(std::string_view str) {
   }
   return ret;
 }
-
-namespace Detail {
-template <typename T>
-struct FNV1A {};
-
-template <>
-struct FNV1A<u32> {
-  static constexpr u32 Hash(std::string_view str) { return FNV1A32(str); }
-  static constexpr u32 Hash(const std::string& str) { return FNV1A32(str); }
-};
-
-template <>
-struct FNV1A<u64> {
-  static constexpr u64 Hash(std::string_view str) { return FNV1A64(str); }
-  static constexpr u64 Hash(const std::string& str) { return FNV1A64(str); }
-};
-}  // namespace Detail
 }  // namespace PD

include/pd/core/formatters.hpp

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

include/pd/core/fquat.hpp

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

include/pd/core/hashid.hpp

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

include/pd/core/io.hpp

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

include/pd/core/mat.hpp

@@ -2,7 +2,8 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +24,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 #include <pd/core/vec3.hpp>
 
 namespace PD {
@@ -40,7 +41,7 @@ constexpr float Radians(float v) { return v * (Numbers::Tau / 360.0f); }
  * @note That this is not a full Matrix Library
  */
 
-struct PD_API Mat4 {
+struct PD_CORE_API Mat4 {
   std::array<float, 16> m;
   constexpr Mat4() : m{} {}
   constexpr static Mat4 Diagonal(float x, float y, float z, float w) {
@@ -56,9 +57,21 @@ struct PD_API Mat4 {
   constexpr float* Ptr() { return m.data(); }
   constexpr const float* Ptr() const { return m.data(); }
 
-  constexpr float& operator()(int row, int col) { return m[col * 4 + row]; }
+  constexpr float& operator()(int row, int col) {
-  constexpr float operator()(int row, int col) const {
+#ifdef __3DS__
+    // 3ds is full reverse order iirc
+    return m[row * 4 + (3 - col)];
+#else
     return m[col * 4 + row];
+#endif
+  }
+  constexpr float operator()(int row, int col) const {
+#ifdef __3DS__
+    // 3ds is full reverse order iirc
+    return m[row * 4 + (3 - col)];
+#else
+    return m[col * 4 + row];
+#endif
   }
 
   constexpr Mat4 operator*(const Mat4& v) const {
@@ -97,25 +110,24 @@ struct PD_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;
+#ifdef __3DS__  // Patch to rotate the Matrix correctly
+    ret(0, 1) = 2.f / (t - b);
+    ret(0, 3) = (b + t) / (b - t);
+    ret(1, 0) = 2.f / (l - r);
+    ret(1, 3) = (l + r) / (r - l);
+    ret(2, 2) = 1.f / (n - f);
+    ret(2, 3) = 0.5f * (n + f) / (n - f) - 0.5f;
+#else
     ret(0, 0) = 2.0f / (r - l);
     ret(0, 3) = -(r + l) / (r - l);
     ret(1, 1) = 2.0f / (t - b);
     ret(1, 3) = -(t + b) / (t - b);
     ret(2, 2) = -2.0f / (f - n);
     ret(2, 3) = -(f + n) / (f - n);
+#endif
     ret(3, 3) = 1.f;
     return ret;
   }

include/pd/core/pd_p_api.hpp

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

include/pd/core/pool.hpp

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

include/pd/core/strings.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 namespace PD {
 /**
@@ -43,47 +43,47 @@ constexpr int HexChar2Int(char c) {
  * @param exts List of Extensions to check for
  * @return true if one of the extensions is found in the String
  */
-PD_API bool StringEndsWith(const std::string& str,
+PD_CORE_API bool StringEndsWith(const std::string& str,
-                           const std::vector<std::string>& exts);
+                                const std::vector<std::string>& exts);
 /**
  * Function to Create a wstring of a string
  * @param s Input String to Convert
  * @return Result wstring
  * @note Returns Empty if it has an error
  */
-PD_API std::wstring MakeWstring(const std::string& s);
+PD_CORE_API std::wstring MakeWstring(const std::string& s);
 /**
  * Generate a Formatted String by an Nanoseconds Input
  * @param nanos Nanoseconds Input
  * @return Result String
  */
-PD_API const std::string FormatNanos(unsigned long long nanos);
+PD_CORE_API const std::string FormatNanos(unsigned long long nanos);
 /**
  * Generate a Formatted String by an Milliseconds Input
  * @param millis Milliseconds Input
  * @return Result String
  */
-PD_API const std::string FormatMillis(unsigned long long millis);
+PD_CORE_API const std::string FormatMillis(unsigned long long millis);
 /**
  * Create a formatted String by an input bytes value
  * @param bytes value in bytes
  * @result Formatted String for example `2.5MB`
  */
-PD_API const std::string FormatBytes(unsigned long long bytes);
+PD_CORE_API const std::string FormatBytes(unsigned long long bytes);
 /**
  * Extract the Filename out of a Path
  * @param path Path to extract from
  * @param saperators Path Split Chars
  * @return extracted filename
  */
-PD_API const std::string GetFileName(const std::string& path,
+PD_CORE_API const std::string GetFileName(
-                                     const std::string& saperators = "/\\");
+    const std::string& path, const std::string& saperators = "/\\");
 /**
  * Remove Extension from a Path / Filename
  * @param path Input Path
  * @return Path without Extension
  */
-PD_API const std::string PathRemoveExtension(const std::string& path);
+PD_CORE_API const std::string PathRemoveExtension(const std::string& path);
 /**
  * Function to Convert a Type to a hex value
  * @tparam T Type
@@ -92,79 +92,39 @@ PD_API const std::string PathRemoveExtension(const std::string& path);
  */
 template <typename T>
 inline const std::string ToHex(const T& v) {
-  return std::format("{0:0{1}X}", v, sizeof(v) * 2);
+  std::stringstream s;
+  s << "0x" << std::setfill('0') << std::setw(sizeof(v) * 2) << std::hex << v;
+  return s.str();
 }
 /**
  * Generate a Hash out of a string
  * @param s String to hash
  * @return 32Bit Hash
  */
-PD_API u32 FastHash(const std::string& s);
+PD_CORE_API u32 FastHash(const std::string& s);
 /**
  * Function to Generate a Compiler Name and Version String
  * Based on their Macros
  * @return CompilerName: Version
  */
-inline const char* GetCompilerVersion() {
+inline const std::string GetCompilerVersion() {
-/// As the function looks like this Project is meant to
+  /// As the function looks like this Project is meant to
-/// Be ported to other systems as well
+  /// Be ported to other systems as well
-#define __mks(x) #x
+  std::stringstream res;
-#define mkstring(x) __mks(x)
 #ifdef __clang__  // Check clang first
-  return "Clang: " mkstring(__clang_major__) "." mkstring(
+  res << "Clang: " << __clang_major__ << ".";
-      __clang_minor__) "." mkstring(__clang_patchlevel__);
+  res << __clang_minor__ << ".";
+  res << __clang_patchlevel__;
 #elif __GNUC__
-  return "GCC: " mkstring(__GNUC__) "." mkstring(__GNUC_MINOR__) "." mkstring(
+  res << "GCC: " << __GNUC__;
-      __GNUC_PATCHLEVEL__);
+  res << "." << __GNUC_MINOR__ << ".";
+  res << __GNUC_PATCHLEVEL__;
 #elif _MSC_VER
-  return "MSVC; " mkstring(_MSC_VER);
+  res << "MSVC: " << _MSC_VER;
 #else
-  return "Unknown Compiler";
+  res << "Unknown Compiler";
 #endif
+  return res.str();
 }
 }  // namespace Strings
-class U8Iterator {
- public:
-  explicit U8Iterator(const char* s) : ptr(reinterpret_cast<const u8*>(s)) {}
-  ~U8Iterator() = default;
-
-  bool Decode32(u32& ret) {
-    if (ptr == nullptr || *ptr == 0) return false;
-    u8 c = *ptr;
-    if (c < 0x80) {
-      ret = c;
-      ptr += 1;
-    } else if ((c >> 5) == 0x6) {
-      ret = ((c & 0x1F) << 6) | (ptr[1] & 0x3F);
-      ptr += 2;
-    } else if ((c >> 4) == 0xE) {
-      ret = ((c & 0x0F) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
-      ptr += 3;
-    } else {
-      ret = ((c & 0x07) << 18) | ((ptr[1] & 0x3F) << 12) |
-            ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
-      ptr += 4;
-    }
-    return true;
-  }
-
-  bool PeekNext32(u32& ret) {
-    if (ptr == 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 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,13 +23,13 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 namespace PD {
 /**
  * Timer class
  */
-class PD_API Timer {
+class PD_CORE_API Timer {
  public:
   /**
    * Constructor
@@ -41,6 +41,8 @@ class PD_API Timer {
    */
   ~Timer() {}
 
+  PD_SHARED(Timer);
+
   /**
    * Resume Timer if Paused
    */

include/pd/core/timetrace.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,8 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <map>
+#include <pd/core/common.hpp>
-#include <pd/common.hpp>
 
 namespace PD {
 /**
@@ -39,6 +38,8 @@ 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
@@ -101,12 +102,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
@@ -150,14 +151,16 @@ namespace TT {
 class Res {
  public:
   /** Constructore that Inits a protocol at size of 60 frames */
-  Res() : start(0), end(0), protocol(60) {}
+  Res() : start(0), end(0) { protocol = TimeStats::New(60); }
   ~Res() = default;
 
+  PD_SHARED(Res);
+
   /**
    * Setter for the ID (Name)
    * @param v ID of the Trace
    */
-  void SetID(const std::string& v) { id = v; }
+  void SetID(const std::string &v) { id = v; }
   /**
    * Getter for the traces ID
    * @return Trace ID
@@ -180,7 +183,7 @@ class Res {
   void SetEnd(u64 v) {
     end = v;
     diff = end - start;
-    protocol.Add(GetLastDiff());
+    protocol->Add(GetLastDiff());
   }
   /**
    * Getter for the End Time
@@ -197,34 +200,30 @@ class Res {
    * Get Protcol Reference
    * @return Protocol Ref
    */
-  TimeStats& GetProtocol() { return protocol; }
+  TimeStats::Ref GetProtocol() { return protocol; }
 
  private:
   /** Trace ID */
   std::string id;
   /** Start time */
-  u64 start = 0;
+  u64 start;
   /** End Time */
-  u64 end = 0;
+  u64 end;
   /** Last Diff */
-  u64 diff = 0;
+  u64 diff;
   /** Protocol */
-  TimeStats protocol;
+  TimeStats::Ref protocol;
 };
-using TraceMap = std::map<std::string, TT::Res>;
 /**
  * Begin a Trace
  * @param id Name of the Trace
  */
-PD_API void Beg(const std::string& id);
+PD_CORE_API void Beg(const std::string &id);
 /**
  * End a Trace
  * @param id Name of the Trace
  */
-PD_API void End(const std::string& id);
+PD_CORE_API void End(const std::string &id);
-PD_API TraceMap& GetTraceMap();
-PD_API TT::Res& GetTraceRef(const std::string& id);
-PD_API bool TraceExist(const std::string& id);
 /**
  * Collect Start end end of the trace by tracking
  * when the Scope object goes out of scope
@@ -246,7 +245,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 - 2026 René Amthor (tobid7)
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846

include/pd/core/u128.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <pd/common.hpp>
+#include <pd/core/common.hpp>
 
 namespace PD {
 /**

include/pd/core/vec.hpp

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

include/pd/core/vec3.hpp

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

include/pd/core/vec4.hpp

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

include/pd/drivers/drivers.hpp

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

include/pd/drivers/gfx.hpp

@@ -1,324 +1,119 @@
 #pragma once
 
-#include <pd/core/mat.hpp>
+/*
-#include <pd/drivers/interface.hpp>
+MIT License
-#include <pd/lithium/drawlist.hpp>
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
-#include <pd/lithium/pools.hpp>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+#include <pd/lithium/command.hpp>
 #include <pd/lithium/texture.hpp>
 
-using PDGfxBackendFlags = PD::u32;
+using LiBackendFlags = PD::u32;
-enum PDGfxBackendFlags_ {
+enum LiBackendFlags_ {
-  PDGfxBackendFlags_None = 0,
+  LiBackendFlags_None = 0,
-  PDGfxBackendFlags_FlipUV_Y = 1 << 0,     // Essential for font loading
+  LiBackendFlags_FlipUV_Y = PD_BIT(0),  // Essential for font loading
-  PDGfxBackendFlags_WindingCW = 1 << 1,    // Use CW instead of CCW winding
-  PDGfxBackendFlags_HasClipRect = 1 << 2,  // Clip rects supported
-  PDGfxBackendFlags_ReqPow2 = 1 << 3,      // Tex size must be pow of 2
-  PDGfxBackendFlags_ApproxSDF = 1 << 4,  // Fake SDF for non smoothstep systems
 };
 
 namespace PD {
-
+class GfxDriver {
-// Pre interface class
-class PD_API GfxDriver : public DriverInterface {
  public:
-  GfxDriver(std::string_view name);
+  GfxDriver(const std::string& name = "NullGfx") : pName(name) {};
-  virtual ~GfxDriver();
+  ~GfxDriver() = default;
+
+  PD_SHARED(GfxDriver);
+
+  void PostInit();
 
   virtual void Init() {}
-  virtual void Deinit() {
+  virtual void Deinit() {}
-    DeleteTexture(pWhite);
+  virtual void NewFrame() {}
-    SysDeinit();
+
+  virtual void BindTex(Li::TexAddress addr) {}
+
+  virtual void RenderDrawData(const Li::CmdPool& 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;
   }
 
-  void SetViewPort(const ivec2& size);
+  virtual void DestroyTex(PD::Li::Texture::Ref tex) {}
-  void SetViewPort(int x, int y);
-  virtual void BindTexture(TextureID id) {}
-  void Reset();
-  virtual Li::Texture LoadTexture(
-      const std::vector<PD::u8>& pixels, int w, int h,
-      TextureFormat type = TextureFormat::RGBA32,
-      TextureFilter filter = TextureFilter::Linear) {
-    return Li::Texture();
-  }
-  virtual void DeleteTexture(const Li::Texture& tex) {}
-  virtual void Draw(const Li::Drawlist& commands) {}
-  Li::Texture::Ptr GetWhiteTexture() { return &pWhite; }
-  PDGfxBackendFlags GetFlags() { return Flags; }
 
-  size_t GetNumVertices() const { return CountVertices; }
+  Li::Texture::Ref GetSolidTex() { return pSolid; }
-  size_t GetNumIndices() const { return CountIndices; }
-  size_t GetNumDrawcalls() const { return CountDrawcalls; }
-  size_t GetNumCommands() const { return CountCommands; }
 
-  // Global Pool Interface
+  const std::string pName = "NullGfx";
-  virtual size_t AllocateVertices(size_t count, PD::ptr accessor) = 0;
+  LiBackendFlags Flags = 0;
-  virtual size_t AllocateIndices(size_t count, PD::ptr accessor) = 0;
-  virtual bool ExpandVertices(size_t count, PD::ptr accessor) = 0;
-  virtual bool ExpandIndices(size_t count, PD::ptr accessor) = 0;
-  virtual void PutVertex(size_t loc, const Li::Vertex& vtx,
-                         PD::ptr accessor) = 0;
-  virtual void PutIndex(size_t loc, u16 idx, PD::ptr accessor) = 0;
-  virtual const Li::Vertex& GetVertex(size_t loc) const = 0;
-  virtual const u16& GetIndex(size_t loc) const = 0;
-  virtual void ResetPools() = 0;
-
- protected:
-  virtual void SysDeinit() {}
-  virtual void SysInit() {}
-  virtual void SysReset() {}
-  virtual void Submit(size_t count, size_t start) {}
-  virtual void UploadPools() {}  // not every driver requires it
-  virtual void ClipRect() {}
-  void RegisterTexture(const Li::Texture& tex);
-  void UnregisterTexture(const Li::Texture& tex);
-
-  // Counters
-  size_t CountDrawcalls = 0;
-  size_t CountCommands = 0;
-  size_t CountVertices = 0;
-  size_t CountIndices = 0;
-  size_t CurrentIndex = 0;
-  size_t CurrentVertex = 0;
-  size_t pCountDrawcalls = 0;
-  size_t pCountCommands = 0;
-  // State Variables oder so
-  TextureID CurrentTex = 0;
-  bool CurrentTexIsSDF = false;
-  bool CurrentHasClip = false;
-  fvec4 CurrentClip = 0;
-  Mat4 Projection;
   ivec2 ViewPort;
-  std::unordered_map<TextureID, Li::Texture> pTextureRegestry;
+  Mat4 Projection;
-  Li::Texture pWhite;
+  Li::Texture::Ref pSolid;
-  PDGfxBackendFlags Flags = 0;
+  size_t CurrentVertex = 0;
+  size_t CurrentIndex = 0;
+
+  /** Debug Variables */
+
+  // Optional Index counter
+  u32 IndexCounter;
+  // Optional Vertex counter
+  u32 VertexCounter;
+  // Optional Frame Counter
+  u64 FrameCounter;
 };
 
-struct DefaultGfxConfig {
+/** Static Gfx Controller */
-  // Vertex Allocator
+class Gfx {
-  template <typename T>
-  using VertexAlloc = std::allocator<T>;
-  // Index Allocator
-  template <typename T>
-  using IndexAlloc = std::allocator<T>;
-};
-
-template <typename Config = DefaultGfxConfig>
-class GfxDriverBase : public GfxDriver {
- public:
-  using VtxPool =
-      Pool<Li::Vertex, typename Config::template VertexAlloc<Li::Vertex>>;
-  using IdxPool = Pool<u16, typename Config::template VertexAlloc<u16>>;
-  GfxDriverBase(std::string_view name = "Default") : GfxDriver(name) {}
-  virtual ~GfxDriverBase() {}
-
-  void Init() override {
-    SysInit();
-    std::vector<u8> img(16 * 16 * 4, 0xff);
-    pWhite = LoadTexture(img, 16, 16);
-  }
-
-  void Draw(const Li::Drawlist& dl) override {
-    const auto& commands = dl.Data();
-    if (commands.size() == 0) return;
-    pCountCommands += commands.size();
-
-    size_t vtotal = dl.GetNumVertices();
-    size_t itotal = dl.GetNumIndices();
-
-    size_t start_vtx = pVtxPool.size();
-    pVtxPool.Allocate(vtotal);
-    CurrentVertex += vtotal;
-
-    size_t start_idx = pIdxPool.size();
-    pIdxPool.Allocate(itotal);
-    CurrentIndex += itotal;
-
-    size_t current_vtx = start_vtx;
-    size_t current_idx = start_idx;
-
-    const auto& vpool = Li::GetVertexPool();
-    const auto& ipool = Li::GetIndexPool();
-    /** Build Pools */
-    for (size_t i = 0; i < commands.size(); i++) {
-      const auto& cmd = commands[i];
-      if (cmd.VertexCount > 0) {
-        std::memcpy(reinterpret_cast<void*>(pVtxPool.begin() + current_vtx),
-                    vpool.begin() + cmd.FirstVertex,
-                    cmd.VertexCount * sizeof(Li::Vertex));
-      }
-      for (size_t idx = 0; idx < cmd.IndexCount; idx++) {
-        u16 local_idx = ipool[cmd.FirstIndex + idx];
-        pIdxPool[current_idx + idx] = static_cast<u16>(current_vtx + local_idx);
-      }
-      current_vtx += cmd.VertexCount;
-      current_idx += cmd.IndexCount;
-    }
-
-    UploadPools();
-
-    size_t index = 0;
-    size_t ioff = start_idx;
-
-    while (index < commands.size()) {
-      CurrentTex = commands[index].Tex;
-      CurrentTexIsSDF = commands[index].SDF;
-      CurrentHasClip = commands[index].ClipRectUsed;
-      CurrentClip = commands[index].ClipRect;
-      if (!CurrentTex) {
-        CurrentTex = pWhite.GetID();
-      }
-      size_t num_indices = 0;
-      ClipRect();
-      while (index < commands.size() &&
-             CurrentTexIsSDF == commands[index].SDF &&
-             (CurrentTex == commands[index].Tex ||
-              (CurrentTex == pWhite.GetID() && commands[index].Tex == 0)) &&
-             CurrentClip == commands[index].ClipRect &&
-             CurrentHasClip == commands[index].ClipRectUsed) {
-        num_indices += commands[index].IndexCount;
-        index++;
-      }
-      if (num_indices > 0) {
-        Submit(num_indices, ioff);
-        ioff += num_indices;
-        pCountDrawcalls++;
-      }
-    }
-  }
-
-  size_t AllocateVertices(size_t count, PD::ptr accessor) override {
-    pVertexAccessor = accessor;
-    size_t loc = pVtxPool.size();
-    pVtxPool.Allocate(count);
-    return loc;
-  }
-
-  size_t AllocateIndices(size_t count, PD::ptr accessor) override {
-    pIndexAccessor = accessor;
-    size_t loc = pIdxPool.size();
-    pIdxPool.Allocate(count);
-    return loc;
-  }
-
-  bool ExpandVertices(size_t count, PD::ptr accessor) override {
-    if (pVertexAccessor != accessor) return false;
-    pVtxPool.Allocate(count);
-    return true;
-  }
-
-  bool ExpandIndices(size_t count, PD::ptr accessor) override {
-    if (pIndexAccessor != accessor) return false;
-    pIdxPool.Allocate(count);
-    return true;
-  }
-
-  void PutVertex(size_t loc, const Li::Vertex& vtx, PD::ptr accessor) override {
-    if (pVertexAccessor != accessor) return;
-    pVtxPool.Put(loc, vtx);
-  }
-
-  void PutIndex(size_t loc, u16 idx, PD::ptr accessor) override {
-    if (pIndexAccessor != accessor) return;
-    pIdxPool.Put(loc, idx);
-  }
-
-  const Li::Vertex& GetVertex(size_t loc) const override {
-    return pVtxPool[loc];
-  }
-
-  const u16& GetIndex(size_t loc) const override { return pIdxPool[loc]; }
-
-  void ResetPools() override {
-    pVtxPool.NoReset();
-    pIdxPool.NoReset();
-  }
-
- protected:
-  u16* GetIndexBufPtr(size_t start) { return &pIdxPool[start]; }
-  Li::Vertex* GetVertexBufPtr(size_t start) { return &pVtxPool[start]; }
-  size_t GetVertexPoolSize() const { return pVtxPool.size(); }
-  size_t GetIndexPoolSize() const { return pIdxPool.size(); }
-
- private:
-  VtxPool pVtxPool;
-  IdxPool pIdxPool;
-  PD::ptr pVertexAccessor = 0;
-  PD::ptr pIndexAccessor = 0;
-};
-
-class PD_API Gfx {
  public:
   Gfx() = default;
   ~Gfx() = default;
 
-  template <typename T, typename... Args>
+  static void Init(GfxDriver::Ref d);
-  static void UseDriver(Args&&... args) {
+
-    // assert(driver == nullptr && "OS Driver already set");
+  static void Deinit() { pGfx->Deinit(); }
-    driver = std::make_unique<T>(std::forward<Args>(args)...);
+  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 SetViewPort(int w, int h) { pGfx->SetViewPort(PD::ivec2(w, h)); }
+
+  static void RenderDrawData(const Li::CmdPool& Commands) {
+    pGfx->RenderDrawData(Commands);
   }
 
-  static void Init() { driver->Init(); }
+  static LiBackendFlags Flags() { return pGfx->Flags; }
-  static void Deinit() { driver->Deinit(); }
+  static Li::Texture::Ref LoadTex(
-  static void SetViewPort(const ivec2& vp) { driver->SetViewPort(vp); }
+      const std::vector<u8>& pixels, int w, int h,
-  static void SetViewPort(int w, int h) { driver->SetViewPort(w, h); }
+      Li::Texture::Type type = Li::Texture::Type::RGBA32,
-  static void Reset() { driver->Reset(); }
+      Li::Texture::Filter filter = Li::Texture::Filter::LINEAR) {
-  static void Draw(const Li::Drawlist& dl) { driver->Draw(dl); }
+    return pGfx->LoadTex(pixels, w, h, type, filter);
-  static Li::Texture LoadTexture(const std::vector<PD::u8>& pixels, int w,
-                                 int h,
-                                 TextureFormat type = TextureFormat::RGBA32,
-                                 TextureFilter filter = TextureFilter::Linear) {
-    return driver->LoadTexture(pixels, w, h, type, filter);
-  }
-  static void DeleteTexture(const Li::Texture& tex) {
-    driver->DeleteTexture(tex);
-  }
-  static Li::Texture::Ptr GetWhiteTexture() {
-    return driver->GetWhiteTexture();
   }
 
-  static PDGfxBackendFlags GetFlags() { return driver->GetFlags(); }
+  static void DestroyTex(Li::Texture::Ref tex) { pGfx->DestroyTex(tex); }
 
-  static const char* GetDriverName() { return driver->GetName(); }
+  static Li::Texture::Ref GetSolidTex() { return pGfx->GetSolidTex(); }
 
-  static size_t GetNumVertices() { return driver->GetNumVertices(); }
+  static GfxDriver::Ref pGfx;
-  static size_t GetNumIndices() { return driver->GetNumIndices(); }
-  static size_t GetNumDrawcalls() { return driver->GetNumDrawcalls(); }
-  static size_t GetNumCommands() { return driver->GetNumCommands(); }
-
-  // Gloabal Pool Interface
-  static size_t AllocateVertices(size_t count, PD::ptr accessor) {
-    return driver->AllocateVertices(count, accessor);
-  }
-
-  static size_t AllocateIndices(size_t count, PD::ptr accessor) {
-    return driver->AllocateIndices(count, accessor);
-  }
-
-  static bool ExpandVertices(size_t count, PD::ptr accessor) {
-    return driver->ExpandVertices(count, accessor);
-  }
-
-  static bool ExpandIndices(size_t count, PD::ptr accessor) {
-    return driver->ExpandIndices(count, accessor);
-  }
-
-  static void PutVertex(size_t loc, const Li::Vertex& vtx, PD::ptr accessor) {
-    driver->PutVertex(loc, vtx, accessor);
-  }
-
-  static void PutIndex(size_t loc, u16 idx, PD::ptr accessor) {
-    driver->PutIndex(loc, idx, accessor);
-  }
-
-  static const Li::Vertex& GetVertex(size_t loc) {
-    return driver->GetVertex(loc);
-  }
-
-  static const u16& GetIndex(size_t loc) { return driver->GetIndex(loc); }
-
-  static void NewFrame() { driver->ResetPools(); }
-
- private:
-  static std::unique_ptr<GfxDriver> driver;
 };
 }  // namespace PD

include/pd/drivers/hid.hpp

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

include/pd/drivers/interface.hpp

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

include/pd/drivers/os.hpp

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

include/pd/drivers/pd_p_api.hpp

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

include/pd/drivers/snd.hpp

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

include/pd/image/image.hpp

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

include/pd/image/img_blur.hpp

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

include/pd/image/img_convert.hpp

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

include/pd/image/pd_p_api.hpp

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

@@ -1,25 +0,0 @@
-#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,36 +1,103 @@
 #pragma once
 
-#include <cstddef>
+/*
-#include <pd/core/pool.hpp>
+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/pd_p_api.hpp>
+#include <pd/lithium/texture.hpp>
 #include <pd/lithium/vertex.hpp>
 
 namespace PD {
 namespace Li {
 class Command {
  public:
-  Command() { Reset(); }
+  Command() = default;
-  ~Command() {}
+  ~Command() = default;
 
-  void Reserve(size_t vtx, size_t idx);
+  PD_RAW(Command);
+
+  Command& AddIdx(const u16& idx) {
+    IndexBuffer.push_back(VertexBuffer.size() + idx);
+    return *this;
+  }
+  Command& AddIdxs(const u16& a, const u16& b, const u16& c) {
+    IndexBuffer.push_back(VertexBuffer.size() + a);
+    IndexBuffer.push_back(VertexBuffer.size() + b);
+    IndexBuffer.push_back(VertexBuffer.size() + c);
+    return *this;
+  }
+
+  Command& AddVtx(const Vertex& v) {
+    VertexBuffer.push_back(std::move(v));
+    return *this;
+  }
+
+  void Clear() {
+    VertexBuffer.clear();
+    IndexBuffer.clear();
+    Index = 0;
+    Layer = 0;
+    Tex = 0;
+    ScissorOn = false;
+    ScissorRect = ivec4();
+  }
+
+  std::vector<Vertex> VertexBuffer;
+  std::vector<u16> IndexBuffer;
+  ivec4 ScissorRect;
+  bool ScissorOn = false;
+  int Layer;
+  int Index;
+  Texture::Ref Tex;
+};
+
+class PD_LITHIUM_API CmdPool {
+ public:
+  CmdPool() {}
+  ~CmdPool() {}
+
+  Command::Ref NewCmd();
+  void Init(size_t initial_size);
+  void Deinit();
+  void Resize(size_t nulen);
   void Reset();
+  Command::Ref GetCmd(size_t idx) const;
+  Command::Ref GetCmd(size_t idx);
+  size_t Size() const;
+  size_t Cap() const;
+  void Merge(CmdPool& p);
+  void Copy(CmdPool& p);
+  void Sort();
 
-  Command& Add(const Vertex& vtx);
+ private:
-  Command& Add(u16 idx);
+  static bool pTheOrder(const Command::Ref& a, const Command::Ref& b);
-  Command& Add(u16 a, u16 b, u16 c);
+  friend class DrawList;
-
+  Command::Ref* begin() { return &pPool[0]; }
+  Command::Ref* end() { return &pPool[pPoolIdx]; }
+  std::vector<Command::Ref> pPool;
+  u32 pPoolIdx = 0;
   int Layer = 0;
-  ptr Tex = 0;
-  bool SDF = false;
-  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;
-  // ClipRect
-  PD::fvec4 ClipRect;
-  bool ClipRectUsed = false;
 };
 }  // namespace Li
 }  // namespace PD

include/pd/lithium/drawlist.hpp

@@ -1,147 +1,224 @@
-#pragma once
+#pragma once
-
+
-#include <pd/lithium/command.hpp>
+/*
-#include <pd/lithium/font.hpp>
+MIT License
-#include <pd/lithium/texture.hpp>
+
-
+Copyright (c) 2024 - 2025 tobid7
-using LiPathRectFlags = PD::u32;
+
-
+Permission is hereby granted, free of charge, to any person obtaining a copy
-enum LiPathRectFlags_ : PD::u32 {
+of this software and associated documentation files (the "Software"), to deal
-  LiPathRectFlags_None = 0,
+in the Software without restriction, including without limitation the rights
-  LiPathRectFlags_KeepTopLeft = 1 << 0,
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  LiPathRectFlags_KeepTopRight = 1 << 1,
+copies of the Software, and to permit persons to whom the Software is
-  LiPathRectFlags_KeepBotRight = 1 << 2,
+furnished to do so, subject to the following conditions:
-  LiPathRectFlags_KeepBotLeft = 1 << 3,
+
-  LiPathRectFlags_KeepTop =
+The above copyright notice and this permission notice shall be included in all
-      LiPathRectFlags_KeepTopLeft | LiPathRectFlags_KeepTopRight,
+copies or substantial portions of the Software.
-  LiPathRectFlags_KeepBot =
+
-      LiPathRectFlags_KeepBotLeft | LiPathRectFlags_KeepBotRight,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  LiPathRectFlags_KeepLeft =
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-      LiPathRectFlags_KeepTopLeft | LiPathRectFlags_KeepBotLeft,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  LiPathRectFlags_KeepRight =
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-      LiPathRectFlags_KeepTopRight | LiPathRectFlags_KeepBotRight,
+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.
-using LiDrawFlags = PD::u32;
+ */
-enum LiDrawFlags_ : PD::u32 {
+
-  LiDrawFlags_None = 0,
+#include <pd/lithium/command.hpp>
-  LiDrawFlags_Close = 1 << 0,
+#include <pd/lithium/font.hpp>
-  LiDrawFlags_AA = 1 << 1,
+#include <pd/lithium/pd_p_api.hpp>
-};
+
-
+/** Path Rect Flags */
-namespace PD {
+using LiPathRectFlags = PD::u32;
-namespace Li {
+
-class PD_API Drawlist {
+/** Setup for everything (oder so) */
- public:
+enum LiPathRectFlags_ : PD::u32 {
-  Drawlist();
+  LiPathRectFlags_None = 0,
-  ~Drawlist();
+  LiPathRectFlags_KeepTopLeft = PD_BIT(0),
-
+  LiPathRectFlags_KeepTopRight = PD_BIT(1),
-  /** Baisc */
+  LiPathRectFlags_KeepBotRight = PD_BIT(2),
-
+  LiPathRectFlags_KeepBotLeft = PD_BIT(3),
-  void Merge(Drawlist& other);
+  LiPathRectFlags_KeepTop = PD_BIT(0) | PD_BIT(1),
-  void Copy(Drawlist& other);
+  LiPathRectFlags_KeepBot = PD_BIT(2) | PD_BIT(3),
-  void Optimize();
+  LiPathRectFlags_KeepLeft = PD_BIT(0) | PD_BIT(3),
-  void Clear();
+  LiPathRectFlags_KeepRight = PD_BIT(1) | PD_BIT(2),
-  void SetLayer(int layer) { pCurrentLayer = layer; }
+};
-  void LayerUp() { pCurrentLayer++; }
+
-  void LayerDown() { pCurrentLayer--; }
+namespace PD {
-  int GetLayer() const { return pCurrentLayer; }
+namespace Li {
-
+class PD_LITHIUM_API DrawList {
-  size_t GetNumVertices() const {
+ public:
-    size_t count = 0;
+  DrawList(int initial_size = 64);
-    for (const auto& cmd : pCommands) count += cmd.VertexCount;
+  ~DrawList();
-    return count;
+
-  }
+  /** Require Copy and Move Constructors */
-
+
-  size_t GetNumIndices() const {
+  DrawList(const DrawList&) = delete;
-    size_t count = 0;
+  DrawList& operator=(const DrawList&) = delete;
-    for (const auto& cmd : pCommands) count += cmd.IndexCount;
+
-    return count;
+  DrawList(DrawList&&) noexcept = default;
-  }
+  DrawList& operator=(DrawList&&) noexcept = default;
-
+
-  /** Command Allocation */
+  PD_SHARED(DrawList);
-  Command& NewCommand();
+
-  bool HasCommands() { return pCommands.size() > 0; }
+  /**
-  Command& GetLastCommand() { return pCommands[pCommands.size() - 1]; }
+   * Append an input drawlist on top of this one
-
+   * This Function will clear the Input list to make sure
-  /** Path API */
+   * That the moved memory blocks don't get used
-  void PathAdd(const fvec2& point) { pPath.Push(point); }
+   * @param list DrawList to move into current
-  void PathAdd(float x, float y) { pPath.Push(fvec2(x, y)); }
+   */
-  void PathClear() { pPath.Reset(); }
+  void Merge(DrawList::Ref list);
-  /**
+  /**
-   * @brief Reserve memory for the next PathAdd uses
+   * Copy another drawlist to this drawist.
-   * @note As path will autoexpant and keep the size this func is
+   * This is important for static prerendered Drawlists
-   *       only for special use cases
+   * @param list DrawList Reference to copy from
-   */
+   */
-  void PathReserve(size_t num) { pPath.ExpandIf(num); }
+  void Copy(DrawList::Ref list);
-  void PathStroke(const PD::Color& color, int t = 1,
+  /**
-                  LiDrawFlags flags = LiDrawFlags_None);
+   * Optimize a Drawlist to a more or less perfect order
-  void PathFill(const PD::Color& color);
+   * to reduce drawcall overhead... This function also uses
-  void PathFillGradient(const PD::Color& a, const PD::Color& b,
+   * the Layersystem to keep specific stuff in the correct order
-                        float rad = 0.f);
+   */
-  void PathArcToN(const fvec2& c, float r, float amin, float amax, int s);
+  void Optimize();
-  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);
+  Command::Ref GetNewCmd();
-  void PathRectEx(const fvec2& tl, const fvec2& br, float r = 0.f,
+  void Clear();
-                  LiPathRectFlags flags = LiPathRectFlags_None);
+  void Layer(int l) { this->pPool.Layer = l; }
-
+  int Layer() { return this->pPool.Layer; }
-  /** Texture Handling */
+  void LayerUp() { this->pPool.Layer++; }
-  void BindTexture(const Texture& tex);
+  void LayerDown() { this->pPool.Layer--; }
-  void UnbindTexture() { pCurrentTexture = Texture(); }
+
-
+  void SetFont(Font::Ref font) { pCurrentFont = font; }
-  /** Font Handling */
+  void SetFontScale(float scale) { pFontScale = scale; }
-  void SetFont(Font* font) { pFont = font; }
+
-  void SetFontscale(float fontscale = 1.f) { pFontScale = fontscale; }
+  void DrawSolid();
-  const float& GetFontScale() const { return pFontScale; }
+  void DrawTexture(Texture::Ref tex) { CurrentTex = tex; }
-
+
-  /** Data geters */
+  // SECTION: Draw API //
-  const Pool<Command>& Data() const { return pCommands; }
+
-  operator const Pool<Command>&() const { return pCommands; }
+  void DrawRect(const fvec2& pos, const fvec2& size, u32 color,
-
+                int thickness = 1);
-  /** Drawing functions */
+  void DrawRectFilled(const fvec2& pos, const fvec2& size, u32 color);
-  void DrawRect(const fvec2& pos, const fvec2& size, const PD::Color& color,
+  void DrawTriangle(const fvec2& a, const fvec2& b, const fvec2& c, u32 color,
-                int t = 1);
+                    int thickness = 1);
-  void DrawRectFilled(const fvec2& pos, const fvec2& size,
+  void DrawTriangleFilled(const fvec2& a, const fvec2& b, const fvec2& c,
-                      const PD::Color& color);
+                          u32 color);
-  void DrawTriangle(const fvec2& a, const fvec2& b, const fvec2& c,
+  void DrawCircle(const fvec2& center, float rad, u32 color, int num_segments,
-                    const PD::Color& color, int t = 1);
+                  int thickness = 1);
-  void DrawTriangleFilled(const fvec2& a, const fvec2& b, const fvec2& c,
+  void DrawCircleFilled(const fvec2& center, float rad, u32 color,
-                          const PD::Color& color);
+                        int num_segments);
-  void DrawCircle(const fvec2& center, float rad, const PD::Color& color,
+  void DrawText(const fvec2& p, const std::string& text, u32 color);
-                  int num_segments, int t = 1);
+  /**
-  void DrawCircleFilled(const fvec2& center, float rad, const PD::Color& color,
+   * Extended Draw Text Function
-                        int num_segments);
+   */
-  void DrawText(const fvec2& p, const char* text, const PD::Color& color);
+  void DrawTextEx(const fvec2& p, const std::string& text, u32 color,
-  void DrawTextEx(const fvec2& p, const char* text, const PD::Color& color,
+                  LiTextFlags flags, const fvec2& box = fvec2(0.f));
-                  LiTextFlags flags, const fvec2& box = fvec2(0.f));
+  void DrawLine(const fvec2& a, const fvec2& b, u32 color, int t = 1);
-  void DrawLine(const fvec2& a, const fvec2& b, const PD::Color& color,
+  /**
-                int thickness = 1);
+   * Take list of points and display it as a line on screen
-
+   * @param points List of Positions
-  void DrawPolyLine(const Pool<fvec2>& points, const PD::Color& color,
+   * @param clr Color of the Line
-                    LiDrawFlags flags = LiDrawFlags_None, int t = 1);
+   * @param flags Additional Flags (Close for go back to starting point)
-  void DrawConvexPolyFilled(const Pool<fvec2>& points, const PD::Color& color);
+   * @param thickness Thickness of the Line
-  void DrawConvexPolyFilled(const Pool<fvec2>& points, const PD::Color& a,
+   */
-                            const PD::Color b, float rad = 0.f);
+  void DrawPolyLine(const std::vector<fvec2>& points, u32 clr, u32 flags = 0,
-
+                    int thickness = 1);
-  void PrimQuad(Command& cmd, const Rect& quad, const Rect& uv,
+  /**
-                const PD::Color& color);
+   * Take a List ofpoints and display it as Filled Shape
-  void PrimTriangle(Command& cmd, const fvec2& a, const fvec2& b,
+   * @note Keep in mind to setup the list of points clockwise
-                    const fvec2& c, const PD::Color& color);
+   * @param points List of Points
-
+   * @param clr Color of the shape
-  void PushClipRect(const fvec4& r) { pClipRects.push_back(r); }
+   */
-  void PopClipRect() {
+  void DrawConvexPolyFilled(const std::vector<fvec2>& points, u32 clr);
-    if (!pClipRects.empty()) pClipRects.pop_back();
+
-  }
+  // SECTION: PATH API //
-  bool HasClipRect() { return !pClipRects.empty(); }
+
-
+  /**
- private:
+   * Function to reserve Memory to prevent overhead on
-  Texture pCurrentTexture;
+   * pusing a lot of points with PathNext
-  int pCurrentLayer = 0;
+   * @param num_points Number of Positions you want to add
-  Pool<Command> pCommands;
+   */
-  Pool<fvec2> pPath;
+  void PathReserve(size_t num_points) {
-  std::vector<fvec4> pClipRects;
+    pPath.reserve(pPath.size() + num_points);
-  Font* pFont = nullptr;
+  }
-  float pFontScale = 1.f;
+  /**
-};
+   * Clear current Path
-}  // namespace Li
+   * @note PathStroke and PathFill will automatically clear
-}  // namespace PD
+   */
+  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.push_back(v); }
+  /**
+   * Add a Point to the Path
+   * @note Keep in mind that this function is used for
+   * setting the starting point
+   * @param x X Position to add
+   * @param y Y Position to add
+   */
+  void PathAdd(float x, float y) { pPath.push_back(fvec2(x, y)); }
+  /**
+   * 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.empty()) {
+      return;
+    }
+    pClipRects.pop();
+  }
+  const CmdPool& Data() const { return pPool; }
+  /** One linear Clip rect Setup */
+  void pClipCmd(Command* cmd);
+
+  /** Data Section */
+
+  std::stack<fvec4> pClipRects;
+  float pFontScale = 0.7f;
+  Font::Ref pCurrentFont;
+  Texture::Ref CurrentTex;
+  CmdPool pPool;
+  std::vector<fvec2> pPath;
+  u32 pNumIndices = 0;
+  u32 pNumVertices = 0;
+};
+}  // namespace Li
+}  // namespace PD

include/pd/lithium/font.hpp

@@ -1,119 +1,134 @@
-#pragma once
+#pragma once
-
+
-#include <pd/lithium/texture.hpp>
+/*
-
+MIT License
-using LiTextFlags = PD::u32;
+
-enum LiTextFlags_ : PD::u32 {
+Copyright (c) 2024 - 2025 tobid7
-  LiTextFlags_None = 0,             ///< Do nothing
+
-  LiTextFlags_AlignRight = 1 << 0,  ///< Align Right of position
+Permission is hereby granted, free of charge, to any person obtaining a copy
-  LiTextFlags_AlignMid = 1 << 1,    ///< Align in the middle of pos and box
+of this software and associated documentation files (the "Software"), to deal
-  LiTextFlags_Shaddow = 1 << 2,     ///< Draws the text twice to create shaddow
+in the Software without restriction, including without limitation the rights
-  LiTextFlags_Wrap = 1 << 3,        ///< Wrap Text: May be runs better with TMS
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  LiTextFlags_Short = 1 << 4,       ///< Short Text: May be runs better with TMS
+copies of the Software, and to permit persons to whom the Software is
-  LiTextFlags_Scroll = 1 << 5,      ///< Not implemented [scoll text if to long]
+furnished to do so, subject to the following conditions:
-  LiTextFlags_NoOOS = 1 << 6,       ///< No Out of Screen Rendering
+
-};
+The above copyright notice and this permission notice shall be included in all
-
+copies or substantial portions of the Software.
-using LiFontFlags = PD::u32;
+
-enum LiFontFlags_ : PD::u32 {
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  LiFontFlags_None = 0,            ///< Not special (bitmap font)
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  LiFontFlags_SDF = 1 << 0,        ///< SDF Texture (and mode)
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  LiFontFlags_Monospace = 1 << 1,  ///< Monospace Rendering
+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
-namespace PD {
+SOFTWARE.
-namespace Li {
+ */
-class Drawlist;
+
-class PD_API Font {
+#include <pd/core/core.hpp>
- public:
+#include <pd/lithium/command.hpp>
-  struct Codepoint {
+#include <pd/lithium/pd_p_api.hpp>
-    u32 pCodepoint = 0;
+#include <pd/lithium/rect.hpp>
-    fvec4 SimpleUV;
+#include <pd/lithium/texture.hpp>
-    size_t Tex = 0;
+
-    fvec2 Size;
+using LiTextFlags = PD::u32;
-    fvec2 Offset;
+enum LiTextFlags_ {
-    // float Offset = 0.f;
+  LiTextFlags_None = 0,             ///< Do nothing
-    float AdvanceX = 0.f;
+  LiTextFlags_AlignRight = 1 << 0,  ///< Align Right of position
-    bool pInvalid = false;
+  LiTextFlags_AlignMid = 1 << 1,    ///< Align in the middle of pos and box
-  };
+  LiTextFlags_Shaddow = 1 << 2,     ///< Draws the text twice to create shaddow
-  Font() {}
+  LiTextFlags_Wrap = 1 << 3,        ///< Wrap Text: May be runs better with TMS
-  ~Font() {}
+  LiTextFlags_Short = 1 << 4,       ///< Short Text: May be runs better with TMS
-
+  LiTextFlags_Scroll = 1 << 5,      ///< Not implemented [scoll text if to long]
-  bool IsMonospace() { return pFlags & LiFontFlags_Monospace; }
+  LiTextFlags_NoOOS = 1 << 6,       ///< No Out of Screen Rendering
-  bool IsSDF() { return pFlags & LiFontFlags_SDF; }
+};
-
+
-  /**
+namespace PD {
-   * Load a TTF File
+namespace Li {
-   * @param path Path to the TTF file
+class PD_LITHIUM_API Font {
-   * @param px_height Pixelheight of the codepoints (limit by 64)
+ public:
-   */
+  /** Codepoint Data holder */
-  void LoadTTF(const std::string& path, int px_height = 32,
+  struct Codepoint {
-               LiFontFlags flags = LiFontFlags_None);
+    u32 pCodepoint = 0;
-  /**
+    fvec4 SimpleUV;
-   * Load a TTF File from Memory
+    Texture::Ref Tex;
-   * @param data File data
+    fvec2 Size;
-   * @param px_height Pixelheight of the codepoints (limit by 64)
+    float Offset = 0.f;
-   */
+    bool pInvalid = false;
-  void LoadTTF(const std::vector<u8>& data, int px_height = 32,
+  };
-               LiFontFlags flags = LiFontFlags_None);
+
-  /**
+  /** Constructore doesnt need Backand anymore */
-   * Getter for Codepoint reference
+  Font() = default;
-   * @return codepoint dataholder reference
+  ~Font() = default;
-   */
+
-  Codepoint& GetCodepoint(u32 c);
+  PD_SHARED(Font);
-
+
-  /**
+  /**
-   * Get Text Bounding Box
+   * Load a TTF File
-   */
+   * @param path Path to the TTF file
-  fvec2 GetTextBounds(const char* text, float scale);
+   * @param px_height Pixelheight of the codepoints (limit by 64)
-  /**
+   */
-   * Extended Draw Text Function that vreates a Command List
+  void LoadTTF(const std::string& path, int px_height = 32);
-   */
+  /**
-  void CmdTextEx(Drawlist& dl, const fvec2& pos, u32 color, float scale,
+   * Load a TTF File from Memory
-                 const char* text, LiTextFlags flags = 0, const fvec2& box = 0);
+   * @param data File data
-
+   * @param px_height Pixelheight of the codepoints (limit by 64)
-  /**
+   */
-   * Cleanup Font and unload Textures
+  void LoadTTF(const std::vector<u8>& data, int px_height = 32);
-   */
+  /**
-  void Delete();
+   * 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
-   * Garbage collection for TextMapSystem
+   */
-   */
+  void LoadDefaultFont(int id = 0, int pixel_height = 32);
-  void CleanupTMS();
+  /**
-  /**
+   * Getter for Codepoint reference
-   * Utility function to create a font atlas
+   * @return codepoint dataholder reference
-   * During TTF loading (Internal and should not be called)
+   */
-   */
+  Codepoint& GetCodepoint(u32 c);
-  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);
+   * Get Text Bounding Box
-  std::string pShortText(const std::string& txt, float scale,
+   */
-                         const PD::fvec2& max, PD::fvec2& dim);
+  fvec2 GetTextBounds(const std::string& text, float scale);
-
+  /**
-  /** Data Section */
+   * Extended Draw Text Function that vreates a Command List
-  int PixelHeight = 0;
+   */
-  int DefaultPixelHeight = 32;
+  void CmdTextEx(CmdPool& cmds, const fvec2& pos, u32 color, float scale,
-  std::vector<TextureID> Textures;
+                 const std::string& text, LiTextFlags flags = 0,
-  /**
+                 const fvec2& box = 0);
-   * 32Bit Codepoint Dataholder reference map
+
-   * **Now using unordered map**
+  /**
-   */
+   * Garbage collection for TextMapSystem
-  std::unordered_map<u32, Codepoint> CodeMap;
+   */
-  /** need some performance tweaks */
+  void CleanupTMS();
-  std::array<Codepoint, 128> pAsciiCache;
+  /**
-  /** TMS */
+   * Utility function to create a font atlas
-  struct TMELEM {
+   * During TTF loading (Internal and should not be called)
-    PD::u32 ID;
+   */
-    PD::fvec2 Size;
+  void pMakeAtlas(bool final, std::vector<u8>& font_tex, int texszs,
-    std::string Text;
+                  PD::Li::Texture::Ref tex);
-    u64 TimeStamp;
+  std::string pWrapText(const std::string& txt, float scale,
-  };
+                        const PD::fvec2& max, PD::fvec2& dim);
-  std::unordered_map<u32, TMELEM> pTMS;
+  std::string pShortText(const std::string& txt, float scale,
-
+                         const PD::fvec2& max, PD::fvec2& dim);
- private:
+
-  size_t pCurrentTex = 0;
+  /** Data Section */
-  LiFontFlags pFlags = 0;
+  int PixelHeight;
-};
+  int DefaultPixelHeight = 24;
-}  // namespace Li
+  std::vector<Texture::Ref> 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;
+};
+}  // namespace Li
 }  // namespace PD

include/pd/lithium/fonts.hpp

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

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

include/pd/lithium/lithium.hpp

@@ -1,8 +1,32 @@
-#pragma once
+#pragma once
-
+
-#include <pd/lithium/command.hpp>
+/*
-#include <pd/lithium/drawlist.hpp>
+MIT License
-#include <pd/lithium/font.hpp>
+
-#include <pd/lithium/math.hpp>
+Copyright (c) 2024 - 2025 tobid7
-#include <pd/lithium/pools.hpp>
+
-#include <pd/lithium/vertex.hpp>
+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/drawlist.hpp>
+#include <pd/lithium/font.hpp>
+#include <pd/lithium/rect.hpp>
+#include <pd/lithium/renderer.hpp>
+#include <pd/lithium/texture.hpp>

include/pd/lithium/math.hpp

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