Codebase of 0.9.5 26.06.2024 found on my OneDrive

.clang-format

@@ -0,0 +1,259 @@
+---
+Language:        Cpp
+# BasedOnStyle:  Google
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments:
+  Kind:            Always
+  OverEmptyLines:  0
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BitFieldColonSpacing: Both
+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
+BreakAfterAttributes: Never
+BreakAfterJavaFieldAnnotations: false
+BreakArrays:     true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Attach
+BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+BreakInheritanceList: BeforeColon
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: true
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+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
+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
+KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: Signature
+LineEnding:      DeriveLF
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PackConstructorInitializers: NextLine
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+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:  true
+RemoveBracesLLVM: false
+RemoveSemicolon: false
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SortIncludes:    CaseSensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: LexicographicNumeric
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterOverloadedOperator: false
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Auto
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - BOOST_PP_STRINGIZE
+  - CF_SWIFT_NAME
+  - NS_SWIFT_NAME
+  - PP_STRINGIZE
+  - STRINGIZE
+...
+

.gitignore

@@ -2,3 +2,5 @@ release/
 debug/
 lib/
 *.bz2
+rd7le/
+*.DS_Store*

.vscode/launch.json

@@ -0,0 +1,115 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "(gdb) Launch",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/rd7tf/rd7tf.elf",
+            "targetArchitecture": "arm",
+            "serverLaunchTimeout": 10000,
+            "stopAtEntry": true,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": true,
+            "MIMode": "gdb",
+            "miDebuggerPath": "/opt/devkitPro/devkitARM/bin/arm-none-eabi-gdb",
+            "miDebuggerServerAddress": "192.168.2.220:4003",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing",
+                    "text": "file ${workspaceFolder}/rd7tf/rd7tf.elf -enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        }, 
+        {
+            "name": "(gdb-emu) Launch",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/rd7tf/rd7tf.elf",
+            "targetArchitecture": "arm",
+            "serverLaunchTimeout": 10000,
+            "stopAtEntry": true,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": true,
+            "MIMode": "gdb",
+            "miDebuggerPath": "/opt/devkitPro/devkitARM/bin/arm-none-eabi-gdb",
+            "miDebuggerServerAddress": "localhost:4003",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing",
+                    "text": "file ${workspaceFolder}/rd7tf/rd7tf.elf -enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "(gdb-emu) lua",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/rd7le/rd7le.elf",
+            "targetArchitecture": "arm",
+            "serverLaunchTimeout": 10000,
+            "stopAtEntry": true,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": true,
+            "MIMode": "gdb",
+            "miDebuggerPath": "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gdb.exe",
+            "miDebuggerServerAddress": "localhost:4003",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing",
+                    "text": "file ${workspaceFolder}/rd7le/rd7le.elf -enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "(gdb) lua",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/rd7le/rd7le.elf",
+            "targetArchitecture": "arm",
+            "serverLaunchTimeout": 10000,
+            "stopAtEntry": true,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": true,
+            "MIMode": "gdb",
+            "miDebuggerPath": "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gdb.exe",
+            "miDebuggerServerAddress": "192.168.2.220:4003",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing",
+                    "text": "file ${workspaceFolder}/rd7le/rd7le.elf -enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "(gdb) testgame",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/testgame/testgame.elf",
+            "targetArchitecture": "arm",
+            "serverLaunchTimeout": 10000,
+            "stopAtEntry": true,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": true,
+            "MIMode": "gdb",
+            "miDebuggerPath": "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gdb.exe",
+            "miDebuggerServerAddress": "localhost:4003",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing",
+                    "text": "file ${workspaceFolder}/testgame/testgame.elf -enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        }
+    ]
+}

.vscode/settings.json

@@ -97,6 +97,22 @@
         "cfenv": "cpp",
         "cinttypes": "cpp",
         "typeindex": "cpp",
-        "variant": "cpp"
+        "variant": "cpp",
+        "ranges": "cpp",
+        "span": "cpp",
+        "coroutine": "cpp",
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__split_buffer": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__verbose_abort": "cpp",
+        "complex": "cpp"
     }
 }

CHANGELOG.md

@@ -0,0 +1,98 @@
+# RenderD7 Changelog
+## 0.9.5
+- Remove Npi Intro and NVID Api
+- Replace Toasts System with Message 
+- Lots of Optimisations
+- Added GetTime
+- Implement Draw2 Api
+- Implement RD7Color and R7Vec2
+- Add new Features to Color::RGBA
+- Cleanup Code
+- Added RenderD7 Keyboard (Overlay)
+- Added Ftrace Overlay
+- Moved MetrikOVL into an Overlay
+- Removed Old Font/Text Handlers
+- Added UI7 (New UI Api)
+- Remove Old UI Api
+- Added Music Player (MP3, Vorbis)
+- Rewrite of RenderD7::Image
+- Internal Debugger/Database (IDB)
+- Removed BitmapPrinter
+- Added nimg and nimg_engine
+- Removed Old Error/Message Handler
+- GetTextSize (extra buffer) + New TextShorter
+## 0.9.4
+- Implement new Security System To prevent from crashes
+- Implement Functiontrace for better Timing Tests
+- Implement MemAlloc Tracker (only size)
+- Add some new Overlays (not functional yet)
+- Complete Rewrite of Overlay System
+- Fixed the FrameEnd Crash
+- New System to get Hardware Info
+- Removed RenderD7 Super Reselution (800px mode)
+## 0.9.3
+- Completly Documented Everything
+- Fix typo in Sprite::getHeight
+- Remove Deprecated/Useless Stuff
+## 0.9.2
+- Add Nvid Support(v0.0.1)
+- Add Basic RenderD7 Splash
+- Faster Graphics Init
+- Fade Effects
+- Fix Changelog Screen 
+## 0.9.1
+- Fix Critical bug in Spritesheet animations
+- Fix RenderD7::Color::Hex (Major performance tweak)
+## 0.9.0
+- Remove Stupid try of Console
+- Add Services list 
+- Clean up Code
+- Added Minimal Init for hax2.x
+## 0.8.5
+- Fix Deltatime
+## 0.8.4
+- A lot of Fixes 
+- New Features for BitmapPrinter
+## 0.8.3
+- Added Overlaycount to Info
+- Addet ResultDecoder for errors
+## 0.8.2
+- Fix a lot of Stuff
+- Use c++17 std::filesystem for RenderD7::Filesystem
+## 0.8.1
+- Add abillity to Get Stdout as string to render it to the screen.
+## 0.8.0
+- Implement BitmapPrinter
+## 0.7.3
+- Implement Over Render Overlay Framework
+## 0.7.2
+- Implement MT to csv file saving
+- Add RGB2HEX
+## 0.7.1
+- Add the New Overlay Handler. Its Just in code and does nothing yet
+## 0.7.0
+- Made Big Progress In the MT Ovl but it still crashes On a 2nd C3D_FrameEnd                                                            \
+- Implement 800px but doesn't work that good
+## 0.6.2
+- Fix Crash when exiting through Home Menu.
+## 0.6.10
+- Rewrite Threadsystem
+- Improve framerate
+## 0.6.02
+- Fix Code in lang.hpp
+- Add Draw Text Left Function (Right since 0.7.0)
+- Add changelog
+## 0.6.01
+- Add Threading system
+## 0.6.0
+- Better Scene Management
+## 0.5.0
+- Fixed some Bugs!
+## 0.4.0 
+- Trying to fix Filesystem and Bugs
+## 0.3.0
+- Recreate D7-Core into RenderD7
+## 0.2.0
+- Trying to create Animations of Images instead of Sheets
+## 0.1.0
+- Inital Release of D7-Core sprite animation plugin

Makefile

@@ -32,7 +32,7 @@ TIME_TIME := $(shell date --iso=seconds)
 # INCLUDES is a list of directories containing header files
 #---------------------------------------------------------------------------------
 TARGET		:=	renderd7
-SOURCES		:=	source external/source
+SOURCES		:=	source source/external source/music
 DATA		:=	data
 INCLUDES	:=	include
 
@@ -41,9 +41,9 @@ INCLUDES	:=	include
 #---------------------------------------------------------------------------------
 ARCH	:=	-march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
 
-CFLAGS	:=	-g -Wall -Werror -mword-relocations -save-temps\
-			-DV_STRING=\"$(GIT_VER)\" \
-			-DV_TIME=\"$(TIME_TIME)\" \
+CFLAGS	:=	-g -Wall -mword-relocations -save-temps\
+			-DV_RD7CSTRING=\"$(GIT_VER)\" \
+			-DV_RD7BTIME=\"$(TIME_TIME)\" \
 			-ffunction-sections -fdata-sections \
 			$(ARCH) $(BUILD_CFLAGS)
 

README.md

@@ -1,4 +1,4 @@
-# <img alt="LOGO" src="https://github.com/NPI-D7/RenderD7/blob/main/logo.png" height="90">
+# <img alt="LOGO" src="https://github.com/NPI-D7/RenderD7/raw/main/logo.png" height="90">
 RenderD7 is now LibRenderD7.
 ### Installation
 Download a Package From Releses Page

include/rd7.hpp

@@ -1,7 +1,16 @@
 #pragma once
 
 #include <renderd7/StealConsole.hpp>
-#include <renderd7/bmp.hpp>
 #include <renderd7/renderd7.hpp>
 #include <renderd7/sound.hpp>
-#include <renderd7/ToastsV2.hpp>
+#include <renderd7/Message.hpp>
+#include <renderd7/DrawV2.hpp>
+#include <renderd7/Hid.hpp>
+#include <renderd7/UI7.hpp>
+#include <renderd7/FileSystem.hpp>
+#include <renderd7/Image.hpp>
+#include <renderd7/Timer.hpp>
+#include <renderd7/music/Music.hpp>
+#include <renderd7/nimg_engine.hpp>
+#include <renderd7/global_db.hpp>
+#include <renderd7/Error.hpp>

include/renderd7/BitmapPrinter.hpp

@@ -1,219 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-#include <renderd7/bmp.hpp>
-#include <renderd7/bmpconverter.hpp>
-
-#include <renderd7/Image.hpp>
-
-#include <renderd7/Screen.hpp>
-#include <renderd7/Time.hpp>
-
-#include <renderd7/Fonts/NFontApi.hpp>
-
-namespace RenderD7 {
-/// @brief Encoder
-enum Encoder {
-  BITMAP, ///< Encode Data to Bitmap
-  DIRECT, ///< Encode Direct to Framebuffer(No Decoder Required)
-  C3D     ///< Encode Directly to C3D_Tex (Just an Idea)
-};
-
-/// @brief Decoder
-enum Decoder {
-  BITMAP2C3D,    ///< Decode and Encode to C3D_Tex (Currently Fastest) (47,4ms)
-  BITMAP2PNG2C3D ///< Decode Bitmap end Convert to Png, then C3D (Very Slow)
-                 ///< (201,4ms)
-};
-
-/// @brief BitmapPrinetr Class
-class BitmapPrinter {
-public:
-  /// @brief Constructor
-  /// @param w Widrth
-  /// @param h Height
-  BitmapPrinter(int w, int h);
-  /// @brief Deconstructor
-  ~BitmapPrinter();
-  /// @brief Dexode Bitmap File
-  /// @param file path to File
-  /// @return success ?
-  bool DecodeFile(std::string file);
-
-  /// @brief Set the Decoder
-  /// @param deccc Decoder
-  void SetDecoder(Decoder deccc) { decc = deccc; }
-  /// @brief Draw a Pixel
-  /// @param x pos x
-  /// @param y pos y
-  /// @param b color blue
-  /// @param g color green
-  /// @param r color red
-  /// @param a color alpha
-  void DrawPixel(int x, int y, u8 b, u8 g, u8 r, u8 a);
-  /// @brief Draw Rectangle
-  /// @param x pos x
-  /// @param y pos y
-  /// @param w width
-  /// @param h height
-  /// @param line_w line width
-  /// @param b color blue
-  /// @param g color green
-  /// @param r color red
-  /// @param a colr alpha
-  void DrawRect(int x, int y, int w, int h, u8 line_w, u8 b, u8 g, u8 r, u8 a);
-  /// @brief Draw a Fillif Rectangle
-  /// @param x pos x
-  /// @param y pos y
-  /// @param w width
-  /// @param h height
-  /// @param b color blue
-  /// @param g color green
-  /// @param r color red
-  /// @param a color alpha
-  void DrawRectFilled(int x, int y, int w, int h, u8 b, u8 g, u8 r, u8 a);
-  /// @brief Draw Bitmap
-  /// @param x pos x
-  /// @param y pos y
-  /// @param map Bitmap to Print
-  void DrawBitmap(int x, int y, BMP map);
-  /// @brief Use Prebuild Bitmap
-  /// @param map bitmap
-  void UsePreMap(BMP map);
-  /// @brief Use Prebuild Printer Setup
-  /// @param printmap Printer
-  void UsePrePrintMap(BitmapPrinter printmap);
-  /// @brief Get Bitmap
-  /// @return Bitmap
-  BMP GetBitmap() { return bitmap; }
-  /// @brief Save to File
-  /// @param name Name/Path
-  void SaveBmp(std::string name);
-  /// @brief Save as Png
-  /// @param name Name/Path
-  void SavePng(std::string name);
-
-  /// @brief Setup Screen
-  /// @param target Screen
-  void CreateScreen(C3D_RenderTarget *target);
-  /// @brief Draw Directly to Screen With Framerate
-  /// @param framerate Framerate
-  /// @return
-  bool DrawScreenDirectF(int framerate);
-  /// @brief Draw Directly to Screen
-  /// @return
-  bool DrawScreenDirect();
-  /// @brief Render on Screen by Framerate
-  /// @param framerate Framerate
-  void DrawScreenF(int framerate);
-  /// @brief Draw to Screen
-  void DrawScreen();
-  /// @brief Update Image by Framerate
-  /// @param framerate Framerate
-  /// @return
-  bool UpdateScreenF(int framerate);
-  /// @brief Update Image
-  /// @return
-  bool UpdateScreen();
-  /// @brief Clear by Color
-  /// @param b color blue
-  /// @param g color green
-  /// @param r color red
-  /// @param a color alpha
-  void Clear(u8 b = 0, u8 g = 0, u8 r = 0, u8 a = 255);
-  /// @brief Clear Completly Blank
-  void ClearBlank();
-  /// @brief Get Rendered Image
-  /// @return Image
-  RenderD7::Image GetImage();
-  /// Test to Find out The Best Settings for BitmapPrinter
-  void Benchmark();
-  /// @brief Setup the Benchmark
-  /// \param framerate The Fps of the ScreenUpdates
-  void SetupBenchmark(int framerate);
-  /// @brief Check if Benchmark is Running
-  /// @return is running or not
-  bool IsBenchmarkRunning() { return this->benchmark; }
-
-  /// @brief Draw a Dubug Text
-  /// @param x pos x
-  /// @param y pos y
-  /// @param t_size Size of the Text
-  /// @param color Color of the Text
-  /// @param text String of the Text
-  void DrawDebugText(int x, int y, int t_size, u32 color, std::string text);
-  /// @brief Draw a Text width NFontApi (TTF)
-  /// @param x pos x
-  /// @param y pos y
-  /// @param t_size size of the Text
-  /// @param color Color of The Text
-  /// @param text String of The Text
-  /// @param font TTF Font
-  void DrawText(int x, int y, float t_size, u32 color, std::string text,
-                RenderD7::NFontApi font);
-
-private:
-  // funcs
-
-  /// @brief Decode 2 RenderD7::Image
-  /// @param deccc Decoder
-  /// @return
-  bool Decode(Decoder deccc);
-  /// @brief Draw Char Func
-  /// @param posX pos x
-  /// @param posY pos y
-  /// @param t_size size
-  /// @param color color
-  /// @param character char
-  void DrawDebugChar(u32 posX, u32 posY, int t_size, u32 color, char character);
-  /// @brief NFont Draw Char
-  /// @param posX pos x
-  /// @param posY pos y
-  /// @param t_size size
-  /// @param color color
-  /// @param character char
-  /// @param font ttf
-  void DrawChar(int posX, int posY, float t_size, u32 color, char character,
-                RenderD7::NFontApi font);
-  // parameter
-  int frame = 0;
-  RenderD7::Image renderframe;
-  bool isscreen = false;
-  C3D_RenderTarget *targetr;
-  BMP bitmap = BMP(
-      20, 20,
-      true); // Need to Set e Predefined Bitmap. If not the System will Crash.
-  BMP blank = BMP(
-      20, 20,
-      true); // Need to Set e Predefined Bitmap. If not the System will Crash.
-
-  ///////////////////////////////////////////////////////////////////////////////////////////////////
-  // Benchmark Stuff;
-  int testfpsd;
-  bool benchmark = false;
-  bool setupbenchmark;
-  float frametime = 0;
-  uint64_t lastTime = 0;
-  float dtt = 0.f;
-  float dtt2 = 0.f;
-  float dtt3 = 0.f;
-  float timer = 0;
-  float mhdtt = 0;
-  float mdtt2;
-  float mdtt3;
-
-  float fpsClock = 0.f;
-  int frameCounter = 0, fps = 0;
-
-  std::vector<float> hdttt;
-  std::vector<float> hdttt2;
-  std::vector<float> hdttt3;
-  std::vector<int> fpscountc;
-  int renderedframes = 0;
-  int testfps = 60;
-  Encoder encc = Encoder::BITMAP;
-  Decoder decc = Decoder::BITMAP2C3D;
-  ////////////////////////////////////////////////////////////////////////////////////////////////
-};
-} // namespace RenderD7

include/renderd7/Color.hpp

@@ -1,22 +1,81 @@
 #pragma once
+#include <unistd.h>
+
 #include <cstring>
 #include <functional>
 #include <memory>
 #include <regex>
 #include <sstream>
 #include <string>
-#include <unistd.h>
 
 #define UNPACK_RGBA(col) (uint8_t)(col >> 24), (col >> 16), (col >> 8), (col)
 #define UNPACK_BGRA(col) (uint8_t)(col >> 8), (col >> 16), (col >> 24), (col)
+// it is actually not RGBA lol
+inline uint32_t RGBA8(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) {
+#define ISIMPLEPAK(x, y) (((x) & 0xff) << y)
+  return (ISIMPLEPAK(r, 0) | ISIMPLEPAK(g, 8) | ISIMPLEPAK(b, 16) |
+          ISIMPLEPAK(a, 24));
+}
+
+/*#define RGBA8(r, g, b, a) \
+  ((((r)&0xFF) << 0) | (((g)&0xFF) << 8) | (((b)&0xFF) << 16) |                \
+   (((a)&0xFF) << 24))*/
+
+typedef int RD7Color;
+
+// MultiColor (Less FunctionNameLen)
+
+struct Color2 {
+  unsigned int color0;
+  unsigned int color1;
+};
+
+struct Color3 {
+  unsigned int color0;
+  unsigned int color1;
+  unsigned int color2;
+};
+
+struct Color4 {
+  unsigned int color0;
+  unsigned int color1;
+  unsigned int color2;
+  unsigned int color3;
+};
+
+enum RD7Color_ {
+  RD7Color_Text,  ///< This Color Should always be used for Light Backgrounds
+  RD7Color_TextDisabled,  /// Text Disabled Color
+  RD7Color_Text2,         ///< And This want for Texts on Dark Backgrounds
+  RD7Color_Background,    ///< Your Bg Color
+  RD7Color_Header,  ///< Header Color (if the header is dark text2 is used)
+  RD7Color_Selector,
+  RD7Color_SelectorFade,
+  RD7Color_List0,
+  RD7Color_List1,
+  RD7Color_MessageBackground,
+  RD7Color_Button,
+  RD7Color_ButtonHovered,
+  RD7Color_ButtonDisabled,
+  RD7Color_ButtonActive,
+  RD7Color_Checkmark,
+  RD7Color_FrameBg,
+  RD7Color_FrameBgHovered,
+  RD7Color_Progressbar,
+};
 
 namespace RenderD7 {
+unsigned int StyleColor(RD7Color color);
+void RedirectColor(RD7Color to, RD7Color from);
+void TextColorByBg(RD7Color background);
+/// @brief Customices a color until undone
+/// For example with RebderD7::Color::Hex
+void CustomizeColor(RD7Color color, unsigned int custom);
+/// @brief Completly changes a theme color
+void ColorNew(RD7Color color, unsigned int new_color);
+void UndoColorEdit(RD7Color color);
+void UndoAllColorEdits();
 namespace Color {
-/// @brief RGBA Struct
-struct rgba {
-  /// @brief rgba Colors
-  uint8_t r, g, b, a;
-};
 /// @brief RGBA Class
 class RGBA {
  public:
@@ -25,12 +84,72 @@ public:
   /// @param g
   /// @param b
   /// @param a
-  RGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+  RGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
       : m_r(r), m_g(g), m_b(b), m_a(a) {}
+  /// @brief Construct
+  /// @param r
+  /// @param g
+  /// @param b
+  /// @param a
+  RGBA(float r, float g, float b, float a = 1.f)
+      : m_r(r * 255.f), m_g(g * 255.f), m_b(b * 255.f), m_a(a * 255.f) {}
+  RGBA(unsigned int in) {
+#define ISIMPLEUNPAK(x, y) (((x) >> y) & 0xFF)
+    m_r = ISIMPLEUNPAK(in, 0);
+    m_g = ISIMPLEUNPAK(in, 8);
+    m_b = ISIMPLEUNPAK(in, 16);
+    m_a = ISIMPLEUNPAK(in, 24);
+  }
+  RGBA(RD7Color in) {
+    unsigned int col = RenderD7::StyleColor(in);
+    m_r = ISIMPLEUNPAK(col, 0);
+    m_g = ISIMPLEUNPAK(col, 8);
+    m_b = ISIMPLEUNPAK(col, 16);
+    m_a = ISIMPLEUNPAK(col, 24);
+  }
+  RGBA &changeR(unsigned char r) {
+    m_r = r;
+    return *this;
+  }
+  RGBA &changeG(unsigned char g) {
+    m_g = g;
+    return *this;
+  }
+  RGBA &changeB(unsigned char b) {
+    m_b = b;
+    return *this;
+  }
+  RGBA &changeA(unsigned char a) {
+    m_a = a;
+    return *this;
+  }
+
+  RGBA &fade_to(const RGBA &color, float p) {
+    m_a =
+        m_a + static_cast<unsigned char>((color.m_a - m_a) * ((p + 1.0f) / 2));
+    m_b =
+        m_b + static_cast<unsigned char>((color.m_b - m_b) * ((p + 1.0f) / 2));
+    m_g =
+        m_g + static_cast<unsigned char>((color.m_g - m_g) * ((p + 1.0f) / 2));
+    m_r =
+        m_r + static_cast<unsigned char>((color.m_r - m_r) * ((p + 1.0f) / 2));
+    return *this;
+  }
+
   /// @brief Get as Uint32
   /// @return color
-  uint32_t toRGBA() const {
-    return (m_r << 24) | (m_g << 16) | (m_b << 8) | m_a;
+  uint32_t toRGBA() const { return RGBA8(m_r, m_g, m_b, m_a); }
+
+  // Just calculate the "lightness" f.e. to use Text or Text2
+  float luminance() const {
+    // For Reference https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness
+    return (0.3 * (m_r / 255.f) + 0.59 * (m_g / 255.f) + 0.11 * (m_b / 255.f));
+  }
+
+  bool is_light() {
+    // Gives us the light or dark to not
+    // always use the below "if" statement
+    return (luminance() >= 0.5);
   }
 
   uint8_t m_r, m_g, m_b, m_a;

include/renderd7/Draw.hpp

@@ -1,111 +0,0 @@
-#pragma once
-#include <3ds.h>
-#include <citro2d.h>
-#include <citro3d.h>
-#include <string>
-
-namespace RenderD7 {
-namespace Draw {
-/// @brief Draw Rectangle
-/// @param x Pos X
-/// @param y Pos Y
-/// @param w Width
-/// @param h Height
-/// @param color Color
-/// @return success ?
-bool Rect(float x, float y, float w, float h, u32 color);
-/// @brief Draw a not filled Rectangle
-/// @param p1x Pos X
-/// @param p1y Pos Y
-/// @param w Width
-/// @param h Height
-/// @param color Color
-/// @param scale Scale
-/// @return success ?
-bool NFRect(float p1x, float p1y, float w, float h, u32 color, float scale = 1);
-/// @brief Draw A Pixel
-/// @param x Pos X
-/// @param y Pos Y
-/// @param color Color
-/// @return success ?
-bool Px(float x, float y, u32 color);
-/// @brief Draw a Centered Text
-/// @param x Pos X
-/// @param y Pos Y
-/// @param size Scale of the Text
-/// @param color Color of The Text
-/// @param Text Striing to Display
-/// @param maxWidth Width to Calculate Centered Pos
-/// @param maxHeight Height to Calculate Centered Pos
-/// @param fnt Custom Font
-void TextCentered(float x, float y, float size, u32 color, std::string Text,
-                  int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
-/// @brief Draw a Text
-/// @param x Pos X
-/// @param y Pos Y
-/// @param size Scale of the Text
-/// @param color Color of The Text
-/// @param Text Striing to Display
-/// @param maxWidth Width to Calculate Centered Pos
-/// @param maxHeight Height to Calculate Centered Pos
-/// @param fnt Custom Font
-void Text(float x, float y, float size, u32 color, std::string Text,
-          int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
-/// @brief Draw a Text Set to the Right
-/// @param x Pos X
-/// @param y Pos Y
-/// @param size Scale of the Text
-/// @param color Color of The Text
-/// @param Text Striing to Display
-/// @param maxWidth Width to Calculate Centered Pos
-/// @param maxHeight Height to Calculate Centered Pos
-/// @param fnt Custom Font
-void TextRight(float x, float y, float size, u32 color, std::string Text,
-               int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
-/// @brief Get Width of Text
-/// @param size Size of the Text
-/// @param Text String of The text
-/// @param fnt Custom Font
-/// @return The Size
-float GetTextWidth(float size, std::string Text, C2D_Font fnt = nullptr);
-/// @brief Get Text Size
-/// @param size Size of The Text
-/// @param width Width of the Text
-/// @param height Height of The Text
-/// @param Text String of Text
-/// @param fnt Custom Font
-void GetTextSize(float size, float *width, float *height, std::string Text,
-                 C2D_Font fnt = nullptr);
-/// @brief Get Height of the Text
-/// @param size Size of the Text
-/// @param Text String of the Text
-/// @param fnt Custom Font
-/// @return The Height
-float GetTextHeight(float size, std::string Text, C2D_Font fnt = nullptr);
-/// @brief Load A .bcfnt
-/// @param fnt Output Font
-/// @param Path path of The File
-/// @return Result Code
-Result LoadFont(C2D_Font &fnt, const char *Path = "");
-/// @brief Unload a Font
-/// @param fnt Font to Unload
-/// @return Result Code
-Result UnloadFont(C2D_Font &fnt);
-/// @brief Draw a Circle
-/// @param x Pos X
-/// @param y Pos Y
-/// @param radius Radius of the Circle
-/// @param color Color of the circle
-/// @return success ?
-bool Circle(float x, float y, float radius, u32 color);
-/// @brief Draw A Citro2D Image
-/// @param img Image to Draw
-/// @param x Pos X
-/// @param y Pos Y
-/// @param scaleX Scale of X-Axis
-/// @param scaleY Scale of Y-Axis
-/// @return success ?
-bool Image(C2D_Image img, float x, float y, float scaleX = 1.0f,
-           float scaleY = 1.0f);
-} // namespace Draw
-} // namespace RenderD7

include/renderd7/DrawV2.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <citro2d.h>
+
+#include <renderd7/Color.hpp>
+#include <renderd7/R7Vec.hpp>
+#include <renderd7/Image.hpp>
+#include <string>
+
+#define MAKEFLAG(x) (1 << x)
+
+typedef unsigned int RD7TextFlags;
+
+enum RD7TextFlags_ {
+  RD7TextFlags_None = 0, //< Align is Left and Other things are disabled
+  RD7TextFlags_AlignRight = MAKEFLAG(0),
+  RD7TextFlags_AlignMid = MAKEFLAG(1),
+  RD7TextFlags_Shaddow = MAKEFLAG(2), // TextBuf Killer lol (doubled Text)
+  RD7TextFlags_Wrap = MAKEFLAG(3),
+  RD7TextFlags_Short = MAKEFLAG(4),
+  RD7TextFlags_Scroll = MAKEFLAG(5),
+};
+
+namespace RenderD7 {
+R7Vec2 GetTextDimensions(const std::string &text);
+void CustomTextSize(float size);
+void TextDefaultSize();
+std::string TextShort(const std::string& in, int max_len);
+// Overrite TextBox Size (by default Screenwidth x Text.h)
+void TextMaxBox(R7Vec2 size);
+void TextDefaultBox();
+void TextFont(C2D_Font fnt);
+void TextDefaultFont();
+namespace Draw2 {
+void Rect(R7Vec2 pos, R7Vec2 size, unsigned int color, int t = 1);
+void RectFilled(R7Vec2 pos, R7Vec2 size, Color4 colors);
+void RectFilledSolid(R7Vec2 pos, R7Vec2 size, unsigned int color);
+// Wrapper of RectFilledSolid
+inline void RFS(R7Vec2 pos, R7Vec2 size, unsigned int color) {
+  RectFilledSolid(pos, size, color);
+}
+void Line(R7Vec2 pos0, R7Vec2 pos1, unsigned int color, int t = 1);
+void Triangle(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, Color3 colors);
+void TriangleSolid(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color);
+// Beta and Very unstable
+void TriangleLined(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color,
+                   int t = 1);
+void Text(R7Vec2 pos, const std::string& text, RD7TextFlags flags = 0);
+void Image(RenderD7::Image* img, const R7Vec2& pos = R7Vec2(0, 0), const R7Vec2& scale = R7Vec2(1, 1));
+} // namespace Draw2
+} // namespace RenderD7

include/renderd7/Error.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+
+namespace RenderD7 {
+    void Error(const std::string& msg);
+    inline void InlineError(const std::string& msg) {
+        std::string location = __FILE__ + std::string(":") + std::to_string(__LINE__);
+        Error("Error: \n" + location + "\n" + msg);
+    }
+    inline void InlineAssert(bool v, const std::string& msg) {
+        std::string location = __FILE__ + std::string(":") + std::to_string(__LINE__);
+        if(v == false)
+            Error("Assert Failed:\n" + location + "\n" + msg);
+    }
+}

include/renderd7/FileSystem.hpp

@@ -1,5 +1,3 @@
-// FileSystem based on libphyfs based on
-// https://github.com/TurtleP/3ds-examples/blob/fs/physfs/fs/physfs/include/filesystem.h
 #pragma once
 #include <string>
 #include <vector>
@@ -19,5 +17,9 @@ struct Entry {
 /// @param path The Path of the Directory
 /// @return The Vector of found Entrys
 std::vector<RenderD7::FileSystem::Entry> GetDirContent(std::string path);
+std::string GetParentPath(std::string path, std::string mount_point);
+std::vector<Entry>
+GetDirContentsExt(std::string &path,
+                  const std::vector<std::string> &extensions);
 } // namespace FileSystem
 } // namespace RenderD7

include/renderd7/Fonts/NFontApi.hpp

@@ -1,142 +0,0 @@
-#pragma once
-#include <bitset>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include <renderd7/external/stb_truetype.h>
-
-#define MAXUNICODE 0x10FFFF
-
-namespace RenderD7 {
-inline int utf8_decode(const char *o) {
-  static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
-  const unsigned char *s = (const unsigned char *)o;
-  unsigned int c = s[0];
-  unsigned int res = 0; /* final result */
-  if (c < 0x80)         /* ascii? */
-    res = c;
-  else {
-    int count = 0;             /* to count number of continuation bytes */
-    while (c & 0x40) {         /* still have continuation bytes? */
-      int cc = s[++count];     /* read next byte */
-      if ((cc & 0xC0) != 0x80) /* not a continuation byte? */
-        return -1;             /* invalid byte sequence */
-      res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */
-      c <<= 1;                        /* to test next bit */
-    }
-    res |= ((c & 0x7F) << (count * 5)); /* add first byte */
-    if (count > 3 || res > MAXUNICODE || res <= limits[count])
-      return -1; /* invalid byte sequence */
-    s += count;  /* skip continuation bytes read */
-  }
-  return res;
-}
-
-inline std::string IntToUtf8(int convertval) {
-
-  // We only care about plane 1 right now,
-  // but know that we have other options (0x10FFFF)
-  // Technically UTF-8 is "limited" to 4 bytes, so it's not
-  // Like it matters much anyways these days
-
-  if (convertval == 0)
-    return " ";
-  if ((convertval <= 0x7F) && (convertval > 0x00)) {
-
-    std::string out(".");
-
-    std::bitset<8> x(convertval);
-
-    unsigned long l = x.to_ulong();
-    unsigned char c = static_cast<unsigned char>(l);
-    out[0] = c;
-
-    return out;
-
-  } else if ((convertval >= 0x80) && (convertval <= 0x07FF)) {
-
-    std::string out("..");
-
-    int firstShift = (convertval >> 0x06) ^ 0xC0;
-    int secondShift = ((convertval ^ 0xFFC0) | 0x80) & ~0x40;
-
-    std::bitset<8> first(firstShift);
-    std::bitset<8> last(secondShift);
-
-    unsigned long l = first.to_ulong();
-    unsigned char c = static_cast<unsigned char>(l);
-    out[0] = c;
-
-    unsigned long ltwo = last.to_ulong();
-    unsigned char ctwo = static_cast<unsigned char>(ltwo);
-    out[1] = ctwo;
-
-    return out;
-
-  } else if ((convertval >= 0x0800) && (convertval <= 0xFFFF)) {
-
-    std::string out("...");
-
-    int firstShift = ((convertval ^ 0xFC0FFF) >> 0x0C) | 0xE0;
-    int secondShift = (((convertval ^ 0xFFF03F) >> 0x06) | 0x80) & ~0x40;
-    int thirdShift = ((convertval ^ 0xFFFC0) | 0x80) & ~0x40;
-
-    std::bitset<8> first(firstShift);
-    std::bitset<8> second(secondShift);
-    std::bitset<8> third(thirdShift);
-
-    unsigned long lone = first.to_ulong();
-    unsigned char cone = static_cast<unsigned char>(lone);
-    out[0] = cone;
-
-    unsigned long ltwo = second.to_ulong();
-    unsigned char ctwo = static_cast<unsigned char>(ltwo);
-    out[1] = ctwo;
-
-    unsigned long lthree = third.to_ulong();
-    unsigned char cthree = static_cast<unsigned char>(lthree);
-    out[2] = cthree;
-
-    return out;
-
-  } else {
-    return " ";
-  }
-}
-#define I2U82I(val) RenderD7::utf8_decode(RenderD7::IntToUtf8(val).c_str())
-
-class NFontApi {
-public:
-  NFontApi();
-  ~NFontApi();
-  void LoadTTF(std::string path);
-  unsigned char *GetGlyphBitmap(char glyph);
-  std::string GetStatus() { return status; }
-  float GetScale() { return scale; }
-  int GetGlyphWidth(char glyph);
-  int GetGlyphHeight(char glyph);
-  int GetLineHeight() { return l_h; }
-  int GetBaseHeight() { return height; }
-
-private:
-  std::string status;
-
-  int height;
-
-  float scale;
-  int b_w;
-  int b_h;
-  int l_h;
-
-  int w;
-  int h;
-
-  int x0, y0, x1, y1;
-  int ascent, baseline, decent, linegap;
-
-  int linespace;
-
-  stbtt_fontinfo font;
-};
-} // namespace RenderD7

include/renderd7/FunctionTrace.hpp

@@ -24,6 +24,7 @@ struct FTRes {
   uint64_t time_start; ///< when started
   uint64_t time_end;   ///< when stopped
   float time_of;       ///< stop - start (how long)
+  bool is_ovl; ///< is displayed in overlay?
 };
 
 /// @brief Map of Traces

include/renderd7/Hid.hpp

@@ -0,0 +1,41 @@
+/// WARNING
+/// THIS IS BETA STUFF
+/// ITS MAKE LIKE EXTERNAL BUT
+/// FOR RENDERD7 ITS INTEGRATED
+
+#pragma once
+
+#include <renderd7/R7Vec.hpp>
+#include <string>
+
+namespace RenderD7 {
+namespace Hid {
+enum Actions {
+  Down = 0,
+  Held = 1,
+  Up = 2,
+  DownRepeat = 3,
+};
+// Register Functions
+// Register Current state values
+void RegKeyDown(uint32_t &key_down);
+void RegKeyHeld(uint32_t &key_held);
+void RegKeyUp(uint32_t &key_up);
+void RegKeyRepeat(uint32_t &repeat);
+void RegTouchCoords(R7Vec2 &touch_pos);
+// Not Corectly Implemented Yet
+void RegAnalog1Movement(R7Vec2 &movement);
+void RegAnalog2Movement(R7Vec2 &movement);
+// Register Keys
+void RegKeyEvent(const std::string &event, uint32_t key);
+// KeyEvents
+bool IsEvent(const std::string &event, Actions action);
+R7Vec2 GetTouchPosition();
+R7Vec2 GetLastTouchPosition();
+void Update();
+// Lock/Unlock Input api for example for Keyboard
+void Lock();
+void Unlock();
+void Clear();
+} // namespace Hid
+} // namespace RenderD7

include/renderd7/Image.hpp

@@ -1,50 +1,30 @@
 #pragma once
+
 #include <citro2d.h>
-#include <citro3d.h>
-#include <memory>
+#include <3ds.h>
 
-#include <renderd7/Sheet.hpp>
-#include <renderd7/bmp.hpp>
-#include <renderd7/bmpconverter.hpp>
+#include <renderd7/R7Vec.hpp>
+#include <renderd7/nimg.hpp>
 
-#include <cassert>
-#include <cstring>
-#include <renderd7/Color.hpp>
-#include <renderd7/external/lodepng.h>
+#include <string>
 
 namespace RenderD7 {
-/// Image Class
     class Image {
         public:
-  /// @brief Constructor
-  Image() {}
-  /// @brief Deconstructor
+        Image();
         ~Image();
-  /// @brief Unload The Image
-  void Unload();
-  /// Load Image from Png
-  /// \param path path to png file
-  void LoadPng(const std::string path);
-  /// Load the Image from buffer
-  /// \param buffer the frame buffer
-  void LoadPFromBuffer(const std::vector<u8> &buffer);
-  void LoadFromBitmap(BMP bitmap);
-  void LoadJpg(std::string path);
-  void LoadPixels(int w, int h, int bpp, void *buffer);
-  /// Draw the Image directly
-  /// \param x The x position
-  /// \param y the y position
-  /// \param scaleX x scale from 0.0 to 1.0
-  /// \param scaleY y scale from 0.0 to 1.0
-  bool Draw(float x, float y, float scaleX = 1.0f, float scaleY = 1.0f);
-  /// \brief Get The Image
-  /// \return C2D_Image
-  C2D_Image Get() { return this->img; }
+        void load(const std::string& path);
+        void from_nimg(const nimg& image);
 
-  void FromSheet(RenderD7::Sheet sheet, size_t index);
-  /// \param img this is the C2D_Image
+        C2D_Image get();
+        C2D_Image& get_ref();
+        void set(const C2D_Image& i);
+        R7Vec2 get_size();
+        bool loaded();
+
+        private:
+        void safe_del();
+        bool ld = false;
         C2D_Image img;
-  /// \param loadet whether the image is loadet or not
-  bool loadet = false;
     };
-} // namespace RenderD7
+}

include/renderd7/Message.hpp

@@ -18,7 +18,7 @@ namespace RenderD7 {
     void ProcessMessages();
     void PushMessage(const Message& msg);
     // Config
-    void SetIdleStartFrame(int frame);
-    void SetTotalAnimationFrames(int total_frames);
-    void SetFadeOutStartFrame(int frame);
+    void SetMessageIdleStartFrame(int frame);
+    void SetMessageTotalAnimationFrames(int total_frames);
+    void SetMessageFadeOutStartFrame(int frame);
 }

include/renderd7/Ovarlays.hpp

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <renderd7/Ovl.hpp>
-
-namespace RenderD7 {
-class Ovl_Ftrace : public RenderD7::Ovl {
-  /// @brief Constructor
-  Ovl_Ftrace();
-  /// @brief Override for Draw
-  void Draw(void) const override;
-  /// @brief Override for Logic
-  void Logic() override;
-
-private:
-};
-} // namespace RenderD7

include/renderd7/Overlays.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <renderd7/Ovl.hpp>
+#include <string>
+
+namespace RenderD7 {
+class Ovl_Ftrace : public RenderD7::Ovl {
+public:
+  /// @brief Constructor
+  Ovl_Ftrace(bool* is_enabled);
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+bool* i_is_enabled;
+};
+
+class Ovl_Metrik : public RenderD7::Ovl {
+public:
+  /// @brief Constructor
+  Ovl_Metrik(bool* is_enabled, bool* screen, uint32_t* mt_color, uint32_t* txt_color, float* txt_size);
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+// Mutable internal values
+mutable std::string mt_fps;
+mutable std::string mt_cpu;
+mutable std::string mt_gpu;
+mutable std::string mt_cmd;
+mutable std::string mt_lfr;
+mutable std::string mt_tbs;
+
+// Importand Adresses
+bool* i_is_enabled;
+bool* i_screen;
+uint32_t* i_mt_color;
+uint32_t* i_txt_color;
+float* i_txt_size;
+};
+
+typedef int RD7Keyboard;
+
+enum RD7Keyboard_ {
+  RD7Keyboard_Default,
+  RD7Keyboard_Numpad,
+  RD7Keyboard_Password,
+};
+
+class Ovl_Keyboard : public RenderD7::Ovl {
+public:
+  /// @brief Constructor
+  /// Keyboard Type not Supported for now
+  Ovl_Keyboard(std::string& ref, const std::string& hint = "", RD7Keyboard type = 0);
+  /// @brief Deconstructor
+  ~Ovl_Keyboard();
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+mutable std::map<unsigned char, char> shared_data;
+// Pointer to useres String
+std::string *typed_text = nullptr;
+std::string str_bak;
+int mode = 0;
+int ft3 = 0;
+};
+} // namespace RenderD7

include/renderd7/R7Vec.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+struct R7Vec2 {
+  // Init Funcs
+  R7Vec2() : x(0), y(0) {}
+  R7Vec2(float i0, float i1) : x(i0), y(i1) {}
+  R7Vec2(const R7Vec2 &i) {
+    x = i.x;
+    y = i.y;
+  }
+
+  // Operators
+  // Add
+  R7Vec2 &operator+=(const R7Vec2 &i) {
+    x += i.x;
+    y += i.y;
+    return *this;
+  }
+  
+  R7Vec2 operator+(const R7Vec2 &i) const { return R7Vec2(x + i.x, y + i.y); }
+
+  // Sub
+  R7Vec2 &operator-=(const R7Vec2 &i) {
+    x -= i.x;
+    y -= i.y;
+    return *this;
+  }
+
+  R7Vec2 operator-(const R7Vec2 &i) const { return R7Vec2(x - i.x, y - i.y); }
+
+  // Compare
+  bool operator==(const R7Vec2 &in) const { return x == in.x && y == in.y; }
+
+  bool operator!=(const R7Vec2 &in) const {
+    // use the first comparefuncs result
+    // and swap it lol
+    return !(*this == in);
+  }
+  // Internal Values
+  float x;
+  float y;
+};

include/renderd7/ResultDecoder.hpp

@@ -43,6 +43,8 @@ public:
   /// @brief Get the Summary Value
   /// @return Summary Value
   int GetSummaryInt();
+  /// @brief Write a Result log file to sd
+  void WriteLog(void);
 
 private:
   /// @param m_rescode Result code

include/renderd7/Sheet.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include <citro2d.h>
 #include <citro3d.h>
+#include <3ds.h> // Result
+#include <string>
 
 namespace RenderD7 {
 /// @brief SpriteSheet Class
@@ -13,7 +15,7 @@ public:
   /// @brief Load A Spritesheet File
   /// @param path Path to the t3x
   /// @return Result Code
-  Result Load(const char *path);
+  Result Load(const std::string& path);
   /// @brief Unload the Sheet
   void Free();
   /// \param spritesheet The Sheet

include/renderd7/Timer.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <3ds.h>
+
+namespace RenderD7 {
+    class Timer {
+        public:
+        Timer(bool autostart = true);
+        ~Timer() {}
+        void reset();
+        void tick();
+        void pause();
+        void resume();
+        float get();
+        float get_live();
+        bool running();
+        private:
+        uint64_t last = 0;
+        uint64_t current = 0;
+        bool is_running = false;
+    };
+}

include/renderd7/UI7.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <algorithm>
+#include <renderd7/R7Vec.hpp>
+#include <renderd7/DrawV2.hpp>
+#include <string>
+#include <vector>
+
+// UI7: The new RenderD7 UI Standart based on
+// Draw2 (based on Citro2D)
+
+#define UI7MAKEFLAG(x) (1 << x)
+
+typedef int UI7MenuFlags;
+
+enum UI7MenuFlags_ {
+  UI7MenuFlags_None = 0,
+  UI7MenuFlags_NoTitlebar = UI7MAKEFLAG(0),
+  UI7MenuFlags_TitleMid = UI7MAKEFLAG(1),
+};
+
+namespace UI7 {
+// Key functions
+void Init();
+void Deinit();
+void Update();
+float GetTime();
+float GetDeltaTime();
+
+bool Button(const std::string &label, R7Vec2 size = R7Vec2(0, 0));
+void Checkbox(const std::string &label, bool &c);
+void Label(const std::string &label, RD7TextFlags flags = 0);
+void Progressbar(float value);
+/// @brief Draw Image in Menu
+/// @param img Pointer f.e to RenderD7::Image2
+void Image(RenderD7::Image* img);
+void BrowserList(const std::vector<std::string> &entrys, int &selection, RD7TextFlags txtflags = 0,
+                 R7Vec2 size = R7Vec2(0, 0), int max_entrys = 13);
+void InputText(const std::string &label, std::string &text,
+               const std::string &hint = "");
+bool BeginMenu(const std::string &title, R7Vec2 size = R7Vec2(0, 0),
+               UI7MenuFlags flags = 0);
+void EndMenu();
+void Grid(const std::string& name, const R7Vec2 &size, R7Vec2(*display_func)(void*, R7Vec2), void**data_array, size_t num_entrys);
+R7Vec2 GetCursorPos();
+void SetCursorPos(R7Vec2 cp);
+void RestoreCursor();
+void SameLine();
+} // namespace UI7

include/renderd7/bmp.hpp

@@ -1,707 +0,0 @@
-#pragma once
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <sstream>
-#include <stdexcept>
-#include <vector>
-
-using namespace std;
-#pragma pack(push, 1)
-
-struct BMPFileHeader {
-  uint16_t file_type{0x4D42}; // File type always BM which is 0x4D42 (stored as
-                              // hex uint16_t in little endian)
-  uint32_t file_size{0};      // Size of the file (in bytes)
-  uint16_t reserved1{0};      // Reserved, always 0
-  uint16_t reserved2{0};      // Reserved, always 0
-  uint32_t offset_data{
-      0}; // Start position of pixel data (bytes from the beginning of the file)
-};
-
-struct BMPInfoHeader {
-  uint32_t size{0}; // Size of this header (in bytes)
-  int32_t width{0}; // width of bitmap in pixels
-  int32_t height{
-      0}; // height of bitmap in pixels
-          //       (if positive, bottom-up, with origin in lower left corner)
-          //       (if negative, top-down, with origin in upper left corner)
-  uint16_t planes{1}; // No. of planes for the target device, this is always 1
-  uint16_t bit_count{0};   // No. of bits per pixel
-  uint32_t compression{0}; // 0 or 3 - uncompressed. THIS PROGRAM CONSIDERS ONLY
-                           // UNCOMPRESSED BMP images
-  uint32_t size_image{0};  // 0 - for uncompressed images
-  int32_t x_pixels_per_meter{0};
-  int32_t y_pixels_per_meter{0};
-  uint32_t colors_used{0}; // No. color indexes in the color table. Use 0 for
-                           // the max number of colors allowed by bit_count
-  uint32_t colors_important{0}; // No. of colors used for displaying the bitmap.
-                                // If 0 all colors are required
-};
-
-struct BMPColorHeader {
-  uint32_t red_mask{0x00ff0000};         // Bit mask for the red channel
-  uint32_t green_mask{0x0000ff00};       // Bit mask for the green channel
-  uint32_t blue_mask{0x000000ff};        // Bit mask for the blue channel
-  uint32_t alpha_mask{0xff000000};       // Bit mask for the alpha channel
-  uint32_t color_space_type{0x73524742}; // Default "sRGB" (0x73524742)
-  uint32_t unused[16]{0};                // Unused data for sRGB color space
-};
-#pragma pack(pop)
-
-class BMP {
-public:
-  BMPFileHeader file_header;
-  BMPInfoHeader bmp_info_header;
-  BMPColorHeader bmp_color_header;
-  std::vector<uint8_t> data;
-
-  BMP(const char *fname) { read(fname); }
-
-  int read(const char *fname) {
-    std::ifstream inp{fname, std::ios_base::binary};
-    if (inp) {
-      inp.read((char *)&file_header, sizeof(file_header));
-      if (file_header.file_type != 0x4D42) {
-
-        return 50;
-        // throw std::runtime_error("Error! Unrecognized file format.");
-      }
-      inp.read((char *)&bmp_info_header, sizeof(bmp_info_header));
-
-      // The BMPColorHeader is used only for transparent images
-      if (bmp_info_header.bit_count == 32) {
-        // Check if the file has bit mask color information
-        if (bmp_info_header.size >=
-            (sizeof(BMPInfoHeader) + sizeof(BMPColorHeader))) {
-          inp.read((char *)&bmp_color_header, sizeof(bmp_color_header));
-          // Check if the pixel data is stored as BGRA and if the color space
-          // type is sRGB
-          check_color_header(bmp_color_header);
-        } else {
-          // std::cerr << "Error! The file \"" << fname << "\" does not seem to
-          // contain bit mask information\n"; return 51;//throw
-          // std::runtime_error("Error! Unrecognized file format.");
-        }
-      }
-
-      // Jump to the pixel data location
-      inp.seekg(file_header.offset_data, inp.beg);
-
-      // Adjust the header fields for output.
-      // Some editors will put extra info in the image file, we only save the
-      // headers and the data.
-      if (bmp_info_header.bit_count == 32) {
-        bmp_info_header.size = sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
-        file_header.offset_data = sizeof(BMPFileHeader) +
-                                  sizeof(BMPInfoHeader) +
-                                  sizeof(BMPColorHeader);
-      } else {
-        bmp_info_header.size = sizeof(BMPInfoHeader);
-        file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
-      }
-      file_header.file_size = file_header.offset_data;
-
-      if (bmp_info_header.height < 0) {
-        return 52; // throw std::runtime_error("The program can treat only BMP
-                   // images with the origin in the bottom left corner!");
-      }
-
-      data.resize(bmp_info_header.width * bmp_info_header.height *
-                  bmp_info_header.bit_count / 8);
-
-      // Here we check if we need to take into account row padding
-      if (bmp_info_header.width % 4 == 0) {
-        inp.read((char *)data.data(), data.size());
-        file_header.file_size += static_cast<uint32_t>(data.size());
-      } else {
-        row_stride = bmp_info_header.width * bmp_info_header.bit_count / 8;
-        uint32_t new_stride = make_stride_aligned(4);
-        std::vector<uint8_t> padding_row(new_stride - row_stride);
-
-        for (int y = 0; y < bmp_info_header.height; ++y) {
-          inp.read((char *)(data.data() + row_stride * y), row_stride);
-          inp.read((char *)padding_row.data(), padding_row.size());
-        }
-        file_header.file_size +=
-            static_cast<uint32_t>(data.size()) +
-            bmp_info_header.height * static_cast<uint32_t>(padding_row.size());
-      }
-    } else {
-      return 53; // throw std::runtime_error("Unable to open the input image
-                 // file   "+std::string(fname));
-    }
-    return 0;
-  }
-
-  int read_mem(std::vector<unsigned char> buffer) {
-    std::stringstream inp;
-    std::copy(buffer.begin(), buffer.end(),
-              std::ostream_iterator<unsigned char>(inp, "\n"));
-    std::cout << buffer.size() << std::endl;
-    if (inp) {
-      inp.read((char *)&file_header, sizeof(file_header));
-      if (file_header.file_type != 0x4D42) {
-
-        return 50;
-        // throw std::runtime_error("Error! Unrecognized file format. Header " +
-        //                          std::to_string(file_header.file_type));
-      }
-      inp.read((char *)&bmp_info_header, sizeof(bmp_info_header));
-
-      // The BMPColorHeader is used only for transparent images
-      if (bmp_info_header.bit_count == 32) {
-        // Check if the file has bit mask color information
-        if (bmp_info_header.size >=
-            (sizeof(BMPInfoHeader) + sizeof(BMPColorHeader))) {
-          inp.read((char *)&bmp_color_header, sizeof(bmp_color_header));
-          // Check if the pixel data is stored as BGRA and if the color space
-          // type is sRGB
-          check_color_header(bmp_color_header);
-        } else {
-          // std::cerr << "Error! The file \"" << fname << "\" does not seem to
-          // contain bit mask information\n";
-          return 51;
-          // throw std::runtime_error("Error! Unrecognized file format. Size");
-        }
-      }
-
-      // Jump to the pixel data location
-      inp.seekg(file_header.offset_data, inp.beg);
-
-      // Adjust the header fields for output.
-      // Some editors will put extra info in the image file, we only save the
-      // headers and the data.
-      if (bmp_info_header.bit_count == 32) {
-        bmp_info_header.size = sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
-        file_header.offset_data = sizeof(BMPFileHeader) +
-                                  sizeof(BMPInfoHeader) +
-                                  sizeof(BMPColorHeader);
-      } else {
-        bmp_info_header.size = sizeof(BMPInfoHeader);
-        file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
-      }
-      file_header.file_size = file_header.offset_data;
-
-      if (bmp_info_header.height < 0) {
-        return 52;
-        // throw std::runtime_error("The program can treat only BMP images with
-        // "
-        //                          "the origin in the bottom left corner!");
-      }
-
-      data.resize(bmp_info_header.width * bmp_info_header.height *
-                  bmp_info_header.bit_count / 8);
-
-      // Here we check if we need to take into account row padding
-      if (bmp_info_header.width % 4 == 0) {
-        inp.read((char *)data.data(), data.size());
-        file_header.file_size += static_cast<uint32_t>(data.size());
-      } else {
-        row_stride = bmp_info_header.width * bmp_info_header.bit_count / 8;
-        uint32_t new_stride = make_stride_aligned(4);
-        std::vector<uint8_t> padding_row(new_stride - row_stride);
-
-        for (int y = 0; y < bmp_info_header.height; ++y) {
-          inp.read((char *)(data.data() + row_stride * y), row_stride);
-          inp.read((char *)padding_row.data(), padding_row.size());
-        }
-        file_header.file_size +=
-            static_cast<uint32_t>(data.size()) +
-            bmp_info_header.height * static_cast<uint32_t>(padding_row.size());
-      }
-    } else {
-      return 53;
-      // throw std::runtime_error("Unable to open the input image buffer");
-    }
-    return 0;
-  }
-
-  BMP(int32_t width, int32_t height, bool has_alpha = true) {
-    if (width <= 0 || height <= 0) {
-      width = 1;
-      height = 1;
-    }
-
-    bmp_info_header.width = width;
-    bmp_info_header.height = height;
-    if (has_alpha) {
-      bmp_info_header.size = sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
-      file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) +
-                                sizeof(BMPColorHeader);
-
-      bmp_info_header.bit_count = 32;
-      bmp_info_header.compression = 3;
-      row_stride = width * 4;
-      data.resize(row_stride * height);
-      file_header.file_size = file_header.offset_data + data.size();
-    } else {
-      bmp_info_header.size = sizeof(BMPInfoHeader);
-      file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
-
-      bmp_info_header.bit_count = 24;
-      bmp_info_header.compression = 0;
-      row_stride = width * 3;
-      data.resize(row_stride * height);
-
-      uint32_t new_stride = make_stride_aligned(4);
-      file_header.file_size =
-          file_header.offset_data + static_cast<uint32_t>(data.size()) +
-          bmp_info_header.height * (new_stride - row_stride);
-    }
-  }
-
-  unsigned write(const char *fname) {
-    std::ofstream of{fname, std::ios_base::binary};
-    if (of) {
-      if (bmp_info_header.bit_count == 32) {
-        write_headers_and_data(of);
-      } else if (bmp_info_header.bit_count == 24) {
-        if (bmp_info_header.width % 4 == 0) {
-          write_headers_and_data(of);
-        } else {
-          uint32_t new_stride = make_stride_aligned(4);
-          std::vector<uint8_t> padding_row(new_stride - row_stride);
-
-          write_headers(of);
-
-          for (int y = 0; y < bmp_info_header.height; ++y) {
-            of.write((const char *)(data.data() + row_stride * y), row_stride);
-            of.write((const char *)padding_row.data(), padding_row.size());
-          }
-        }
-      } else {
-        return 54; // throw std::runtime_error("The program can treat only 24 or
-                   // 32 bits per pixel BMP files");
-      }
-    } else {
-      return 55; // throw std::runtime_error("Unable to open the output image
-                 // file.");
-    }
-    return 0;
-  }
-
-  std::vector<unsigned char> DATA() {
-    std::stringstream ss;
-    if (ss) {
-      if (bmp_info_header.bit_count == 32) {
-        write_headers_and_datass(ss);
-      } else if (bmp_info_header.bit_count == 24) {
-        if (bmp_info_header.width % 4 == 0) {
-          write_headers_and_datass(ss);
-        } else {
-          uint32_t new_stride = make_stride_aligned(4);
-          std::vector<uint8_t> padding_row(new_stride - row_stride);
-
-          write_headersss(ss);
-
-          for (int y = 0; y < bmp_info_header.height; ++y) {
-            ss.write((const char *)(data.data() + row_stride * y), row_stride);
-            ss.write((const char *)padding_row.data(), padding_row.size());
-          }
-        }
-      } else {
-      }
-    } else {
-    }
-    std::string test11 = ss.str();
-    std::vector<unsigned char> test12(test11.begin(), test11.end());
-    return test12;
-  }
-
-  unsigned fill_region(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
-                       uint8_t B, uint8_t G, uint8_t R, uint8_t A) {
-    uint32_t channels = bmp_info_header.bit_count / 8;
-    for (uint32_t y = y0; y < y0 + h; ++y) {
-      for (uint32_t x = x0; x < x0 + w; ++x) {
-        /*if (x + w > (uint32_t)bmp_info_header.width || y + h >
-        (uint32_t)bmp_info_header.height) {
-            //
-        }*/
-        // else{
-        data[channels * (y * bmp_info_header.width + x) + 0] = B;
-        data[channels * (y * bmp_info_header.width + x) + 1] = G;
-        data[channels * (y * bmp_info_header.width + x) + 2] = R;
-        if (channels == 4) {
-          data[channels * (y * bmp_info_header.width + x) + 3] = A;
-        }
-        //}
-      }
-    }
-    return 0;
-  }
-
-  void fill_region_df(uint32_t x1, uint32_t y1, uint32_t w, uint32_t h,
-                      uint8_t B, uint8_t G, uint8_t R, uint8_t A) {
-
-    int x0 = x1;
-    int y0 = this->bmp_info_header.height - y1 - h;
-
-    uint32_t channels = bmp_info_header.bit_count / 8;
-    for (uint32_t y = y0; y < y0 + h; ++y) {
-      for (uint32_t x = x0; x < x0 + w; ++x) {
-        if ((x + w < (uint32_t)bmp_info_header.width) ||
-            this->bmp_info_header.height - y - h > 0) {
-
-          data[channels * (y * bmp_info_header.width + x) + 0] = B;
-          data[channels * (y * bmp_info_header.width + x) + 1] = G;
-          data[channels * (y * bmp_info_header.width + x) + 2] = R;
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-  }
-
-  void manipulate_region(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
-                         uint8_t A) {
-    int choice, choice2, intensity;
-    cout << "What color do you want to change? " << endl;
-    cout << "Enter 1 for Blue, 2 for Green, 3 for Red " << endl;
-    cin >> choice;
-    cout << "To what color do you want to change it too?" << endl;
-    cout << "Enter 1 for Blue, 2 for Green, 3 for Red " << endl;
-    cin >> choice2;
-    cout << "Enter the intensity of the color. (From 0 to 255) " << endl;
-    cin >> intensity;
-    if (x0 + w > (uint32_t)bmp_info_header.width ||
-        y0 + h > (uint32_t)bmp_info_header.height) {
-      return; // throw std::runtime_error("The region does not fit in the
-              // image!");
-    }
-
-    uint32_t channels = bmp_info_header.bit_count / 8;
-    if (choice == 1 && choice2 == 1) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make blue thing blue
-          if (data[channels * (y * bmp_info_header.width + x) + 0] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 0] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = intensity;
-            data[channels * (y * bmp_info_header.width + x) + 1] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 2] = 0;
-          }
-          // data[channels * (y * bmp_info_header.width + x) + 0] = B;
-          // data[channels * (y * bmp_info_header.width + x) + 1] = G;
-          // data[channels * (y * bmp_info_header.width + x) + 2] = R;
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 1 && choice2 == 2) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make blue thing green
-          if (data[channels * (y * bmp_info_header.width + x) + 0] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 0] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 1] = intensity;
-            data[channels * (y * bmp_info_header.width + x) + 2] = 0;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 1 && choice2 == 3) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make blue thing red
-          if (data[channels * (y * bmp_info_header.width + x) + 0] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 0] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 1] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 2] = intensity;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 2 && choice2 == 1) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make green thing blue
-          if (data[channels * (y * bmp_info_header.width + x) + 1] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 1] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = intensity;
-            data[channels * (y * bmp_info_header.width + x) + 1] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 2] = 0;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 2 && choice2 == 2) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make green thing green
-          if (data[channels * (y * bmp_info_header.width + x) + 1] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 1] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 1] = intensity;
-            data[channels * (y * bmp_info_header.width + x) + 2] = 0;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 2 && choice2 == 3) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make green thing red
-          if (data[channels * (y * bmp_info_header.width + x) + 1] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 1] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 1] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 2] = intensity;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 3 && choice2 == 1) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make red thing blue
-          if (data[channels * (y * bmp_info_header.width + x) + 2] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 2] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = intensity;
-            data[channels * (y * bmp_info_header.width + x) + 1] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 2] = 0;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 3 && choice2 == 2) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make red thing green
-          if (data[channels * (y * bmp_info_header.width + x) + 2] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 2] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 1] = intensity;
-            data[channels * (y * bmp_info_header.width + x) + 2] = 0;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-    if (choice == 3 && choice2 == 3) {
-      for (uint32_t y = y0; y < y0 + h; ++y) {
-        for (uint32_t x = x0; x < x0 + w; ++x) {
-          cout << channels * (y * bmp_info_header.width + x) << endl;
-          // Make red thing blue
-          if (data[channels * (y * bmp_info_header.width + x) + 2] > 80 &&
-              data[channels * (y * bmp_info_header.width + x) + 2] < 255) {
-            data[channels * (y * bmp_info_header.width + x) + 0] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 1] = 0;
-            data[channels * (y * bmp_info_header.width + x) + 2] = intensity;
-          }
-          if (channels == 4) {
-            data[channels * (y * bmp_info_header.width + x) + 3] = A;
-          }
-        }
-      }
-    }
-  }
-
-  unsigned set_pixel(uint32_t x0, uint32_t y0, uint8_t B, uint8_t G, uint8_t R,
-                     uint8_t A) {
-    if (x0 >= (uint32_t)bmp_info_header.width ||
-        y0 >= (uint32_t)bmp_info_header.height || x0 < 0 || y0 < 0) {
-      return 59;
-      // std::string errr = "The point is outside the image boundaries! -> " +
-      // std::to_string(x0) + "," + std::to_string(y0); throw
-      // std::runtime_error(errr);
-    }
-    uint32_t channels = bmp_info_header.bit_count / 8;
-    data[channels * (y0 * bmp_info_header.width + x0) + 0] = B;
-    data[channels * (y0 * bmp_info_header.width + x0) + 1] = G;
-    data[channels * (y0 * bmp_info_header.width + x0) + 2] = R;
-    if (channels == 4) {
-      data[channels * (y0 * bmp_info_header.width + x0) + 3] = A;
-    }
-    return 0;
-  }
-
-  void set_pixel_df(uint32_t x0, uint32_t y0, uint8_t B, uint8_t G, uint8_t R,
-                    uint8_t A) {
-    uint32_t y1 = this->bmp_info_header.height - y0;
-    if (x0 >= (uint32_t)bmp_info_header.width ||
-        y1 <= (uint32_t)bmp_info_header.width || x0 < 0 || y0 > 0) {
-      return;
-      // throw std::runtime_error("The point is outside the image boundaries! ->
-      // " + std::to_string(x0) + "," + std::to_string(y1));
-    }
-
-    uint32_t channels = bmp_info_header.bit_count / 8;
-    data[channels * (y0 * bmp_info_header.width + x0) + 0] = B;
-    data[channels * (y0 * bmp_info_header.width + x0) + 1] = G;
-    data[channels * (y0 * bmp_info_header.width + x0) + 2] = R;
-    if (channels == 4) {
-      data[channels * (y0 * bmp_info_header.width + x0) + 3] = A;
-    }
-  }
-
-  uint32_t get_pixel(uint32_t x0, uint32_t y0) {
-    if (x0 >= (uint32_t)bmp_info_header.width ||
-        y0 >= (uint32_t)bmp_info_header.height || x0 < 0 || y0 < 0) {
-      return 59; // throw std::runtime_error("The point is outside the image
-                 // boundaries!");
-    }
-    uint32_t channels = bmp_info_header.bit_count / 8;
-    uint32_t outcol = 0;
-    uint8_t red = 0;
-    uint8_t green = 0;
-    uint8_t blue = 0;
-    uint8_t alpha = 255;
-    blue = data[channels * (y0 * bmp_info_header.width + x0) + 0];
-    green = data[channels * (y0 * bmp_info_header.width + x0) + 1];
-    red = data[channels * (y0 * bmp_info_header.width + x0) + 2];
-    if (channels == 4) {
-      alpha = data[channels * (y0 * bmp_info_header.width + x0) + 3];
-    }
-    outcol = ((red << 24) | (green << 16) | (blue << 8) | alpha);
-    return outcol;
-  }
-
-  uint32_t get_pixel_df(uint32_t x0, uint32_t y0) {
-    uint32_t y1 = this->bmp_info_header.height - y0;
-    if (x0 >= (uint32_t)bmp_info_header.width ||
-        y1 <= (uint32_t)bmp_info_header.width || x0 < 0 || y0 > 0) {
-      return 0; // throw std::runtime_error("The point is outside the image
-                // boundaries!");
-    }
-
-    uint32_t channels = bmp_info_header.bit_count / 8;
-    uint32_t outcol = 0;
-    uint8_t red = 0;
-    uint8_t green = 0;
-    uint8_t blue = 0;
-    uint8_t alpha = 255;
-    blue = data[channels * (y0 * bmp_info_header.width + x0) + 0];
-    green = data[channels * (y0 * bmp_info_header.width + x0) + 1];
-    red = data[channels * (y0 * bmp_info_header.width + x0) + 2];
-    if (channels == 4) {
-      alpha = data[channels * (y0 * bmp_info_header.width + x0) + 3];
-    }
-    outcol = ((red << 24) | (green << 16) | (blue << 8) | alpha);
-    return outcol;
-  }
-
-  unsigned draw_rectangle(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
-                          uint8_t B, uint8_t G, uint8_t R, uint8_t A,
-                          uint8_t line_w) {
-    if (x0 + w > (uint32_t)bmp_info_header.width ||
-        y0 + h > (uint32_t)bmp_info_header.height) {
-      return 59; // throw std::runtime_error("The rectangle does not fit in the
-                 // image!");
-    }
-
-    fill_region(x0, y0, w, line_w, B, G, R, A);                // top line
-    fill_region(x0, (y0 + h - line_w), w, line_w, B, G, R, A); // bottom line
-    fill_region((x0 + w - line_w), (y0 + line_w), line_w, (h - (2 * line_w)), B,
-                G, R, A); // right line
-    fill_region(x0, (y0 + line_w), line_w, (h - (2 * line_w)), B, G, R,
-                A); // left line
-    return 0;
-  }
-
-  void draw_rectangle_df(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
-                         uint8_t B, uint8_t G, uint8_t R, uint8_t A,
-                         uint8_t line_w) {
-    if (x0 + w > (uint32_t)bmp_info_header.width ||
-        y0 + h > (uint32_t)bmp_info_header.height) {
-      return; // throw std::runtime_error("The rectangle does not fit in the
-              // image!");
-    }
-
-    fill_region_df(x0, y0, w, line_w, B, G, R, A);                // top line
-    fill_region_df(x0, (y0 + h - line_w), w, line_w, B, G, R, A); // bottom line
-    fill_region_df((x0 + w - line_w), (y0 + line_w), line_w, (h - (2 * line_w)),
-                   B, G, R, A); // right line
-    fill_region_df(x0, (y0 + line_w), line_w, (h - (2 * line_w)), B, G, R,
-                   A); // left line
-  }
-
-private:
-  uint32_t row_stride{0};
-
-  void write_headers(std::ofstream &of) {
-    of.write((const char *)&file_header, sizeof(file_header));
-    of.write((const char *)&bmp_info_header, sizeof(bmp_info_header));
-    if (bmp_info_header.bit_count == 32) {
-      of.write((const char *)&bmp_color_header, sizeof(bmp_color_header));
-    }
-  }
-
-  void write_headers_and_data(std::ofstream &of) {
-    write_headers(of);
-    of.write((const char *)data.data(), data.size());
-  }
-
-  void write_headersss(std::stringstream &of) {
-    of.write((const char *)&file_header, sizeof(file_header));
-    of.write((const char *)&bmp_info_header, sizeof(bmp_info_header));
-    if (bmp_info_header.bit_count == 32) {
-      of.write((const char *)&bmp_color_header, sizeof(bmp_color_header));
-    }
-  }
-
-  void write_headers_and_datass(std::stringstream &of) {
-    write_headersss(of);
-    of.write((const char *)data.data(), data.size());
-  }
-
-  // Add 1 to the row_stride until it is divisible with align_stride
-  uint32_t make_stride_aligned(uint32_t align_stride) {
-    uint32_t new_stride = row_stride;
-    while (new_stride % align_stride != 0) {
-      new_stride++;
-    }
-    return new_stride;
-  }
-
-  // Check if the pixel data is stored as BGRA and if the color space type is
-  // sRGB
-  void check_color_header(BMPColorHeader &bmp_color_header) {
-    BMPColorHeader expected_color_header;
-    if (expected_color_header.red_mask != bmp_color_header.red_mask ||
-        expected_color_header.blue_mask != bmp_color_header.blue_mask ||
-        expected_color_header.green_mask != bmp_color_header.green_mask ||
-        expected_color_header.alpha_mask != bmp_color_header.alpha_mask) {
-      return; // throw std::runtime_error("Unexpected color mask format! The
-              // program expects the pixel data to be in the BGRA format");
-    }
-    if (expected_color_header.color_space_type !=
-        bmp_color_header.color_space_type) {
-      return; // throw std::runtime_error("Unexpected color space type! The
-              // program expects sRGB values");
-    }
-  }
-};

include/renderd7/bmpconverter.hpp

@@ -1,21 +0,0 @@
-#pragma once
-#include <renderd7/external/lodepng.h>
-
-#include <iostream>
-
-namespace BitmapConverter {
-/// returns 0 if all went ok, non-0 if error
-/// output image is always given in RGBA (with alpha channel), even if it's a
-/// BMP without alpha channel
-unsigned decodeBMP(std::vector<unsigned char> &image, unsigned &w, unsigned &h,
-                   const std::vector<unsigned char> &bmp);
-
-/// @brief Convert A File
-/// @param filename
-/// @return data
-std::vector<unsigned char> ConvertFile(std::string filename);
-/// @brief Convert data
-/// @param data
-/// @return data
-std::vector<unsigned char> ConvertData(std::vector<unsigned char> data);
-} // namespace BitmapConverter

include/renderd7/debugfont.h

@@ -1,187 +0,0 @@
-/*
-  This file was autogenerated by raw2c.
-Visit http://www.devkitpro.org
-*/
-
-//---------------------------------------------------------------------------------
-#ifndef _debugfont_h_
-#define _debugfont_h_
-//---------------------------------------------------------------------------------
-static const unsigned char debugfont[] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81,
-    0xbd, 0x99, 0x81, 0x7e, 0x7e, 0xff, 0xdb, 0xff, 0xc3, 0xe7, 0xff, 0x7e,
-    0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x10, 0x38, 0x7c, 0xfe,
-    0x7c, 0x38, 0x10, 0x00, 0x3c, 0x3c, 0x18, 0xff, 0xe7, 0x18, 0x3c, 0x00,
-    0x10, 0x38, 0x7c, 0xfe, 0xee, 0x10, 0x38, 0x00, 0x00, 0x00, 0x18, 0x3c,
-    0x3c, 0x18, 0x00, 0x00, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff,
-    0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 0xff, 0xc3, 0x99, 0xbd,
-    0xbd, 0x99, 0xc3, 0xff, 0x0f, 0x07, 0x0f, 0x7d, 0xcc, 0xcc, 0xcc, 0x78,
-    0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x08, 0x0c, 0x0a, 0x0a,
-    0x08, 0x78, 0xf0, 0x00, 0x18, 0x14, 0x1a, 0x16, 0x72, 0xe2, 0x0e, 0x1c,
-    0x10, 0x54, 0x38, 0xee, 0x38, 0x54, 0x10, 0x00, 0x80, 0xe0, 0xf8, 0xfe,
-    0xf8, 0xe0, 0x80, 0x00, 0x02, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x02, 0x00,
-    0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x00, 0x66, 0x66, 0x66, 0x66,
-    0x66, 0x00, 0x66, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x00,
-    0x1c, 0x22, 0x38, 0x44, 0x44, 0x38, 0x88, 0x70, 0x00, 0x00, 0x00, 0x00,
-    0x7e, 0x7e, 0x7e, 0x00, 0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x7e,
-    0x18, 0x3c, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18,
-    0x5a, 0x3c, 0x18, 0x00, 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00,
-    0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,
-    0xc0, 0xfe, 0x00, 0x00, 0x00, 0x24, 0x42, 0xff, 0x42, 0x24, 0x00, 0x00,
-    0x00, 0x10, 0x38, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c,
-    0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x18, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x18, 0x00, 0x6c, 0x24, 0x24, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00,
-    0x10, 0x7c, 0xd0, 0x7c, 0x16, 0xfc, 0x10, 0x00, 0x00, 0x66, 0xac, 0xd8,
-    0x36, 0x6a, 0xcc, 0x00, 0x38, 0x4c, 0x38, 0x78, 0xce, 0xcc, 0x7a, 0x00,
-    0x30, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x60,
-    0x60, 0x30, 0x18, 0x00, 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00,
-    0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc,
-    0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20,
-    0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x30, 0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00,
-    0x7c, 0xce, 0xde, 0xf6, 0xe6, 0xe6, 0x7c, 0x00, 0x18, 0x38, 0x78, 0x18,
-    0x18, 0x18, 0x7e, 0x00, 0x7c, 0xc6, 0x06, 0x1c, 0x70, 0xc6, 0xfe, 0x00,
-    0x7c, 0xc6, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00, 0x1c, 0x3c, 0x6c, 0xcc,
-    0xfe, 0x0c, 0x1e, 0x00, 0xfe, 0xc0, 0xfc, 0x06, 0x06, 0xc6, 0x7c, 0x00,
-    0x7c, 0xc6, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00, 0xfe, 0xc6, 0x0c, 0x18,
-    0x30, 0x30, 0x30, 0x00, 0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00,
-    0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x30, 0x00, 0x00,
-    0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20,
-    0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x7e, 0x00,
-    0x00, 0x7e, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00,
-    0x78, 0xcc, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00, 0x7c, 0x82, 0x9e, 0xa6,
-    0x9e, 0x80, 0x7c, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00,
-    0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xfc, 0x00, 0x7c, 0xc6, 0xc0, 0xc0,
-    0xc0, 0xc6, 0x7c, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x66, 0x66, 0xfc, 0x00,
-    0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0xfe, 0x00, 0xfe, 0x62, 0x68, 0x78,
-    0x68, 0x60, 0xf0, 0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0xce, 0xc6, 0x7e, 0x00,
-    0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x3c, 0x18, 0x18, 0x18,
-    0x18, 0x18, 0x3c, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00,
-    0xe6, 0x66, 0x6c, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0xf0, 0x60, 0x60, 0x60,
-    0x62, 0x66, 0xfe, 0x00, 0x82, 0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0x00,
-    0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6,
-    0xc6, 0xc6, 0x7c, 0x00, 0xfc, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00,
-    0x7c, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 0x06, 0xfc, 0x66, 0x66, 0x7c,
-    0x66, 0x66, 0xe6, 0x00, 0x7c, 0xc6, 0xc0, 0x7c, 0x06, 0xc6, 0x7c, 0x00,
-    0x7e, 0x5a, 0x5a, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6,
-    0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00,
-    0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x82, 0x00, 0xc6, 0x6c, 0x38, 0x38,
-    0x38, 0x6c, 0xc6, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x3c, 0x00,
-    0xfe, 0xc6, 0x8c, 0x18, 0x32, 0x66, 0xfe, 0x00, 0x78, 0x60, 0x60, 0x60,
-    0x60, 0x60, 0x78, 0x00, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00,
-    0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00, 0x10, 0x38, 0x6c, 0xc6,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
-    0x30, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c,
-    0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x60, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x00,
-    0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00, 0x1c, 0x0c, 0x0c, 0x7c,
-    0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00,
-    0x1c, 0x36, 0x30, 0x78, 0x30, 0x30, 0x78, 0x00, 0x00, 0x00, 0x76, 0xcc,
-    0xcc, 0x7c, 0x0c, 0x78, 0xe0, 0x60, 0x6c, 0x76, 0x66, 0x66, 0xe6, 0x00,
-    0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x0c, 0x00, 0x1c,
-    0x0c, 0x0c, 0xcc, 0x78, 0xe0, 0x60, 0x66, 0x6c, 0x78, 0x6c, 0xe6, 0x00,
-    0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0xcc, 0xfe,
-    0xd6, 0xd6, 0xd6, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00,
-    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xdc, 0x66,
-    0x66, 0x7c, 0x60, 0xf0, 0x00, 0x00, 0x7c, 0xcc, 0xcc, 0x7c, 0x0c, 0x1e,
-    0x00, 0x00, 0xde, 0x76, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x7c, 0xc0,
-    0x7c, 0x06, 0x7c, 0x00, 0x10, 0x30, 0xfc, 0x30, 0x30, 0x34, 0x18, 0x00,
-    0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0xc6, 0xc6,
-    0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, 0xc6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00,
-    0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0xcc, 0xcc,
-    0xcc, 0x7c, 0x0c, 0xf8, 0x00, 0x00, 0xfc, 0x98, 0x30, 0x64, 0xfc, 0x00,
-    0x0e, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0e, 0x00, 0x18, 0x18, 0x18, 0x00,
-    0x18, 0x18, 0x18, 0x00, 0xe0, 0x30, 0x30, 0x18, 0x30, 0x30, 0xe0, 0x00,
-    0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,
-    0xc6, 0xc6, 0xfe, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x18, 0x70,
-    0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x0e, 0x10, 0x7c, 0xc6,
-    0xfe, 0xc0, 0x7c, 0x00, 0x7c, 0x82, 0x38, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
-    0xcc, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x10, 0x78, 0x0c,
-    0x7c, 0xcc, 0x76, 0x00, 0x30, 0x30, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
-    0x00, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x18, 0x70, 0x7c, 0x82, 0x7c, 0xc6,
-    0xfe, 0xc0, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00,
-    0xe0, 0x10, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00, 0x66, 0x00, 0x38, 0x18,
-    0x18, 0x18, 0x3c, 0x00, 0x7c, 0x82, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00,
-    0xe0, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xc6, 0x00, 0x7c, 0xc6,
-    0xfe, 0xc6, 0xc6, 0x00, 0x38, 0x38, 0x7c, 0xc6, 0xfe, 0xc6, 0xc6, 0x00,
-    0x0e, 0x10, 0xfe, 0x60, 0x78, 0x60, 0xfe, 0x00, 0x00, 0x00, 0x7c, 0x12,
-    0x7e, 0xd0, 0x7e, 0x00, 0x7e, 0xc8, 0xc8, 0xfe, 0xc8, 0xc8, 0xce, 0x00,
-    0x7c, 0x82, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6,
-    0xc6, 0xc6, 0x7c, 0x00, 0xe0, 0x10, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
-    0x7c, 0x82, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0xe0, 0x10, 0xcc, 0xcc,
-    0xcc, 0xcc, 0x76, 0x00, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8,
-    0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0xc6, 0xc6,
-    0xc6, 0xc6, 0x7c, 0x00, 0x18, 0x7c, 0xd6, 0xd0, 0xd6, 0x7c, 0x18, 0x00,
-    0x38, 0x6c, 0x60, 0xf0, 0x60, 0xf2, 0xdc, 0x00, 0x66, 0x3c, 0x18, 0x7e,
-    0x18, 0x7e, 0x18, 0x00, 0xf8, 0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0x06,
-    0x0e, 0x1b, 0x18, 0x3c, 0x18, 0x18, 0xd8, 0x70, 0x0e, 0x10, 0x78, 0x0c,
-    0x7c, 0xcc, 0x76, 0x00, 0x0e, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00,
-    0x0e, 0x10, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x0e, 0x10, 0xcc, 0xcc,
-    0xcc, 0xcc, 0x76, 0x00, 0x66, 0x98, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00,
-    0x66, 0x98, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0x00, 0x38, 0x0c, 0x3c, 0x34,
-    0x00, 0x7e, 0x00, 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, 0x00,
-    0x30, 0x00, 0x30, 0x60, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0xfc,
-    0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x0c, 0x0c, 0x00, 0x00,
-    0xc0, 0xc8, 0xd0, 0xfe, 0x46, 0x8c, 0x1e, 0x00, 0xc0, 0xc8, 0xd0, 0xec,
-    0x5c, 0xbe, 0x0c, 0x00, 0x18, 0x00, 0x18, 0x18, 0x3c, 0x3c, 0x18, 0x00,
-    0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36,
-    0x6c, 0xd8, 0x00, 0x00, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88,
-    0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0xdb, 0x77, 0xdb, 0xee,
-    0xdb, 0x77, 0xdb, 0xee, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18,
-    0xf8, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36,
-    0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x00, 0x00, 0xf8, 0x18,
-    0xf8, 0x18, 0x18, 0x18, 0x36, 0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36,
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0xfe, 0x06,
-    0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00,
-    0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x18, 0x18, 0xf8, 0x18,
-    0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18,
-    0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,
-    0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18,
-    0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
-    0xff, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18,
-    0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,
-    0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00,
-    0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36,
-    0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x00, 0x00, 0xff, 0x00,
-    0xff, 0x00, 0x00, 0x00, 0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36,
-    0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36,
-    0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18,
-    0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x3f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
-    0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36,
-    0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-    0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
-    0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xcc, 0xc8, 0xdc, 0x76, 0x00,
-    0x78, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xdc, 0x40, 0xfe, 0x62, 0x60, 0x60,
-    0x60, 0x60, 0xf0, 0x00, 0x00, 0x02, 0x7e, 0xec, 0x6c, 0x6c, 0x48, 0x00,
-    0xfe, 0x62, 0x30, 0x18, 0x30, 0x62, 0xfe, 0x00, 0x00, 0x00, 0x7e, 0xd0,
-    0xc8, 0xc8, 0x70, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xf8, 0x80,
-    0x00, 0x00, 0x7e, 0xd8, 0x18, 0x18, 0x10, 0x00, 0x38, 0x10, 0x7c, 0xd6,
-    0xd6, 0x7c, 0x10, 0x38, 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x7c, 0x00,
-    0x7c, 0xc6, 0xc6, 0xc6, 0x6c, 0x28, 0xee, 0x00, 0x3c, 0x22, 0x18, 0x7c,
-    0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x66, 0x99, 0x99, 0x66, 0x00, 0x00,
-    0x00, 0x06, 0x7c, 0x9e, 0xf2, 0x7c, 0xc0, 0x00, 0x00, 0x00, 0x7c, 0xc0,
-    0xf8, 0xc0, 0x7c, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
-    0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18,
-    0x18, 0x00, 0x7e, 0x00, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0x00,
-    0x18, 0x30, 0x60, 0x30, 0x18, 0x00, 0x7c, 0x00, 0x0e, 0x1b, 0x1b, 0x18,
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70,
-    0x00, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,
-    0x76, 0xdc, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x3c, 0x00,
-    0xd8, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x30, 0xc0, 0xf0,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x3c, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-
-};
-const int debugfont_size = sizeof(debugfont);
-//---------------------------------------------------------------------------------
-#endif //_font_h_
-//---------------------------------------------------------------------------------

include/renderd7/global_db.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <renderd7/renderd7.hpp>
+#include <renderd7/external/json.hpp>
+
+// Outdated HidApi (HidV2Patched)
+extern u32 d7_hDown;
+extern u32 d7_hHeld;
+extern u32 d7_hUp;
+extern u32 d7_hRepeat;  // Inofficial lol
+extern touchPosition d7_touch;
+
+// Outdated Screens
+extern C3D_RenderTarget *Top;
+extern C3D_RenderTarget *TopRight;
+extern C3D_RenderTarget *Bottom;
+
+// Modern Global Api
+extern int rd7_max_objects;
+extern bool rd7_do_splash;
+extern bool rd7_enable_scene_system;
+extern bool rd7_debugging;
+extern C3D_RenderTarget *rd7_top;
+extern C3D_RenderTarget *rd7_top_right;
+extern C3D_RenderTarget *rd7_bottom;
+
+// Draw2
+extern float rd7_draw2_tsm;

include/renderd7/internal_db.hpp

@@ -0,0 +1,55 @@
+#pragma once
+#include <renderd7/renderd7.hpp>
+#include <renderd7/external/json.hpp>
+#include <renderd7/global_db.hpp>
+
+#define CFGVER "0"
+
+#ifndef V_RD7BTIME
+#define V_RD7BTIME "SUBMODULE"
+#endif
+#ifndef V_RD7CSTRING
+#define V_RD7CSTRING "SUBMODULE"
+#endif
+
+/// Base ///
+extern std::string rd7i_app_name;
+extern std::string rd7i_config_path;
+extern nlohmann::json rd7i_config;
+extern u8 rd7i_console_model;
+extern u8 rd7i_system_region;
+extern bool rd7i_is_citra;
+extern bool rd7i_settings;
+extern R7Vec2 rd7i_hid_touch_pos;
+extern C2D_TextBuf rd7i_text_buffer;
+extern C2D_TextBuf rd7i_d2_dimbuf;
+extern C2D_Font rd7i_base_font;
+extern bool rd7i_is_ndsp;
+extern bool rd7i_running;
+extern std::unique_ptr<RenderD7::Scene> rd7i_fade_scene;
+extern std::vector<std::unique_ptr<RenderD7::Ovl>> rd7i_overlays;
+extern unsigned int rd7i_frames;
+extern u64 rd7i_last_time;
+extern float rd7i_framerate;
+extern u32 rd7i_mt_color;
+extern u32 rd7i_mt_txtcolor;
+extern bool rd7i_mt_screen;
+extern float rd7i_mt_txtSize;
+extern bool rd7i_metrikd;
+extern bool rd7i_ftraced;
+extern bool rd7i_current_screen;
+extern u64 rd7i_delta_time;
+extern u64 rd7i_last_tm;
+extern float rd7i_dtm;
+extern float rd7i_time;
+extern bool rd7i_fadeout;
+extern bool rd7i_fadein;
+extern bool rd7i_fadeout2; 
+extern bool rd7i_fadein2;
+extern int rd7i_fadealpha;
+extern int rd7i_fadecolor;
+extern bool rd7i_wait_fade;
+extern bool rd7i_fade_exit;
+extern bool rd7i_fade_scene_wait;
+extern bool rd7i_idb_running;
+extern bool rd7i_graphics_on;

include/renderd7/music/Mp3.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <renderd7/music/Music.hpp>
+#include <fstream>
+
+#include <mpg123.h>
+
+namespace RenderD7 {
+    class Mp3Decoder : public MusicDecoder {
+        public:
+        Mp3Decoder() {}
+        ~Mp3Decoder() {}
+
+        int _init(const std::string& path, MusicMeta& meta) override;
+        unsigned int _getSampleRate() override;
+        unsigned char _getChannels() override;
+        size_t _getBufSize() override;
+        unsigned long long _decode(signed short* buf_addr) override;
+        void _deinit() override;
+        size_t _getFileSamples() override;
+
+        private:
+        mpg123_handle *hnd = nullptr;
+        size_t buf_size = 0;
+        long rate = 0;
+        int channels = 0;
+    };
+}

include/renderd7/music/Music.hpp

@@ -0,0 +1,90 @@
+// RenderD7 Music Backend
+#pragma once
+
+#include <string>
+
+namespace RenderD7 {
+class MusicMeta {
+ public:
+  MusicMeta() {
+    ititle = "Unknown";
+    ialbum = "Unknown";
+    iyear = "Unknown";
+    iname = "Unknown";
+    ipath = "Unknown";
+    iartist = "Unknown";
+    imdt = "Unknown";
+  }
+  ~MusicMeta() {}
+  std::string name() { return iname; }
+  std::string album() { return ialbum; }
+  std::string year() { return iyear; }
+  std::string title() { return ititle; }
+  std::string path() { return ipath; }
+  std::string artist() { return iartist; }
+  std::string mdt() { return imdt; }
+
+  void name(std::string name) { iname = name; }
+  void album(std::string album) { ialbum = album; }
+  void year(std::string year) { iyear = year; }
+  void title(std::string title) { ititle = title; }
+  void path(std::string path) { ipath = path; }
+  void artist(std::string artist) { iartist = artist; }
+  void mdt(std::string mdt) { imdt = mdt; }
+
+ private:
+  std::string ititle = "";
+  std::string ialbum = "";
+  std::string iyear = "";
+  std::string iname = "";
+  std::string ipath = "";
+  std::string iartist = "";
+  std::string imdt = "";
+};
+
+// Template Class for Decoders
+class MusicDecoder {
+ public:
+  MusicDecoder() = default;
+  virtual ~MusicDecoder() {}
+
+  static void LoadFile(const std::string &path);
+  static void CleanUp();
+
+  static int init(const std::string &path, MusicMeta &meta) {
+    return decoder->_init(path, meta);
+  }
+  static unsigned int getSampleRate() { return decoder->_getSampleRate(); }
+  static unsigned char getChannels() { return decoder->_getChannels(); }
+  static size_t getBufSize() { return decoder->_getBufSize(); }
+  static unsigned long long decode(signed short *buf_addr) {
+    return decoder->_decode(buf_addr);
+  }
+  static void deinit() { decoder->_deinit(); }
+  static size_t getFileSamples() { return decoder->_getFileSamples(); }
+
+  static MusicDecoder *decoder;
+
+ protected:
+  virtual int _init(const std::string &path, MusicMeta &meta) = 0;
+  virtual unsigned int _getSampleRate() = 0;
+  virtual unsigned char _getChannels() = 0;
+  virtual size_t _getBufSize() = 0;
+  virtual unsigned long long _decode(signed short *buf_addr) = 0;
+  virtual void _deinit() = 0;
+  virtual size_t _getFileSamples() = 0;
+};
+
+namespace MusicPlayer {
+void PlayFile(const std::string &path);
+void Play();
+void Pause();
+void Stop();
+bool IsPlaying();
+bool IsRunning();
+int PosCurrent();
+int Total();
+int SampleRate();
+MusicMeta GetMeta();
+}  // namespace MusicPlayer
+}  // namespace RenderD7

include/renderd7/music/Vorbis.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <renderd7/music/Music.hpp>
+#include <fstream>
+
+#include <tremor/ivorbiscodec.h>
+#include <tremor/ivorbisfile.h>
+
+namespace RenderD7 {
+    class VorbisDecoder : public MusicDecoder {
+        public:
+        VorbisDecoder() {}
+        ~VorbisDecoder() {}
+
+        int _init(const std::string& path, MusicMeta& meta) override;
+        unsigned int _getSampleRate() override;
+        unsigned char _getChannels() override;
+        size_t _getBufSize() override;
+        unsigned long long _decode(signed short* buf_addr) override;
+        void _deinit() override;
+        size_t _getFileSamples() override;
+
+        private:
+        OggVorbis_File vorbis_file;
+        vorbis_info *vi;
+        FILE* f; // Only used cause required by lib
+        const size_t buf_size = 8 * 4096;
+    };
+}

include/renderd7/nimg.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+#include <iostream>
+
+#define NPI_NIMG_ (uint32_t)0x4e494d47 // Magic: NIMG
+
+/**
+ * NIMG Format Value Description
+ * int format
+ * 0 = rgba32
+ * 1 = rgb24 (3x8bit)
+ */
+
+/**
+ * NIMG Compression Value Description
+ * int compression
+ * 0 = no compression
+ * 1 = npi_simple_compress (RLE Style)
+ */
+
+namespace RenderD7
+{
+    struct nimg
+    {
+        unsigned int magic; // Magic number defaults do NPI_NIMG_
+        int width;
+        int height;
+        int format;
+        int compression;
+        std::vector<unsigned char> pixel_buffer;
+
+        nimg(int w = 0, int h = 0, int fmt = 0, int cmp = 0)
+        {
+            magic = NPI_NIMG_;
+            width = w;
+            height = h;
+            format = fmt;
+            compression = cmp;
+            pixel_buffer.resize((w*h)*(format ? 3 : 4));
+        }
+    };
+    nimg NIMG_Load(std::string path);
+    nimg NIMG_LoadFromMem(unsigned char* buffer, size_t bf_size);
+    void NIMG_Save(nimg image, std::string path);
+}

include/renderd7/nimg_engine.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <renderd7/nimg.hpp>
+
+namespace RenderD7
+{
+    class NIMG_Engine
+    {
+        public:
+        NIMG_Engine(int w, int h);
+        NIMG_Engine();
+        ~NIMG_Engine();
+        nimg& GetImage() { return image; }
+        void load_file(const std::string& path);
+        void load_nimg(const std::string& path);
+
+        // Rendering
+        void draw_pixel(int x, int y, unsigned int color);
+        void draw_rect(int x, int y, int w, int h, unsigned int color, int t = 1);
+        void draw_rect_solid(int x, int y, int w, int h, unsigned int color);
+        void flip(bool h, bool v);
+
+        private:
+        nimg image;
+    };
+}

include/renderd7/renderd7.hpp

@@ -24,12 +24,9 @@
 #include <citro2d.h>
 #include <citro3d.h>
 /// RenderD7 Includes
-#include <renderd7/BitmapPrinter.hpp>
 #include <renderd7/Color.hpp>
-#include <renderd7/Draw.hpp>
 #include <renderd7/FunctionTrace.hpp>
 #include <renderd7/Hardware.hpp>
-#include <renderd7/Image.hpp>
 #include <renderd7/Memory.hpp>
 #include <renderd7/Ovl.hpp>
 #include <renderd7/ResultDecoder.hpp>
@@ -40,8 +37,6 @@
 #include <renderd7/SpriteAnimation.hpp>
 #include <renderd7/Tasks.hpp>
 #include <renderd7/Time.hpp>
-#include <renderd7/bmp.hpp>
-#include <renderd7/bmpconverter.hpp>
 #include <renderd7/external/lodepng.h>
 #include <renderd7/ini.hpp>
 #include <renderd7/lang.hpp>
@@ -50,78 +45,24 @@
 #include <renderd7/thread.hpp>
 
 #define RENDERD7VSTRING "0.9.5"
-#define CHANGELOG                                                              \
-  "0.9.5: Remove Npi Intro and NVID Api\nReplace Toasts System with "          \
-  "ToastsV2\n  aka MessageHandler\nLots of Optimisations\n"                    \
-  "0.9.4: Implement new Security System\n To prevent from crashes\nImplement " \
-  "Functiontrace for better\nTiming Tests\nImplement MemAlloc Tracker (only "  \
-  "size)\nAdd some new Overlays (not functional yet)\nComplete Rewrite of "    \
-  "Overlay System\nFixed the FrameEnd Crash\nNew System to get Hardware "      \
-  "Info\nRemoved RD7SR\n0.9.3: Completly Documented Everything\nFix typo "     \
-  "in "                                                                        \
-  "Sprite::getHeight()\nRemove Deprecated/Useless Stuff\n0.9.2: Add "          \
-  "NpiSplashVideo\nNvid Support(v0.0.1)\nAdd "                                 \
-  "Basic RenderD7 "                                                            \
-  "Splash\nFaster Graphics Init\nFade Effects\nFix Screen for this "           \
-  "Changelog\n0.9.1: Fix Critical bug in\nSpritesheet animations\nFix "        \
-  "Color "                                                                     \
-  "Conver(Hex)\n0.9.0: Remove Stupid try of Console\nAdd Services list and "   \
-  "Clean up "                                                                  \
-  "Code.\nAlso added Minimal Init for hax2.x\n0.8.5: Fix Deltatime \n0.8.4: "  \
-  "A lot of Fixes and new\nFeatures for BitmapPrinter! \n0.8.3: Addet "        \
-  "Overlaycount to Info\nand Addet ResultDecoder for errors.\n0.8.2: Fix a "   \
-  "lot of Stuff and\nadd c++17 based filesystem class.\n0.8.1: Add abillity "  \
-  "to Get Stdout as string\nto render it to the screen.\n0.8.0: Implement "    \
-  "BitmapPrinter\n0.7.3: Implement Over\nRender Overlay Framework\n0.7.2: "    \
-  "Implement MT to csv file\nsaving.(removed) Add RGB2HEX.\n0.7.1: Add the "   \
-  "New Overlay Handler. Its\nJust in code and does nothing yet.\n0.7.0: Made " \
-  "Big Progress In the MT\nOvl but it still crashes On\na Scnd "               \
-  "C3D_FrameEnd()."                                                            \
-  "\nImplement 800px but\ndoesn't work that good. \n0.6.2: Fix Crash when "    \
-  "exiting\ntrouth Home Menu.\n0.6.10: rewrite Threadsystem,\nImprove "        \
-  "framerate\n0.6.02: Fix Code in lang.hpp\nadd Draw Text Left "               \
-  "Function\n(Right since 0.7.0).\nadd changelog\n0.6.01: add Threading "      \
-  "system.\n0.6.0: Better "                                                    \
-  "Scene Management\n0.5.0: Fixed some Bugs!\n0.4.0: Trying to fix "           \
-  "Filesystem and Bugs!\n0.3.0: Recreate D7-Core into RenderD7!\n0.2.0: "      \
-  "Trying to create Animations of\nImages instead of Sheets!\n0.1.0: Initial " \
-  "Release of\nD7-Core sprite animation plugin!"
 
 #define DEFAULT_CENTER 0.5f
 
-#define RD7_DEPRECATED // __attribute__ ((deprecated))
-
-/// @param d7_hDown Current Key Down
-extern u32 d7_hDown;
-/// @param d7_hHeld Current Key Held
-extern u32 d7_hHeld;
-/// @param d7_hUp Current Key Up
-extern u32 d7_hUp;
-/// @param d7_touch Current Touch Position
-extern touchPosition d7_touch;
-
-/// @param dspststus Dsp Status String
-extern std::string dspststus;
-
 /// @param rd7_do_splash Config Value To Enable RenderD7 Splash
 extern bool rd7_do_splash;
 /// @param rd7_enable_memtrack Config Value to Track Mem Allocations
 extern bool rd7_enable_memtrack;
+/// @param rd7_max_objects Config Param for C2D Mac objects
+extern int rd7_max_objects;
+/// @param rd7_enable_scene_system Enable/Disable Scene System (for example for your own implementations)
+extern bool rd7_enable_scene_system;
 
 /// RenderD7
 namespace RenderD7 {
 /// @brief Get Deltatime
 /// @return Deltatime
 float GetDeltaTime();
-/// @brief Keyboard
-enum kbd {
-  /// @brief libctru Keyboard
-  SWKBD,
-  /// @brief Unk (Not Usable)
-  BKBD
-};
-/// @brief Keyboar Type
-enum kbd_type { NUMPAD, STANDARD };
+
 /// @brief A Button
 struct TObject {
   int x;                 ///< Position X
@@ -138,12 +79,7 @@ public:
   static std::stack<std::unique_ptr<Scene>> scenes;
   /// @brief Deconstructor
   virtual ~Scene() {}
-  /// @brief Logic To Overide
-  /// @param hDown Key Down
-  /// @param hHeld Key Held
-  /// @param hUp Key Up
-  /// @param touch Touch Position
-  virtual void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) = 0;
+  virtual void Logic() = 0;
   /// @brief Draw Func to Override
   virtual void Draw() const = 0;
   /// @brief Push a Scene to Stack
@@ -154,43 +90,31 @@ public:
   static void Back();
   /// @brief do the Draw (Called in RenderD7::MainLoop())
   static void doDraw();
-  /// @brief do the Logic (Called in RenderD7::MainLoop())
-  /// @param hDown Key Down
-  /// @param hHeld Key Held
-  /// @param hUp Key Up
-  /// @param touch Touch Positon
-  static void doLogic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch);
+  static void doLogic();
 };
 
 /// @brief Integrated Setting Menu of RenderD7
 class RSettings : public RenderD7::Scene {
 private:
-  /// @brief Calculate the Changelog Screen Stuff
-  /// @param lines vector of Lines
-  /// @param screen_index Current Screen
-  /// @param screens Count of Possible Screens
-  void calculate_screens(const std::vector<std::string> &lines,
-                         int &screen_index, int &screens);
   /// @brief State (Define for Menus)
   enum RState {
     RSETTINGS,
     RINFO,
     RSERVICES,
-    RCLOG,
     RMCONFIG,
     RFTRACE,
-    RSECM,
+    RUI7,
     RCREDITS
   };
+
+  /// @param shared_request Defines requests from Draw to Logic
+  /// As it is not planned to make Draw non const you'll need
+  /// A map of data or bool values that are mutable ake
+  /// editable by const functions
+  mutable std::map<unsigned int, unsigned int> shared_request;
   /// @param m_state Current menu State (Default=MainMenu aka RSETTINGS)
   RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS;
 
-  /// @param screens Count of Changelog Screens
-  int screens = 0;
-  /// @param screen_index Current Changelog Screen
-  int screen_index = 0;
-  /// @param lines Vector of Changelog-Lines
-  std::vector<std::string> lines;
   /// @brief Position in FTrace Menu
   int ftrace_index = 0;
 
@@ -198,13 +122,9 @@ private:
   std::string mtovlstate = "false";
   /// @param mtscreenstate Screen the Overlay is Set to
   std::string mtscreenstate = "Top";
-
-  /// @param buttons Vector of Buttons
-  std::vector<RenderD7::TObject> buttons = {
-      {20, 35, 120, 35, "NotYET"},      {20, 85, 120, 35, "Changelog"},
-      {20, 135, 120, 35, "Metrik-Ovl"}, {20, 185, 120, 35, "Tasks"},
-      {180, 35, 120, 35, "FTrace"},     {180, 85, 120, 35, "Credits"},
-      {180, 135, 120, 35, "Info"},      {180, 185, 120, 35, "Security"}};
+  std::string kbd_test;
+  bool statemtold = false;
+  bool stateftold = false;
 
 public:
   /// @brief Constructor
@@ -214,30 +134,23 @@ public:
   void Draw(void) const override;
   /// @brief Deconstructor
   ~RSettings();
-  /// @brief Override for Logic
-  /// @param hDown Key Down
-  /// @param hHeld Key Held
-  /// @param hUp Key Up
-  /// @param touch Touch Position
-  void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) override;
+  void Logic() override;
 };
 
 /// @brief Show Up the RenderD7-Settings Menu
 void LoadSettings();
+/// @brief Get's The Programs Time running
+/// @return Time Running
+float GetTime();
+/// @brief Get Framerate as Number
+/// @return FPS
+int GetFps();
 
 /// @brief Get A Rendom Int
 /// @param b From
 /// @param e To
 /// @return Random Int
 int GetRandomInt(int b, int e);
-/// @brief Short a String with (..,)
-/// @param in Input string
-/// @param size Size of Input Text
-/// @param maxlen Max length of texr
-/// @param font Custom Font for Correct Size Calculation
-/// @return Shorted String
-std::string ShortString(std::string in, float size, int maxlen,
-                        C2D_Font font = nullptr);
 /// @brief DrawMetrikOvl (YOUR OWN RISK)
 void DrawMetrikOvl();
 /// @brief Draw Image from RenderD7 Sheet
@@ -259,17 +172,10 @@ void FadeOut();
 /// @brief Display Fade Effects
 void FadeDisplay();
 
-namespace Error {
-/// @brief DEPRECATED Display Error for n Seconds
-/// @param toptext Head Text
-/// @param errortext Error Text
-/// @param timesec Time n to Display in Seconds
-void DisplayError(std::string toptext, std::string errortext, int timesec = 3);
-/// @brief Display A Fatal Error
-/// @param toptext Head Text
-/// @param errortext Error Text
-void DisplayFatalError(std::string toptext, std::string errortext);
-} // namespace Error
+/// @brief Loads a font
+/// @param path path to font (bcfnt)
+/// @return link to C2D_Font Object
+C2D_Font LoadFont(const std::string& path);
 
 namespace Init {
 /// @brief Init Default RenderD7
@@ -289,23 +195,6 @@ void Graphics();
 void NdspFirm();
 } // namespace Init
 
-namespace Msg {
-/// @brief Display A Message
-/// @param titletxt Header Text
-/// @param subtext Message Text
-/// @param target Screen
-void Display(std::string titletxt, std::string subtext,
-             C3D_RenderTarget *target);
-/// @brief Display A Message Wit Progress
-/// @param titletext Header Text
-/// @param subtext Message Text
-/// @param current Current Progress
-/// @param total Total Progress
-/// @param prgbarcolor Color of Progressbar
-void DisplayWithProgress(std::string titletext, std::string subtext,
-                         float current, float total, u32 prgbarcolor);
-} // namespace Msg
-
 namespace Convert {
 /// @brief Convert a String to Flaot
 /// @param inp Input String
@@ -344,59 +233,11 @@ void ExitApp();
 /// @param
 void ClearTextBufs(void);
 
-/// @brief Open A Keyboard (SWKBD)
-/// @param lenght Length of the string
-/// @param tp Type of The Keyboard
-/// @return the string if pressed Ok
-std::string Kbd(int lenght, SwkbdType tp);
-
 /// @brief Draw Overlays And end the Frame. DO NEVER USE C3D_FRAMEEND cause it
 /// breaks Overlay crash Security
 void FrameEnd();
 
-/// @brief Textless Button
-struct TLBtn {
-  int x; ///< Position X
-  int y; ///< Position Y
-  int w; ///< Button Width
-  int h; ///< Button Height
-};
-/// @brief Draw Buttons
-/// @param tobjects Vector of Buttons
-/// @param color Color of the Buttons
-/// @param txtcolor Color of The Text
-/// @param selection Positon of Selection
-/// @param selbgcolor Selection BackgroundColor
-/// @param selcolor Selection Color
-void DrawTObjects(std::vector<RenderD7::TObject> tobjects, u32 color,
-                  u32 txtcolor, int selection = -1,
-                  u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"),
-                  u32 selcolor = RenderD7::Color::Hex("#000000"));
-/// @brief Draw A Single Button
-/// @param tobject Button
-/// @param tobjectindex Button Index
-/// @param color Color of the Button
-/// @param txtcolor Color of The Text
-void DrawSTObject(std::vector<RenderD7::TObject> tobject, int tobjectindex,
-                  u32 color, u32 txtcolor);
-/// @brief Touched A Button
-/// @param touch Touch Position
-/// @param button Button
-/// @return is touched or not
-bool touchTObj(touchPosition touch, RenderD7::TObject button);
-/// @brief Touched A Textless Button
-/// @param touch Touch Position
-/// @param button Button
-/// @return is touched or not
-bool touchTLBtn(touchPosition touch, RenderD7::TLBtn button);
-/// @brief Draw Textless Buttons
-/// @param tobjects Vector of Buttons
-/// @param color Color of the Buttons
-/// @param selection Positon of Selection
-/// @param selbgcolor Selection BackgroundColor
-/// @param selcolor Selection Color
-void DrawTLBtns(std::vector<RenderD7::TLBtn> btns, u32 color,
-                int selection = -1,
-                u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"),
-                u32 selcolor = RenderD7::Color::Hex("#000000"));
+/// @brief Returns App Working Directory path
+/// @return AppDir Path
+std::string GetAppDirectory();
 } // namespace RenderD7

include/renderd7/stringtool.hpp

@@ -11,14 +11,11 @@ namespace RenderD7 {
 /// @return Ends with or not
 inline bool NameIsEndingWith(const std::string &name,
                              const std::vector<std::string> &extensions) {
-  if (name.substr(0, 2) == "._")
-    return false;
+  if (name.substr(0, 2) == "._") return false;
 
-  if (name.size() == 0)
-    return false;
+  if (name.size() == 0) return false;
 
-  if (extensions.size() == 0)
-    return true;
+  if (extensions.size() == 0) return true;
 
   for (int i = 0; i < (int)extensions.size(); i++) {
     const std::string ext = extensions.at(i);
@@ -32,7 +29,7 @@ inline bool NameIsEndingWith(const std::string &name,
 /// Plugins)
 /// @param t_time Time in ms
 /// @return String
-inline std::string MsTimeFmt(float t_time) {
+inline std::string MsTimeFmt(float t_time, bool dems = false) {
   std::ostringstream oss;
 
   if (t_time < 0.001f) {
@@ -46,6 +43,7 @@ inline std::string MsTimeFmt(float t_time) {
     if (seconds > 0) {
       oss << seconds << "s ";
     }
+    if (!dems)
       oss << std::fixed << std::setprecision(2) << milliseconds << "ms";
   } else {
     int minutes = static_cast<int>(t_time / 60000.0f);
@@ -56,24 +54,48 @@ inline std::string MsTimeFmt(float t_time) {
     if (seconds > 0 || milliseconds > 0.0f) {
       oss << seconds << "s ";
     }
-    if (milliseconds > 0.0f) {
+    if (milliseconds > 0.0f && !dems) {
       oss << std::fixed << std::setprecision(2) << milliseconds << "ms";
     }
   }
 
   return oss.str();
 }
+
+inline std::string FormatBytes(int bytes) {
+  char out[32];
+
+  if (bytes == 1)
+    snprintf(out, sizeof(out), "%d Byte", bytes);
+
+  else if (bytes < 1024)
+    snprintf(out, sizeof(out), "%d Bytes", bytes);
+
+  else if (bytes < 1024 * 1024)
+    snprintf(out, sizeof(out), "%.1f KB", (float)bytes / 1024);
+
+  else if (bytes < 1024 * 1024 * 1024)
+    snprintf(out, sizeof(out), "%.1f MB", (float)bytes / 1024 / 1024);
+
+  else
+    snprintf(out, sizeof(out), "%.1f GB", (float)bytes / 1024 / 1024 / 1024);
+
+  return out;
+}
 }  // namespace RenderD7
 
-template <class T> T GetFileName(T const &path, T const &delims = "/\\") {
+template <class T>
+T GetFileName(T const &path, T const &delims = "/\\") {
   return path.substr(path.find_last_of(delims) + 1);
 }
-template <class T> T remove_ext(T const &filename) {
+template <class T>
+T remove_ext(T const &filename) {
   typename T::size_type const p(filename.find_last_of('.'));
   return p > 0 && p != T::npos ? filename.substr(0, p) : filename;
 }
 
-template <typename T> std::string Int_To_Hex(T i) {
+template <typename T>
+std::string Int_To_Hex(T i) {
   std::stringstream stream;
   stream << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex
          << i;

not_functional/Flac.cpp

@@ -0,0 +1,52 @@
+#include <renderd7/music/Flac.hpp>
+#ifdef RENDERD7_MUSICDEC
+#define DR_FLAC_IMPLEMENTATION
+#include <renderd7/external/dr_flac.h>
+
+int rd7i_check_flac(const std::string &path) {
+  int err = -1;
+	drflac* flac = drflac_open_file(path.c_str(), NULL);
+
+	if(flac != NULL)
+		err = 0;
+
+	drflac_close(flac);
+	return err;
+}
+
+namespace RenderD7 {
+int FlacDecoder::_init(const std::string &path, MusicMeta& meta) {
+  meta.path(path);
+  if(path.find_last_of('/') != path.npos)
+    meta.name(path.substr(path.find_last_of('/')));
+  else
+    meta.name(path);
+  flac = drflac_open_file(path.c_str(), NULL);
+  return flac == NULL ? -1 : 0;
+}
+
+unsigned int FlacDecoder::_getSampleRate() { return flac->sampleRate; }
+
+unsigned char FlacDecoder::_getChannels() { return flac->channels; }
+
+size_t FlacDecoder::_getBufSize() { return buf_size; }
+
+unsigned long long FlacDecoder::_decode(signed short*buf_addr) {
+  unsigned long long bsf = (unsigned long long)buf_size/(unsigned long long)flac->channels;
+  
+  unsigned long long samples_read = drflac_read_pcm_frames_s16(flac, bsf, buf_addr);
+  samples_read *= (unsigned long long)flac->channels;
+
+  return samples_read;
+}
+
+void FlacDecoder::_deinit() {
+  drflac_close(flac);
+}
+
+size_t FlacDecoder::_getFileSamples() {
+  return flac->totalPCMFrameCount * (size_t)flac->channels;
+}
+
+} // namespace RenderD7
+#endif

not_functional/Flac.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <renderd7/music/Music.hpp>
+#include <fstream>
+
+#include <renderd7/external/dr_flac.h>
+
+namespace RenderD7 {
+    class FlacDecoder : public MusicDecoder {
+        public:
+        FlacDecoder() {}
+        ~FlacDecoder() {}
+
+        int _init(const std::string& pat, MusicMeta& meta) override;
+        unsigned int _getSampleRate() override;
+        unsigned char _getChannels() override;
+        size_t _getBufSize() override;
+        unsigned long long _decode(signed short* buf_addr) override;
+        void _deinit() override;
+        size_t _getFileSamples() override;
+
+        private:
+        drflac* flac;
+        const size_t buf_size = 16 * 1024;
+    };
+}

not_functional/MUSIC.md

@@ -0,0 +1,40 @@
+# Copy of removed Music.cpp file loaders
+```
+#include <renderd7/music/Flac.hpp>
+#include <renderd7/music/Wav.hpp>
+ // "RIFF"
+/*case 0x46464952:
+// "riff"
+case 0x66666972:
+// "RIFX"
+case 0x58464952:
+// "RF64"
+case 0x34364652:
+// "FORM"
+case 0x4D524F46:
+  decoder = new WavDecoder();
+  if (init(path, rd7i_mp_internal_data.meta)) {
+    MusicDecoder::CleanUp();
+    return;
+  }
+  break;*/
+// Flac
+/*case 0x43614c66:
+  decoder = new FlacDecoder();
+  if (init(path, rd7i_mp_internal_data.meta)) {
+    RenderD7::PushMessage(
+        RenderD7::Message("Music Player", "Failed to load FLAC"));
+    MusicDecoder::CleanUp();
+    return;
+  }
+  break;*/
+
+// The other one
+/*else if (rd7i_check_flac(path) == 0) {
+        decoder = new FlacDecoder();
+        if (init(path, rd7i_mp_internal_data.meta)) {
+          MusicDecoder::CleanUp();
+          return;
+        }
+      }*/
+```

not_functional/Wav.cpp

@@ -0,0 +1,41 @@
+#include <renderd7/music/Wav.hpp>
+
+#ifdef RENDERD7_MUSICDEC
+#define DR_WAV_IMPLEMENTATION
+#include <renderd7/external/dr_wav.h>
+
+namespace RenderD7 {
+int WavDecoder::_init(const std::string &path, MusicMeta& meta) {
+  meta.path(path);
+  if(path.find_last_of('/') != path.npos)
+    meta.name(path.substr(path.find_last_of('/')));
+  else
+    meta.name(path);
+  return !drwav_init_file(&wav, path.c_str(), NULL);
+}
+
+unsigned int WavDecoder::_getSampleRate() { return wav.sampleRate; }
+
+unsigned char WavDecoder::_getChannels() { return wav.channels; }
+
+size_t WavDecoder::_getBufSize() { return buf_size; }
+
+unsigned long long WavDecoder::_decode(signed short*buf_addr) {
+  unsigned long long bsf = (unsigned long long)buf_size/(unsigned long long)wav.channels;
+  
+  unsigned long long samples_read = drwav_read_pcm_frames(&wav, bsf, buf_addr);
+  samples_read *= (unsigned long long)wav.channels;
+
+  return samples_read;
+}
+
+void WavDecoder::_deinit() {
+  drwav_uninit(&wav);
+}
+
+size_t WavDecoder::_getFileSamples() {
+  return wav.totalPCMFrameCount * (size_t)wav.channels;
+}
+
+} // namespace RenderD7
+#endif

not_functional/Wav.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <renderd7/music/Music.hpp>
+#include <fstream>
+
+#include <renderd7/external/dr_wav.h>
+
+namespace RenderD7 {
+    class WavDecoder : public MusicDecoder {
+        public:
+        WavDecoder() {}
+        ~WavDecoder() {}
+
+        int _init(const std::string& path, MusicMeta& meta) override;
+        unsigned int _getSampleRate() override;
+        unsigned char _getChannels() override;
+        size_t _getBufSize() override;
+        unsigned long long _decode(signed short* buf_addr) override;
+        void _deinit() override;
+        size_t _getFileSamples() override;
+
+        private:
+        drwav wav;
+        const size_t buf_size = 16 * 1024;
+    };
+}

rd7tf/Makefile

@@ -52,7 +52,7 @@ else
 GIT_VER := $(shell git rev-parse --short HEAD)
 endif
 
-TIME_TIME := $(shell date --iso=seconds)
+TIME_TIME := unk
 
 #---------------------------------------------------------------------------------
 # Version number
@@ -70,8 +70,11 @@ VERSION_MICRO := 0
 # is located somewhere else
 # Using ../ cause rd7tf is shipped with the RenderD7
 # Repository!
-RENDERD7_SRC := ../source ../external
+RENDERD7_SRC := ../source ../external ../source/music
 RENDERD7_INC := ../include
+# Libraries used for RenderD7
+# if you already use -lm, -lctru etc place a # before -lm
+RENDERD7_LIBS := -lcurl -lm -lcitro2dd -lcitro3d -lctru
 TARGET		:=	rd7tf
 BUILD		:=	build
 SOURCES		:=	source $(RENDERD7_SRC)
@@ -93,7 +96,7 @@ ARCH	:=	-march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
 CFLAGS	:=	-g -Wall -Wno-psabi -O2 -mword-relocations \
 			-DV_STRING=\"$(GIT_VER)\" \
 			-DV_TIME=\"$(TIME_TIME)\" \
-			-fomit-frame-pointer -ffunction-sections \
+			-ffunction-sections \
 			$(ARCH)
 
 CFLAGS	+=	$(INCLUDE) -D__3DS__ -D_GNU_SOURCE=1
@@ -103,7 +106,7 @@ CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++20
 ASFLAGS	:=	-g $(ARCH)
 LDFLAGS	=	-specs=3dsx.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
 
-LIBS	:= -lcurl -lstdc++ -lm -lz -lcitro2d -lcitro3d -lctru -ljpeg 
+LIBS	:= -lstdc++ $(RENDERD7_LIBS) 
 
 
 #---------------------------------------------------------------------------------

rd7tf/source/main.cpp

@@ -1,24 +1,49 @@
-#include <rd7.hpp>
+#include "scene.hpp"
+#include "renderd7/music/Music.hpp"
+
+void ColorThemeSample() {
+  RenderD7::ColorNew(RD7Color_Text, RenderD7::Color::Hex("#000000", 255)); 
+  RenderD7::ColorNew(RD7Color_TextDisabled, RenderD7::Color::Hex("#212121", 200));
+  RenderD7::ColorNew(RD7Color_Text2, RenderD7::Color::Hex("#ffffff", 255));        
+  RenderD7::ColorNew(RD7Color_Background, RenderD7::Color::Hex("#eeeeee", 170));   
+  RenderD7::ColorNew(RD7Color_Header, RenderD7::Color::Hex("#222222", 190));       
+  RenderD7::ColorNew(RD7Color_Selector, RenderD7::Color::Hex("#4444dd", 200));
+  RenderD7::ColorNew(RD7Color_SelectorFade, RenderD7::Color::Hex("#7777dd", 200));
+  RenderD7::ColorNew(RD7Color_List0, RenderD7::Color::Hex("#555555", 130));
+  RenderD7::ColorNew(RD7Color_List1, RenderD7::Color::Hex("#777777", 130));
+  RenderD7::ColorNew(RD7Color_MessageBackground, RenderD7::Color::Hex("#222222", 180));
+  RenderD7::ColorNew(RD7Color_Button, RenderD7::Color::Hex("#4444dd", 150));
+  RenderD7::ColorNew(RD7Color_ButtonHovered, RenderD7::Color::Hex("#6666dd", 150));
+  RenderD7::ColorNew(RD7Color_ButtonDisabled, RenderD7::Color::Hex("#2222dd", 150));
+  RenderD7::ColorNew(RD7Color_ButtonActive, RenderD7::Color::Hex("#7777dd", 150));
+  RenderD7::ColorNew(RD7Color_Checkmark, RenderD7::Color::Hex("#4444dd", 130));
+  RenderD7::ColorNew(RD7Color_FrameBg, RenderD7::Color::Hex("#555555", 160));
+  RenderD7::ColorNew(RD7Color_FrameBgHovered, RenderD7::Color::Hex("#777777", 160));
+  RenderD7::ColorNew(RD7Color_Progressbar, RenderD7::Color::Hex("#4444dd", 200));
+}
+
+extern void IdbServer();
 
 int main() {
+  rd7_enable_memtrack = true;
   rd7_do_splash = true;
   RenderD7::Ftrace::Beg("app", "app_init");
   RenderD7::Init::Main("rd7tf");
+  RenderD7::FadeIn();
+  //RenderD7::InlineAssert(1 == 2, "1 is not 2!");
+  //IdbServer();
+  ColorThemeSample();
   RenderD7::Init::NdspFirm();
-  RenderD7::Ftrace::Beg("app", f2s(RenderD7::LoadSettings));
-  RenderD7::LoadSettings();
-  RenderD7::Ftrace::End("app", f2s(RenderD7::LoadSettings));
-  sound snd("romfs:/thesound.wav", 0);
-  snd.play();
-  RenderD7::PushMessage(RenderD7::Message(std::string("RenderD7 ") + RENDERD7VSTRING, "Testing the ToastsV2"));
+  RenderD7::Scene::Load(std::make_unique<Sample>());
   RenderD7::Ftrace::End("app", "app_init");
   while (RenderD7::MainLoop()) {
+    RenderD7::OnScreen(Top);
     RenderD7::Ftrace::Beg("app", "app_mainloop");
-    if (d7_hDown & KEY_START)
+    if (d7_hDown & KEY_START) {
+      RenderD7::FadeOut();
       RenderD7::ExitApp();
-    if(d7_hDown & KEY_A) {
-      RenderD7::PushMessage(RenderD7::Message(std::string("RenderD7 ") + RENDERD7VSTRING, "Testing the ToastsV2\nPressed A"));
     }
+    RenderD7::OnScreen(Top);
     RenderD7::FrameEnd();
     RenderD7::Ftrace::End("app", "app_mainloop");
   }

rd7tf/source/scene.cpp

@@ -0,0 +1,132 @@
+#include "scene.hpp"
+
+#include <cmath>
+
+static float MakeOffset(float x) {
+  float y = cos(x) * 42;
+  return y - floor(y);
+}
+
+static void Wave(int index, R7Vec2 position, R7Vec2 size, float time,
+                 bool dbg) {
+  float offset = MakeOffset(index) * 62;
+  float x_position =
+      position.x + size.x / 8 * ((index % 11) - 1) + cos(offset + time) * 10;
+  float y_position = position.y + size.y / 8 * (index / 11) + 40 +
+                     sin(offset + time) * 10 + 30;
+  float color_effect = 1 - exp(-(index / 11) / 3.0f);
+
+  // As this is 3ds dont go out of the box
+  int shrink = 0;
+  if (y_position >= position.y + size.y - 90) {
+    shrink = y_position - (position.y + size.y - 90);
+  }
+  // Just to make sure...
+  y_position = std::min(y_position, position.y + size.y - (90 - shrink));
+
+  if (dbg)
+    RenderD7::Draw2::TriangleLined(
+        R7Vec2(x_position, y_position),
+        R7Vec2(x_position + 300, y_position + (90 - shrink)),
+        R7Vec2(x_position - 300, y_position + (90 - shrink)),
+        RenderD7::Color::RGBA(.94f - .17f * color_effect,
+                              .61f - .25f * color_effect,
+                              .36f + .38f * color_effect)
+            .toRGBA());
+  else
+    RenderD7::Draw2::TriangleSolid(
+        R7Vec2(x_position, y_position),
+        R7Vec2(x_position + 300, y_position + (90 - shrink)),
+        R7Vec2(x_position - 300, y_position + (90 - shrink)),
+        RenderD7::Color::RGBA(.94f - .17f * color_effect,
+                              .61f - .25f * color_effect,
+                              .36f + .38f * color_effect)
+            .toRGBA());
+}
+
+void DrawWave(R7Vec2 position, R7Vec2 size, float time, bool dbg) {
+  RenderD7::Draw2::RectFilledSolid(position, size, 0xff64c9fd);
+  int i = 0;
+  for (; i < 44; i++) Wave(i, position, size, time, dbg);
+}
+
+R7Vec2 testv2 = R7Vec2(48, 48);
+
+R7Vec2 grid_display_entry(void* data, R7Vec2 pos) {
+  auto img = reinterpret_cast<RenderD7::Image*>(data);
+  RenderD7::Draw2::Image(img, pos);
+  RenderD7::Draw2::RFS(pos, testv2, RenderD7::Color::Hex("#0000ff", 140));
+  return testv2;
+}
+
+std::vector<RenderD7::Image*> imgdb;
+
+Sample::Sample() {
+  /*RenderD7::Image* im = new RenderD7::Image();
+  im->load("romfs:/icons/icon.png");
+  for(int i = 0; i < 64; i++) 
+    imgdb.push_back(im);*/
+  auto t = RenderD7::FileSystem::GetDirContent("sdmc:/music/");
+  for(const auto& it : t)
+    names.push_back(it.path);
+}
+
+Sample::~Sample() {
+  // Here you can clear your data
+}
+
+void Sample::Draw() const {
+  // Draw Things to Screen:
+  // Step 1 -> Select Screen
+  RenderD7::OnScreen(Top);
+  // Step 2 -> Draw Things
+  // The hbloader Triangle Wave
+  DrawWave(R7Vec2(0, 0), R7Vec2(400, 240), RenderD7::GetTime(),
+           debug_background);
+  // For Example A Rect with Draw2 and StyleColorApi
+  // And the RFS Wrapper for RectFilledSolid lol
+  /*RenderD7::Draw2::RFS(R7Vec2(0, 0), R7Vec2(400, 20),
+                       RenderD7::StyleColor(RD7Color_Header));
+  // As the Top bar is Dark you need TextColor2
+  RenderD7::RedirectColor(RD7Color_Text, RD7Color_Text2);
+  RenderD7::Draw2::Text(R7Vec2(5, 2), "RenderD7 - Test Framework");
+  RenderD7::Draw2::Text(R7Vec2(395, 2), RENDERD7VSTRING,
+                        RD7TextFlags_AlignRight);
+  RenderD7::UndoColorEdit(RD7Color_Text);*/
+  if (UI7::BeginMenu("RenderD7 Test Framework")) {
+    UI7::SetCursorPos(R7Vec2(395, 2));
+    UI7::Label(RenderD7::FormatBytes(RenderD7::Memory::GetCurrent()), RD7TextFlags_AlignRight);
+    UI7::RestoreCursor();
+    //UI7::Grid("Files", R7Vec2(390, 210), grid_display_entry, reinterpret_cast<void**>(imgdb.data()), imgdb.size());
+    UI7::BrowserList(names, sel);
+    UI7::EndMenu();
+  }
+  RenderD7::OnScreen(Bottom);
+  if (UI7::BeginMenu("Control Center")) {
+    if (UI7::Button("RenderD7 Settings"))
+      shared_requests[1U] = 1U;  // Request a Toggle
+    UI7::SameLine();
+    if (UI7::Button("Test Message"))
+      shared_requests[2U] = 1U;  // Request Test Msg
+    UI7::Checkbox("Debug BG", debug_background);
+    UI7::SameLine();
+    UI7::Checkbox("RD7-Debug", rd7_debugging);
+    UI7::InputText("Search", search__, "Tap Here");
+    UI7::EndMenu();
+  }
+}
+
+void Sample::Logic() {
+  for (const auto& it : shared_requests) {
+    if (it.first == 1U) {
+      if (it.second) RenderD7::LoadSettings();
+    } else if (it.first == 2U) {
+      if (it.second)
+        RenderD7::PushMessage(RenderD7::Message(
+            "Test Message", "Button Bressed\nBest Msg Handler..."));
+    }
+  }
+  // Make sure to clear after processing!!!;
+  shared_requests.clear();
+  if (d7_hDown & KEY_B) debug_background = !debug_background;
+}

rd7tf/source/scene.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <rd7.hpp>
+
+class Sample : public RenderD7::Scene {
+public:
+  Sample();
+  ~Sample();
+
+  void Draw() const override;
+  void Logic() override;
+
+private:
+  // Just as the RD7 Settings Shows here as example
+  // by using a mutale map you're able to process
+  // requests from the const Draw function in the
+  // Logic Function! you could also create lots of
+  // mutable bool or make all Variables mutable but
+  // i think seperating draw and logic is better
+  // editable map  request_id    data/operation
+  mutable std::map<unsigned int, unsigned int> shared_requests;
+  // For Checkbox its best to use mutable
+  mutable bool debug_background = false;
+  mutable std::string search__ = "";
+  mutable std::vector<std::string> names;
+  mutable int sel;
+};

source/BitmapPrinter.cpp

@@ -1,475 +0,0 @@
-#include <renderd7/BitmapPrinter.hpp>
-#include <renderd7/ToastsV2.hpp>
-#include <renderd7/stringtool.hpp>
-
-
-extern bool shouldbe_disabled;
-extern std::string csvpc;
-
-RenderD7::BitmapPrinter::BitmapPrinter(int w, int h) {
-  BMP newmap(w, h, true);
-  bitmap = newmap;
-  // renderframe.LoadPFromBuffer(BitmapConverter::ConvertData(bitmap.DATA()));
-  blank = newmap;
-}
-
-RenderD7::BitmapPrinter::~BitmapPrinter() {
-  if (this->renderframe.loadet)
-    this->renderframe.Unload();
-}
-
-bool RenderD7::BitmapPrinter::DecodeFile(std::string file) {
-  unsigned error = bitmap.read(file.c_str());
-
-  if (error) {
-    RenderD7::PushMessage(RenderD7::Message(
-        "BitmapPrinter", "Error Code: " + std::to_string(error)));
-    return false;
-  }
-
-  return true;
-}
-
-void RenderD7::BitmapPrinter::DrawPixel(int x, int y, u8 b, u8 g, u8 r, u8 a) {
-  unsigned error =
-      bitmap.set_pixel(x, bitmap.bmp_info_header.height - y, b, g, r, a);
-  if (error) {
-    RenderD7::PushMessage(RenderD7::Message(
-        "BitmapPrinter->Pixel", "Error Code: " + std::to_string(error)));
-  }
-}
-void RenderD7::BitmapPrinter::DrawRect(int x, int y, int w, int h, u8 line_w,
-                                       u8 b, u8 g, u8 r, u8 a) {
-  unsigned error = bitmap.draw_rectangle(
-      x, bitmap.bmp_info_header.height - y - h, w, h, b, g, r, a, line_w);
-  if (error) {
-    RenderD7::PushMessage(RenderD7::Message(
-        "BitmapPrinter->Rect", "Error Code: " + std::to_string(error)));
-  }
-}
-
-void RenderD7::BitmapPrinter::DrawRectFilled(int x, int y, int w, int h, u8 b,
-                                             u8 g, u8 r, u8 a) {
-  unsigned error = bitmap.fill_region(x, bitmap.bmp_info_header.height - h - y,
-                                      w, h, b, g, r, a);
-  if (error) {
-    RenderD7::PushMessage(RenderD7::Message(
-        "BitmapPrinter->RectF", "Error Code: " + std::to_string(error)));
-  }
-}
-
-void RenderD7::BitmapPrinter::SaveBmp(std::string name) {
-  if (!RenderD7::NameIsEndingWith(name, {"bmp"})) {
-    name += ".bmp";
-  }
-  bitmap.write(name.c_str());
-}
-void RenderD7::BitmapPrinter::SavePng(std::string name) {
-  if (!RenderD7::NameIsEndingWith(name, {"png"})) {
-    name += ".png";
-  }
-  std::vector<unsigned char> ImageBuffer;
-  ImageBuffer = BitmapConverter::ConvertData(bitmap.DATA());
-  lodepng::save_file(ImageBuffer, name);
-}
-
-void RenderD7::BitmapPrinter::CreateScreen(C3D_RenderTarget *target) {
-  isscreen = true;
-  targetr = target;
-  if (target == Top) {
-    bitmap = BMP(400, 240, true);
-    blank = BMP(400, 240, true);
-  }
-  if (target == TopRight) {
-    bitmap = BMP(400, 240, true);
-    blank = BMP(400, 240, true);
-  }
-  if (target == Bottom) {
-    bitmap = BMP(320, 240, true);
-    blank = BMP(320, 240, true);
-  }
-  renderframe.LoadPFromBuffer(BitmapConverter::ConvertData(bitmap.DATA()));
-}
-bool RenderD7::BitmapPrinter::DrawScreenDirectF(int framerate) {
-  bool updtt = false;
-  if (isscreen) {
-    if (frame == (60 / framerate)) {
-      RenderD7::OnScreen(targetr);
-      if (renderframe.loadet)
-        renderframe.Unload();
-      this->Decode(decc);
-      frame = 0;
-      updtt = true;
-    }
-
-    if (renderframe.loadet)
-      renderframe.Draw(0, 0);
-    frame++;
-  }
-  return updtt;
-}
-
-bool RenderD7::BitmapPrinter::DrawScreenDirect() {
-  bool updtt = false;
-  if (isscreen) {
-    RenderD7::OnScreen(targetr);
-    if (renderframe.loadet)
-      renderframe.Unload();
-    this->Decode(decc);
-    updtt = true;
-    if (renderframe.loadet)
-      renderframe.Draw(0, 0);
-  }
-  return updtt;
-}
-
-RenderD7::Image RenderD7::BitmapPrinter::GetImage() {
-  RenderD7::Image img;
-  img.LoadFromBitmap(bitmap);
-  return img;
-}
-
-void RenderD7::BitmapPrinter::UsePreMap(BMP map) { bitmap = map; }
-void RenderD7::BitmapPrinter::UsePrePrintMap(BitmapPrinter printmap) {
-  bitmap = printmap.GetBitmap();
-}
-
-void RenderD7::BitmapPrinter::Clear(u8 b, u8 g, u8 r, u8 a) {
-  bitmap.fill_region(0, 0, bitmap.bmp_info_header.width,
-                     bitmap.bmp_info_header.height, b, g, r, a);
-}
-void RenderD7::BitmapPrinter::ClearBlank() { bitmap = blank; }
-
-void RenderD7::BitmapPrinter::DrawScreenF(int framerate) {
-  if (isscreen) {
-    if (frame == (60 / framerate)) {
-      RenderD7::OnScreen(targetr);
-      frame = 0;
-    }
-
-    if (renderframe.loadet)
-      renderframe.Draw(0, 0);
-    frame++;
-  }
-}
-void RenderD7::BitmapPrinter::DrawScreen() {
-  if (isscreen) {
-    RenderD7::OnScreen(targetr);
-    if (renderframe.loadet)
-      renderframe.Draw(0, 0);
-  }
-}
-bool RenderD7::BitmapPrinter::UpdateScreenF(int framerate) {
-  bool updtt = false;
-  if (isscreen) {
-    if (frame == (60 / framerate)) {
-      if (renderframe.loadet)
-        renderframe.Unload();
-      // renderframe.LoadFromBitmap(bitmap);
-      this->Decode(decc);
-      frame = 0;
-      updtt = true;
-    }
-    frame++;
-  }
-  return updtt;
-}
-bool RenderD7::BitmapPrinter::UpdateScreen() {
-  bool updtt = false;
-  if (isscreen) {
-    if (renderframe.loadet)
-      renderframe.Unload();
-    this->Decode(decc);
-    updtt = true;
-  }
-  return updtt;
-}
-
-#define TICKS_PER_MSEC 268111.856
-
-void RenderD7::BitmapPrinter::Benchmark() {
-  if (setupbenchmark) {
-    frametime = 0;
-    renderedframes = 0;
-    timer = 0;
-    setupbenchmark = false;
-    lastTime = svcGetSystemTick();
-  }
-  if (benchmark) {
-    if (timer >= 60) {
-      std::string renderedf = std::to_string(renderedframes);
-      std::string avgdtt = std::to_string(mhdtt);
-      float alldtt = 0;
-      for (size_t i = 1; i < hdttt.size(); i++) {
-        alldtt += hdttt[i];
-      }
-      float alldtt2 = 0;
-      for (size_t i = 0; i < hdttt2.size(); i++) {
-        alldtt2 += hdttt2[i];
-      }
-      float alldtt3 = 0;
-      for (size_t i = 0; i < hdttt3.size(); i++) {
-        alldtt3 += hdttt3[i];
-      }
-      int allfps = 0;
-      for (size_t f = 1; f < fpscountc.size(); f++) {
-        allfps += fpscountc[f];
-      }
-
-      std::string avgcpu = std::to_string((alldtt / (float)hdttt.size() - 1));
-      std::string avgcpu2 =
-          std::to_string(((alldtt2 / (float)hdttt2.size()) * 1000));
-      std::string avgcpu3 =
-          std::to_string(((alldtt3 / (float)hdttt3.size()) * 1000));
-      std::string avgfps = std::to_string((allfps / (int)fpscountc.size() - 1));
-
-      std::string resultt =
-          "TestMode: " + std::to_string(testfpsd) + "fps" +
-          "\nRendered Frames: " + renderedf + "\nMax Cpu Time: " + avgdtt +
-          "\nAvg Cpu Time: " + avgcpu + "\nAvg Fps: " + avgfps +
-          "\nAvg EncodeTime: " + avgcpu2 + "ms/f\nAvg DecodeTime: " + avgcpu3 +
-          "ms\n";
-      this->ClearBlank();
-      this->DrawRectFilled(0, 0, this->bitmap.bmp_info_header.width,
-                           this->bitmap.bmp_info_header.height, 0, 0, 0, 255);
-      this->DrawDebugText(0, 0, 0, RenderD7::Color::Hex("#ffffff"), resultt);
-      std::string outname =
-          csvpc + "/benchmark_" + RenderD7::GetTimeStr() + ".png";
-      this->SavePng(outname);
-      RenderD7::PushMessage(
-          RenderD7::Message("Benchmark", "Saved to: \n" + outname));
-      benchmark = false;
-    }
-    uint64_t currentTime = svcGetSystemTick();
-    dtt = ((float)(currentTime / (float)TICKS_PER_MSEC) -
-           (float)(lastTime / (float)TICKS_PER_MSEC)) /
-          1000.f;
-    lastTime = currentTime;
-    lastTime = currentTime;
-    frameCounter++;
-    fpsClock += dtt;
-    if (fpsClock >= 1.f) {
-      fps = frameCounter;
-      frameCounter = 0;
-      fpsClock = 0.f;
-    }
-    uint64_t lastTime2 = svcGetSystemTick();
-    this->ClearBlank();
-    this->DrawRectFilled(0, 0, this->bitmap.bmp_info_header.width,
-                         this->bitmap.bmp_info_header.width, 255, 255, 255,
-                         255);
-    this->DrawRect(5, 5, this->bitmap.bmp_info_header.width - 10,
-                   this->bitmap.bmp_info_header.height - 10, 5, 0, 0, 0, 0);
-    // this->DrawDebugText(20, 20, 0, RenderD7::Color::Hex("#ffffff"), "Fps: " +
-    // std::to_string(fps));
-    this->DrawDebugText(0, 0, 0.5f, RenderD7::Color::Hex("#ff0000"),
-                        "Time: " + std::to_string(timer));
-    this->DrawDebugText(0, 10, 0.5f, RenderD7::Color::Hex("#ff0000"),
-                        "Fps: " + std::to_string(fps));
-    this->DrawDebugText(0, 20, 0.5f, RenderD7::Color::Hex("#ff0000"),
-                        "dt: " + std::to_string(dtt));
-    this->DrawDebugText(0, 30, 0.5f, RenderD7::Color::Hex("#ff0000"),
-                        "MaxEncodeTime: " + std::to_string(mdtt2 * 1000) +
-                            "ms/f");
-    this->DrawDebugText(0, 40, 0.5f, RenderD7::Color::Hex("#ff0000"),
-                        "MaxDecodeTime: " + std::to_string(mdtt3 * 1000) +
-                            "ms");
-    uint64_t currentTime2 = svcGetSystemTick();
-    dtt2 = ((float)(currentTime2 / (float)TICKS_PER_MSEC) -
-            (float)(lastTime2 / (float)TICKS_PER_MSEC)) /
-           1000.f;
-    hdttt2.push_back(dtt2);
-    lastTime2 = svcGetSystemTick();
-    bool updgg = this->UpdateScreenF(testfps);
-    currentTime2 = svcGetSystemTick();
-    dtt3 = ((float)(currentTime2 / (float)TICKS_PER_MSEC) -
-            (float)(lastTime2 / (float)TICKS_PER_MSEC)) /
-           1000.f;
-    if (updgg)
-      hdttt3.push_back(dtt3);
-    if (!shouldbe_disabled)
-      this->DrawScreen();
-    renderedframes++;
-    if (mdtt2 < dtt2) {
-      mdtt2 = dtt2;
-    }
-    if (mdtt3 < dtt3 && updgg) {
-      mdtt3 = dtt3;
-    }
-    timer += 1 * dtt;
-    float hdtt = C3D_GetProcessingTime();
-    hdttt.push_back(hdtt);
-    fpscountc.push_back(fps);
-    if (mhdtt < hdtt) {
-      mhdtt = C3D_GetProcessingTime();
-    }
-    /*if (!shouldbe_disabled)
-    {
-            RenderD7::OnScreen(Bottom);
-            RenderD7::DrawText(0, 0, 0.5f, RenderD7::Color::Hex("#ff0000"),
-    "Time: " + std::to_string(timer)); RenderD7::DrawText(0, 20, 0.5f,
-    RenderD7::Color::Hex("#ff0000"), "Fps: " + std::to_string(fps));
-            RenderD7::DrawText(0, 40, 0.5f, RenderD7::Color::Hex("#ff0000"),
-    "dt: " + std::to_string(dtt)); RenderD7::DrawText(0, 60, 0.5f,
-    RenderD7::Color::Hex("#ff0000"), "MaxRenderTime: " +
-    std::to_string(mdtt2*1000) + "ms/f"); RenderD7::DrawText(0, 80, 0.5f,
-    RenderD7::Color::Hex("#ff0000"), "MaxConvertTime: " +
-    std::to_string(mdtt3*1000) + "ms");
-
-    }*/
-  }
-}
-
-void RenderD7::BitmapPrinter::SetupBenchmark(int framerate) {
-  benchmark = true;
-  setupbenchmark = true;
-  this->testfps = framerate;
-  this->testfpsd = framerate;
-}
-
-#include <renderd7/debugfont.h>
-
-void RenderD7::BitmapPrinter::DrawDebugChar(u32 posX, u32 posY, int t_size,
-                                            u32 color, char character) {
-  bool isscale = (t_size > 1) ? true : false;
-  for (u32 y = 0; y < 8; y++) {
-    char charPos = debugfont[character * 8 + y];
-
-    for (u32 x = 0; x < 8; x++)
-      if (((charPos >> (7 - x)) & 1) == 1) {
-        if (!isscale)
-          DrawPixel((int)posX + x + 1, (int)posY + y + 1, UNPACK_BGRA(color));
-        if (isscale)
-          DrawRectFilled(((int)posX) + (x * t_size) + 1,
-                         ((int)posY) + (y * t_size) + 1, t_size, t_size,
-                         UNPACK_BGRA(color));
-      }
-  }
-}
-
-void RenderD7::BitmapPrinter::DrawChar(int posX, int posY, float t_size,
-                                       u32 color, char character,
-                                       RenderD7::NFontApi font) {
-  for (int y = 0; y < font.GetGlyphHeight(character); y++) {
-    for (int x = 0; x < font.GetGlyphWidth(character); x++) {
-      DrawPixel(posX + x + 1, posY + y + 1, 255, 255, 255,
-                font.GetGlyphBitmap(
-                    character)[((y * font.GetGlyphWidth(character) + x) * 1)]);
-      if (((font.GetGlyphBitmap(
-                character)[font.GetGlyphHeight(character) + y] >>
-            (font.GetGlyphWidth(character - 1) - x)) &
-           1) == 1) {
-      }
-    }
-  }
-  // for(int y = 0; y < font.GetGlyphHeight(character) *
-  // font.GetGlyphWidth(character); y++)
-  //{
-  //    DrawPixel(posX + x + 1, posY + y + 1, UNPACK_BGRA(color));
-  //}
-}
-
-#define SPACING_Y 10
-#define SPACING_X 8
-
-void RenderD7::BitmapPrinter::DrawDebugText(int x, int y, int t_size, u32 color,
-                                            std::string text) {
-  if (t_size < 1) {
-    t_size = 1;
-  }
-
-  for (u32 i = 0, line_i = 0; i < strlen(text.c_str()); i++)
-    switch (text[i]) {
-    case '\n':
-      y += (SPACING_Y * t_size);
-      line_i = 0;
-      break;
-
-    case '\t':
-      line_i += 2;
-      break;
-
-    default:
-      // Make sure we never get out of the screen
-      if (line_i >= (((u32)this->bitmap.bmp_info_header.width) - (u32)x) /
-                        (SPACING_X * t_size)) {
-        y += (SPACING_Y * t_size);
-        line_i = 1; // Little offset so we know the same text continues
-        if (text[i] == ' ')
-          break; // Spaces at the start look weird
-      }
-
-      this->DrawDebugChar((u32)x + line_i * (SPACING_X * t_size), (u32)y,
-                          t_size, color, text[i]);
-
-      line_i++;
-      break;
-    }
-}
-
-void RenderD7::BitmapPrinter::DrawText(int x, int y, float t_size, u32 color,
-                                       std::string text,
-                                       RenderD7::NFontApi font) {
-  if (t_size < 1) {
-    t_size = 1;
-  }
-
-  for (u32 i = 0, line_i = 0; i < strlen(text.c_str()); i++)
-    switch (text[i]) {
-    case '\n':
-      y += (font.GetLineHeight());
-      line_i = 0;
-      break;
-
-    case '\t':
-      line_i += 2;
-      break;
-
-    default:
-      // Make sure we never get out of the screen
-      if (line_i >= (((u32)this->bitmap.bmp_info_header.width) - (u32)x) /
-                        (u32)(font.GetGlyphWidth(text[i]))) {
-        y += (SPACING_Y * t_size);
-        line_i = 1; // Little offset so we know the same text continues
-        if (text[i] == ' ')
-          break; // Spaces at the start look weird
-      }
-
-      this->DrawChar(x + line_i * (font.GetGlyphWidth(text[i])), y, t_size,
-                     color, text[i], font);
-
-      line_i++;
-      break;
-    }
-}
-
-bool RenderD7::BitmapPrinter::Decode(Decoder deccc) {
-  bool res = false;
-
-  switch (deccc) {
-  case Decoder::BITMAP2PNG2C3D:
-    renderframe.LoadPFromBuffer(
-        BitmapConverter::ConvertData(this->bitmap.DATA()));
-    res = true;
-    break;
-  case Decoder::BITMAP2C3D:
-    renderframe.LoadFromBitmap(this->bitmap);
-    res = true;
-    break;
-
-  default:
-    res = false;
-    break;
-  }
-  return res;
-}
-
-void RenderD7::BitmapPrinter::DrawBitmap(int x, int y, BMP map) {
-  for (int i = 0; i < map.bmp_info_header.width; i++) {
-    for (int j = 0; j < map.bmp_info_header.height; j++) {
-      bitmap.set_pixel(
-          x + i, (bitmap.bmp_info_header.height - 1) - (y + j),
-          UNPACK_BGRA(map.get_pixel(i, (map.bmp_info_header.height - 1) - j)));
-    }
-  }
-}

source/Color.cpp

@@ -1,23 +1,71 @@
 #include <map>
 #include <renderd7/Color.hpp>
 
-#define RGBA8(r, g, b, a)                                                      \
-  ((((r)&0xFF) << 0) | (((g)&0xFF) << 8) | (((b)&0xFF) << 16) |                \
-   (((a)&0xFF) << 24))
+// This is btw the default theme setup
+// RenderD7 StyleColor Api
+// not const cause const = error lol
+std::map<RD7Color, unsigned int> rd7i_color_map = {
+    {RD7Color_Text, RGBA8(0, 0, 0, 255)},
+    {RD7Color_Text2, RGBA8(255, 255, 255, 255)}, // For Background change or so
+    {RD7Color_TextDisabled, RGBA8(170, 170, 170, 255)},
+    {RD7Color_Background, RGBA8(238, 238, 238, 255)},
+    {RD7Color_Header, RGBA8(17, 17, 17, 255)},
+    {RD7Color_Selector, RGBA8(34, 34, 34, 255)},
+    {RD7Color_SelectorFade, RGBA8(90, 90, 90, 255)},
+    {RD7Color_List0, RGBA8(204, 204, 204, 255)}, // List0 = % 2
+    {RD7Color_List1, RGBA8(187, 187, 187, 255)},
+    {RD7Color_MessageBackground, RGBA8(51, 51, 51, 255)},
+    {RD7Color_Button, RGBA8(17, 17, 17, 255)},
+    {RD7Color_ButtonHovered, RGBA8(34, 34, 34, 255)},
+    {RD7Color_ButtonDisabled, RGBA8(8, 8, 8, 255)},
+    {RD7Color_ButtonActive, RGBA8(42, 42, 42, 255)},
+    {RD7Color_Checkmark, RGBA8(42, 42, 42, 255)},
+    {RD7Color_FrameBg, RGBA8(85, 85, 85, 255)},
+    {RD7Color_FrameBgHovered, RGBA8(119, 119, 119, 255)},
+    {RD7Color_Progressbar, RGBA8(0, 255, 0, 255)},
+};
 
-// uint32_t RenderD7::Color::Hex(const std::string &color, uint8_t a) {
-//   if (color.length() < 7 ||
-//       std::regex_search(color.substr(1),
-//                         std::regex("[^0-9A-Fa-f]"))) { // invalid color.
-//     return RenderD7::Color::Hex("#000000", 0);
-//   }
-//   int r = std::stoi(color.substr(1, 2), nullptr, 16);
-//   int g = std::stoi(color.substr(3, 2), nullptr, 16);
-//   int b = std::stoi(color.substr(5, 2), nullptr, 16);
-//   return RGBA8(r, g, b, a);
-// }
+std::map<RD7Color, unsigned int> rd7i_color_swap_map;
 
-// Lookup-Table für Hex-to-Dez-Konvertierung
+unsigned int RenderD7::StyleColor(RD7Color color) {
+  if (rd7i_color_swap_map.find(color) != rd7i_color_swap_map.end())
+    return rd7i_color_swap_map[color];
+  else if (rd7i_color_map.find(color) != rd7i_color_map.end())
+    return rd7i_color_map[color];
+  return RGBA8(0, 0, 0, 0);
+}
+
+void RenderD7::ColorNew(RD7Color color, unsigned int new_color) {
+  rd7i_color_map[color] = new_color;
+}
+
+void RenderD7::RedirectColor(RD7Color to, RD7Color from) {
+  // As you see at the code Redirect doesnt redirect xd
+  // Just named cause it feels like redirecting
+  // Oh and if the color is edit you redirect to it is
+  // grabs that redirected lol
+  rd7i_color_swap_map[to] = StyleColor(from);
+}
+
+void RenderD7::CustomizeColor(RD7Color color, unsigned int custom) {
+  rd7i_color_swap_map[color] = custom;
+}
+
+void RenderD7::TextColorByBg(RD7Color background) {
+  UndoColorEdit(RD7Color_Text); // To be sure
+  rd7i_color_swap_map[RD7Color_Text] = StyleColor(
+      Color::RGBA(background).is_light() ? RD7Color_Text : RD7Color_Text2);
+}
+
+void RenderD7::UndoColorEdit(RD7Color color) {
+  if (rd7i_color_swap_map.find(color) == rd7i_color_swap_map.end())
+    return;
+  rd7i_color_swap_map.erase(color);
+}
+
+void RenderD7::UndoAllColorEdits() { rd7i_color_swap_map.clear(); }
+
+// Standart Color Converter
 static const std::map<char, int> HEX_TO_DEC = {
     {'0', 0},  {'1', 1},  {'2', 2},  {'3', 3},  {'4', 4},  {'5', 5},
     {'6', 6},  {'7', 7},  {'8', 8},  {'9', 9},  {'a', 10}, {'b', 11},

source/Draw.cpp

@@ -1,216 +0,0 @@
-#include <renderd7/Draw.hpp>
-
-extern C2D_TextBuf TextBuf;
-extern C2D_Font Font;
-extern bool currentScreen;
-
-bool RenderD7::Draw::Rect(float x, float y, float w, float h, u32 color) {
-  return C2D_DrawRectSolid(x, y, 0.5f, w, h, color);
-}
-
-bool RenderD7::Draw::Px(float x, float y, u32 color) {
-  return C2D_DrawRectSolid(x, y, 0.5f, 1, 1, color);
-}
-
-void RenderD7::Draw::TextCentered(float x, float y, float size, u32 color,
-                                  std::string Text, int maxWidth, int maxHeight,
-                                  C2D_Font fnt) {
-  float lineHeight, widthScale;
-
-  // Check for the lineHeight.
-  if (fnt != nullptr) {
-    lineHeight = RenderD7::Draw::GetTextHeight(size, " ", fnt);
-  } else {
-    lineHeight = RenderD7::Draw::GetTextHeight(size, " ");
-  }
-
-  int line = 0;
-  while (Text.find('\n') != Text.npos) {
-    if (maxWidth == 0) {
-      // Do the widthScale.
-      if (fnt != nullptr) {
-        widthScale = RenderD7::Draw::GetTextWidth(
-            size, Text.substr(0, Text.find('\n')), fnt);
-      } else {
-        widthScale =
-            RenderD7::Draw::GetTextWidth(size, Text.substr(0, Text.find('\n')));
-      }
-    } else {
-      // Do the widthScale 2.
-      if (fnt != nullptr) {
-        widthScale = std::min((float)maxWidth,
-                              RenderD7::Draw::GetTextWidth(
-                                  size, Text.substr(0, Text.find('\n')), fnt));
-      } else {
-        widthScale = std::min((float)maxWidth,
-                              RenderD7::Draw::GetTextWidth(
-                                  size, Text.substr(0, Text.find('\n'))));
-      }
-    }
-    if (fnt != nullptr) {
-      RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
-                           y + (lineHeight * line), size, color,
-                           Text.substr(0, Text.find('\n')), maxWidth, maxHeight,
-                           fnt);
-    } else {
-      RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
-                           y + (lineHeight * line), size, color,
-                           Text.substr(0, Text.find('\n')), maxWidth,
-                           maxHeight);
-    }
-
-    Text = Text.substr(Text.find('\n') + 1);
-    line++;
-  }
-
-  if (maxWidth == 0) {
-    // Do the next WidthScale.
-    if (fnt != nullptr) {
-      widthScale = RenderD7::Draw::GetTextWidth(
-          size, Text.substr(0, Text.find('\n')), fnt);
-    } else {
-      widthScale =
-          RenderD7::Draw::GetTextWidth(size, Text.substr(0, Text.find('\n')));
-    }
-  } else {
-    // And again.
-    if (fnt != nullptr) {
-      widthScale = std::min((float)maxWidth,
-                            RenderD7::Draw::GetTextWidth(
-                                size, Text.substr(0, Text.find('\n')), fnt));
-    } else {
-      widthScale = std::min(
-          (float)maxWidth,
-          RenderD7::Draw::GetTextWidth(size, Text.substr(0, Text.find('\n'))));
-    }
-  }
-  if (fnt != nullptr) {
-    RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
-                         y + (lineHeight * line), size, color,
-                         Text.substr(0, Text.find('\n')), maxWidth, maxHeight,
-                         fnt);
-  } else {
-    RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
-                         y + (lineHeight * line), size, color,
-                         Text.substr(0, Text.find('\n')), maxWidth, maxHeight);
-  }
-}
-
-// Draw String or Text.
-void RenderD7::Draw::Text(float x, float y, float size, u32 color,
-                          std::string Text, int maxWidth, int maxHeight,
-                          C2D_Font fnt) {
-  C2D_Text c2d_text;
-
-  if (fnt != nullptr) {
-    C2D_TextFontParse(&c2d_text, fnt, TextBuf, Text.c_str());
-  } else {
-    C2D_TextFontParse(&c2d_text, Font, TextBuf, Text.c_str());
-  }
-
-  C2D_TextOptimize(&c2d_text);
-
-  float heightScale;
-  if (maxHeight == 0) {
-    heightScale = size;
-  } else {
-    if (fnt != nullptr) {
-      heightScale = std::min(
-          size,
-          size * (maxHeight / RenderD7::Draw::GetTextHeight(size, Text, fnt)));
-    } else {
-      heightScale = std::min(
-          size, size * (maxHeight / RenderD7::Draw::GetTextHeight(size, Text)));
-    }
-  }
-
-  if (maxWidth == 0) {
-    C2D_DrawText(&c2d_text, C2D_WithColor, x, y, 0.5f, size, heightScale,
-                 color);
-  } else {
-    if (fnt != nullptr) {
-      C2D_DrawText(
-          &c2d_text, C2D_WithColor, x, y, 0.5f,
-          std::min(size, size * (maxWidth / RenderD7::Draw::GetTextWidth(
-                                                size, Text, fnt))),
-          heightScale, color);
-    } else {
-      C2D_DrawText(
-          &c2d_text, C2D_WithColor, x, y, 0.5f,
-          std::min(size, size * (maxWidth /
-                                 RenderD7::Draw::GetTextWidth(size, Text))),
-          heightScale, color);
-    }
-  }
-}
-void RenderD7::Draw::TextRight(float x, float y, float size, u32 color,
-                               std::string Text, int maxWidth, int maxHeight,
-                               C2D_Font fnt) {
-  RenderD7::Draw::Text(x - RenderD7::Draw::GetTextWidth(size, Text, fnt), y,
-                       size, color, Text, maxWidth, maxHeight, fnt);
-}
-// Get String or Text Width.
-float RenderD7::Draw::GetTextWidth(float size, std::string Text, C2D_Font fnt) {
-  float width = 0;
-  if (fnt != nullptr) {
-    GetTextSize(size, &width, NULL, Text, fnt);
-  } else {
-    GetTextSize(size, &width, NULL, Text);
-  }
-  return width;
-}
-
-// Get String or Text Size.
-void RenderD7::Draw::GetTextSize(float size, float *width, float *height,
-                                 std::string Text, C2D_Font fnt) {
-  C2D_Text c2d_text;
-  if (fnt != nullptr) {
-    C2D_TextFontParse(&c2d_text, fnt, TextBuf, Text.c_str());
-  } else {
-    C2D_TextFontParse(&c2d_text, Font, TextBuf, Text.c_str());
-  }
-  C2D_TextGetDimensions(&c2d_text, size, size, width, height);
-}
-
-// Get String or Text Height.
-float RenderD7::Draw::GetTextHeight(float size, std::string Text,
-                                    C2D_Font fnt) {
-  float height = 0;
-  if (fnt != nullptr) {
-    GetTextSize(size, NULL, &height, Text.c_str(), fnt);
-  } else {
-    GetTextSize(size, NULL, &height, Text.c_str());
-  }
-  return height;
-}
-
-Result RenderD7::Draw::LoadFont(C2D_Font &fnt, const char *Path) {
-  fnt = C2D_FontLoad(Path); // Only load if found.
-  return 0;
-}
-
-// Unload a Font.
-Result RenderD7::Draw::UnloadFont(C2D_Font &fnt) {
-  if (fnt != nullptr) {
-    C2D_FontFree(fnt); // Make sure to only unload if not nullptr.
-  }
-  return 0;
-}
-
-bool RenderD7::Draw::Circle(float x, float y, float radius, u32 color) {
-  return C2D_DrawCircleSolid(x, y, 0.5f, radius, color);
-}
-
-bool RenderD7::Draw::Image(C2D_Image img, float x, float y, float scaleX,
-                           float scaleY) {
-  return C2D_DrawImageAt(img, x, y, 0.5f, nullptr, scaleX, scaleY);
-}
-
-bool RenderD7::Draw::NFRect(float p1x, float p1y, float w, float h, u32 color,
-                            float scale) {
-  C2D_DrawLine(p1x, p1y, color, w, p1y, color, scale, 1);
-  C2D_DrawLine(w, p1y, color, w, h, color, scale, 1);
-  C2D_DrawLine(w, h, color, p1x, h, color, scale, 1);
-  C2D_DrawLine(p1x, h, color, p1x, p1y, color, scale, 1);
-  return true;
-}

source/DrawV2.cpp

@@ -0,0 +1,237 @@
+#include <citro2d.h>
+
+#include <algorithm>
+#include <renderd7/DrawV2.hpp>
+#include <renderd7/global_db.hpp>
+#include <renderd7/internal_db.hpp>
+
+const float rd7i_d7_dts = 0.5f;
+float rd7i_d2_txt_size = rd7i_d7_dts;
+C2D_Font rd7i_d2_fnt = nullptr;
+R7Vec2 rd7i_d7_mwh = R7Vec2(0, 0);
+std::map<std::string, float> rd7i_d2_ts;
+std::map<std::string, int> rd7i_d2_mln;
+
+bool rd7i_txt_init = false;
+
+std::string GetShortedText(const std::string &in, int maxlen) {
+  auto textdim = RenderD7::GetTextDimensions(in);
+  if (textdim.x < (float)maxlen) return in;
+  std::string ft = "";
+  std::string worker = in;
+  if (in.find_last_of('.') != in.npos) {
+    ft = in.substr(in.find_last_of('.'));
+    worker = in.substr(0, in.find_last_of('.'));
+  }
+
+  maxlen -= RenderD7::GetTextDimensions(ft).x -
+            RenderD7::GetTextDimensions("(...)").x;
+  float len_mod = (float)maxlen / textdim.x;
+  int pos = (in.length() * len_mod) / rd7_draw2_tsm;
+  std::string out;
+
+  out = in.substr(0, pos);
+
+  for (size_t i = pos; i < worker.length(); i++) {
+    out += worker[i];
+    if (RenderD7::GetTextDimensions(out + "(...)" + ft).x > (float)maxlen) {
+      out += "(...)";
+      out += ft;
+      return out;
+    }
+  }
+  return "";  // Impossible to reach
+}
+
+std::string WrapText(const std ::string &in, int maxlen) {
+  std::string out;
+  std::string line;
+  int line_x = 0;
+  std::istringstream istream(in);
+  std::string temp;
+
+  while (istream >> temp) {
+    R7Vec2 dim = RenderD7::GetTextDimensions(line + temp);
+    if (line_x + dim.x <= maxlen) {
+      line += temp + ' ';
+      line_x += dim.x;
+    } else {
+      out += line + '\n';
+      line = temp + ' ';
+      line_x = dim.x;
+    }
+  }
+  out += line;
+  return out;
+}
+
+bool RD7I_FNT_VALID() {
+  if (rd7i_d2_fnt != nullptr && !rd7i_txt_init) {
+    rd7i_txt_init = true;
+  }
+  if (!rd7i_txt_init) {
+    if (rd7i_base_font != nullptr) {
+      rd7i_d2_fnt = rd7i_base_font;
+      rd7i_txt_init = true;
+      return true;
+    }
+  }
+  if (rd7i_d2_fnt != nullptr) {
+    return true;
+  } else {
+    rd7i_d2_fnt = rd7i_base_font;
+    return true;
+  }
+  // Schould never be reached
+  return false;
+}
+
+namespace RenderD7 {
+R7Vec2 GetTextDimensions(const std::string &text) {
+  C2D_TextBufClear(rd7i_d2_dimbuf);
+  float w = 0, h = 0;
+  if (!RD7I_FNT_VALID()) return R7Vec2(w, h);
+  C2D_Text c2dtext;
+  C2D_TextFontParse(&c2dtext, rd7i_d2_fnt, rd7i_d2_dimbuf, text.c_str());
+  C2D_TextGetDimensions(&c2dtext, rd7i_d2_txt_size, rd7i_d2_txt_size, &w, &h);
+  return R7Vec2(w, h);
+}
+
+void CustomTextSize(float size) { rd7i_d2_txt_size = size; }
+
+void TextDefaultSize() { rd7i_d2_txt_size = rd7i_d7_dts; }
+
+void TextMaxBox(R7Vec2 size) { rd7i_d7_mwh = size; }
+
+void TextDefaultBox() { rd7i_d7_mwh = R7Vec2(0, 0); }
+
+void TextFont(C2D_Font fnt) { rd7i_d2_fnt = fnt; }
+
+void TextDefaultFont() { rd7i_d2_fnt = rd7i_base_font; }
+
+std::string TextShort(const std::string &in, int max_len) {
+  return GetShortedText(in, max_len);
+}
+
+namespace Draw2 {
+void Rect(R7Vec2 pos, R7Vec2 size, unsigned int color, int t) {
+  // 4 DrawLine Calls Lol
+  C2D_DrawLine(pos.x, pos.y, color, pos.x + size.x, pos.y, color, t, 1.f);
+  C2D_DrawLine(pos.x, pos.y, color, pos.x, pos.y + size.y, color, t, 1.f);
+  C2D_DrawLine(pos.x + size.x, pos.y, color, pos.x + size.x, pos.y + size.y,
+               color, t, 1.f);
+  C2D_DrawLine(pos.x, pos.y + size.y, color, pos.x + size.x, pos.y + size.y,
+               color, t, 1.f);
+}
+
+void RectFilled(R7Vec2 pos, R7Vec2 size, Color4 colors) {
+  C2D_DrawRectangle(pos.x, pos.y, 0.5f, size.x, size.y, colors.color0,
+                    colors.color1, colors.color2, colors.color3);
+}
+
+void RectFilledSolid(R7Vec2 pos, R7Vec2 size, unsigned int color) {
+  C2D_DrawRectSolid(pos.x, pos.y, 0.5f, size.x, size.y, color);
+}
+
+void Line(R7Vec2 pos0, R7Vec2 pos1, unsigned int color, int t) {
+  C2D_DrawLine(pos0.x, pos0.y, color, pos1.x, pos1.y, color, t, 1.f);
+}
+
+void Triangle(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, Color3 colors) {
+  C2D_DrawTriangle(pos0.x, pos0.y, colors.color0, pos1.x, pos1.y, colors.color1,
+                   pos2.x, pos2.y, colors.color2, 0.5f);
+}
+
+void TriangleSolid(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color) {
+  C2D_DrawTriangle(pos0.x, pos0.y, color, pos1.x, pos1.y, color, pos2.x, pos2.y,
+                   color, 0.5f);
+}
+
+void TriangleLined(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color,
+                   int t) {
+  // 3 Line Cqalls lol more efficient than Rect
+  C2D_DrawLine(pos0.x, pos0.y, color, pos1.x, pos1.y, color, t, 1.f);
+  C2D_DrawLine(pos0.x, pos0.y, color, pos2.x, pos2.y, color, t, 1.f);
+  C2D_DrawLine(pos1.x, pos1.y, color, pos2.x, pos2.y, color, t, 1.f);
+}
+
+void Text(R7Vec2 pos, const std::string &text, RD7TextFlags flags) {
+  // The Start of the C2D Text Hell
+  if (!RD7I_FNT_VALID()) return;
+  // Variables
+  bool updated_mwh = false;
+  if (rd7i_d7_mwh.x == 0.0f) {
+    rd7i_d7_mwh.x = rd7i_current_screen ? 400 : 320;
+    updated_mwh = true;
+  }
+  if (rd7i_d7_mwh.y == 0.0f) {
+    rd7i_d7_mwh.y = 240;
+    updated_mwh = true;
+  }
+  std::string edit_text = text;
+  if (edit_text.substr(text.length() - 1) != "\n")
+    edit_text.append("\n");  // Add \n to end if not exist
+  int line = 0;
+
+  if(flags & RD7TextFlags_Wrap)
+    edit_text = WrapText(text, rd7i_d7_mwh.x - pos.x);
+
+  while (edit_text.find('\n') != edit_text.npos) {
+    std::string current_line = edit_text.substr(0, edit_text.find('\n'));
+    if (flags & RD7TextFlags_Short)
+      current_line = GetShortedText(current_line, rd7i_d7_mwh.x - pos.x);
+    R7Vec2 newpos = pos;
+    // Check Flags
+    R7Vec2 dim = GetTextDimensions(current_line);
+    if (flags & RD7TextFlags_AlignRight)
+      newpos.x = newpos.x - GetTextDimensions(current_line).x;
+    if (flags & RD7TextFlags_AlignMid)  // Offset by inpos
+      newpos.x = (rd7i_d7_mwh.x * 0.5) - (dim.x * 0.5) + pos.x;
+    if (flags & RD7TextFlags_Scroll) {  // Scroll Text
+      if (newpos.x + dim.x > rd7i_d7_mwh.x - newpos.x - 10) {
+        if (rd7i_d2_ts.find(current_line) == rd7i_d2_ts.end())
+          rd7i_d2_ts[current_line] = 0;
+        if (rd7i_d2_mln.find(current_line) == rd7i_d2_mln.end())
+          rd7i_d2_mln[current_line] =
+              GetShortedText(current_line, rd7i_d7_mwh.x - newpos.x).length();
+        rd7i_d2_ts[current_line] += rd7i_dtm * 6;
+        if ((int)rd7i_d2_ts[current_line] >= (int)current_line.length()) {
+          rd7i_d2_ts[current_line] = 0.0f;
+        }
+        std::string bcl = current_line;
+        current_line = current_line.substr((int)rd7i_d2_ts[current_line],
+                                           rd7i_d2_mln[current_line]);
+        if (newpos.x + GetTextDimensions(current_line).x <
+            rd7i_d7_mwh.x - newpos.x)
+          current_line +=
+              "|" + bcl.substr(0, rd7i_d2_ts[bcl] - (int)current_line.length());
+      }
+    }
+    if (rd7_debugging) {
+      RenderD7::Draw2::Rect(newpos, dim, RenderD7::Color::Hex("#ff0000"));
+    }
+    C2D_Text c2dtext;
+    C2D_TextFontParse(&c2dtext, rd7i_d2_fnt, rd7i_text_buffer,
+                      current_line.c_str());
+    C2D_TextOptimize(&c2dtext);
+
+    if (flags & RD7TextFlags_Shaddow)  // performance Killer xd
+      C2D_DrawText(&c2dtext, C2D_WithColor, newpos.x + 1 + (dim.y * line),
+                   newpos.y + 1, 0.5, rd7i_d2_txt_size, rd7i_d2_txt_size,
+                   RenderD7::StyleColor(RD7Color_TextDisabled));
+
+    C2D_DrawText(&c2dtext, C2D_WithColor, newpos.x, newpos.y + (dim.y * line),
+                 0.5, rd7i_d2_txt_size, rd7i_d2_txt_size,
+                 RenderD7::StyleColor(RD7Color_Text));
+    edit_text = edit_text.substr(edit_text.find('\n') + 1);
+    line++;
+  }
+
+  if (updated_mwh) rd7i_d7_mwh = R7Vec2(0, 0);
+}
+void Image(RenderD7::Image *img, const R7Vec2 &pos, const R7Vec2 &scale) {
+  if (img->loaded())
+    C2D_DrawImageAt(img->get(), pos.x, pos.y, 0.5f, nullptr, scale.x, scale.y);
+}
+}  // namespace Draw2
+}  // namespace RenderD7

source/Error.cpp

@@ -0,0 +1,44 @@
+#include <renderd7/Error.hpp>
+
+#include <3ds.h>
+#include <renderd7/renderd7.hpp>
+#include <renderd7/internal_db.hpp>
+#include <renderd7/UI7.hpp>
+
+namespace RenderD7 {
+    void Error(const std::string& msg) {
+        if(rd7i_graphics_on) {
+            C3D_FrameEnd(0);
+            while(aptMainLoop()) {
+                hidScanInput();
+                if(hidKeysDown() & KEY_START) break;
+                C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
+                RenderD7::ClearTextBufs();
+                C2D_TargetClear(Top, 0x00000000);
+                C2D_TargetClear(Bottom, 0x00000000);
+                RenderD7::OnScreen(Top);
+                if(UI7::BeginMenu("RenderD7 - Error Manager", R7Vec2(), UI7MenuFlags_TitleMid)) {
+                    UI7::Label(msg, RD7TextFlags_Wrap);
+                    UI7::Label("Press Start to Exit!");
+                    UI7::EndMenu();
+                }
+                RenderD7::OnScreen(Bottom);
+                C3D_FrameEnd(0);
+            }
+            exit(0);
+        } else {
+            gfxInitDefault();
+            consoleInit(GFX_TOP, NULL);
+            printf("RENDERD7 - ERROR MANAGER\n\n%s\n",  msg.c_str());
+            printf("Press Start to Exit\n");
+            while(aptMainLoop()) {
+                hidScanInput();
+                if(hidKeysDown() & KEY_START)
+                    break;
+                gfxSwapBuffers();
+            }
+            gfxExit();
+            exit(0);
+        }
+    }
+}

source/FileSystem.cpp

@@ -1,12 +1,42 @@
 #include <3ds.h>
 #include <cstring>
+#include <stdarg.h>
+#include <unistd.h>
+#include <stdio.h>
 #include <renderd7/FileSystem.hpp>
 // Debugging
 #include <memory>
 #include <renderd7/stringtool.hpp>
-
+#include <algorithm>
 #include <filesystem>
 
+bool ___dir__predicate__(const RenderD7::FileSystem::Entry &lhs,
+                         const RenderD7::FileSystem::Entry &rhs) {
+  if (!lhs.dir && rhs.dir)
+    return false;
+  if (lhs.dir && !rhs.dir)
+    return true;
+
+  return strcasecmp(lhs.name.c_str(), rhs.name.c_str()) < 0;
+}
+
+std::string RenderD7::FileSystem::GetParentPath(std::string path,
+                                                std::string mount_point) {
+  std::string tcl = path;
+  if (path.substr(path.length() - 1, 1) != "/") {
+    tcl += "/";
+  }
+  std::string res;
+  if (std::filesystem::exists(
+          std::filesystem::path(tcl).parent_path().parent_path()))
+    res = std::filesystem::path(tcl).parent_path().parent_path().string();
+  if (res.length() > mount_point.length()) {
+    return res;
+  }
+
+  return mount_point;
+}
+
 std::vector<RenderD7::FileSystem::Entry>
 RenderD7::FileSystem::GetDirContent(std::string path) {
   std::vector<RenderD7::FileSystem::Entry> res;
@@ -17,3 +47,24 @@ RenderD7::FileSystem::GetDirContent(std::string path) {
   }
   return res;
 }
+
+std::vector<RenderD7::FileSystem::Entry>
+RenderD7::FileSystem::GetDirContentsExt(
+    std::string &path, const std::vector<std::string> &extensions) {
+  std::vector<RenderD7::FileSystem::Entry> res;
+  for (auto const &it :
+       std::filesystem::directory_iterator(std::filesystem::path(path))) {
+    RenderD7::FileSystem::Entry temp;
+    std::string fn = it.path().string();
+    temp.name = GetFileName(fn);
+    temp.path = it.path().string().c_str();
+    temp.dir = it.is_directory();
+    if (NameIsEndingWith(GetFileName(it.path().string()),
+                                  extensions) ||
+        it.is_directory()) {
+      res.push_back(temp);
+    }
+  }
+  std::sort(res.begin(), res.end(), ___dir__predicate__);
+  return res;
+}

source/Hid.cpp

@@ -0,0 +1,111 @@
+#include <map>
+#include <renderd7/Hid.hpp>
+
+namespace RenderD7 {
+class HidApi {
+public:
+  HidApi() {}
+  ~HidApi() {}
+
+  void setKdown(uint32_t &in) { actions[Hid::Down] = &in; }
+  void setKheld(uint32_t &in) { actions[Hid::Held] = &in; }
+  void setKup(uint32_t &in) { actions[Hid::Up] = &in; }
+  void setKrepeat(uint32_t &in) { actions[Hid::DownRepeat] = &in; }
+  void setTouchCoords(R7Vec2 &touch_coords) { touch_pos = &touch_coords; }
+  void setJS1Movement(R7Vec2 &mvmt) { js1_mv = &mvmt; }
+  void setJS2Movement(R7Vec2 &mvmt) { js2_mv = &mvmt; }
+  void bindKey(const std::string &event, uint32_t key) {
+    key_bindings[event] = key; // Overrides if existing
+  }
+  void lock(bool lock) { locked = lock; }
+
+  void clear() {
+    // Clears Functionality for 1 Frame
+    last_touch_pos = R7Vec2();
+    touch_pos[0] = R7Vec2();
+    backups[Hid::Down] = 0;
+    backups[Hid::Held] = 0;
+    backups[Hid::Up] = 0;
+    backups[Hid::DownRepeat] = 0;
+  }
+
+  bool isEvent(const std::string &event, Hid::Actions action) {
+    if (locked)
+      return false;
+    if (key_bindings.find(event) == key_bindings.end())
+      return false; // Unknown Event
+    if (backups.find(action) == backups.end())
+      return false; // What? NOT Alowed acrion
+    if (backups[action] & key_bindings[event])
+      return true; // Action contains key as flag
+    return false;  // Nothing to do
+  }
+
+  R7Vec2 getTouchPos() { return touch_pos[0]; }
+  R7Vec2 getLastTouchPos() { return last_touch_pos; }
+
+  void update() {
+    last_touch_pos = touch_pos[0];
+    for (const auto &it : actions) {
+      backups[it.first] = it.second[0];
+    }
+    if(locked) {
+      actions[Hid::Down][0] = 0;
+      actions[Hid::Held][0] = 0;
+      actions[Hid::Up][0] = 0;
+      actions[Hid::DownRepeat][0] = 0;
+    }
+  }
+
+private:
+  std::map<Hid::Actions, uint32_t *> actions;
+  std::map<Hid::Actions, uint32_t> backups;
+  R7Vec2 *touch_pos = nullptr;
+  R7Vec2 *js1_mv = nullptr;
+  R7Vec2 *js2_mv = nullptr;
+
+  R7Vec2 last_touch_pos;
+
+  std::map<std::string, uint32_t> key_bindings;
+  bool locked = false;
+};
+static HidApi hid_handler;
+namespace Hid {
+// Register Functions
+// Register Current state values
+void RegKeyDown(uint32_t &key_down) { hid_handler.setKdown(key_down); }
+
+void RegKeyHeld(uint32_t &key_held) { hid_handler.setKheld(key_held); }
+
+void RegKeyUp(uint32_t &key_up) { hid_handler.setKup(key_up); }
+
+void RegKeyRepeat(uint32_t &repeat) { hid_handler.setKrepeat(repeat); }
+
+void RegTouchCoords(R7Vec2 &touch_pos) {
+  hid_handler.setTouchCoords(touch_pos);
+}
+
+void RegAnalog1Movement(R7Vec2 &movement) {
+  hid_handler.setJS1Movement(movement);
+}
+
+void RegAnalog2Movement(R7Vec2 &movement) {
+  hid_handler.setJS2Movement(movement);
+}
+
+// Register Keys
+void RegKeyEvent(const std::string &event, uint32_t key) {
+  hid_handler.bindKey(event, key);
+}
+
+bool IsEvent(const std::string &event, Actions action) {
+  return hid_handler.isEvent(event, action);
+}
+R7Vec2 GetTouchPosition() { return hid_handler.getTouchPos(); }
+R7Vec2 GetLastTouchPosition() { return hid_handler.getLastTouchPos(); }
+void Update() { hid_handler.update(); }
+void Lock() { hid_handler.lock(true); }
+void Unlock() { hid_handler.lock(false); }
+void Clear() { hid_handler.clear(); }
+} // namespace Hid
+} // namespace RenderD7

source/Image.cpp

@@ -1,23 +1,9 @@
-#include <renderd7/Image.hpp>
-#include <renderd7/ToastsV2.hpp>
 #include <renderd7/external/stb_image.h>
-extern bool usedbgmsg;
 
-void convert24to32(unsigned char *inputImage, int width, int height,
-                   unsigned char *outputImage) {
-  for (int y = 0; y < height; y++) {
-    for (int x = 0; x < width; x++) {
-      int i = (y * width + x) * 3;    // index of current pixel in input image
-      int j = (y * width + x) * 4;    // index of current pixel in output image
-      outputImage[j] = inputImage[i]; // copy red channel
-      outputImage[j + 1] = inputImage[i + 1]; // copy green channel
-      outputImage[j + 2] = inputImage[i + 2]; // copy blue channel
-      outputImage[j + 3] = 255; // set alpha channel to 255 (fully opaque)
-    }
-  }
-}
+#include <renderd7/Image.hpp>
+#include <vector>
 
-static u32 GetNextPowerOf2(u32 v) {
+static u32 __rd7i_gp2o__(u32 v) {
   v--;
   v |= v >> 1;
   v |= v >> 2;
@@ -28,70 +14,24 @@ static u32 GetNextPowerOf2(u32 v) {
   return (v >= 64 ? v : 64);
 }
 
-static bool C3DTexToC2DImage(C2D_Image *texture, u32 width, u32 height,
-                             u8 *buf) {
-  if (width >= 1024 || height >= 1024)
-    return false;
-
-  C3D_Tex *tex = new C3D_Tex[sizeof(C3D_Tex)];
-  Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture[sizeof(Tex3DS_SubTexture)];
-  subtex->width = static_cast<u16>(width);
-  subtex->height = static_cast<u16>(height);
-  // RGBA -> ABGR
-  for (u32 row = 0; row < subtex->width; row++) {
-    for (u32 col = 0; col < subtex->height; col++) {
-      u32 z = (row + col * subtex->width) * 4;
-
-      u8 r = *(u8 *)(buf + z);
-      u8 g = *(u8 *)(buf + z + 1);
-      u8 b = *(u8 *)(buf + z + 2);
-      u8 a = *(u8 *)(buf + z + 3);
-
-      *(buf + z) = a;
-      *(buf + z + 1) = b;
-      *(buf + z + 2) = g;
-      *(buf + z + 3) = r;
+static void __rd7i_r24r32(std::vector<uint8_t> &out,
+                          const std::vector<uint8_t> &in, const int &w,
+                          const int &h) {
+  // Converts RGB24 to RGBA32
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      int src = (y * w + x) * 3;
+      int dst = (y * w + x) * 4;
+      out[dst + 0] = in[src + 0];
+      out[dst + 1] = in[src + 1];
+      out[dst + 2] = in[src + 2];
+      out[dst + 3] = 255;
+    }
   }
 }
 
-  u32 w_pow2 = GetNextPowerOf2(subtex->width);
-  u32 h_pow2 = GetNextPowerOf2(subtex->height);
-  subtex->left = 0.f;
-  subtex->top = 1.f;
-  subtex->right = (subtex->width / static_cast<float>(w_pow2));
-  subtex->bottom = (1.0 - (subtex->height / static_cast<float>(h_pow2)));
-  C3D_TexInit(tex, static_cast<u16>(w_pow2), static_cast<u16>(h_pow2),
-              GPU_RGBA8);
-  C3D_TexSetFilter(tex, GPU_NEAREST, GPU_NEAREST);
-
-  std::memset(tex->data, 0, tex->size);
-
-  for (u32 x = 0; x < subtex->width; x++) {
-    for (u32 y = 0; y < subtex->height; y++) {
-      u32 dst_pos = ((((y >> 3) * (w_pow2 >> 3) + (x >> 3)) << 6) +
-                     ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
-                      ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
-                    4;
-      u32 src_pos = (y * subtex->width + x) * 4;
-      std::memcpy(&(static_cast<u8 *>(tex->data))[dst_pos],
-                  &(static_cast<u8 *>(buf))[src_pos], 4);
-    }
-  }
-
-  C3D_TexFlush(tex);
-  tex->border = RenderD7::Color::Hex("#000000", 0);
-  C3D_TexSetWrap(tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
-  if (tex && subtex) {
-    texture->tex = tex;
-    texture->subtex = subtex;
-    return true;
-  }
-  return false;
-}
-
-static void OLD_C3DTexToC2DImage(C3D_Tex *tex, Tex3DS_SubTexture *subtex,
-                                 u8 *buf, u32 size, u32 width, u32 height,
-                                 GPU_TEXCOLOR format) {
+static void __rd7i_c3dc2d__(C3D_Tex *tex, Tex3DS_SubTexture *subtex, u8 *buf,
+                            u32 size, u32 width, u32 height) {
   // RGBA -> ABGR
   for (u32 row = 0; row < width; row++) {
     for (u32 col = 0; col < height; col++) {
@@ -109,8 +49,8 @@ static void OLD_C3DTexToC2DImage(C3D_Tex *tex, Tex3DS_SubTexture *subtex,
     }
   }
 
-  u32 w_pow2 = GetNextPowerOf2(width);
-  u32 h_pow2 = GetNextPowerOf2(height);
+  u32 w_pow2 = __rd7i_gp2o__(width);
+  u32 h_pow2 = __rd7i_gp2o__(height);
 
   subtex->width = (u16)width;
   subtex->height = (u16)height;
@@ -119,7 +59,7 @@ static void OLD_C3DTexToC2DImage(C3D_Tex *tex, Tex3DS_SubTexture *subtex,
   subtex->right = (width / (float)w_pow2);
   subtex->bottom = 1.0 - (height / (float)h_pow2);
 
-  C3D_TexInit(tex, (u16)w_pow2, (u16)h_pow2, format);
+  C3D_TexInit(tex, (u16)w_pow2, (u16)h_pow2, GPU_RGBA8);
   C3D_TexSetFilter(tex, GPU_NEAREST, GPU_NEAREST);
 
   u32 pixel_size = (size / width / height);
@@ -142,197 +82,87 @@ static void OLD_C3DTexToC2DImage(C3D_Tex *tex, Tex3DS_SubTexture *subtex,
 
   tex->border = 0x00000000;
   C3D_TexSetWrap(tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
-  linearFree(buf);
-}
-
-bool IMG_LoadImageFile(C2D_Image *texture, const char *path) {
-  stbi_uc *image = NULL;
-  int width = 0, height = 0;
-  int nc;
-
-  image = stbi_load(path, &width, &height, &nc, 4);
-
-  if (width > 1024 || height > 1024) {
-    stbi_image_free(image);
-    return false;
-  }
-
-  C3D_Tex *tex = new C3D_Tex;
-  Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture;
-  OLD_C3DTexToC2DImage(tex, subtex, image, (u32)(width * height * 4),
-                       (u32)width, (u32)height, GPU_RGBA8);
-  texture->tex = tex;
-  texture->subtex = subtex;
-  stbi_image_free(image);
-  return true;
-}
-
-void RenderD7::Image::LoadPng(const std::string path) {
-  if (usedbgmsg) {
-    // RenderD7::Msg::Display("RenderD7", "Loading Png:" + path, Top);
-  }
-  std::vector<u8> ImageBuffer;
-  unsigned width, height;
-  if (loadet) {
-    C3D_TexDelete(this->img.tex);
-    loadet = false;
-  }
-  lodepng::decode(ImageBuffer, width, height, path);
-
-  this->img.tex = new C3D_Tex;
-  this->img.subtex =
-      new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
-                             width / 1024.0f, 1.0f - (height / 1024.0f)});
-
-  C3D_TexInit(this->img.tex, 1024, 1024, GPU_RGBA8);
-  C3D_TexSetFilter(this->img.tex, GPU_LINEAR, GPU_LINEAR);
-  this->img.tex->border = 0xFFFFFFFF;
-  C3D_TexSetWrap(this->img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
-
-  for (u32 x = 0; x < width && x < 1024; x++) {
-    for (u32 y = 0; y < height && y < 1024; y++) {
-      const u32 dstPos = ((((y >> 3) * (1024 >> 3) + (x >> 3)) << 6) +
-                          ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
-                           ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
-                         4;
-
-      const u32 srcPos = (y * width + x) * 4;
-      ((uint8_t *)this->img.tex->data)[dstPos + 0] =
-          ImageBuffer.data()[srcPos + 3];
-      ((uint8_t *)this->img.tex->data)[dstPos + 1] =
-          ImageBuffer.data()[srcPos + 2];
-      ((uint8_t *)this->img.tex->data)[dstPos + 2] =
-          ImageBuffer.data()[srcPos + 1];
-      ((uint8_t *)this->img.tex->data)[dstPos + 3] =
-          ImageBuffer.data()[srcPos + 0];
-    }
-  }
-  loadet = true;
-}
-
-RenderD7::Image::~Image() {
-  if (loadet)
-    C3D_TexDelete(img.tex);
-  loadet = false;
-}
-
-void RenderD7::Image::Unload() {
-  if (loadet)
-    C3D_TexDelete(img.tex);
-  loadet = false;
-}
-
-void RenderD7::Image::LoadPFromBuffer(const std::vector<u8> &buffer) {
-  std::vector<u8> ImageBuffer;
-  if (loadet) {
-    C3D_TexDelete(this->img.tex);
-    loadet = false;
-  }
-  unsigned width, height;
-  lodepng::decode(ImageBuffer, width, height, buffer);
-
-  img.tex = new C3D_Tex;
-  img.subtex =
-      new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
-                             width / 512.0f, 1.0f - (height / 512.0f)});
-
-  C3D_TexInit(img.tex, 512, 512, GPU_RGBA8);
-  C3D_TexSetFilter(img.tex, GPU_LINEAR, GPU_LINEAR);
-  img.tex->border = 0xFFFFFFFF;
-  C3D_TexSetWrap(img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
-
-  for (u32 x = 0; x < width && x < 512; x++) {
-    for (u32 y = 0; y < height && y < 512; y++) {
-      const u32 dstPos = ((((y >> 3) * (512 >> 3) + (x >> 3)) << 6) +
-                          ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
-                           ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
-                         4;
-
-      const u32 srcPos = (y * width + x) * 4;
-      ((uint8_t *)img.tex->data)[dstPos + 0] = ImageBuffer.data()[srcPos + 3];
-      ((uint8_t *)img.tex->data)[dstPos + 1] = ImageBuffer.data()[srcPos + 2];
-      ((uint8_t *)img.tex->data)[dstPos + 2] = ImageBuffer.data()[srcPos + 1];
-      ((uint8_t *)img.tex->data)[dstPos + 3] = ImageBuffer.data()[srcPos + 0];
-    }
-  }
-}
-
-void RenderD7::Image::FromSheet(RenderD7::Sheet sheet, size_t index) {}
-
-bool RenderD7::Image::Draw(float x, float y, float scaleX, float scaleY) {
-  if (loadet)
-    return C2D_DrawImageAt(this->img, x, y, 0.5f, nullptr, scaleX, scaleY);
-  return false;
-}
-
-void RenderD7::Image::LoadFromBitmap(BMP bitmap) {
-  loadet = false;
-  unsigned error =
-      C3DTexToC2DImage(&this->img, bitmap.bmp_info_header.width,
-                       bitmap.bmp_info_header.height, bitmap.data.data());
-  if (error == 0) {
-    this->loadet = true;
-  }
-
-  if (error) {
-    std::cout << "BMP decoding error " << error << std::endl;
-    RenderD7::PushMessage(
-        RenderD7::Message("Bmp - Error", "Code: " + std::to_string(error)));
-  }
+  // linearFree(buf);
 }
 
 namespace RenderD7 {
-void Image::LoadJpg(std::string path) {
-  if (usedbgmsg) {
-    // RenderD7::Msg::Display("RenderD7", "Loading Png:" + path, Top);
-  }
-  if (loadet) {
-    C3D_TexDelete(this->img.tex);
-    loadet = false;
-  }
-  IMG_LoadImageFile(&this->img, path.c_str());
-  loadet = true;
+Image::Image() {
+  img.tex = nullptr;
+  img.subtex = nullptr;
 }
 
-void Image::LoadPixels(int w, int h, int bpp, void *buffer) {
-  if (loadet) {
-    C3D_TexDelete(this->img.tex);
-    loadet = false;
+Image::~Image() { safe_del(); }
+
+void Image::load(const std::string &path) {
+  // Make sure to cleanup
+  safe_del();
+  ld = false;
+  // Setup Func and Load Data
+  int w, h, c = 0;
+  uint8_t *image = stbi_load(path.c_str(), &w, &h, &c, 4);
+  if (image == nullptr) {
+    return;
   }
-  unsigned width, height;
-  width = w;
-  height = h;
-  uint8_t *ImageBuffer = new uint8_t[w * h * 4];
-
-  if (bpp == 3)
-    convert24to32((uint8_t *)buffer, width, height, ImageBuffer);
-
-  img.tex = new C3D_Tex;
-  img.subtex =
-      new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
-                             width / 512.0f, 1.0f - (height / 512.0f)});
-
-  C3D_TexInit(img.tex, 512, 512, GPU_RGBA8);
-  C3D_TexSetFilter(img.tex, GPU_LINEAR, GPU_LINEAR);
-  img.tex->border = 0xFFFFFFFF;
-  C3D_TexSetWrap(img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
-
-  for (u32 x = 0; x < width && x < 512; x++) {
-    for (u32 y = 0; y < height && y < 512; y++) {
-      const u32 dstPos = ((((y >> 3) * (512 >> 3) + (x >> 3)) << 6) +
-                          ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
-                           ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
-                         4;
-
-      const u32 srcPos = (y * width + x) * 4;
-      ((uint8_t *)img.tex->data)[dstPos + 0] = ImageBuffer[srcPos + 3];
-      ((uint8_t *)img.tex->data)[dstPos + 1] = ImageBuffer[srcPos + 2];
-      ((uint8_t *)img.tex->data)[dstPos + 2] = ImageBuffer[srcPos + 1];
-      ((uint8_t *)img.tex->data)[dstPos + 3] = ImageBuffer[srcPos + 0];
-    }
-  }
-  delete[] ImageBuffer;
-  loadet = true;
+  // Size/Fmt Check
+  if (w > 1024 || h > 1024) {
+    // Reason: Image to Large
+    stbi_image_free(image);
+    return;
   }
 
+  std::vector<uint8_t> wimg(w * h * 4);
+  if (c == 3) {
+    stbi_image_free(image);
+    image = stbi_load(path.c_str(), &w, &h, &c, 3);
+    __rd7i_r24r32(wimg, std::vector<uint8_t>(image, image + (w * h * 3)), w, h);
+  } else {
+    // Maybe find a better solution later
+    for (size_t i = 0; i < wimg.size(); i++) {
+      wimg[i] = image[i];
+    }
+  }
+  stbi_image_free(image);
+  // Create C2D_Image
+  C3D_Tex *tex = new C3D_Tex;
+  Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture;
+  __rd7i_c3dc2d__(tex, subtex, wimg.data(), (u32)(w * h * 4), (u32)w, (u32)h);
+  img.tex = tex;
+  img.subtex = subtex;
+  ld = true;
+}
+
+void Image::from_nimg(const nimg &image) {
+  // Make sure to cleanup
+  safe_del();
+  ld = false;
+  if (image.width > 1024 || image.height > 1024) return;
+  C3D_Tex *tex = new C3D_Tex;
+  Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture;
+  __rd7i_c3dc2d__(tex, subtex, (u8 *)image.pixel_buffer.data(),
+                  (u32)image.pixel_buffer.size(), (u32)image.width,
+                  (u32)image.height);
+  img.tex = tex;
+  img.subtex = subtex;
+  ld = true;
+}
+
+C2D_Image Image::get() { return img; }
+C2D_Image &Image::get_ref() { return img; }
+
+void Image::set(const C2D_Image &i) {
+  safe_del();
+  img = i;
+}
+
+R7Vec2 Image::get_size() {
+  if (!img.subtex) return R7Vec2(0, 0);
+  return R7Vec2(img.subtex->width, img.subtex->height);
+}
+
+void Image::safe_del() {
+  if (img.subtex != nullptr) delete img.subtex;
+  if (img.tex != nullptr) delete img.tex;
+}
+
+bool Image::loaded() { return ld; }
 }  // namespace RenderD7

source/Memory.cpp

@@ -1,4 +1,5 @@
 #include <map>
+#include <cstdlib>
 #include <renderd7/Memory.hpp>
 
 static RenderD7::Memory::memory_metrics metrics;

source/Message.cpp

@@ -1,7 +1,7 @@
 #include <renderd7/Color.hpp>
-#include <renderd7/Draw.hpp>
+#include <renderd7/DrawV2.hpp> // Update to Draw2
 #include <renderd7/Screen.hpp>
-#include <renderd7/ToastsV2.hpp>
+#include <renderd7/Message.hpp>
 
 #include <algorithm>
 #include <memory>
@@ -14,14 +14,14 @@ int fade_outs = 200; // Start of fadeout
 int idles = 60;      // start of Idle
 int anim_len = 300;  // Full Length of Animation
 
-std::pair<int, int> MakePos(int frame, int entry) {
+R7Vec2 MakePos(int frame, int entry) {
   float fol = anim_len - fade_outs;
   if (frame > fade_outs)
-    return std::make_pair(5, 240 - ((entry + 1) * 55) - 5 +
+    return R7Vec2(5, 240 - ((entry + 1) * 55) - 5 +
                          (float)((frame - fade_outs) / fol) * -20);
   if (frame > idles)
-    return std::make_pair(5, 240 - ((entry + 1) * 55) - 5);
-  return std::make_pair(-150 + ((float)(frame / (float)idles) * 155),
+    return R7Vec2(5, 240 - ((entry + 1) * 55) - 5);
+  return R7Vec2(-150 + ((float)(frame / (float)idles) * 155),
                 240 - ((entry + 1) * 55) - 5);
 }
 
@@ -34,8 +34,8 @@ void ProcessMessages() {
   float fol = anim_len - fade_outs;
   std::reverse(msg_lst.begin(), msg_lst.end());
   for (size_t i = 0; i < msg_lst.size(); i++) {
-    std::pair<int, int> pos = MakePos(msg_lst[i]->animationframe, i);
-    if ((pos.second + 150) < 0) {
+    R7Vec2 pos = MakePos(msg_lst[i]->animationframe, i);
+    if ((pos.y + 150) < 0) {
       // Dont Render Out of Screen
       // And as thay aren't relevant anymore
       // Thay get deleted!
@@ -47,17 +47,23 @@ void ProcessMessages() {
         new_alpha =
             200 - (float(msg_lst[i]->animationframe - fade_outs) / fol) * 200;
       }
-      u32 txtcol = RenderD7::Color::Hex("#ffffff", new_alpha);
-      RenderD7::Draw::Rect(pos.first, pos.second, 150, 50,
-                           RenderD7::Color::Hex("#333333", new_alpha));
-      RenderD7::Draw::Text(pos.first + 5, pos.second + 1, 0.4f, txtcol,
-                           msg_lst[i]->title);
-      RenderD7::Draw::Text(pos.first + 5, pos.second + 17, 0.4f, txtcol,
-                           msg_lst[i]->message);
+      // Wtf is this function lol
+      RenderD7::CustomizeColor(RD7Color_MessageBackground,
+                               RenderD7::Color::RGBA(RD7Color_MessageBackground)
+                                   .changeA(new_alpha)
+                                   .toRGBA());
+      RenderD7::CustomizeColor(
+          RD7Color_Text,
+          RenderD7::Color::RGBA(RD7Color_Text2).changeA(new_alpha).toRGBA());
+      RenderD7::Draw2::RFS(pos, R7Vec2(150, 50),
+                           RenderD7::StyleColor(RD7Color_MessageBackground));
+      RenderD7::Draw2::Text(pos + R7Vec2(5, 1), msg_lst[i]->title);
+      RenderD7::Draw2::Text(pos + R7Vec2(5, 17), msg_lst[i]->message);
       if (rd7_debugging)
-        RenderD7::Draw::Text(pos.first + 160, pos.second + 1, 0.5f,
-                             RenderD7::Color::Hex("#000000"),
+        RenderD7::Draw2::Text(pos + R7Vec2(155, 1),
                               std::to_string(msg_lst[i]->animationframe));
+      RenderD7::UndoColorEdit(RD7Color_Text);
+      RenderD7::UndoColorEdit(RD7Color_MessageBackground);
       // Why Frameadd? because Message uses int as frame and
       // It seems that lower 0.5 will be rounded to 0
       // Why not replace int with float ?
@@ -85,9 +91,9 @@ void PushMessage(const Message &msg) {
   msg_lst.push_back(std::make_shared<RenderD7::Message>(msg));
 }
 
-void SetIdleStartFrame(int frame) { idles = frame; }
+void SetMessageIdleStartFrame(int frame) { idles = frame; }
 
-void SetTotalAnimationFrames(int total_frames) { anim_len = total_frames; }
+void SetMessageTotalAnimationFrames(int total_frames) { anim_len = total_frames; }
 
-void SetFadeOutStartFrame(int frame) { fade_outs = frame; }
+void SetMessageFadeOutStartFrame(int frame) { fade_outs = frame; }
 } // namespace RenderD7

source/NFontApi.cpp

@@ -1,71 +0,0 @@
-#include <renderd7/Fonts/NFontApi.hpp>
-#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate
-                                    // implementation
-#include <renderd7/external/stb_truetype.h>
-
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include <renderd7/external/stb_image_write.h>
-
-#include <fstream>
-
-RenderD7::NFontApi::NFontApi() {}
-
-RenderD7::NFontApi::~NFontApi() {}
-
-void RenderD7::NFontApi::LoadTTF(std::string path) {
-  /////READ FILE
-  unsigned char *buffer;
-  long size = 0;
-  std::fstream ttf__(path, std::ios::in | std::ios::binary);
-  if(!ttf__.is_open()) {
-    return; // Add Error Handler in future
-  }
-  ttf__.seekg(0, std::ios::end);
-  size = ttf__.tellg();
-  ttf__.seekg(0, std::ios::beg);
-  buffer = (unsigned char *)malloc(size);
-  ttf__.read(reinterpret_cast<char*>(buffer), size);
-  ttf__.close();
-  /////Setup Font
-  if (!stbtt_InitFont(&font, buffer, 0)) {
-    printf("failed\n");
-    status += "failed\n";
-    return;
-  }
-  status += "success!\n";
-  b_h = 128;
-  b_w = 512;
-  l_h = 24; /* line height */
-  scale = stbtt_ScaleForPixelHeight(&font, l_h);
-
-  stbtt_GetFontVMetrics(&font, &ascent, &decent, &linegap);
-  linespace = scale * (ascent - decent + linegap);
-
-  baseline = (int)(ascent * scale);
-  height = (int)((ascent - decent) * scale);
-}
-
-unsigned char *RenderD7::NFontApi::GetGlyphBitmap(char glyph) {
-  // stbtt_GetGlyphBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
-  stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
-  w = x1 - x0;
-  h = y1 - y0;
-
-  unsigned char *bitmap;
-  bitmap = stbtt_GetCodepointBitmap(&font, scale, scale, glyph, &w, &h, 0, 0);
-  return bitmap;
-}
-
-int RenderD7::NFontApi::GetGlyphHeight(char glyph) {
-  stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
-  w = x1 - x0;
-  h = y1 - y0;
-  return h;
-}
-
-int RenderD7::NFontApi::GetGlyphWidth(char glyph) {
-  stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
-  w = x1 - x0;
-  h = y1 - y0;
-  return w;
-}

source/Ovarlays.cpp

@@ -1,11 +0,0 @@
-#include <renderd7/FunctionTrace.hpp>
-#include <renderd7/Ovarlays.hpp>
-#include <renderd7/renderd7.hpp>
-
-namespace RenderD7 {
-Ovl_Ftrace::Ovl_Ftrace() {}
-
-void Ovl_Ftrace::Draw(void) const { RenderD7::OnScreen(Top); }
-
-void Ovl_Ftrace::Logic() {}
-} // namespace RenderD7

source/Overlays.cpp

@@ -0,0 +1,451 @@
+#include <renderd7/DrawV2.hpp>
+#include <renderd7/FunctionTrace.hpp>
+#include <renderd7/Hid.hpp>
+#include <renderd7/Overlays.hpp>
+#include <renderd7/renderd7.hpp>
+#include <renderd7/internal_db.hpp>
+
+///////////////////////////////
+struct Key {
+  std::string disp;
+  R7Vec2 pos;
+  R7Vec2 size;
+  // 0 = default key
+  // 1 = Shift
+  // 2 = Backsp
+  // 3 = Enter
+  // 4 = Cancel
+  // 5 = Confirm
+  // 6 = Tab
+  // 7 = Caps
+  // 8 = Space
+  int action = 0;
+};
+
+std::vector<Key> keyboard_layout = {
+    // 1st row
+    {"`", R7Vec2(5, 137), R7Vec2(18, 18), 0},
+    {"1", R7Vec2(25, 137), R7Vec2(18, 18), 0},
+    {"2", R7Vec2(45, 137), R7Vec2(18, 18), 0},
+    {"3", R7Vec2(65, 137), R7Vec2(18, 18), 0},
+    {"4", R7Vec2(85, 137), R7Vec2(18, 18), 0},
+    {"5", R7Vec2(105, 137), R7Vec2(18, 18), 0},
+    {"6", R7Vec2(125, 137), R7Vec2(18, 18), 0},
+    {"7", R7Vec2(145, 137), R7Vec2(18, 18), 0},
+    {"8", R7Vec2(165, 137), R7Vec2(18, 18), 0},
+    {"9", R7Vec2(185, 137), R7Vec2(18, 18), 0},
+    {"0", R7Vec2(205, 137), R7Vec2(18, 18), 0},
+    {"-", R7Vec2(225, 137), R7Vec2(18, 18), 0},
+    {"=", R7Vec2(245, 137), R7Vec2(18, 18), 0},
+    {"Bksp", R7Vec2(265, 137), R7Vec2(50, 18), 2},
+    // 2nd row
+    {"Tab", R7Vec2(5, 157), R7Vec2(40, 18), 6},
+    {"q", R7Vec2(47, 157), R7Vec2(18, 18), 0},
+    {"w", R7Vec2(67, 157), R7Vec2(18, 18), 0},
+    {"e", R7Vec2(87, 157), R7Vec2(18, 18), 0},
+    {"r", R7Vec2(107, 157), R7Vec2(18, 18), 0},
+    {"t", R7Vec2(127, 157), R7Vec2(18, 18), 0},
+    {"y", R7Vec2(147, 157), R7Vec2(18, 18), 0},
+    {"u", R7Vec2(167, 157), R7Vec2(18, 18), 0},
+    {"i", R7Vec2(187, 157), R7Vec2(18, 18), 0},
+    {"o", R7Vec2(207, 157), R7Vec2(18, 18), 0},
+    {"p", R7Vec2(227, 157), R7Vec2(18, 18), 0},
+    {"[", R7Vec2(247, 157), R7Vec2(18, 18), 0},
+    {"]", R7Vec2(267, 157), R7Vec2(18, 18), 0},
+    {"\\", R7Vec2(287, 157), R7Vec2(28, 18), 0},
+    // 3rd row
+    {"Caps", R7Vec2(5, 177), R7Vec2(50, 18), 7},
+    {"a", R7Vec2(57, 177), R7Vec2(18, 18), 0},
+    {"s", R7Vec2(77, 177), R7Vec2(18, 18), 0},
+    {"d", R7Vec2(97, 177), R7Vec2(18, 18), 0},
+    {"f", R7Vec2(117, 177), R7Vec2(18, 18), 0},
+    {"g", R7Vec2(137, 177), R7Vec2(18, 18), 0},
+    {"h", R7Vec2(157, 177), R7Vec2(18, 18), 0},
+    {"j", R7Vec2(177, 177), R7Vec2(18, 18), 0},
+    {"k", R7Vec2(197, 177), R7Vec2(18, 18), 0},
+    {"l", R7Vec2(217, 177), R7Vec2(18, 18), 0},
+    {";", R7Vec2(237, 177), R7Vec2(18, 18), 0},
+    {"'", R7Vec2(257, 177), R7Vec2(18, 18), 0},
+    {"Enter", R7Vec2(277, 177), R7Vec2(38, 18), 3},
+    // 4th row
+    {"Shift", R7Vec2(5, 197), R7Vec2(60, 18), 1},
+    {"z", R7Vec2(67, 197), R7Vec2(18, 18), 0},
+    {"x", R7Vec2(87, 197), R7Vec2(18, 18), 0},
+    {"c", R7Vec2(107, 197), R7Vec2(18, 18), 0},
+    {"v", R7Vec2(127, 197), R7Vec2(18, 18), 0},
+    {"b", R7Vec2(147, 197), R7Vec2(18, 18), 0},
+    {"n", R7Vec2(167, 197), R7Vec2(18, 18), 0},
+    {"m", R7Vec2(187, 197), R7Vec2(18, 18), 0},
+    {",", R7Vec2(207, 197), R7Vec2(18, 18), 0},
+    {".", R7Vec2(227, 197), R7Vec2(18, 18), 0},
+    {"/", R7Vec2(247, 197), R7Vec2(18, 18), 0},
+    {"Shift", R7Vec2(267, 197), R7Vec2(48, 18), 1},
+    // 5th row
+    {"Cancel", R7Vec2(5, 217), R7Vec2(70, 18), 4},
+    {"(X)", R7Vec2(77, 217), R7Vec2(23, 18), 10},
+    {"Space", R7Vec2(102, 217), R7Vec2(108, 18), 8},
+    {"(!)", R7Vec2(212, 217), R7Vec2(23, 18), 10},
+    {"Confirm", R7Vec2(237, 217), R7Vec2(78, 18), 5},
+    /*{"←", R7Vec2(237, 217), R7Vec2(18, 18)},
+    {"→", R7Vec2(257, 217), R7Vec2(18, 18)},
+    {"↓", R7Vec2(277, 217), R7Vec2(18, 18)},
+    {"↑", R7Vec2(297, 217), R7Vec2(18, 18)},*/
+};
+
+std::vector<Key> keyboard_layout_caps = {
+    // 1st row
+    {"`", R7Vec2(5, 137), R7Vec2(18, 18), 0},
+    {"1", R7Vec2(25, 137), R7Vec2(18, 18), 0},
+    {"2", R7Vec2(45, 137), R7Vec2(18, 18), 0},
+    {"3", R7Vec2(65, 137), R7Vec2(18, 18), 0},
+    {"4", R7Vec2(85, 137), R7Vec2(18, 18), 0},
+    {"5", R7Vec2(105, 137), R7Vec2(18, 18), 0},
+    {"6", R7Vec2(125, 137), R7Vec2(18, 18), 0},
+    {"7", R7Vec2(145, 137), R7Vec2(18, 18), 0},
+    {"8", R7Vec2(165, 137), R7Vec2(18, 18), 0},
+    {"9", R7Vec2(185, 137), R7Vec2(18, 18), 0},
+    {"0", R7Vec2(205, 137), R7Vec2(18, 18), 0},
+    {"-", R7Vec2(225, 137), R7Vec2(18, 18), 0},
+    {"=", R7Vec2(245, 137), R7Vec2(18, 18), 0},
+    {"Bksp", R7Vec2(265, 137), R7Vec2(50, 18), 2},
+    // 2nd row
+    {"Tab", R7Vec2(5, 157), R7Vec2(40, 18), 6},
+    {"Q", R7Vec2(47, 157), R7Vec2(18, 18), 0},
+    {"W", R7Vec2(67, 157), R7Vec2(18, 18), 0},
+    {"E", R7Vec2(87, 157), R7Vec2(18, 18), 0},
+    {"R", R7Vec2(107, 157), R7Vec2(18, 18), 0},
+    {"T", R7Vec2(127, 157), R7Vec2(18, 18), 0},
+    {"Y", R7Vec2(147, 157), R7Vec2(18, 18), 0},
+    {"U", R7Vec2(167, 157), R7Vec2(18, 18), 0},
+    {"I", R7Vec2(187, 157), R7Vec2(18, 18), 0},
+    {"O", R7Vec2(207, 157), R7Vec2(18, 18), 0},
+    {"P", R7Vec2(227, 157), R7Vec2(18, 18), 0},
+    {"[", R7Vec2(247, 157), R7Vec2(18, 18), 0},
+    {"]", R7Vec2(267, 157), R7Vec2(18, 18), 0},
+    {"\\", R7Vec2(287, 157), R7Vec2(28, 18), 0},
+    // 3rd row
+    {"Caps", R7Vec2(5, 177), R7Vec2(50, 18), 7},
+    {"A", R7Vec2(57, 177), R7Vec2(18, 18), 0},
+    {"S", R7Vec2(77, 177), R7Vec2(18, 18), 0},
+    {"D", R7Vec2(97, 177), R7Vec2(18, 18), 0},
+    {"F", R7Vec2(117, 177), R7Vec2(18, 18), 0},
+    {"G", R7Vec2(137, 177), R7Vec2(18, 18), 0},
+    {"H", R7Vec2(157, 177), R7Vec2(18, 18), 0},
+    {"J", R7Vec2(177, 177), R7Vec2(18, 18), 0},
+    {"K", R7Vec2(197, 177), R7Vec2(18, 18), 0},
+    {"L", R7Vec2(217, 177), R7Vec2(18, 18), 0},
+    {";", R7Vec2(237, 177), R7Vec2(18, 18), 0},
+    {"'", R7Vec2(257, 177), R7Vec2(18, 18), 0},
+    {"Enter", R7Vec2(277, 177), R7Vec2(38, 18), 3},
+    // 4th row
+    {"Shift", R7Vec2(5, 197), R7Vec2(60, 18), 1},
+    {"Z", R7Vec2(67, 197), R7Vec2(18, 18), 0},
+    {"X", R7Vec2(87, 197), R7Vec2(18, 18), 0},
+    {"C", R7Vec2(107, 197), R7Vec2(18, 18), 0},
+    {"V", R7Vec2(127, 197), R7Vec2(18, 18), 0},
+    {"B", R7Vec2(147, 197), R7Vec2(18, 18), 0},
+    {"N", R7Vec2(167, 197), R7Vec2(18, 18), 0},
+    {"M", R7Vec2(187, 197), R7Vec2(18, 18), 0},
+    {",", R7Vec2(207, 197), R7Vec2(18, 18), 0},
+    {".", R7Vec2(227, 197), R7Vec2(18, 18), 0},
+    {"/", R7Vec2(247, 197), R7Vec2(18, 18), 0},
+    {"Shift", R7Vec2(267, 197), R7Vec2(48, 18), 1},
+    // 5th row
+    {"Cancel", R7Vec2(5, 217), R7Vec2(70, 18), 4},
+    {"(X)", R7Vec2(77, 217), R7Vec2(23, 18), 10},
+    {"Space", R7Vec2(102, 217), R7Vec2(108, 18), 8},
+    {"(!)", R7Vec2(212, 217), R7Vec2(23, 18), 10},
+    {"Confirm", R7Vec2(237, 217), R7Vec2(78, 18), 5},
+    /*{"←", R7Vec2(237, 217), R7Vec2(18, 18)},
+    {"→", R7Vec2(257, 217), R7Vec2(18, 18)},
+    {"↑", R7Vec2(277, 217), R7Vec2(18, 18)},
+    {"↓", R7Vec2(297, 217), R7Vec2(18, 18)},*/
+};
+
+std::vector<Key> keyboard_layout_shift = {
+    // 1st row
+    {"~", R7Vec2(5, 137), R7Vec2(18, 18), 0},
+    {"!", R7Vec2(25, 137), R7Vec2(18, 18), 0},
+    {"@", R7Vec2(45, 137), R7Vec2(18, 18), 0},
+    {"#", R7Vec2(65, 137), R7Vec2(18, 18), 0},
+    {"$", R7Vec2(85, 137), R7Vec2(18, 18), 0},
+    {"%", R7Vec2(105, 137), R7Vec2(18, 18), 0},
+    {"^", R7Vec2(125, 137), R7Vec2(18, 18), 0},
+    {"&", R7Vec2(145, 137), R7Vec2(18, 18), 0},
+    {"*", R7Vec2(165, 137), R7Vec2(18, 18), 0},
+    {"(", R7Vec2(185, 137), R7Vec2(18, 18), 0},
+    {")", R7Vec2(205, 137), R7Vec2(18, 18), 0},
+    {"_", R7Vec2(225, 137), R7Vec2(18, 18), 0},
+    {"+", R7Vec2(245, 137), R7Vec2(18, 18), 0},
+    {"Bksp", R7Vec2(265, 137), R7Vec2(50, 18), 2},
+    // 2nd row
+    {"Tab", R7Vec2(5, 157), R7Vec2(40, 18), 6},
+    {"Q", R7Vec2(47, 157), R7Vec2(18, 18), 0},
+    {"W", R7Vec2(67, 157), R7Vec2(18, 18), 0},
+    {"E", R7Vec2(87, 157), R7Vec2(18, 18), 0},
+    {"R", R7Vec2(107, 157), R7Vec2(18, 18), 0},
+    {"T", R7Vec2(127, 157), R7Vec2(18, 18), 0},
+    {"Y", R7Vec2(147, 157), R7Vec2(18, 18), 0},
+    {"U", R7Vec2(167, 157), R7Vec2(18, 18), 0},
+    {"I", R7Vec2(187, 157), R7Vec2(18, 18), 0},
+    {"O", R7Vec2(207, 157), R7Vec2(18, 18), 0},
+    {"P", R7Vec2(227, 157), R7Vec2(18, 18), 0},
+    {"{", R7Vec2(247, 157), R7Vec2(18, 18), 0},
+    {"}", R7Vec2(267, 157), R7Vec2(18, 18), 0},
+    {"|", R7Vec2(287, 157), R7Vec2(28, 18), 0},
+    // 3rd row
+    {"Caps", R7Vec2(5, 177), R7Vec2(50, 18), 7},
+    {"A", R7Vec2(57, 177), R7Vec2(18, 18), 0},
+    {"S", R7Vec2(77, 177), R7Vec2(18, 18), 0},
+    {"D", R7Vec2(97, 177), R7Vec2(18, 18), 0},
+    {"F", R7Vec2(117, 177), R7Vec2(18, 18), 0},
+    {"G", R7Vec2(137, 177), R7Vec2(18, 18), 0},
+    {"H", R7Vec2(157, 177), R7Vec2(18, 18), 0},
+    {"J", R7Vec2(177, 177), R7Vec2(18, 18), 0},
+    {"K", R7Vec2(197, 177), R7Vec2(18, 18), 0},
+    {"L", R7Vec2(217, 177), R7Vec2(18, 18), 0},
+    {":", R7Vec2(237, 177), R7Vec2(18, 18), 0},
+    {"\"", R7Vec2(257, 177), R7Vec2(18, 18), 0},
+    {"Enter", R7Vec2(277, 177), R7Vec2(38, 18), 3},
+    // 4th row
+    {"Shift", R7Vec2(5, 197), R7Vec2(60, 18), 1},
+    {"Z", R7Vec2(67, 197), R7Vec2(18, 18), 0},
+    {"X", R7Vec2(87, 197), R7Vec2(18, 18), 0},
+    {"C", R7Vec2(107, 197), R7Vec2(18, 18), 0},
+    {"V", R7Vec2(127, 197), R7Vec2(18, 18), 0},
+    {"B", R7Vec2(147, 197), R7Vec2(18, 18), 0},
+    {"N", R7Vec2(167, 197), R7Vec2(18, 18), 0},
+    {"M", R7Vec2(187, 197), R7Vec2(18, 18), 0},
+    {"<", R7Vec2(207, 197), R7Vec2(18, 18), 0},
+    {">", R7Vec2(227, 197), R7Vec2(18, 18), 0},
+    {"?", R7Vec2(247, 197), R7Vec2(18, 18), 0},
+    {"Shift", R7Vec2(267, 197), R7Vec2(48, 18), 1},
+    // 5th row
+    {"Cancel", R7Vec2(5, 217), R7Vec2(70, 18), 4},
+    {"(X)", R7Vec2(77, 217), R7Vec2(23, 18), 10},
+    {"Space", R7Vec2(102, 217), R7Vec2(108, 18), 8},
+    {"(!)", R7Vec2(212, 217), R7Vec2(23, 18), 10},
+    {"Confirm", R7Vec2(237, 217), R7Vec2(78, 18), 5},
+    /*{"←", R7Vec2(237, 217), R7Vec2(18, 18)},
+    {"→", R7Vec2(257, 217), R7Vec2(18, 18)},
+    {"↑", R7Vec2(277, 217), R7Vec2(18, 18)},
+    {"↓", R7Vec2(297, 217), R7Vec2(18, 18)},*/
+};
+
+// From UI7
+bool StolenInBox(R7Vec2 inpos, R7Vec2 boxpos, R7Vec2 boxsize) {
+  if ((inpos.x > boxpos.x) && (inpos.y > boxpos.y) &&
+      (inpos.x < boxpos.x + boxsize.x) && (inpos.y < boxpos.y + boxsize.y))
+    return true;
+  return false;
+}
+
+namespace RenderD7 {
+Ovl_Ftrace::Ovl_Ftrace(bool* is_enabled) { i_is_enabled = is_enabled; }
+
+void Ovl_Ftrace::Draw(void) const {
+  RenderD7::OnScreen(Top);
+  RenderD7::Draw2::RFS(R7Vec2(0, 0), R7Vec2(400, 20),
+                       RenderD7::StyleColor(RD7Color_Background));
+  
+  std::vector<RenderD7::Ftrace::FTRes> dt;
+  for(auto const& it : RenderD7::Ftrace::rd7_traces)
+    if(it.second.is_ovl && dt.size()<10)
+      dt.push_back(it.second);
+  for(size_t i = 0; i < (dt.size() < 10 ? dt.size() : 10); i++) {
+    RenderD7::Draw2::Text(R7Vec2(5, 30 + i*15), dt[i].func_name);
+    RenderD7::Draw2::Text(R7Vec2(295, 30 + i*15), RenderD7::MsTimeFmt(dt[i].time_of));
+  }
+}
+
+void Ovl_Ftrace::Logic() {
+  if (!i_is_enabled[0]) this->Kill();
+}
+
+Ovl_Metrik::Ovl_Metrik(bool* is_enabled, bool* screen, uint32_t* mt_color,
+                       uint32_t* txt_color, float* txt_size) {
+  i_is_enabled = is_enabled;
+  i_screen = screen;
+  i_mt_color = mt_color;
+  i_txt_color = txt_color;
+  i_txt_size = txt_size;
+}
+
+void Ovl_Metrik::Draw(void) const {
+  if (i_screen[0]) {
+    RenderD7::OnScreen(Bottom);
+  } else {
+    RenderD7::OnScreen(Top);
+  }
+  std::string info =
+      "RenderD7 " + std::string(RENDERD7VSTRING) + " Debug Overlay";
+  float dim_y = RenderD7::GetTextDimensions(info).y;
+  float infoy = 240 - dim_y;
+  mt_fps = "FPS: " + RenderD7::GetFramerate();
+  if(rd7i_idb_running)
+    mt_fps += " IDB -> ON";
+  mt_cpu = "CPU: " +
+           std::to_string(C3D_GetProcessingTime() * (RenderD7::GetFps() / 10))
+               .substr(0, 4) +
+           "%/" + std::to_string(C3D_GetProcessingTime()).substr(0, 4) + "ms";
+  mt_gpu = "GPU: " +
+           std::to_string(C3D_GetDrawingTime() * (RenderD7::GetFps() / 10))
+               .substr(0, 4) +
+           "%/" + std::to_string(C3D_GetDrawingTime()).substr(0, 4) + "ms";
+  mt_cmd =
+      "CMD: " + std::to_string(C3D_GetCmdBufUsage() * 100.0f).substr(0, 4) +
+      "%";
+  mt_lfr = "Linear: " + RenderD7::FormatBytes(linearSpaceFree());
+  mt_tbs =
+      "TextBuf: " + std::to_string(C2D_TextBufGetNumGlyphs(rd7i_text_buffer)) + "/4096";
+  RenderD7::Draw2::RFS(R7Vec2(0, 0), RenderD7::GetTextDimensions(mt_fps),
+                       i_mt_color[0]);
+  RenderD7::Draw2::RFS(R7Vec2(0, 50), RenderD7::GetTextDimensions(mt_cpu),
+                       i_mt_color[0]);
+  RenderD7::Draw2::RFS(R7Vec2(0, 50 + dim_y * 1),
+                       RenderD7::GetTextDimensions(mt_gpu), i_mt_color[0]);
+  RenderD7::Draw2::RFS(R7Vec2(0, 50 + dim_y * 2),
+                       RenderD7::GetTextDimensions(mt_cmd), i_mt_color[0]);
+  RenderD7::Draw2::RFS(R7Vec2(0, 50 + dim_y * 3),
+                       RenderD7::GetTextDimensions(mt_lfr), i_mt_color[0]);
+  RenderD7::Draw2::RFS(R7Vec2(0, 50 + dim_y * 4),
+                       RenderD7::GetTextDimensions(mt_tbs), i_mt_color[0]);
+  RenderD7::Draw2::RFS(R7Vec2(0, infoy), RenderD7::GetTextDimensions(info),
+                       i_mt_color[0]);
+  RenderD7::CustomizeColor(RD7Color_Text, i_txt_color[0]);
+  RenderD7::Draw2::Text(R7Vec2(0, 0), mt_fps);
+  RenderD7::Draw2::Text(R7Vec2(0, 50), mt_cpu);
+  RenderD7::Draw2::Text(R7Vec2(0, 50 + dim_y * 1), mt_gpu);
+  RenderD7::Draw2::Text(R7Vec2(0, 50 + dim_y * 2), mt_cmd);
+  RenderD7::Draw2::Text(R7Vec2(0, 50 + dim_y * 3), mt_lfr);
+  RenderD7::Draw2::Text(R7Vec2(0, 50 + dim_y * 4), mt_tbs);
+  RenderD7::Draw2::Text(R7Vec2(0, infoy), info);
+  RenderD7::UndoColorEdit(RD7Color_Text);
+
+  // Force Bottom (Debug Touchpos)
+  RenderD7::OnScreen(Bottom);
+  if (Hid::IsEvent("touch", Hid::Held)) {
+    RenderD7::Draw2::Line(R7Vec2(Hid::GetTouchPosition().x, 0),
+                          R7Vec2(Hid::GetTouchPosition().x, 240),
+                          RenderD7::Color::Hex("#ff0000"));
+    RenderD7::Draw2::Line(R7Vec2(0, Hid::GetTouchPosition().y),
+                          R7Vec2(320, Hid::GetTouchPosition().y),
+                          RenderD7::Color::Hex("#ff0000"));
+  }
+}
+
+void Ovl_Metrik::Logic() {
+  if (!i_is_enabled[0]) this->Kill();
+}
+
+Ovl_Keyboard::Ovl_Keyboard(std::string& ref, const std::string& hint,
+                           RD7Keyboard type) {
+  // Blocks All Input outside of Keyboard
+  // Doesnt work for Hidkeys down etc
+  RenderD7::Hid::Lock();
+  typed_text = &ref;
+  str_bak = ref;
+  ft3 = 0;
+}
+
+Ovl_Keyboard::~Ovl_Keyboard() {
+  // And Unlock when closing Keyboard lol
+  RenderD7::Hid::Unlock();
+}
+
+void Ovl_Keyboard::Draw(void) const {
+  if(ft3 > 5)
+    RenderD7::Hid::Unlock();
+  auto key_table = keyboard_layout;
+  if (mode == 1)
+    key_table = keyboard_layout_caps;
+  else if (mode == 2)
+    key_table = keyboard_layout_shift;
+  RenderD7::OnScreen(Top);
+  RenderD7::Draw2::RFS(
+      R7Vec2(0, 0), R7Vec2(400, 240),
+      RenderD7::Color::RGBA(RD7Color_FrameBg).changeA(150).toRGBA());
+  RenderD7::OnScreen(Bottom);
+  RenderD7::Draw2::RFS(
+      R7Vec2(0, 0), R7Vec2(320, 112),
+      RenderD7::Color::RGBA(RD7Color_FrameBg).changeA(150).toRGBA());
+  RenderD7::Draw2::RFS(R7Vec2(0, 112), R7Vec2(320, 128),
+                       RenderD7::StyleColor(RD7Color_FrameBg));
+  RenderD7::Draw2::RFS(R7Vec2(0, 112), R7Vec2(320, 20),
+                       RenderD7::StyleColor(RD7Color_Header));
+  RenderD7::TextColorByBg(RD7Color_Header);
+  RenderD7::Draw2::Text(R7Vec2(5, 114), "> " + *typed_text);
+  RenderD7::UndoColorEdit(RD7Color_Text);
+  for (auto const& it : key_table) {
+    R7Vec2 txtdim = RenderD7::GetTextDimensions(it.disp);
+    R7Vec2 txtpos = R7Vec2(it.pos.x + it.size.x * 0.5 - txtdim.x * 0.5,
+                           it.pos.y + it.size.y * 0.5 - txtdim.y * 0.5);
+    RD7Color btn = RD7Color_Button;
+    if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
+        StolenInBox(RenderD7::Hid::GetLastTouchPosition(), it.pos, it.size)) {
+      if (mode == 2)  // Request Disable Shift
+        shared_data[0x02] = 1;
+
+      if (it.action == 0)
+        shared_data[0x01] = it.disp[0];
+      else if (it.action == 1)
+        shared_data[0x02] = 1;
+      else if (it.action == 2)
+        shared_data[0x03] = 1;
+      else if (it.action == 3)
+        shared_data[0x04] = 1;
+      else if (it.action == 4)
+        shared_data[0x05] = 1;
+      else if (it.action == 5)
+        shared_data[0x06] = 1;
+      else if (it.action == 6)
+        shared_data[0x07] = 1;
+      else if (it.action == 7)
+        shared_data[0x08] = 1;
+      else if (it.action == 8)
+        shared_data[0x09] = 1;
+    } else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held) &&
+               StolenInBox(RenderD7::Hid::GetTouchPosition(), it.pos,
+                           it.size)) {
+      btn = RD7Color_ButtonHovered;
+    }
+    RenderD7::Draw2::RFS(it.pos, it.size, RenderD7::StyleColor(btn));
+    RenderD7::TextColorByBg(btn);
+    RenderD7::Draw2::Text(txtpos, it.disp);
+    RenderD7::UndoColorEdit(RD7Color_Text);
+  }
+  if(ft3 > 5)
+    RenderD7::Hid::Lock();
+}
+
+void Ovl_Keyboard::Logic() {
+  ft3++;
+  for (const auto& it : shared_data) {
+    if (it.first == 0x01) {
+      typed_text->push_back(it.second);
+    } else if (it.first == 0x02) {
+      // Shift
+      mode = (mode == 2) ? 0 : 2;
+    } else if (it.first == 0x03) {
+      if (typed_text->length() >= 1)
+        typed_text->erase(typed_text->begin() + typed_text->length() - 1);
+    } else if (it.first == 0x04) {
+      // Enter
+    } else if (it.first == 0x05) {
+      *typed_text = str_bak;
+      this->Kill();
+    } else if (it.first == 0x06) {
+      this->Kill();
+    } else if (it.first == 0x07) {
+      //this->typed_text += '\t';  // Tab
+    } else if (it.first == 0x08) {
+      // Caps
+      mode = (mode == 1) ? 0 : 1;
+    } else if (it.first == 0x09) {
+      typed_text->append(" ");  // Space
+    }
+  }
+
+  shared_data.clear();
+}
+}  // namespace RenderD7

source/ResultDecoder.cpp

@@ -1,6 +1,10 @@
 #include <map>
 #include <renderd7/ResultDecoder.hpp>
 #include <sstream>
+#include <fstream>
+#include <filesystem>
+
+extern std::string D_app_name;
 
 static std::map<int, std::string> modules = {
     {0, "common"},
@@ -418,5 +422,24 @@ std::string ResultDecoder::GetSummary() {
   return res;
 }
 
+void RenderD7::ResultDecoder::WriteLog() {
+  std::string out_path = "sdmc:/RenderD7/Apps/" + D_app_name + "/resdec/";
+  std::filesystem::create_directories(out_path);
+  out_path += "/err_result_" + std::to_string(time(0)) + ".log";
+  std::ofstream out(out_path, std::ios::app);
+  out << "--------------------\n";
+  out << "| Error: " << GetCode() << "\n";
+  out << "|-------------------\n";
+  out << "| Module: " << GetModule() << "\n";
+  out << "|-------------------\n";
+  out << "| Level: " << GetLevel() << "\n";
+  out << "|-------------------\n";
+  out << "| Summary: " << GetSummary() << "\n";
+  out << "|-------------------\n";
+  out << "| Description: " << GetDescription() << "\n";
+  out << "--------------------\n";
+  out.close();
+}
+
 int ResultDecoder::GetSummaryInt() { return R_SUMMARY(m_rescode); }
 } // namespace RenderD7

source/Screen.cpp

@@ -1,8 +1,7 @@
 #include <renderd7/Screen.hpp>
-
-extern bool currentScreen;
+#include <renderd7/internal_db.hpp>
 
 void RenderD7::OnScreen(C3D_RenderTarget *target) {
   C2D_SceneBegin(target);
-  currentScreen = (target == Top || target == TopRight) ? 1 : 0;
+  rd7i_current_screen = (target == Top || target == TopRight) ? 1 : 0;
 }

source/Security.cpp

@@ -3,10 +3,10 @@
 #include <3ds.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <renderd7/internal_db.hpp>
 
 RenderD7::Security *rd7_security;
 
-extern bool running;
 bool *running_addr = NULL;
 
 struct SecurityReport {
@@ -27,7 +27,7 @@ void RenderD7::Security::Report(uint32_t addr, void *result_ptr) {
   // Create Report
 }
 namespace RenderD7 {
-Security::Security() { running_addr = &running; }
+Security::Security() { running_addr = &rd7i_running; }
 
 Security::~Security() { *running_addr = false; }
 void Security::SafeExit(void (*exit_func)()) { atexit(exit_func); }

source/Sheet.cpp

@@ -7,8 +7,8 @@ RenderD7::Sheet::~Sheet() {
   //
 }
 
-Result RenderD7::Sheet::Load(const char *path) {
-  this->spritesheet = C2D_SpriteSheetLoad(path);
+Result RenderD7::Sheet::Load(const std::string& path) {
+  this->spritesheet = C2D_SpriteSheetLoad(path.c_str());
   return 0;
 }
 

source/Sprite.cpp

@@ -9,7 +9,11 @@ RenderD7::Sprite::~Sprite() {
 void RenderD7::Sprite::FromSheet(RenderD7::Sheet *sheet, size_t index) {
   C2D_SpriteFromSheet(&this->sprite, sheet->spritesheet, index);
 }
-bool RenderD7::Sprite::Draw() { return C2D_DrawSprite(&this->sprite); }
+bool RenderD7::Sprite::Draw() {
+  // Patch Depth before draw
+  sprite.params.depth = 0.5;
+  return C2D_DrawSprite(&this->sprite);
+}
 void RenderD7::Sprite::SetCenter(float x, float y) {
   C2D_SpriteSetCenter(&this->sprite, x, y);
 }
@@ -28,7 +32,7 @@ float RenderD7::Sprite::getPosX() { return this->sprite.params.pos.x; }
 float RenderD7::Sprite::getPosY() { return this->sprite.params.pos.y; }
 
 void RenderD7::Sprite::FromImage(RenderD7::Image *img) {
-  C2D_SpriteFromImage(&this->sprite, img->img);
+  C2D_SpriteFromImage(&this->sprite, img->get());
 }
 
 void RenderD7::Sprite::SetScale(float x, float y) {

source/Timer.cpp

@@ -0,0 +1,43 @@
+#include <renderd7/Timer.hpp>
+
+// Ticks per MSEC
+#define TPMS 268111.856
+
+namespace RenderD7 {
+    Timer::Timer(bool autostart) {
+        if(autostart)
+            is_running = true;
+        last = svcGetSystemTick();
+        current = last;
+    }
+
+    void Timer::reset() {
+        last = svcGetSystemTick();
+        current = last;
+    }
+
+    void Timer::tick() {
+        if(is_running)
+            current = svcGetSystemTick();
+    }
+
+    void Timer::pause() {
+        is_running = false;
+    }
+
+    void Timer::resume() {
+        is_running = true;
+    }
+
+    bool Timer::running() {
+        return is_running;
+    }
+    
+    float Timer::get() {
+        return (float)((current-last)/TPMS);
+    }
+
+    float Timer::get_live() {
+        return (float)((svcGetSystemTick()-last)/TPMS);
+    }
+}

source/UI7.cpp

@@ -0,0 +1,423 @@
+#include <renderd7/Color.hpp>
+#include <renderd7/DrawV2.hpp>
+#include <renderd7/Hid.hpp>
+#include <renderd7/Overlays.hpp>
+#include <renderd7/UI7.hpp>
+#include <renderd7/internal_db.hpp>
+
+// As the 3ds doesn't support std::chrono
+#ifdef __3DS__
+/// @brief 3ds System Ticks per milli second
+/// Already defined in FTrace ik but
+/// I Want to make UI7 and Draw2 more
+/// Independent of the main RenderD7 api
+#define TICKS_PER_MSEC 268111.856
+#include <3ds.h>
+#define __get_time() svcGetSystemTick() / TICKS_PER_MSEC
+#else
+#include <chrono>
+#define __get_time()                                        \
+  std::chrono::duration_cast<std::chrono::milliseconds>(    \
+      std::chrono::system_clock().now().time_since_epoch()) \
+      .count()
+#endif
+
+// Basement structs enums etc
+struct UI7ID {
+  UI7ID(const std::string &id) {
+    real_id = id;
+    title = id;
+    // Ensure the id is lowercase
+    std::transform(real_id.begin(), real_id.end(), real_id.begin(),
+                   [](unsigned char c) { return std::tolower(c); });
+  }
+  UI7ID() {
+    title = "";
+    real_id = "";
+  }
+
+  bool operator==(const UI7ID &in) { return (real_id == in.real_id); }
+
+  bool operator!=(const UI7ID &in) { return !(*this == in); }
+
+  std::string title;
+  std::string real_id;
+};
+
+struct UI7_Ctx {
+  UI7_Ctx() {
+    delta = 0.0f;
+    time = 0.0f;
+    is_activated = false;
+    _last = 0;
+    cursor = R7Vec2();
+    slc = R7Vec2();
+    cbackup = R7Vec2();
+    in_menu = false;
+    current_menu = UI7ID("");
+  }
+  float delta;
+  float time;
+  bool is_activated;
+  unsigned long long _last;
+  R7Vec2 cursor;
+  R7Vec2 cbackup;
+  R7Vec2 slc;
+  bool in_menu;
+  UI7ID current_menu;
+  std::map<std::string, R7Vec2> grid_mapping;
+};
+
+UI7_Ctx *ui7_ctx;
+
+bool UI7CtxValidate() {
+  if (ui7_ctx == nullptr) return false;
+  if (!ui7_ctx->is_activated) return false;
+  return true;
+}
+
+bool UI7CtxInMenu() {
+  if (!UI7CtxValidate()) return false;
+  return ui7_ctx->in_menu;
+}
+
+bool UI7CtxBeginMenu(const std::string &lb) {
+  if (!UI7CtxValidate()) return false;
+  if (UI7CtxInMenu()) return false;
+  ui7_ctx->current_menu = UI7ID(lb);
+  ui7_ctx->in_menu = true;
+  return true;
+}
+
+void UI7CtxEndMenu() {
+  if (!UI7CtxValidate()) return;
+  if (!UI7CtxInMenu()) return;
+  ui7_ctx->current_menu = UI7ID("");
+  ui7_ctx->in_menu = false;
+}
+
+void UI7CtxCursorMove(R7Vec2 size) {
+  if (!UI7CtxValidate()) return;
+  if (!UI7CtxInMenu()) return;
+  ui7_ctx->slc = ui7_ctx->cursor + R7Vec2(5, 0);
+  ui7_ctx->cursor.x = 5;
+  ui7_ctx->cursor += R7Vec2(0, size.y + 5);
+  ui7_ctx->slc += R7Vec2(size.x, 0);
+}
+
+namespace UI7 {
+bool InBox(R7Vec2 inpos, R7Vec2 boxpos, R7Vec2 boxsize) {
+  if ((inpos.x > boxpos.x) && (inpos.y > boxpos.y) &&
+      (inpos.x < boxpos.x + boxsize.x) && (inpos.y < boxpos.y + boxsize.y))
+    return true;
+  return false;
+}
+
+void Init() {
+  // If Context is valid it makes no sense to reinit lol
+  if (UI7CtxValidate()) return;
+  ui7_ctx = new UI7_Ctx;
+  ui7_ctx->delta = 0.0f;
+  ui7_ctx->time = 0.0f;
+  ui7_ctx->cursor = R7Vec2(0, 0);
+  ui7_ctx->is_activated = true;
+}
+
+void Deinit() {
+  // Dont deinit something not initialized
+  // Please dont count how often init... was
+  // written wront by me :(
+  if (!UI7CtxValidate()) return;
+  ui7_ctx->is_activated = false;
+  delete ui7_ctx;
+}
+
+void Update() {
+  // Dont do anithing without ctx;
+  if (!UI7CtxValidate()) return;
+  unsigned long long current = __get_time();
+  ui7_ctx->delta = (float)((float)current - (float)ui7_ctx->_last) / 1000.f;
+  ui7_ctx->_last = current;
+  ui7_ctx->time += ui7_ctx->delta;
+  ui7_ctx->cursor = R7Vec2();
+}
+
+float GetTime() {
+  if (!UI7CtxValidate()) return 0;
+  return ui7_ctx->time;
+}
+
+float GetDeltaTime() {
+  if (!UI7CtxValidate()) return 0;
+  return ui7_ctx->delta;
+}
+
+bool Button(const std::string &label, R7Vec2 size) {
+  bool ret = false;
+  if (!UI7CtxValidate()) return ret;
+  R7Vec2 textdim = RenderD7::GetTextDimensions(label);
+  if (size.x == 0) {
+    size.x = textdim.x + 8;
+  }
+  if (size.y == 0) {
+    size.y = textdim.y + 4;
+  }
+  RD7Color btn = RD7Color_Button;
+  R7Vec2 pos = GetCursorPos();
+
+  UI7CtxCursorMove(size);
+
+  if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
+      InBox(RenderD7::Hid::GetLastTouchPosition(), pos, size)) {
+    btn = RD7Color_ButtonActive;
+    ret = true;
+  } else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held) &&
+             InBox(RenderD7::Hid::GetTouchPosition(), pos, size)) {
+    btn = RD7Color_ButtonHovered;
+  }
+
+  RenderD7::Draw2::RFS(pos, size, RenderD7::StyleColor(btn));
+  pos = R7Vec2(pos.x + size.x * 0.5f - textdim.x * 0.5,
+               pos.y + size.y * 0.5f - textdim.y * 0.5);
+  RenderD7::TextColorByBg(btn);
+  RenderD7::Draw2::Text(pos, label);
+  RenderD7::UndoColorEdit(RD7Color_Text);
+  return ret;
+}
+
+void Checkbox(const std::string &label, bool &c) {
+  if (!UI7CtxValidate()) return;
+  R7Vec2 cbs = R7Vec2(18, 18);
+  R7Vec2 txtdim = RenderD7::GetTextDimensions(label);
+  R7Vec2 inp = cbs + R7Vec2(txtdim.x + 5, 0);
+  RD7Color bg = RD7Color_FrameBg;
+
+  R7Vec2 pos = GetCursorPos();
+
+  UI7CtxCursorMove(inp);
+
+  if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
+      InBox(RenderD7::Hid::GetLastTouchPosition(), pos, inp)) {
+    bg = RD7Color_FrameBgHovered;
+    c = !c;
+  } else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held) &&
+             InBox(RenderD7::Hid::GetTouchPosition(), pos, inp)) {
+    bg = RD7Color_FrameBgHovered;
+  }
+
+  RenderD7::Draw2::RFS(pos, cbs, RenderD7::StyleColor(bg));
+  if (c == true) {
+    RenderD7::Draw2::RFS(pos + R7Vec2(2, 2), cbs - R7Vec2(4, 4),
+                         RenderD7::StyleColor(RD7Color_Checkmark));
+  }
+  RenderD7::Draw2::Text(pos + R7Vec2(cbs.x + 5, 1), label);
+}
+
+void Label(const std::string &label, RD7TextFlags flags) {
+  if (!UI7CtxValidate()) return;
+  R7Vec2 textdim = RenderD7::GetTextDimensions(label);
+  R7Vec2 pos = GetCursorPos();
+  // Remove some y offset cause texts have some offset
+  UI7CtxCursorMove(textdim - R7Vec2(0, 4));
+  RenderD7::TextColorByBg(
+      (pos.y + textdim.y < 20 ? RD7Color_Header : RD7Color_Background));
+  RenderD7::Draw2::Text(pos, label, flags);
+  RenderD7::UndoColorEdit(RD7Color_Text);
+}
+
+void Progressbar(float value) {
+  if (!UI7CtxValidate()) return;
+  R7Vec2 pos = GetCursorPos();
+  R7Vec2 size = R7Vec2((rd7i_current_screen ? 400 : 320) - (pos.x * 2), 20);
+  UI7CtxCursorMove(size);
+
+  RenderD7::Draw2::RFS(pos, size, RenderD7::StyleColor(RD7Color_FrameBg));
+  RenderD7::Draw2::RFS(pos + R7Vec2(2, 2), size - R7Vec2(4, 4),
+                       RenderD7::StyleColor(RD7Color_FrameBgHovered));
+  if (!(value != value) && !(value < 0.0) && !(value > 1.0))
+    RenderD7::Draw2::RFS(pos + R7Vec2(2, 2),
+                         R7Vec2((size.x - 4) * value, size.y - 4),
+                         RenderD7::StyleColor(RD7Color_Progressbar));
+}
+
+void Image(RenderD7::Image *img) {
+  if (!UI7CtxValidate()) return;
+  R7Vec2 pos = GetCursorPos();
+  UI7CtxCursorMove(R7Vec2(img->get_size().x, img->get_size().y));
+
+  RenderD7::Draw2::Image(img, pos);
+}
+
+void BrowserList(const std::vector<std::string> &entrys, int &selection,
+                 RD7TextFlags txtflags, R7Vec2 size, int max_entrys) {
+  if (!UI7CtxValidate()) return;
+  if (selection < 0) return;
+  R7Vec2 pos = GetCursorPos();
+  if (pos.y + 15 * max_entrys > 230) max_entrys = (int)((230 - pos.y) / 15);
+  if (size.x == 0) size.x = (rd7i_current_screen ? 400 : 320) - (pos.x * 2);
+  if (size.y == 0) size.y = (max_entrys * 15);
+  UI7CtxCursorMove(size);
+  for (int i = 0; i < max_entrys; i++) {
+    RenderD7::Draw2::RFS(
+        pos + R7Vec2(0, 15 * i), R7Vec2(size.x, 15),
+        RenderD7::StyleColor((i % 2) == 0 ? RD7Color_List0 : RD7Color_List1));
+  }
+  for (size_t i = 0;
+       i < ((entrys.size() < (size_t)max_entrys) ? entrys.size()
+                                                 : (size_t)max_entrys);
+       i++) {
+    int selindex = (selection < max_entrys ? selection : (max_entrys - 1));
+    int list_index =
+        (selection < max_entrys ? i : (i + selection - (max_entrys - 1)));
+    if (i == (size_t)selindex) {
+      RenderD7::Draw2::RectFilled(
+          pos + R7Vec2(0, 15 * i), R7Vec2(size.x, 15),
+          {RenderD7::StyleColor(RD7Color_Selector),
+           RenderD7::Color::RGBA(RD7Color_Selector)
+               .fade_to(RD7Color_SelectorFade, std::sin(RenderD7::GetTime()))
+               .toRGBA(),
+           RenderD7::StyleColor(RD7Color_Selector),
+           RenderD7::Color::RGBA(RD7Color_Selector)
+               .fade_to(RD7Color_SelectorFade, std::sin(RenderD7::GetTime()))
+               .toRGBA()});
+      RenderD7::TextColorByBg(RD7Color_Selector);
+      RenderD7::TextMaxBox(R7Vec2(size.x, 0));
+      RenderD7::Draw2::Text(pos + R7Vec2(5, 15 * i), entrys[list_index],
+                            txtflags | RD7TextFlags_Short);
+      RenderD7::TextDefaultBox();
+      RenderD7::UndoColorEdit(RD7Color_Text);
+    } else {
+      RenderD7::Ftrace::Beg("app", "short_algo");
+      RenderD7::TextColorByBg(RD7Color_List0);
+      RenderD7::TextMaxBox(R7Vec2(size.x, 0));
+      RenderD7::Draw2::Text(pos + R7Vec2(5, 15 * i), entrys[list_index],
+                            txtflags | RD7TextFlags_Short);
+      RenderD7::TextDefaultBox();
+      RenderD7::UndoColorEdit(RD7Color_Text);
+      RenderD7::Ftrace::End("app", "short_algo");
+    }
+  }
+}
+
+void InputText(const std::string &label, std::string &text,
+               const std::string &hint) {
+  if (!UI7CtxValidate()) return;
+  R7Vec2 cbs = R7Vec2(144, 18);
+  R7Vec2 txtdim = RenderD7::GetTextDimensions(label);
+  R7Vec2 inp = cbs + R7Vec2(txtdim.x + 5, 0);
+  RD7Color bg = RD7Color_FrameBg;
+
+  R7Vec2 pos = GetCursorPos();
+
+  UI7CtxCursorMove(inp);
+
+  if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Up) &&
+      InBox(RenderD7::Hid::GetLastTouchPosition(), pos, inp)) {
+    bg = RD7Color_FrameBgHovered;
+    RenderD7::AddOvl(std::make_unique<RenderD7::Ovl_Keyboard>(text, hint));
+  } else if (RenderD7::Hid::IsEvent("touch", RenderD7::Hid::Held) &&
+             InBox(RenderD7::Hid::GetTouchPosition(), pos, inp)) {
+    bg = RD7Color_FrameBgHovered;
+  }
+
+  RenderD7::Draw2::RFS(pos, cbs, RenderD7::StyleColor(bg));
+  RenderD7::TextColorByBg(bg);
+  RenderD7::Draw2::Text(pos + R7Vec2(5, 1), (text != "" ? text : hint));
+  RenderD7::UndoColorEdit(RD7Color_Text);
+  RenderD7::Draw2::Text(pos + R7Vec2(cbs.x + 5, 1), label);
+}
+
+bool BeginMenu(const std::string &title, R7Vec2 size, UI7MenuFlags flags) {
+  if (!UI7CtxValidate()) return false;
+  bool titlebar = true;
+  if (size.x == 0) {
+    size.x = rd7i_current_screen ? 400 : 320;
+  }
+  if (size.y == 0) {
+    size.y = 240;
+  }
+  RD7TextFlags txtflags = 0;
+  if (flags & UI7MenuFlags_NoTitlebar) titlebar = false;
+  if (flags & UI7MenuFlags_TitleMid) txtflags = RD7TextFlags_AlignMid;
+  RenderD7::Draw2::RFS(R7Vec2(0, 0), size,
+                       RenderD7::StyleColor(RD7Color_Background));
+  if (titlebar) {
+    RenderD7::Draw2::RFS(R7Vec2(0, 0), R7Vec2(size.x, 20),
+                         RenderD7::StyleColor(RD7Color_Header));
+    RenderD7::TextColorByBg(RD7Color_Header);
+    RenderD7::Draw2::Text(R7Vec2(5, 2), title, txtflags);
+    RenderD7::UndoColorEdit(RD7Color_Text);
+  }
+
+  SetCursorPos(R7Vec2(5, 25));
+  return UI7CtxBeginMenu(title);
+}
+
+void EndMenu() { UI7CtxEndMenu(); }
+
+void Grid(const std::string &name, const R7Vec2 &size,
+          R7Vec2 (*display_func)(void *, R7Vec2), void **data_array,
+          size_t num_entrys) {
+  if (!UI7CtxValidate()) return;
+  if (num_entrys <= 0) return;
+  if (data_array == nullptr) return;
+  if (ui7_ctx->grid_mapping.find(UI7ID(name).real_id) ==
+      ui7_ctx->grid_mapping.end())
+    ui7_ctx->grid_mapping[UI7ID(name).real_id] =
+        R7Vec2();  // Register id not exist
+  R7Vec2 pos = GetCursorPos();
+  R7Vec2 cpos(pos);
+
+  // Debug Grid
+  RenderD7::Draw2::Rect(pos, size, RenderD7::Color::Hex("#ff0000"), 1);
+
+  // Y-Offset
+  int yoff = 0;
+
+  pos += ui7_ctx->grid_mapping[UI7ID(name).real_id];
+  for (size_t i = 0; i < num_entrys; i++) {
+    R7Vec2 szs = display_func(data_array[i], pos);
+    RenderD7::Draw2::Text(pos + R7Vec2(4, 4), std::to_string(i));
+    if (pos.x + (szs.x * 2) > (cpos.x + size.x) &&
+        pos.y + szs.y > cpos.y + size.y) {
+      if (ui7_ctx->grid_mapping[UI7ID(name).real_id].y == 0)
+        ui7_ctx->grid_mapping[UI7ID(name).real_id].y =
+            (cpos.y + size.y) / 2 - ((yoff + 1) * (szs.y + 4)) / 2;
+      break;
+    } else if (pos.x + (szs.x * 2) > (cpos.x + size.x)) {
+      if (ui7_ctx->grid_mapping[UI7ID(name).real_id].x == 0)
+        ui7_ctx->grid_mapping[UI7ID(name).real_id].x =
+            (cpos.x + size.x) / 2 - ((i + 1) * (szs.x + 4)) / 2;
+      pos = R7Vec2(5 + ui7_ctx->grid_mapping[UI7ID(name).real_id].x,
+                   pos.y + szs.y + 4);
+      yoff++;
+    } else {
+      pos += R7Vec2(szs.x + 4, 0);
+    }
+  }
+
+  UI7CtxCursorMove(size);
+}
+
+R7Vec2 GetCursorPos() {
+  if (!UI7CtxValidate()) return R7Vec2();
+  return ui7_ctx->cursor;
+}
+
+void SetCursorPos(R7Vec2 cp) {
+  if (!UI7CtxValidate()) return;
+  ui7_ctx->cbackup = ui7_ctx->cursor;
+  ui7_ctx->cursor = cp;
+}
+
+void RestoreCursor() {
+  if (!UI7CtxValidate()) return;
+  ui7_ctx->cursor = ui7_ctx->cbackup;
+}
+
+void SameLine() {
+  if (!UI7CtxValidate()) return;
+  ui7_ctx->cursor = ui7_ctx->slc;
+}
+
+}  // namespace UI7

source/bmpconverter.cpp

@@ -1,110 +0,0 @@
-#include <renderd7/bmpconverter.hpp>
-
-namespace BitmapConverter {
-
-// returns 0 if all went ok, non-0 if error
-// output image is always given in RGBA (with alpha channel), even if it's a BMP
-// without alpha channel
-unsigned decodeBMP(std::vector<unsigned char> &image, unsigned &w, unsigned &h,
-                   const std::vector<unsigned char> &bmp) {
-  static const unsigned MINHEADER = 54; // minimum BMP header size
-
-  if (bmp.size() < MINHEADER)
-    return -1;
-  if (bmp[0] != 'B' || bmp[1] != 'M')
-    return 1; // It's not a BMP file if it doesn't start with marker 'BM'
-  unsigned pixeloffset = bmp[10] + 256 * bmp[11]; // where the pixel data starts
-  // read width and height from BMP header
-  w = bmp[18] + bmp[19] * 256;
-  h = bmp[22] + bmp[23] * 256;
-  // read number of channels from BMP header
-  if (bmp[28] != 24 && bmp[28] != 32)
-    return 2; // only 24-bit and 32-bit BMPs are supported.
-  unsigned numChannels = bmp[28] / 8;
-
-  // The amount of scanline bytes is width of image times channels, with extra
-  // bytes added if needed to make it a multiple of 4 bytes.
-  unsigned scanlineBytes = w * numChannels;
-  if (scanlineBytes % 4 != 0)
-    scanlineBytes = (scanlineBytes / 4) * 4 + 4;
-
-  unsigned dataSize = scanlineBytes * h;
-  if (bmp.size() < dataSize + pixeloffset)
-    return 3; // BMP file too small to contain all pixels
-
-  image.resize(w * h * 4);
-
-  /*
-  There are 3 differences between BMP and the raw image buffer for LodePNG:
-  -it's upside down
-  -it's in BGR instead of RGB format (or BRGA instead of RGBA)
-  -each scanline has padding bytes to make it a multiple of 4 if needed
-  The 2D for loop below does all these 3 conversions at once.
-  */
-  for (unsigned y = 0; y < h; y++)
-    for (unsigned x = 0; x < w; x++) {
-      // pixel start byte position in the BMP
-      unsigned bmpos =
-          pixeloffset + (h - y - 1) * scanlineBytes + numChannels * x;
-      // pixel start byte position in the new raw image
-      unsigned newpos = 4 * y * w + 4 * x;
-      if (numChannels == 3) {
-        image[newpos + 0] = bmp[bmpos + 2]; // R
-        image[newpos + 1] = bmp[bmpos + 1]; // G
-        image[newpos + 2] = bmp[bmpos + 0]; // B
-        image[newpos + 3] = 255;            // A
-      } else {
-        image[newpos + 0] = bmp[bmpos + 2]; // R
-        image[newpos + 1] = bmp[bmpos + 1]; // G
-        image[newpos + 2] = bmp[bmpos + 0]; // B
-        image[newpos + 3] = bmp[bmpos + 3]; // A
-      }
-    }
-  return 0;
-}
-
-std::vector<unsigned char> ConvertFile(std::string filename) {
-
-  std::vector<unsigned char> bmp;
-  lodepng::load_file(bmp, filename);
-
-  std::vector<unsigned char> image;
-  unsigned w, h;
-  unsigned error = BitmapConverter::decodeBMP(image, w, h, bmp);
-
-  if (error) {
-    std::cout << "BMP decoding error " << error << std::endl;
-  }
-
-  std::vector<unsigned char> png;
-  error = lodepng::encode(png, image, w, h);
-
-  if (error) {
-    std::cout << "PNG encoding error " << error << ": "
-              << lodepng_error_text(error) << std::endl;
-  }
-
-  return png;
-}
-
-std::vector<unsigned char> ConvertData(std::vector<unsigned char> data) {
-
-  std::vector<unsigned char> image;
-  unsigned w, h;
-  unsigned error = BitmapConverter::decodeBMP(image, w, h, data);
-
-  if (error) {
-    std::cout << "BMP decoding error " << error << std::endl;
-  }
-
-  std::vector<unsigned char> png;
-  error = lodepng::encode(png, image, w, h);
-
-  if (error) {
-    std::cout << "PNG encoding error " << error << ": "
-              << lodepng_error_text(error) << std::endl;
-  }
-
-  return png;
-}
-} // namespace BitmapConverter

source/internal_db.cpp

@@ -0,0 +1,262 @@
+#include <renderd7/renderd7.hpp>
+#include <renderd7/external/json.hpp>
+#include <renderd7/FileSystem.hpp>
+#include <filesystem>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+
+/// Base ///
+static RenderD7::Thread rd7i_idb_server; // Protected
+std::string rd7i_app_name;
+std::string rd7i_config_path;
+nlohmann::json rd7i_config;
+u8 rd7i_console_model = 0;
+u8 rd7i_system_region = CFG_REGION_USA;
+bool rd7i_is_citra = false;
+bool rd7i_settings = false;
+R7Vec2 rd7i_hid_touch_pos;
+C2D_TextBuf rd7i_text_buffer;
+C2D_Font rd7i_base_font;
+C2D_TextBuf rd7i_d2_dimbuf;
+bool rd7i_is_ndsp = false;
+bool rd7i_running = true;
+std::stack<std::unique_ptr<RenderD7::Scene>> RenderD7::Scene::scenes;
+std::unique_ptr<RenderD7::Scene> rd7i_fade_scene;
+std::vector<std::unique_ptr<RenderD7::Ovl>> rd7i_overlays;
+unsigned int rd7i_frames = 0;
+u64 rd7i_last_time = 0;
+float rd7i_framerate = 0.0f;
+u32 rd7i_mt_color = 0xaa000000;
+u32 rd7i_mt_txtcolor = 0xbbffffff;
+bool rd7i_mt_screen;
+float rd7i_mt_txtSize;
+bool rd7i_metrikd = false;
+bool rd7i_ftraced = false;
+bool rd7i_current_screen = false;
+u64 rd7i_delta_time;
+u64 rd7i_last_tm;
+float rd7i_dtm;
+float rd7i_time;
+bool rd7i_fadeout = false, rd7i_fadein = false, rd7i_fadeout2 = false, rd7i_fadein2 = false;
+int rd7i_fadealpha = 0;
+int rd7i_fadecolor = 0;
+bool rd7i_wait_fade = false;
+bool rd7i_fade_exit = false;
+bool rd7i_fade_scene_wait = false;
+bool rd7i_idb_running = false;
+bool rd7i_graphics_on = false;
+float rd7_draw2_tsm = 1.2f;
+
+/// Global ///
+// Outdated HidApi (HidV2Patched)
+u32 d7_hDown;
+u32 d7_hHeld;
+u32 d7_hUp;
+u32 d7_hRepeat;  // Inofficial lol
+touchPosition d7_touch;
+
+// Outdated Screens
+C3D_RenderTarget *Top;
+C3D_RenderTarget *TopRight;
+C3D_RenderTarget *Bottom;
+
+// Modern Global Api
+int rd7_max_objects = C2D_DEFAULT_MAX_OBJECTS;
+bool rd7_do_splash = false;
+bool rd7_enable_scene_system = true;
+bool rd7_debugging = false;
+C3D_RenderTarget *rd7_top;
+C3D_RenderTarget *rd7_top_right;
+C3D_RenderTarget *rd7_bottom;
+
+
+class Logger
+{
+public:
+    Logger() = default;
+    virtual ~Logger() = default;
+
+    static void log(const std::string &prefix, const std::string &message)
+    {
+        std::cout << "[" << prefix << "]: " << message << std::endl;
+    }
+};
+
+#define rd7_err(x) Logger::log("ERROR", x)
+#define rd7_wrn(x) Logger::log("WARNING", x)
+
+class tcp_server
+{
+public:
+    tcp_server(const std::string &ip, int port)
+    {
+        sockfd = socket(AF_INET, SOCK_STREAM, 0);
+        if (sockfd < 0)
+        {
+            rd7_err("Unable to create socket!");
+            return;
+        }
+        server.sin_family = AF_INET;
+        server.sin_port = port;
+        server.sin_addr.s_addr = inet_addr(ip.c_str());
+
+        e = bind(sockfd, (struct sockaddr *)&server, sizeof(server));
+        if (e == -1)
+        {
+            rd7_err("Unable to bind!");
+            return;
+        }
+        e = listen(sockfd, 10);
+        if (e == 0)
+        {
+            printf("[+]Listening...\n");
+        }
+        else
+        {
+            rd7_err("Error in Binding");
+            return;
+        }
+        addr_size = sizeof(new_addr);
+        new_sock = accept(sockfd, (struct sockaddr *)&new_addr, &addr_size);
+        std::cout << "Connected" << std::endl;
+    }
+    ~tcp_server() {
+        // Nothing here
+    }
+
+    bool reconnect() {
+        close(new_sock);
+        new_sock = accept(sockfd, (struct sockaddr *)&new_addr, &addr_size);
+        return true;
+    }
+
+    size_t snd(void* ptr, size_t size) {
+        return send(new_sock, ptr, size, 0);
+    }
+
+    size_t rec(void* ptr, size_t size) {
+        return recv(new_sock, ptr, size, 0);
+    }
+
+private:
+    int e, sockfd, new_sock;
+    struct sockaddr_in server, new_addr;
+    socklen_t addr_size;
+};
+
+#define stupid(x) &x, sizeof(x)
+#define rd7i_reacttion(x) ({int code = x; server.snd(stupid(code));})
+
+struct pak32 {
+    pak32() {
+
+    }
+    pak32(const std::string& n0, float n1, unsigned char n2, unsigned char n3, bool n4, bool n5, bool n6, float n7, float n8, float n9, float n10, unsigned int n11, unsigned int n12, unsigned int n13, unsigned int n14) {
+        magic = 0x44772277;
+        for(int i = 0; i < 64; i++)
+            app_name[i] = (char)0;
+        int l = n0.length();
+        if(l > 64) l = 64;
+        for(int i = 0; i < l; i++)
+            app_name[i] = n0[i];
+        framerate = n1;
+        console_model = n2;
+        system_region = n3;
+        is_citra = n4;
+        ndsp_support = n5;
+        in_settings = n6;
+        deltatime = n7;
+        rtime = n8;
+        cpu = n9;
+        gpu = n10;
+        mem_alloc = n11;
+        mem_dalloc = n12;
+        mem_ialloc = n13;
+        tbs = n14;
+    }
+    uint32_t magic;
+    char app_name[64];
+    float framerate;
+    unsigned char console_model;
+    unsigned char system_region;
+    bool is_citra;
+    bool ndsp_support;
+    bool in_settings;
+    float deltatime;
+    float rtime;
+    float cpu;
+    float gpu;
+    unsigned int mem_alloc;
+    unsigned int mem_dalloc;
+    unsigned int mem_ialloc;
+    unsigned int tbs;
+};
+
+#define SOC_ALIGN       0x1000
+#define SOC_BUFFERSIZE  0x100000
+
+static u32 *SOC_buffer = NULL;
+static bool rd7i_idb_fp = false;
+
+void KillIdbServer() {
+    rd7i_idb_fp = true;
+    socExit();
+}
+
+void ServerThread(RenderD7::Parameter param) {
+    Result ret;
+    SOC_buffer = (u32*)memalign(SOC_ALIGN, SOC_BUFFERSIZE);
+
+	if(SOC_buffer == NULL) {
+		return;
+	}
+
+	// Now intialise soc:u service
+	if ((ret = socInit(SOC_buffer, SOC_BUFFERSIZE)) != 0) {
+    	return;
+	}
+    rd7i_idb_running = true;
+    rd7_security->SafeExit(KillIdbServer);
+    tcp_server server("0.0.0.0", 4727);
+    int cmd = 0;
+    while(true && !rd7i_idb_fp)  {
+        size_t r = server.rec(&cmd, sizeof(int));
+        if(r == 0) {
+            server.reconnect();
+        }
+        if(cmd == 1) {
+            rd7i_reacttion(1);
+            auto pak = pak32(rd7i_app_name, rd7i_framerate, rd7i_console_model,
+                rd7i_system_region, rd7i_is_citra, rd7i_is_ndsp, rd7i_settings,
+                rd7i_dtm, rd7i_time, C3D_GetProcessingTime(), C3D_GetDrawingTime(),
+                RenderD7::Memory::GetTotalAllocated(), RenderD7::Memory::GetTotalFreed(),
+                RenderD7::Memory::GetCurrent(), C2D_TextBufGetNumGlyphs(rd7i_text_buffer));
+            server.snd(stupid(pak));
+        } else if (cmd == 2) {
+            rd7i_reacttion(2);
+            std::vector<RenderD7::FileSystem::Entry> el = RenderD7::FileSystem::GetDirContent("sdmc:/");
+            size_t buf = el.size()*sizeof(RenderD7::FileSystem::Entry);
+            server.snd(stupid(buf));
+            server.snd(el.data(), buf);
+
+        } else if (cmd == 3) {
+            rd7i_reacttion(3);
+            RenderD7::ExitApp();
+        } else {
+            rd7i_reacttion(1234);
+        }
+    }
+    rd7i_idb_running = false;
+}
+
+void IdbServer() {
+    rd7i_idb_server.initialize(ServerThread);
+    rd7i_idb_server.start(true);
+}

source/lang.cpp

@@ -67,13 +67,11 @@ std::string RenderD7::Lang::getSys() {
 std::string RenderD7::Lang::get(const std::string &key) {
   if (!appJson.contains(key))
     return key;
-
   return appJson.at(key).get<std::string>();
 }
 
 void RenderD7::Lang::load(const std::string &lang) {
   std::fstream values;
-
   if(std::filesystem::is_character_file("romfs:/lang/" + lang + "/app.json")) {
     values.open("romfs:/lang/" + lang + "/app.json", std::ios::in);
     if(values.is_open()) {

source/li2.v.pica

@@ -1,34 +0,0 @@
-; Project Li7
-; Copyright (C) 2023 NPI-D7
-
-; Projection Matrix
-.fvec projection[4]
-; Constants
-.constf constants(1.0, 0.0, 0.00392156862745, 0.0)
-
-; Outputs
-.out outPos position
-.out outUv texcoord0
-.out outColor color
-
-; Inputs
-.alias inPos v0
-.alias inUv v1
-.alias inColor v2
-
-.proc main
-    mov r0.xy, inPos.xy
-    mov r0.zw, constants.yx
-
-    dp4 outPos.x, projection[0], r0
-    dp4 outPos.y, projection[1], r0
-    dp4 outPos.z, projection[2], r0 
-    dp4 outPos.w, projection[3], r0
-
-    mov outUv, inUv
-    ; Convert from u32 to float
-    mul r1, constants.zzzz, inColor
-    mov outColor, r1
-
-    end
-.end

source/music/Mp3.cpp

@@ -0,0 +1,133 @@
+#include <renderd7/music/Mp3.hpp>
+
+#ifdef RENDERD7_MUSICDEC
+// MP3 ID3V1
+std::string rd7i_id3v1_to_string(const std::string& in) {
+  std::string ret = "";
+  if(in.length() < 31) ret = in;
+  return ret;
+}
+
+// For MP3 ID3V2 tags
+// Split up a number of lines separated by \n, \r, both or just zero byte
+// and print out each line with specified prefix.
+std::string rd7i_id3v2_to_string(const std::string& prefix, mpg123_string* inlines) {
+    size_t i;
+    int hadcr = 0, hadlf = 0;
+    std::string lines;
+    std::string line;
+    size_t len = 0;
+
+    if(inlines == nullptr) return "";
+    
+    if (inlines->fill > 0) {
+        lines = inlines->p;
+        len = inlines->fill;
+    } else {
+        return "";
+    }
+
+    line = lines;
+    for (i = 0; i < len; ++i) {
+        if (lines[i] == '\n' || lines[i] == '\r' || lines[i] == 0) {
+            char save = lines[i];
+            if (save == '\n') {
+                ++hadlf;
+            }
+            if (save == '\r') {
+                ++hadcr;
+            }
+            if ((hadcr || hadlf) && (hadlf % 2 == 0) && (hadcr % 2 == 0)) {
+                line = "";
+            }
+
+            if (!line.empty()) {
+                lines[i] = 0;
+                std::string result;
+                result = prefix + line;
+                line = "";
+                lines[i] = save;
+                return result;
+            }
+        } else {
+            hadlf = hadcr = 0;
+            if (line.empty()) {
+                line = lines.substr(i);
+            }
+        }
+    }
+    return "";
+}
+
+namespace RenderD7 {
+int Mp3Decoder::_init(const std::string &path, MusicMeta& meta) {
+  int ret = 0;
+  int encoding = 0;
+  if ((ret = mpg123_init() != MPG123_OK)) return ret;
+  if ((hnd = mpg123_new(NULL, &ret)) == NULL) {
+    printf("[MPG123]: ERR -> %s\n", mpg123_plain_strerror(ret));
+    return ret;
+  }
+  if (mpg123_open(hnd, path.c_str()) != MPG123_OK ||
+      mpg123_getformat(hnd, &rate, &channels, &encoding) != MPG123_OK) {
+    printf("[MPG123]: ERR -> %s\n", mpg123_strerror(hnd));
+    return -1;
+  }
+
+  mpg123_id3v1* v1;
+  mpg123_id3v2* v2;
+  mpg123_seek(hnd, 0, SEEK_SET);
+  if(mpg123_meta_check(hnd) & MPG123_ID3 && mpg123_id3(hnd, &v1, &v2) == MPG123_OK) {
+    if(v1 != nullptr) {
+      ///// POSSIBLE CRASH /////
+      //meta.title(rd7i_id3v1_to_string(v1->title));
+      //meta.album(rd7i_id3v1_to_string(v1->album));
+      //meta.artist(rd7i_id3v1_to_string(v1->artist));
+      //meta.year(rd7i_id3v1_to_string(v1->year));
+      meta.mdt("mpg123_id3v1");
+    }
+    if(v2 != nullptr) {
+      meta.title(rd7i_id3v2_to_string("", v2->title));
+      meta.album(rd7i_id3v2_to_string("", v2->album));
+      meta.artist(rd7i_id3v2_to_string("", v2->artist));
+      meta.year(rd7i_id3v2_to_string("", v2->year));
+      meta.mdt("mpg123_id3v2");
+    }
+  }
+
+  mpg123_format_none(hnd);
+  mpg123_format(hnd, rate, channels, encoding);
+  buf_size = mpg123_outblock(hnd) * 16;
+
+  return ret;
+}
+
+unsigned int Mp3Decoder::_getSampleRate() { return rate; }
+
+unsigned char Mp3Decoder::_getChannels(){return channels; }
+
+size_t Mp3Decoder::_getBufSize() {
+  return buf_size;
+}
+
+unsigned long long Mp3Decoder::_decode(signed short*buf_addr) {
+  size_t done = 0;
+  mpg123_read(hnd, buf_addr, buf_size, &done);
+  return done / (sizeof(int16_t));
+}
+
+void Mp3Decoder::_deinit() {
+  mpg123_close(hnd);
+  mpg123_delete(hnd);
+  mpg123_exit();
+}
+
+size_t Mp3Decoder::_getFileSamples() {
+  off_t len = mpg123_length(hnd);
+  if (len != MPG123_ERR) return len * (size_t)channels;
+  return -1;  // Not Exist
+}
+
+}  // namespace RenderD7
+
+#endif

source/music/Music.cpp

@@ -0,0 +1,279 @@
+#include <3ds.h>
+
+#ifdef RENDERD7_MUSICDEC
+
+#include <cstring>
+#include <fstream>
+#include <renderd7/Message.hpp>
+#include <renderd7/music/Mp3.hpp>
+#include <renderd7/music/Music.hpp>
+#include <renderd7/music/Vorbis.hpp>
+#include <renderd7/thread.hpp>
+
+extern bool isndspinit;
+
+struct PlayerData {
+  RenderD7::MusicMeta meta;
+  size_t samples_total = 0;
+  size_t samples_played = 0;
+  size_t samples_per_sec = 0;
+
+  // Song Info
+  std::string file = "";
+
+  signed short *buf1 = NULL;
+  signed short *buf2 = NULL;
+  ndspWaveBuf waveBuf[2] = {0};
+  bool last_buf = false;
+  int ret = -1;
+  bool done = false;
+  bool playing = false;
+
+  bool stop = false;
+};
+
+int rd7i_player_channel = 8;
+PlayerData rd7i_mp_internal_data;
+RenderD7::Thread rd7i_mph;
+
+void rd7i_player_init() {
+  rd7i_mp_internal_data.samples_total = 0;
+  rd7i_mp_internal_data.samples_played = 0;
+  rd7i_mp_internal_data.samples_per_sec = 0;
+  rd7i_mp_internal_data.buf1 = NULL;
+  rd7i_mp_internal_data.buf2 = NULL;
+  rd7i_mp_internal_data.last_buf = false;
+  rd7i_mp_internal_data.ret = -1;
+  rd7i_mp_internal_data.stop = false;
+  rd7i_mp_internal_data.done = false;
+  rd7i_mp_internal_data.playing = true;
+  rd7i_mp_internal_data.file = "";
+}
+
+// Non Public Check funcs
+extern int rd7i_check_vorbis(const std::string &path);
+extern int rd7i_check_flac(const std::string &path);
+
+namespace RenderD7 {
+MusicDecoder *MusicDecoder::decoder = nullptr;
+
+void MusicDecoder::LoadFile(const std::string &path) {
+  rd7i_mp_internal_data.meta = MusicMeta();  // AutoClean
+  std::fstream f(path, std::ios::in | std::ios::binary);
+  if (!f.is_open()) return;
+  if (!f.good()) return;
+  // File Signature
+  unsigned int sig;
+  f.read(reinterpret_cast<char *>(&sig), sizeof(unsigned int));
+  if (f.tellg() != 4) {
+    f.close();
+    return;
+  }
+  f.close();
+  switch (sig) {
+    // "OGG Collection"
+    case 0x5367674F:
+      if (rd7i_check_vorbis(path) == 0) {
+        decoder = new VorbisDecoder();
+        if (init(path, rd7i_mp_internal_data.meta)) {
+          MusicDecoder::CleanUp();
+          return;
+        }
+      }
+      else
+        return;  // Err
+      break;
+
+    default:
+      if ((sig << 16) == 0xFBFF0000 || (sig << 16) == 0xFAFF0000 ||
+          (sig << 8) == 0x33444900) {
+        decoder = new Mp3Decoder();
+        if (init(path, rd7i_mp_internal_data.meta)) {
+          RenderD7::PushMessage(
+              RenderD7::Message("Music Player", "Failed to load MP3"));
+          MusicDecoder::CleanUp();
+          return;
+        }
+        break;
+      }
+      return;
+      break;
+  }
+}
+
+void MusicDecoder::CleanUp() {
+  if (decoder != nullptr) delete decoder;
+  decoder = nullptr;
+}
+
+static void rd7i_player_cleaner() {
+  MusicDecoder::deinit();
+  MusicDecoder::CleanUp();
+  ndspChnWaveBufClear(rd7i_player_channel);
+  linearFree(rd7i_mp_internal_data.buf1);
+  linearFree(rd7i_mp_internal_data.buf2);
+  rd7i_mp_internal_data.ret = -1;
+  // Also clean ret data
+  rd7i_mp_internal_data.samples_per_sec = 0;
+  rd7i_mp_internal_data.samples_total = 0;
+  rd7i_mp_internal_data.samples_played = 0;
+  rd7i_mp_internal_data.file = "";
+}
+
+static void rd7i_mplayer(RenderD7::Parameter param) {
+  MusicDecoder::LoadFile(param.get<std::string>());
+  if (MusicDecoder::decoder == nullptr) return;
+
+  rd7i_mp_internal_data.samples_total = 0;
+  rd7i_mp_internal_data.samples_played = 0;
+  rd7i_mp_internal_data.samples_per_sec = 0;
+  rd7i_mp_internal_data.buf1 = NULL;
+  rd7i_mp_internal_data.buf2 = NULL;
+  rd7i_mp_internal_data.last_buf = false;
+  rd7i_mp_internal_data.ret = -1;
+  rd7i_mp_internal_data.stop = false;
+  rd7i_mp_internal_data.done = false;
+  rd7i_mp_internal_data.playing = true;
+  rd7i_mp_internal_data.file = "";
+
+  if (MusicDecoder::getFileSamples() != (size_t)-1)
+    rd7i_mp_internal_data.samples_total = MusicDecoder::getFileSamples();
+
+  rd7i_mp_internal_data.samples_per_sec =
+      MusicDecoder::getSampleRate() * MusicDecoder::getChannels();
+  rd7i_mp_internal_data.buf1 = (signed short *)linearAlloc(
+      MusicDecoder::getBufSize() * sizeof(signed short));
+  rd7i_mp_internal_data.buf2 = (signed short *)linearAlloc(
+      MusicDecoder::getBufSize() * sizeof(signed short));
+  rd7i_mp_internal_data.file = param.get<std::string>();
+
+  ndspChnReset(rd7i_player_channel);
+  ndspChnWaveBufClear(rd7i_player_channel);
+  ndspSetOutputMode(NDSP_OUTPUT_STEREO);
+  ndspChnSetInterp(rd7i_player_channel, NDSP_INTERP_POLYPHASE);
+  ndspChnSetRate(rd7i_player_channel, MusicDecoder::getSampleRate());
+  ndspChnSetFormat(rd7i_player_channel, MusicDecoder::getChannels() == 2
+                                            ? NDSP_FORMAT_STEREO_PCM16
+                                            : NDSP_FORMAT_MONO_PCM16);
+
+  memset(rd7i_mp_internal_data.waveBuf, 0,
+         sizeof(rd7i_mp_internal_data.waveBuf));
+  rd7i_mp_internal_data.waveBuf[0].nsamples =
+      MusicDecoder::decode(&rd7i_mp_internal_data.buf1[0]) /
+      MusicDecoder::getChannels();
+  rd7i_mp_internal_data.waveBuf[0].data_vaddr = &rd7i_mp_internal_data.buf1[0];
+  ndspChnWaveBufAdd(rd7i_player_channel, &rd7i_mp_internal_data.waveBuf[0]);
+
+  rd7i_mp_internal_data.waveBuf[1].nsamples =
+      MusicDecoder::decode(&rd7i_mp_internal_data.buf2[0]) /
+      MusicDecoder::getChannels();
+  rd7i_mp_internal_data.waveBuf[1].data_vaddr = &rd7i_mp_internal_data.buf2[0];
+  ndspChnWaveBufAdd(rd7i_player_channel, &rd7i_mp_internal_data.waveBuf[1]);
+
+  // Wait for music to start playing
+  while (ndspChnIsPlaying(rd7i_player_channel) == false) {
+    // Waiting
+  }
+
+  while (rd7i_mp_internal_data.stop == false) {
+    svcSleepThread(100 * 1000);
+    if (rd7i_mp_internal_data.last_buf == true &&
+        rd7i_mp_internal_data.waveBuf[0].status == NDSP_WBUF_DONE &&
+        rd7i_mp_internal_data.waveBuf[1].status == NDSP_WBUF_DONE)
+      break;
+
+    if (ndspChnIsPaused(rd7i_player_channel) == true ||
+        rd7i_mp_internal_data.last_buf == true)
+      continue;
+
+    if (rd7i_mp_internal_data.waveBuf[0].status == NDSP_WBUF_DONE) {
+      size_t read = MusicDecoder::decode(&rd7i_mp_internal_data.buf1[0]);
+      /* The previous block of samples have finished playing,
+       * so accumulate them here. */
+      rd7i_mp_internal_data.samples_played +=
+          rd7i_mp_internal_data.waveBuf[0].nsamples *
+          MusicDecoder::getChannels();
+
+      if (read <= 0) {
+        rd7i_mp_internal_data.last_buf = true;
+        continue;
+      } else if (read < MusicDecoder::getBufSize())
+        rd7i_mp_internal_data.waveBuf[0].nsamples =
+            read / MusicDecoder::getChannels();
+
+      ndspChnWaveBufAdd(rd7i_player_channel, &rd7i_mp_internal_data.waveBuf[0]);
+    }
+
+    if (rd7i_mp_internal_data.waveBuf[1].status == NDSP_WBUF_DONE) {
+      size_t read = MusicDecoder::decode(&rd7i_mp_internal_data.buf2[0]);
+      rd7i_mp_internal_data.samples_played +=
+          rd7i_mp_internal_data.waveBuf[0].nsamples *
+          MusicDecoder::getChannels();
+
+      if (read <= 0) {
+        rd7i_mp_internal_data.last_buf = true;
+        continue;
+      } else if (read < MusicDecoder::getBufSize())
+        rd7i_mp_internal_data.waveBuf[1].nsamples =
+            read / MusicDecoder::getChannels();
+
+      ndspChnWaveBufAdd(rd7i_player_channel, &rd7i_mp_internal_data.waveBuf[1]);
+    }
+
+    DSP_FlushDataCache(rd7i_mp_internal_data.buf1,
+                       MusicDecoder::getBufSize() * sizeof(int16_t));
+    DSP_FlushDataCache(rd7i_mp_internal_data.buf2,
+                       MusicDecoder::getBufSize() * sizeof(int16_t));
+  }
+  rd7i_mp_internal_data.samples_played +=
+      rd7i_mp_internal_data.waveBuf[0].nsamples * MusicDecoder::getChannels();
+  rd7i_mp_internal_data.samples_played +=
+      rd7i_mp_internal_data.waveBuf[0].nsamples * MusicDecoder::getChannels();
+  rd7i_player_cleaner();
+  rd7i_mp_internal_data.playing = false;
+  rd7i_mp_internal_data.done = true;
+  return;
+}
+
+void MusicPlayer::PlayFile(const std::string &path) {
+  if (MusicPlayer::IsRunning()) {
+    rd7i_mp_internal_data.stop = true;
+  }
+  while (rd7i_mp_internal_data.playing) {
+  }
+  RenderD7::Thread::sleep(100);
+  rd7i_mph.initialize(rd7i_mplayer, path);
+  rd7i_mph.start(true);
+}
+
+void MusicPlayer::Play() {
+  if (!rd7i_mp_internal_data.playing) {
+    ndspChnSetPaused(rd7i_player_channel, false);
+    rd7i_mp_internal_data.playing = true;
+  }
+}
+
+void MusicPlayer::Pause() {
+  if (rd7i_mp_internal_data.playing) {
+    ndspChnSetPaused(rd7i_player_channel, true);
+    rd7i_mp_internal_data.playing = false;
+  }
+}
+
+void MusicPlayer::Stop() { rd7i_mp_internal_data.stop = true; }
+
+bool MusicPlayer::IsPlaying() { return rd7i_mp_internal_data.playing; }
+
+bool MusicPlayer::IsRunning() { return rd7i_mph.isRunning(); }
+
+int MusicPlayer::PosCurrent() { return rd7i_mp_internal_data.samples_played; }
+
+int MusicPlayer::Total() { return rd7i_mp_internal_data.samples_total; }
+
+int MusicPlayer::SampleRate() { return rd7i_mp_internal_data.samples_per_sec; }
+
+MusicMeta MusicPlayer::GetMeta() { return rd7i_mp_internal_data.meta; }
+
+}  // namespace RenderD7
+
+#endif

source/music/Vorbis.cpp

@@ -0,0 +1,74 @@
+#include <renderd7/music/Vorbis.hpp>
+
+#ifdef RENDERD7_MUSICDEC
+
+int rd7i_check_vorbis(const std::string &path) {
+  // As always forced by libvorbis to not use fstream :(
+  FILE *ft = fopen(path.c_str(), "r");
+  OggVorbis_File testvf;
+  int err;
+
+  if (ft == NULL) return -1;
+
+  err = ov_test(ft, &testvf, NULL, 0);
+
+  ov_clear(&testvf);
+  fclose(ft);
+  return err;
+}
+
+namespace RenderD7 {
+int VorbisDecoder::_init(const std::string &path, MusicMeta& meta) {
+  meta.path(path);
+  if(path.find_last_of('/') != path.npos)
+    meta.name(path.substr(path.find_last_of('/')));
+  else
+    meta.name(path);
+  int ret = -1;
+  if ((f = fopen(path.c_str(), "rb")) == NULL) return ret;
+  if (ov_open(f, &vorbis_file, NULL, 0) < 0) return ret;
+  if ((vi = ov_info(&vorbis_file, -1)) == NULL) return ret;
+  ret = 0;
+  return ret;
+}
+
+unsigned int VorbisDecoder::_getSampleRate() { return vi->rate; }
+
+unsigned char VorbisDecoder::_getChannels() { return vi->channels; }
+
+size_t VorbisDecoder::_getBufSize() { return buf_size; }
+
+unsigned long long VorbisDecoder::_decode(signed short*buf_addr) {
+  uint64_t samples_read = 0;
+  int samples2read = buf_size;
+  char *buf = reinterpret_cast<char *>(buf_addr);
+
+  while (samples2read > 0) {
+    int cur_section;
+    int samples_just_read =
+        ov_read(&vorbis_file, buf, samples2read > 4096 ? 4096 : samples2read,
+                &cur_section);
+    if (samples_just_read < 0)
+      return samples_just_read;
+    else if (samples_just_read == 0)
+      break;  // End of File
+    samples_read += samples_just_read;
+    samples2read -= samples_just_read;
+    buf += samples_just_read;
+  }
+  // Aka / sizeof(int16_t)
+  return samples_read / sizeof(signed short);
+}
+
+void VorbisDecoder::_deinit() {
+  ov_clear(&vorbis_file);
+  fclose(f);
+}
+
+size_t VorbisDecoder::_getFileSamples() {
+  return ov_pcm_total(&vorbis_file, -1)*vi->channels; 
+}
+
+}  // namespace RenderD7
+
+#endif

source/nimg.cpp

@@ -0,0 +1,119 @@
+#include <filesystem>
+#include <fstream>
+#include <map>
+#include <renderd7/nimg.hpp>
+#include <sstream>
+
+// Use an Npi simplifier cause I am lazy
+#define reca_cc(x) reinterpret_cast<const char*>(x)
+#define reca_c(x) reinterpret_cast<char*>(x)
+#define pak32(q, w, e, r)                                             \
+  ((((q) & 0xff) << 0) | (((w) & 0xff) << 8) | (((e) & 0xff) << 16) | \
+   (((r) & 0xff) << 24))
+
+// Stupid RLE Algorithm
+void npi_compress(std::vector<unsigned char>& ret,
+                  const std::vector<unsigned char>& in) {
+  unsigned char counter = 1;
+  unsigned char tmp = in[0];
+  for (size_t i = 1; i < in.size(); ++i) {
+    if (tmp == in[i]) {
+      counter++;
+    } else {
+      ret.push_back(counter);
+      ret.push_back(tmp);
+      counter = 1;
+      tmp = in[i];
+    }
+    if (counter == 255) {
+      ret.push_back(counter);
+      ret.push_back(tmp);
+      counter = 0;
+    }
+  }
+  if (counter > 0) {
+    ret.push_back(counter);
+    ret.push_back(tmp);
+  }
+}
+
+void npi_decompress(std::vector<unsigned char>& ret,
+                    const std::vector<unsigned char>& in) {
+  // Size is sus
+  if ((in.size() % 2) != 0) return;
+  for (size_t i = 0; i < in.size(); i += 2) {
+    int count = in[i];
+    int value = in[i + 1];
+    for (int c = 0; c < count; c++) {
+      ret.push_back(value);
+    }
+  }
+}
+
+namespace RenderD7 {
+nimg NIMG_Load(std::string path) {
+  nimg res;
+  std::ifstream fin(path, std::ios::in | std::ios::binary);
+  // Check magic
+  fin.read(reca_c(&res.magic), sizeof(uint32_t));
+  if (res.magic != NPI_NIMG_) {
+    std::cout << path << " is invalid!" << std::endl;
+    return res;
+  }
+  // Read Information
+  fin.read(reca_c(&res.width), sizeof(int));
+  fin.read(reca_c(&res.height), sizeof(int));
+  fin.read(reca_c(&res.format), sizeof(int));
+  fin.read(reca_c(&res.compression), sizeof(int));
+  // Read Pixeldata
+  if (res.compression == 1) {
+    std::vector<unsigned char> tb;
+    int pb_size = 0;
+    fin.read(reca_c(&pb_size), sizeof(int));
+    tb.resize(pb_size);
+    fin.read(reca_c(tb.data()), pb_size);
+    npi_decompress(res.pixel_buffer, tb);
+  } else {
+    int pb_size = 0;
+    fin.read(reca_c(&pb_size), sizeof(int));
+    res.pixel_buffer.resize(pb_size);
+    fin.read(reca_c(res.pixel_buffer.data()), pb_size);
+  }
+
+  // Close stream
+  fin.close();
+  // Return the loadet imaeg
+  return res;
+}
+
+nimg NIMG_LoadFromMem(unsigned char* buffer, size_t bf_size) { return nimg(); }
+
+void NIMG_Save(nimg image, std::string path) {
+  std::ofstream fout(path);
+  // Write Magic
+  fout.write(reca_cc(&image.magic), sizeof(uint32_t));
+  // Write Information
+  fout.write(reca_cc(&image.width), sizeof(int));
+  fout.write(reca_cc(&image.height), sizeof(int));
+  fout.write(reca_cc(&image.format), sizeof(int));
+  fout.write(reca_cc(&image.compression), sizeof(int));
+  std::vector<unsigned char> test;
+  // Write pixels
+  if (image.compression == 1) {
+    std::vector<unsigned char> tb;
+    npi_compress(tb, image.pixel_buffer);
+    int buf_szs = tb.size();
+    fout.write(reca_cc(&buf_szs), sizeof(int));  // buf_size
+    fout.write(reca_cc(tb.data()),
+               tb.size());  // buffer
+  } else {
+    int buf_szs = image.pixel_buffer.size();
+    fout.write(reca_cc(&buf_szs), sizeof(int));  // buf_size
+    fout.write(reca_cc(image.pixel_buffer.data()),
+               image.pixel_buffer.size());  // buffer
+  }
+
+  // Close stream
+  fout.close();
+}
+}  // namespace RenderD7

source/nimg_engine.cpp

@@ -0,0 +1,83 @@
+#include <renderd7/external/stb_image.h>
+
+#include <renderd7/Color.hpp>
+#include <renderd7/nimg_engine.hpp>
+
+namespace RenderD7 {
+NIMG_Engine::NIMG_Engine(int w, int h) { image = RenderD7::nimg(w, h); }
+NIMG_Engine::NIMG_Engine() { image = RenderD7::nimg(1, 1); }
+
+NIMG_Engine::~NIMG_Engine() {
+  // Do nothing
+}
+
+void NIMG_Engine::load_file(const std::string& path) {
+  int w, h, c;
+  uint8_t* dat = stbi_load(path.c_str(), &w, &h, &c, 4);
+  image = nimg(w, h);
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      int pos = (y * w + x) * 4;
+      image.pixel_buffer[pos + 0] = dat[pos + 0];
+      image.pixel_buffer[pos + 1] = dat[pos + 1];
+      image.pixel_buffer[pos + 2] = dat[pos + 2];
+      image.pixel_buffer[pos + 3] = dat[pos + 3];
+    }
+  }
+  stbi_image_free(dat);
+}
+
+void NIMG_Engine::load_nimg(const std::string& path) {
+  image = RenderD7::NIMG_Load(path);
+}
+
+void NIMG_Engine::draw_pixel(int x, int y, unsigned int color) {
+  if (x > image.width || x < 0 || y > image.height || y < 0) return;
+  RenderD7::Color::RGBA splitter(color);
+  image.pixel_buffer[((y * image.width + x) * 4) + 0] = splitter.m_r;
+  image.pixel_buffer[((y * image.width + x) * 4) + 1] = splitter.m_g;
+  image.pixel_buffer[((y * image.width + x) * 4) + 2] = splitter.m_b;
+  image.pixel_buffer[((y * image.width + x) * 4) + 3] = splitter.m_a;
+}
+
+void NIMG_Engine::draw_rect(int x, int y, int w, int h, unsigned int color,
+                            int t) {}
+
+void NIMG_Engine::draw_rect_solid(int x, int y, int w, int h,
+                                  unsigned int color) {
+  for (int ix = x; ix < x + w; ix++) {
+    for (int iy = y; iy < y + h; iy++) {
+      draw_pixel(ix, iy, color);
+    }
+  }
+}
+
+void NIMG_Engine::flip(bool h, bool v) {
+  const nimg _bak = image;
+  if (h) {
+    for (int x = 0; x < image.width; x++) {
+      for (int y = 0; y < image.height; y++) {
+        int src = (y * image.width + x) * 4;
+        int dst = ((image.height - 1 - y) * image.width + x) * 4;
+        image.pixel_buffer[src + 0] = _bak.pixel_buffer[dst + 3];
+        image.pixel_buffer[src + 1] = _bak.pixel_buffer[dst + 2];
+        image.pixel_buffer[src + 2] = _bak.pixel_buffer[dst + 1];
+        image.pixel_buffer[src + 3] = _bak.pixel_buffer[dst + 0];
+      }
+    }
+  }
+
+  if (v) {
+    for (int x = 0; x < image.width; x++) {
+      for (int y = 0; y < image.height; y++) {
+        int src = (y * image.width + x) * 4;
+        int dst = (y * image.width + (image.width - 1 - x)) * 4;
+        image.pixel_buffer[src + 0] = _bak.pixel_buffer[dst + 3];
+        image.pixel_buffer[src + 1] = _bak.pixel_buffer[dst + 2];
+        image.pixel_buffer[src + 2] = _bak.pixel_buffer[dst + 1];
+        image.pixel_buffer[src + 3] = _bak.pixel_buffer[dst + 0];
+      }
+    }
+  }
+}
+}  // namespace RenderD7

source/sound.cpp

@@ -4,7 +4,7 @@
 #include <string>
 #include <cstring>
 
-extern bool isndspinit;
+#include <renderd7/internal_db.hpp>
 using std::string;
 
 // Reference: http://yannesposito.com/Scratch/en/blog/2010-10-14-Fun-with-wav/
@@ -25,7 +25,7 @@ typedef struct _WavHeader {
 static_assert(sizeof(WavHeader) == 44, "WavHeader size is not 44 bytes.");
 
 sound::sound(const string &path, int channel, bool toloop) {
-  if (isndspinit) {
+  if (rd7i_is_ndsp) {
     ndspSetOutputMode(NDSP_OUTPUT_STEREO);
     ndspSetOutputCount(2); // Num of buffers
 
@@ -104,7 +104,7 @@ sound::sound(const string &path, int channel, bool toloop) {
 }
 
 sound::~sound() {
-  if (isndspinit) {
+  if (rd7i_is_ndsp) {
     waveBuf.data_vaddr = 0;
     waveBuf.nsamples = 0;
     waveBuf.looping = false;
@@ -118,7 +118,7 @@ sound::~sound() {
 }
 
 void sound::play() {
-  if (isndspinit) {
+  if (rd7i_is_ndsp) {
     if (!data)
       return;
     DSP_FlushDataCache(data, dataSize);
@@ -127,7 +127,7 @@ void sound::play() {
 }
 
 void sound::stop() {
-  if (isndspinit) {
+  if (rd7i_is_ndsp) {
     if (!data)
       return;
     ndspChnWaveBufClear(chnl);

source/stb.cpp

@@ -1,2 +1,6 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include <renderd7/external/stb_image.h>
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include <renderd7/external/stb_image_write.h>
+#define STB_TRUETYPE_IMPLEMENTATION
+#include <renderd7/external/stb_truetype.h>