Release 0.9.4

BuildAndInstall.sh

@@ -1,4 +0,0 @@
-export DEVKITARM=/opt/devkitpro/devkitARM/
-export DEVKITPRO=/opt/devkitpro/
-make -j12
-make install

Makefile

@@ -10,7 +10,7 @@ include $(DEVKITARM)/3ds_rules
 
 export renderd7_MAJOR	:= 0
 export renderd7_MINOR	:= 9
-export renderd7_PATCH	:= 3
+export renderd7_PATCH	:= 4
 
 VERSION	:=	$(renderd7_MAJOR).$(renderd7_MINOR).$(renderd7_PATCH)
 
@@ -112,17 +112,13 @@ doc:
 	@doxygen Doxyfile
 
 dist-bin: all
-	@tar --exclude=*~ -cjf $(TARGET)-$(VERSION).tar.bz2 include lib
+	@tar --exclude=*~ -cjf $(TARGET).tar.bz2 include lib
 
 dist-src:
-	@tar --exclude=*~ -cjf $(TARGET)-src-$(VERSION).tar.bz2 include $(SOURCES) Makefile
+	@tar --exclude=*~ -cjf $(TARGET)-src.tar.bz2 include $(SOURCES) Makefile
 
 dist: dist-src dist-bin
 
-install: dist-bin
-	mkdir -p $(DEPSDIR)$(DEVKITPRO)/libctru
-	bzip2 -cd $(TARGET)-$(VERSION).tar.bz2 | tar -xf - -C $(DEPSDIR)$(DEVKITPRO)/libctru
-
 lib:
 	@[ -d $@ ] || mkdir -p $@
 

README.md

@@ -1,20 +1,37 @@
-# RenderD7 <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/blob/main/logo.png" height="90">
 RenderD7 is now LibRenderD7.
-### Installation (Ubuntu)
+### Installation
-first run this
+Download a Package From Releses Page
-`sudo su`
+`https://github.com/NPI-D7/RenderD7/releases/download/v0.9.3/renderd7.tar.bz2 -o renderd7.tar.bz2`
-then this
+Then Extract it to your Libraries Path
+`bzip2 -cd renderd7.tar.bz2 | tar -xf - -C path_to_your_libs`
+Finally put `-lrenderd7` to the First Place and add the path_to_your_libs
 ```
-curl -L https://github.com/NPI-D7/RenderD7/releases/download/v0.8.0-pre1/renderd7-0.8.0.tar.bz2 -o renderd7-0.8.0.tar.bz2
+LIBS	:= -lrenderd7 -lcurl -lstdc++ -lm -lcitro2d -lcitro3d -lctru
-mkdir -p /opt/devkitpro/libctru
+#---------------------------------------------------------------------------------
-bzip2 -cd renderd7-0.8.0.tar.bz2 | tar -xf - -C /opt/devkitpro/libctru
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS	:= $(PORTLIBS) $(CTRULIB) ../path_to_your_libs
 ```
 Make sure that `-lrenderd7` is before `-lcitro2d`, `-lcitro3d`, `-lctru`.
-
+Here an example tree
-# RenderD7 (https://npi-d7.github.io/RenderD7/)
+```
-Simple and Easey to use UI and Graphics helper.
+Example-App
-Create DOCS
+├── gfx
-
+├── libs
+│   ├── include
+│   │   ├── rd7.hpp
+│   │   └── renderd7
+│   └── lib
+│       ├── librenderd7.a
+│       └── librenderd7d.a
+├── Makefile
+├── romfs
+│   └── gfx
+└── src
+    └── main.cpp
+```
 # Credits
 - NPI-D7
   - Tobi-D7 Main Dev

cformat.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 
 find . -type f \( -name '*.h' -o -name '*.hpp' -o -name '*.hh' -o -name '*.ino' -o -name '*.cpp' -o -name '*.c' -o -name '*.cxx' -o -name '*.inl' \) -and -not -path './build/*' -not -path './base/external/*' -not -path './DPP/*' | while read file; do
   if [[ "$file" != *"json.hpp" ]]; then

envsetup.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+#Build Tools
+echo "Build Tools..."
+cd tools
+./build_tools.sh
+cd ..
+#Setup asset-arrays
+echo "Generate Asset-Arrays..."
+cd assets
+./build_assets.sh
+echo "Update Files in RenderD7..."
+cp -rf code/*.cpp ../source/
+cp -rf code/*.hpp ../include/renderd7/
+echo "Clean Assets..."
+./clear_assets.sh
+cd ..
+#Clear Tools
+echo "Clean Tools..."
+cd tools
+./clear_tools.sh
+cd ..
+#Finished
+echo "Done!"

include/renderd7/FunctionTrace.hpp

@@ -0,0 +1,52 @@
+#pragma once
+// Base includes
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+// 3ds does not support std::chrono
+#include <3ds.h>
+
+/// @brief 3ds System Ticks per milli second
+#define TICKS_PER_MSEC 268111.856
+
+#define f2s(x_) #x_
+#define scomb(x1, x2) std::string(x1 + x2)
+
+namespace RenderD7 {
+namespace Ftrace {
+/// @brief Result of FTrace
+struct FTRes {
+  std::string group;     ///< Group of the Trace
+  std::string func_name; ///< Function Name
+
+  uint64_t time_start; ///< when started
+  uint64_t time_end;   ///< when stopped
+  float time_of;       ///< stop - start (how long)
+};
+
+/// @brief Map of Traces
+extern std::map<std::string, RenderD7::Ftrace::FTRes> rd7_traces;
+
+/// @brief Set a Start TracePoint
+/// @param group Set a Group Name
+/// @param func_name Set a Function Name
+inline void Beg(std::string group, std::string func_name) {
+  std::string trace_id = scomb(group, func_name);
+  rd7_traces[trace_id].group = group;
+  rd7_traces[trace_id].func_name = func_name;
+  rd7_traces[trace_id].time_start = svcGetSystemTick();
+}
+/// @brief Set an End TracePoint
+/// @param group Set a Group Name
+/// @param func_name Set a Function Name
+inline void End(std::string group, std::string func_name) {
+  std::string trace_id = scomb(group, func_name);
+  rd7_traces[trace_id].time_end = svcGetSystemTick();
+  rd7_traces[trace_id].time_of = static_cast<float>(
+      rd7_traces[trace_id].time_end / (float)TICKS_PER_MSEC -
+      rd7_traces[trace_id].time_start / (float)TICKS_PER_MSEC);
+}
+} // namespace Ftrace
+} // namespace RenderD7

include/renderd7/Hardware.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+namespace RenderD7 {
+namespace Hardware {
+/// @brief Initialisize required Services
+void Initialisize();
+/// @brief Check if Headphones are Plugged in
+/// @return true if headphones plugged in
+bool IsHeadphones();
+/// @brief Check if the 3ds Is Charging
+/// @return true if System gets Charged
+bool IsCharging();
+/// @brief Check the Battery Percentage
+/// @return Persentage as float
+float GetBatteryPercentage();
+/// @brief Get current State of 3d Slider
+/// @return current 3dslider poition
+float Get3dSliderLevel();
+/// @brief Get Current state of Sound Slider
+/// @return current SoundSlider state
+float GetSoundSliderLevel();
+} // namespace Hardware
+} // namespace RenderD7

include/renderd7/Memory.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+namespace RenderD7 {
+namespace Memory {
+/// @brief Metriks struct For the Internal Tracker
+struct memory_metrics {
+  uint32_t t_TotalAllocated = 0; ///< Total Allocated Memory
+  uint32_t t_TotalFreed = 0;     ///< Total Deleted Memory
+  /// @brief Gets the Currently Allocated Memory
+  uint32_t t_CurrentlyAllocated() { return t_TotalAllocated - t_TotalFreed; }
+};
+/// @brief Get Total Allocated Memory
+/// @return Total Allocated Memory
+size_t GetTotalAllocated();
+/// @brief Get Total Deleted Memory
+/// @return Total Deleted Memory
+size_t GetTotalFreed();
+/// @brief Get Current Allocated Memory
+/// @return Current Allocated Memory
+size_t GetCurrent();
+} // namespace Memory
+} // namespace RenderD7

include/renderd7/Ovarlays.hpp

@@ -0,0 +1,64 @@
+#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:
+};
+class Ovl_UiBattery : public RenderD7::Ovl {
+  /// @brief Constructor
+  /// @param percentage Percentage
+  Ovl_UiBattery(float *percentage);
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+  float *_pct_addr = 0;
+};
+class Ovl_UiSound : public RenderD7::Ovl {
+  /// @brief Constructor
+  /// @param percentage Percentage
+  Ovl_UiSound(float *percentage);
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+  float *_pct_addr = 0;
+};
+class Ovl_Ui3d : public RenderD7::Ovl {
+  /// @brief Constructor
+  /// @param percentage Percentage
+  Ovl_Ui3d(float *percentage);
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+  float *_pct_addr = 0;
+};
+class Ovl_UiWifi : public RenderD7::Ovl {
+  /// @brief Constructor
+  /// @param level strengh level
+  Ovl_UiWifi(uint8_t *level);
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+  uint8_t *_pct_addr = 0;
+};
+} // namespace RenderD7

include/renderd7/Ovl.hpp

@@ -21,7 +21,10 @@ private:
   /// @param iskilled For IsKilled();
   bool iskilled = false;
 };
-/// @brief Add an Overlay to the stack
+/// @brief Add an Overlay to the Screen
-/// @param scene Overlay to push to Stack
+/// @param scene Overlay to push to Screen
 void AddOvl(std::unique_ptr<RenderD7::Ovl> scene);
+/// @brief Add an Overlay to the Toast Stack
+/// @param scene Overlay to push to Toast Stack
+void AddToast(std::unique_ptr<RenderD7::Ovl> scene);
 } // namespace RenderD7

include/renderd7/Security.hpp

@@ -0,0 +1,60 @@
+#pragma once
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+#include <3ds.h>
+
+namespace RenderD7 {
+namespace Init {
+void Security();
+}
+
+class Security {
+public:
+  /// @brief Security Levels
+  enum Level {
+    NONE,     ///< Do Completly Nothing (excludes FrameEnd Security)
+    FULL,     ///< Display Every Reports even Success
+    ERRORS,   ///< Display Only Errors
+    WARNINGS, ///< Display Errors and Warnings
+    LOG,      ///< Log Every Error with Detailed Information
+  };
+
+  Security();
+  ~Security();
+  /// @brief Report an Output (For SafeTraceInit)
+  /// @param addr Adress of Pointer
+  /// @param result_ptr Pointer to the result
+  void Report(uint32_t addr, void *result_ptr);
+  /// @brief Set the Security Level
+  /// @param level Level to use
+  void SetLevel(Level level);
+  /// @brief Get Current Security Level
+  /// @return Security Level
+  Level GetLevel();
+  /// @brief Call a Function at Program Crash/Exit
+  /// @param exit_func Function to Call
+  void SafeExit(void (*exit_func)());
+  /// @brief SaveInit a Function and define a Exit Func
+  /// @param init_func Init Function
+  /// @param exit_func Exit Function
+  void SafeInit(void (*init_func)(), void (*exit_func)());
+  /// @brief SaveInit a Function and define a Exit Func
+  /// @param init_func Init Function
+  /// @param exit_func Exit Function
+  void SafeInit(Result (*init_func)(), void (*exit_func)());
+  /// @brief SaveInit a Function and define a Exit Func
+  /// @param init_func Init Function
+  /// @param exit_func Exit Function
+  void SafeInit(void (*init_func)(), Result (*exit_func)());
+  /// @brief SaveInit a Function and define a Exit Func
+  /// @param init_func Init Function
+  /// @param exit_func Exit Function
+  void SafeInit(Result (*init_func)(), Result (*exit_func)());
+};
+} // namespace RenderD7
+
+/// @brief RenderD7 Security Object
+extern RenderD7::Security *rd7_security;

include/renderd7/renderd7.hpp

@@ -1,10 +1,8 @@
 #pragma once
-#include <3ds.h>
+/// c++ Includes
 #include <algorithm>
-#include <citro2d.h>
+#include <codecvt>
-#include <citro3d.h>
 #include <cstring>
-#include <dirent.h>
 #include <filesystem>
 #include <functional>
 #include <iostream>
@@ -13,22 +11,30 @@
 #include <memory>
 #include <random>
 #include <stack>
-#include <stdio.h>
 #include <string>
+#include <vector>
+/// c includes
+#include <dirent.h>
+#include <stdio.h>
 #include <sys/stat.h>
 #include <time.h>
 #include <unistd.h>
-#include <vector>
+/// 3ds Includes
-
+#include <3ds.h>
-#include <codecvt>
+#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>
 #include <renderd7/Screen.hpp>
+#include <renderd7/Security.hpp>
 #include <renderd7/Sheet.hpp>
 #include <renderd7/Sprite.hpp>
 #include <renderd7/SpriteAnimation.hpp>
@@ -44,9 +50,14 @@
 #include <renderd7/stringtool.hpp>
 #include <renderd7/thread.hpp>
 
-#define RENDERD7VSTRING "0.9.3"
+#define RENDERD7VSTRING "0.9.4"
 #define CHANGELOG                                                              \
-  "0.9.3: Completly Documanted Everything\nFix typo in "                       \
+  "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 Documanted Everything\nFix typo "     \
+  "in "                                                                        \
   "Sprite::getHeight()\nRemove Deprecated/Useless Stuff\n0.9.2: Add "          \
   "NpiSplashVideo\nNvid Support(v0.0.1)\nAdd "                                 \
   "Basic RenderD7 "                                                            \
@@ -74,8 +85,11 @@
   "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
@@ -90,6 +104,8 @@ 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;
 
 /// RenderD7
 namespace RenderD7 {
@@ -112,8 +128,6 @@ struct TObject {
   int w;                 ///< Button Width
   int h;                 ///< Button Height
   std::string text = ""; ///< Text
-  float correctx = 0;    ///< Correct X Position
-  float correcty = 0;    ///< Correct Y Position
   float txtsize = 0.7f;  ///< Set Text Size
 };
 /// @brief Scene Class
@@ -157,7 +171,16 @@ private:
   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 };
+  enum RState {
+    RSETTINGS,
+    RINFO,
+    RSERVICES,
+    RCLOG,
+    RMCONFIG,
+    RFTRACE,
+    RSECM,
+    RCREDITS
+  };
   /// @param m_state Current menu State (Default=MainMenu aka RSETTINGS)
   RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS;
 
@@ -167,26 +190,20 @@ private:
   int screen_index = 0;
   /// @param lines Vector of Changelog-Lines
   std::vector<std::string> lines;
+  /// @brief Position in FTrace Menu
+  int ftrace_index = 0;
 
-  /// @param rd7srstate State of RenderD7 Super Reselution
-  std::string rd7srstate = "false";
   /// @param mtovlstate State of Metricks Overlay
   std::string mtovlstate = "false";
-  /// @param fpsstate Value of Forced Framerate
-  std::string fpsstate = "60";
   /// @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, "RD7SR", -8, 10},
+      {20, 35, 120, 35, "NotYET"},      {20, 85, 120, 35, "Changelog"},
-      {20, 85, 120, 35, "Changelog", -24, 11},
+      {20, 135, 120, 35, "Metrik-Ovl"}, {20, 185, 120, 35, "Tasks"},
-      {20, 135, 120, 35, "Metrik-Ovl", -23, 10},
+      {180, 35, 120, 35, "FTrace"},     {180, 85, 120, 35, "Credits"},
-      {20, 185, 120, 35, "NOTYET", -13, 10},
+      {180, 135, 120, 35, "Info"},      {180, 185, 120, 35, "Security"}};
-      {180, 35, 120, 35, "MTSCREEN", -27, 10},
-      {180, 85, 120, 35, "NOTYET", -13, 10},
-      {180, 135, 120, 35, "INFO", 2, 10},
-      {180, 185, 120, 35, "Services", -13, 10}};
 
 public:
   /// @brief Constructor
@@ -229,6 +246,14 @@ private:
 /// @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
@@ -282,17 +307,6 @@ void Graphics();
 void NdspFirm();
 } // namespace Init
 
-namespace Exit {
-/// @brief Exit Default RenderD7
-void Main();
-/// @brief Exit Minimal RenderD7
-void Minimal();
-/// @brief Exit Ndsp
-void NdspFirm();
-/// @brief DEPRECATED Exit Graphics
-void Graphics();
-} // namespace Exit
-
 namespace Msg {
 /// @brief Display A Message
 /// @param titletxt Header Text
@@ -325,13 +339,6 @@ inline int StringtoInt(std::string inp) { return std::atoi(inp.c_str()); }
 inline bool FloatToBool(float inp) { return (inp == 1 ? true : false); }
 } // namespace Convert
 
-/// @brief DEPRECATED DirContent
-struct DirContent {
-  std::string name; ///< Content Name
-  std::string path; ///< Content Path
-  bool isDir;       ///< Is Directory
-};
-
 namespace FS {
 /// @brief Check if File exists
 /// @param path Path to the File
@@ -342,8 +349,6 @@ bool FileExist(const std::string &path);
 /// @brief Check if Ndsp is Init
 /// @return is or not
 bool IsNdspInit();
-/// @brief Setup RenderD7 Logs
-void SetupLog(void);
 /// @brief Get Current Framerate as String
 /// @return Framerate String
 std::string GetFramerate();
@@ -366,11 +371,6 @@ 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 Enable/Disable RenderD7 Super Reselution
-void ToggleRD7SR();
-/// @brief Check if RD7SR is Enabled
-/// @return is or not
-bool IsRD7SR();
 
 /// @brief Textless Button
 struct TLBtn {
@@ -417,14 +417,4 @@ 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 DEPRECATED USE RenderD7::FileSystem
-/// @param dircontent Vector of Content output
-/// @param extensions Extensions
-void GetDirContentsExt(std::vector<RenderD7::DirContent> &dircontent,
-                       const std::vector<std::string> &extensions);
-/// @brief DEPRECATED USE RenderD7::FileSystem
-/// @param dircontent Vector of Content output
-void GetDirContents(std::vector<RenderD7::DirContent> &dircontent);
-
 } // namespace RenderD7

include/renderd7/stringtool.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <iomanip>
 #include <iostream>
+#include <sstream>
 #include <string>
 
 namespace RenderD7 {
@@ -27,6 +28,41 @@ inline bool NameIsEndingWith(const std::string &name,
 
   return false;
 }
+/// @brief Format Milliseconds to clean string (Stolen from one of my Mc
+/// Plugins)
+/// @param t_time Time in ms
+/// @return String
+inline std::string MsTimeFmt(float t_time) {
+  std::ostringstream oss;
+
+  if (t_time < 0.001f) {
+    oss << std::fixed << std::setprecision(2) << t_time * 1000.0f << "ns";
+  } else if (t_time < 1.0f) {
+    oss << std::fixed << std::setprecision(2) << t_time << "ms";
+  } else if (t_time < 60000.0f) {
+    int seconds = static_cast<int>(t_time / 1000.0f);
+    float milliseconds = t_time - (seconds * 1000.0f);
+
+    if (seconds > 0) {
+      oss << seconds << "s ";
+    }
+    oss << std::fixed << std::setprecision(2) << milliseconds << "ms";
+  } else {
+    int minutes = static_cast<int>(t_time / 60000.0f);
+    int seconds = static_cast<int>((t_time - (minutes * 60000.0f)) / 1000.0f);
+    float milliseconds = t_time - (minutes * 60000.0f) - (seconds * 1000.0f);
+
+    oss << minutes << "m ";
+    if (seconds > 0 || milliseconds > 0.0f) {
+      oss << seconds << "s ";
+    }
+    if (milliseconds > 0.0f) {
+      oss << std::fixed << std::setprecision(2) << milliseconds << "ms";
+    }
+  }
+
+  return oss.str();
+}
 } // namespace RenderD7
 
 template <class T> T GetFileName(T const &path, T const &delims = "/\\") {

rd7tf/Makefile

@@ -0,0 +1,295 @@
+#---------------------------------------------------------------------------------
+.SUFFIXES:
+#nicetest
+#---------------------------------------------------------------------------------
+
+ifeq ($(strip $(DEVKITARM)),)
+$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
+endif
+
+TOPDIR ?= $(CURDIR)
+include $(DEVKITARM)/3ds_rules
+
+#---------------------------------------------------------------------------------
+# TARGET is the name of the output
+# BUILD is the directory where object files & intermediate files will be placed
+# SOURCES is a list of directories containing source code
+# DATA is a list of directories containing data files
+# INCLUDES is a list of directories containing header files
+# GRAPHICS is a list of directories containing graphics files
+# GFXBUILD is the directory where converted graphics files will be placed
+#   If set to $(BUILD), it will statically link in the converted
+#   files as if they were data files.
+#
+# NO_SMDH: if set to anything, no SMDH file is generated.
+# ROMFS is the directory which contains the RomFS, relative to the Makefile (Optional)
+# APP_TITLE is the name of the app stored in the SMDH file (Optional)
+# APP_DESCRIPTION is the description of the app stored in the SMDH file (Optional)
+# APP_AUTHOR is the author of the app stored in the SMDH file (Optional)
+# ICON is the filename of the icon (.png), relative to the project folder.
+#   If not set, it attempts to use one of the following (in this order):
+#     - <Project name>.png
+#     - icon.png
+#     - <libctru folder>/default_icon.png
+
+#---------------------------------------------------------------------------------
+# External tools
+#---------------------------------------------------------------------------------
+ifeq ($(OS),Windows_NT)
+MAKEROM 	?= C:/devkitpro/tools/bin/makerom.exe
+BANNERTOOL 	?= C:/devkitpro/tools/bin/bannertool.exe
+
+else
+MAKEROM 	?= makerom
+BANNERTOOL 	?= bannertool
+
+endif
+
+# If on a tagged commit, use the tag instead of the commit
+ifneq ($(shell echo $(shell git tag -l --points-at HEAD) | head -c 1),)
+GIT_VER := $(shell git tag -l --points-at HEAD)
+else
+GIT_VER := $(shell git rev-parse --short HEAD)
+endif
+
+TIME_TIME := $(shell date --iso=seconds)
+
+#---------------------------------------------------------------------------------
+# Version number
+#---------------------------------------------------------------------------------
+
+VERSION_MAJOR := 1
+
+VERSION_MINOR := 0
+
+VERSION_MICRO := 0
+
+
+#---------------------------------------------------------------------------------
+TARGET		:=	rd7tf
+BUILD		:=	build
+SOURCES		:=	source 
+DATA		:=	data
+INCLUDES	:=	source 
+GRAPHICS	:=	gfx
+#GFXBUILD	:=	$(BUILD)
+ROMFS		:=	romfs
+GFXBUILD	:=	$(ROMFS)/gfx
+APP_AUTHOR	:=	NPI-D7
+APP_DESCRIPTION := RenderD7 Test Framework
+ICON		:=	app/icon.png
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+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 \
+			$(ARCH)
+
+CFLAGS	+=	$(INCLUDE) -D__3DS__ -D_GNU_SOURCE=1
+
+CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++20 
+
+ASFLAGS	:=	-g $(ARCH)
+LDFLAGS	=	-specs=3dsx.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
+
+LIBS	:= -lrenderd7d -lcurl -lstdc++ -lm -lz -lcitro2d -lcitro3d -lctru -ljpeg 
+
+
+#---------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS	:= $(PORTLIBS) $(CTRULIB) ../libs
+
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+
+export OUTPUT	:=	$(CURDIR)/$(TARGET)
+export TOPDIR	:=	$(CURDIR)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR	:=	$(CURDIR)/$(BUILD)
+
+CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+PICAFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.v.pica)))
+SHLISTFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.shlist)))
+GFXFILES	:=	$(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.t3s)))
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+#---------------------------------------------------------------------------------
+ifeq ($(GFXBUILD),$(BUILD))
+#---------------------------------------------------------------------------------
+export T3XFILES :=  $(GFXFILES:.t3s=.t3x)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+export ROMFS_T3XFILES	:=	$(patsubst %.t3s, $(GFXBUILD)/%.t3x, $(GFXFILES))
+export T3XHFILES		:=	$(patsubst %.t3s, $(BUILD)/%.h, $(GFXFILES))
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_SOURCES 	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES)) \
+			$(PICAFILES:.v.pica=.shbin.o) $(SHLISTFILES:.shlist=.shbin.o)
+
+export OFILES := $(OFILES_BIN) $(OFILES_SOURCES)
+
+export HFILES	:=	$(PICAFILES:.v.pica=_shbin.h) $(SHLISTFILES:.shlist=_shbin.h) \
+			$(addsuffix .h,$(subst .,_,$(BINFILES)))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I$(CURDIR)/$(BUILD)
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
+
+export _3DSXDEPS	:=	$(if $(NO_SMDH),,$(OUTPUT).smdh)
+
+ifeq ($(strip $(ICON)),)
+	icons := $(wildcard *.png)
+	ifneq (,$(findstring $(TARGET).png,$(icons)))
+		export APP_ICON := $(TOPDIR)/$(TARGET).png
+	else
+		ifneq (,$(findstring icon.png,$(icons)))
+			export APP_ICON := $(TOPDIR)/icon.png
+		endif
+	endif
+else
+	export APP_ICON := $(TOPDIR)/$(ICON)
+endif
+
+ifeq ($(strip $(NO_SMDH)),)
+	export _3DSXFLAGS += --smdh=$(CURDIR)/$(TARGET).smdh
+endif
+
+ifneq ($(ROMFS),)
+	export _3DSXFLAGS += --romfs=$(CURDIR)/$(ROMFS)
+endif
+
+.PHONY: all clean
+
+#---------------------------------------------------------------------------------
+all: $(BUILD) $(GFXBUILD) $(DEPSDIR) $(ROMFS_T3XFILES) $(T3XHFILES)
+	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+
+#------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(BUILD) $(TARGET).elf $(TARGET).3dsx $(TARGET).cia $(TARGET).smdh app/*.bin 
+	@rm -fr $(OUTDIR)
+
+#---------------------------------------------------------------------------------
+send:
+	@3dslink -a $(IP) $(TARGET).3dsx
+#---------------------------------------------------------------------------------
+run:
+	@flatpak run org.citra_emu.citra $(TARGET).3dsx
+#---------------------------------------------------------------------------------
+#---------------------------------------------------------------------------------
+3dsx: $(BUILD)
+	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile 3dsx
+
+#---------------------------------------------------------------------------------
+$(GFXBUILD)/%.t3x	$(BUILD)/%.h	:	%.t3s
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	$(DEVKITPRO)/tools/bin/tex3ds -i $< -H $(BUILD)/$*.h -d $(DEPSDIR)/$*.d -o $(GFXBUILD)/$*.t3x
+
+#---------------------------------------------------------------------------------
+$(BUILD):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+else
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+all: $(OUTPUT).elf $(OUTPUT).3dsx
+
+$(OUTPUT).elf	:	$(OFILES)
+$(OUTPUT).3dsx	:   $(_3DSXDEPS)
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h :	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+#---------------------------------------------------------------------------------
+.PRECIOUS	:	%.t3x
+#---------------------------------------------------------------------------------
+%.t3x.o	%_t3x.h :	%.t3x
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+#---------------------------------------------------------------------------------
+# rules for assembling GPU shaders
+#---------------------------------------------------------------------------------
+define shader-as
+	$(eval CURBIN := $*.shbin)
+	$(eval DEPSFILE := $(DEPSDIR)/$*.shbin.d)
+	echo "$(CURBIN).o: $< $1" > $(DEPSFILE)
+	echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"_end[];" > `(echo $(CURBIN) | tr . _)`.h
+	echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(CURBIN) | tr . _)`.h
+	echo "extern const u32" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_size";" >> `(echo $(CURBIN) | tr . _)`.h
+	picasso -o $(CURBIN) $1
+	bin2s $(CURBIN) | $(AS) -o $*.shbin.o
+endef
+
+%.shbin.o %_shbin.h : %.v.pica %.g.pica
+	@echo $(notdir $^)
+	@$(call shader-as,$^)
+
+%.shbin.o %_shbin.h : %.v.pica
+	@echo $(notdir $<)
+	@$(call shader-as,$<)
+
+%.shbin.o %_shbin.h : %.shlist
+	@echo $(notdir $<)
+	@$(call shader-as,$(foreach file,$(shell cat $<),$(dir $<)$(file)))
+
+#---------------------------------------------------------------------------------
+%.t3x	%.h	:	%.t3s
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@tex3ds -i $< -H $*.h -d $*.d -o $*.t3x
+
+-include $(DEPSDIR)/*.d
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

rd7tf/clean.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+#Clean old build
+echo "Cleaning..."
+make clean
+rm -rf libs/*
+cd ..
+make clean
+echo "Done!"

rd7tf/gfx/sprites.t3s

@@ -0,0 +1,6 @@
+--atlas -f rgba -z auto
+
+renderd7.png
+folder.png
+default_icon.png
+unk_icon.png

rd7tf/romfs/gfx/Leere Datei

@@ -0,0 +1 @@
+vcx

rd7tf/romfs/lang/de/app.json

@@ -0,0 +1,5 @@
+{
+    "LOADINGFILES": "Lade Dateien ...",
+    "MENU": "Menü",
+    "LOADING": "Lade ..."
+}

rd7tf/romfs/lang/en/app.json

@@ -0,0 +1,5 @@
+{
+    "LOADINGFILES": "Loading Files ...",
+    "MENU": "Menu",
+    "LOADING": "Loading ..."
+}

rd7tf/source/main.cpp

@@ -0,0 +1,21 @@
+#include <rd7.hpp>
+
+int main() {
+  rd7_do_splash = true;
+  RenderD7::Ftrace::Beg("app", "app_init");
+  RenderD7::Init::Main("rd7tf");
+  RenderD7::Init::NdspFirm();
+  RenderD7::Ftrace::Beg("app", f2s(RenderD7::LoadSettings));
+  RenderD7::LoadSettings();
+  RenderD7::Ftrace::End("app", f2s(RenderD7::LoadSettings));
+  RenderD7::Ftrace::End("app", "app_init");
+  while (RenderD7::MainLoop()) {
+    RenderD7::Ftrace::Beg("app", "app_mainloop");
+    if (d7_hDown & KEY_START)
+      RenderD7::ExitApp();
+    RenderD7::FrameEnd();
+    RenderD7::Ftrace::End("app", "app_mainloop");
+  }
+
+  return 0;
+}

rd7tf/update.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+#Clean old build
+echo "Cleaning..."
+rm -rf libs/*
+#Format to LLVM
+echo "Format to LLVM"
+cd ..
+./cformat.sh
+#Compile RenderD7
+echo "Compiling RenderD7"
+make
+#Copy new build
+echo "Copy New Build"
+cp -r include rd7tf/libs/
+cp -r lib rd7tf/libs/
+#Build Test Framework
+echo "Building Test Framework"
+cd rd7tf
+make
+
+echo "Done!"

source/FunctionTrace.cpp

@@ -0,0 +1,3 @@
+#include <renderd7/FunctionTrace.hpp>
+
+std::map<std::string, RenderD7::Ftrace::FTRes> RenderD7::Ftrace::rd7_traces;

source/Hardware.cpp

@@ -0,0 +1,46 @@
+#include <renderd7/Hardware.hpp>
+#include <renderd7/Security.hpp>
+
+// Os Specific includes
+#include <3ds.h>
+
+// RenderD7 Security
+extern bool isndspinit;
+
+void RenderD7::Hardware::Initialisize() {
+  rd7_security->SafeInit(mcuHwcInit, &mcuHwcExit);
+  rd7_security->SafeInit(ptmuInit, &ptmuExit);
+}
+
+bool RenderD7::Hardware::IsHeadphones() {
+  if (isndspinit) {
+    bool inserted;
+    DSP_GetHeadphoneStatus(&inserted);
+    return inserted;
+  } else
+    return false;
+}
+
+bool RenderD7::Hardware::IsCharging() {
+  uint8_t var;
+  PTMU_GetBatteryChargeState(&var);
+  // Some Security Stuff
+  if (var < 0x00 && var > 0x01) {
+    return false;
+  }
+  return (var == 0x01 ? true : false);
+}
+
+float RenderD7::Hardware::GetBatteryPercentage() {
+  uint8_t percentLevel;
+  PTMU_GetBatteryLevel(&percentLevel);
+  return (float)percentLevel / 100;
+}
+
+float RenderD7::Hardware::Get3dSliderLevel() { return osGet3DSliderState(); }
+
+float RenderD7::Hardware::GetSoundSliderLevel() {
+  uint8_t percentLevel;
+  MCUHWC_GetSoundSliderLevel(&percentLevel);
+  return (float)percentLevel / 100;
+}

source/Memory.cpp

@@ -0,0 +1,60 @@
+#include <map>
+#include <renderd7/Memory.hpp>
+
+static RenderD7::Memory::memory_metrics metrics;
+
+bool rd7_enable_memtrack;
+
+void *operator new(size_t size) {
+  void *ptr = malloc(size);
+  if (rd7_enable_memtrack)
+    metrics.t_TotalAllocated += size;
+  return ptr;
+}
+
+void operator delete(void *memory, size_t size) {
+  if (rd7_enable_memtrack)
+    metrics.t_TotalFreed += size;
+  free(memory);
+}
+
+int allocations = 0;
+int total_size = 0;
+std::map<void *, size_t> sizes;
+
+void *operator new[](size_t size) {
+  if (rd7_enable_memtrack)
+    allocations++;
+  if (rd7_enable_memtrack)
+    total_size += size;
+  void *ptr = malloc(size);
+  if (rd7_enable_memtrack)
+    sizes[ptr] = size;
+  if (rd7_enable_memtrack)
+    metrics.t_TotalAllocated += size;
+  return ptr;
+}
+
+void operator delete[](void *ptr) {
+  if (rd7_enable_memtrack)
+    allocations--;
+  if (rd7_enable_memtrack)
+    total_size -= sizes[ptr];
+  if (rd7_enable_memtrack)
+    metrics.t_TotalFreed += sizes[ptr];
+  if (rd7_enable_memtrack)
+    sizes.erase(ptr);
+  free(ptr);
+}
+
+namespace RenderD7 {
+
+namespace Memory {
+
+size_t GetTotalAllocated() { return metrics.t_TotalAllocated; }
+
+size_t GetTotalFreed() { return metrics.t_TotalFreed; }
+
+size_t GetCurrent() { return metrics.t_CurrentlyAllocated(); }
+} // namespace Memory
+} // namespace RenderD7

source/Ovarlays.cpp

@@ -0,0 +1,35 @@
+#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() {}
+
+Ovl_UiBattery::Ovl_UiBattery(float *percentage) { _pct_addr = percentage; }
+
+void Ovl_UiBattery::Draw(void) const {}
+
+void Ovl_UiBattery::Logic() {}
+
+Ovl_UiSound::Ovl_UiSound(float *percentage) { _pct_addr = percentage; }
+
+void Ovl_UiSound::Draw(void) const {}
+
+void Ovl_UiSound::Logic() {}
+
+Ovl_Ui3d::Ovl_Ui3d(float *percentage) { _pct_addr = percentage; }
+
+void Ovl_Ui3d::Draw(void) const {}
+
+void Ovl_Ui3d::Logic() {}
+
+Ovl_UiWifi::Ovl_UiWifi(uint8_t *level) { _pct_addr = level; }
+
+void Ovl_UiWifi::Draw(void) const {}
+
+void Ovl_UiWifi::Logic() {}
+} // namespace RenderD7

source/Security.cpp

@@ -0,0 +1,61 @@
+#include <renderd7/Security.hpp>
+
+#include <3ds.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+RenderD7::Security *rd7_security;
+
+extern bool running;
+bool *running_addr = NULL;
+
+struct SecurityReport {
+  uint32_t addr;
+  std::string initialisized_at;
+  bool success;
+};
+
+std::vector<SecurityReport> rd7_security_reports;
+
+RenderD7::Security::Level RenderD7::Security::GetLevel() {
+  return RenderD7::Security::Level::FULL;
+}
+
+void RenderD7::Security::SetLevel(RenderD7::Security::Level level) {}
+
+void RenderD7::Security::Report(uint32_t addr, void *result_ptr) {
+  // Create Report
+}
+namespace RenderD7 {
+Security::Security() { running_addr = &running; }
+
+Security::~Security() { *running_addr = false; }
+void Security::SafeExit(void (*exit_func)()) { atexit(exit_func); }
+
+void Security::SafeInit(void (*init_func)(), void (*exit_func)()) {
+  init_func();
+  atexit(exit_func);
+}
+
+void Security::SafeInit(Result (*init_func)(), void (*exit_func)()) {
+  init_func();
+  atexit(exit_func);
+}
+
+void Security::SafeInit(void (*init_func)(), Result (*exit_func)()) {
+  init_func();
+  atexit(reinterpret_cast<void (*)()>(exit_func));
+}
+
+void Security::SafeInit(Result (*init_func)(), Result (*exit_func)()) {
+  init_func();
+  atexit(reinterpret_cast<void (*)()>(exit_func));
+}
+} // namespace RenderD7
+namespace RenderD7 {
+namespace Init {
+void Security() {
+  rd7_security = new RenderD7::Security(); // Load and Init the Security System
+}
+} // namespace Init
+} // namespace RenderD7

source/renderd7.cpp

@@ -5,19 +5,17 @@
 #include <renderd7/renderd7.hpp>
 #include <renderd7/renderd7_logo.hpp>
 
-#define TICKS_PER_MSEC 268111.856
+#define D7_NOTHING 0x00000000
+#define CFGVER "5"
 
-#define D7_NOTHING C2D_Color32(0, 0, 0, 0)
-#define CFGVER "4"
-
-Log renderd7log;
-float animtime;
 bool isndspinit = false;
 bool running = true;
 std::stack<std::unique_ptr<RenderD7::Scene>> RenderD7::Scene::scenes;
 std::unique_ptr<RenderD7::Scene> tmpFadeS;
-std::stack<std::unique_ptr<RenderD7::Ovl>> overlays;
+/// @brief  Supports Multiple Overlays
-bool usedbgmsg = false;
+std::vector<std::unique_ptr<RenderD7::Ovl>> overlays;
+/// @brief Displays Overlays step by step from first 2 last
+std::vector<std::unique_ptr<RenderD7::Ovl>> toast_overlays;
 std::string dspststus = "Not Initialisized!";
 
 int cobj___;
@@ -29,8 +27,6 @@ std::unique_ptr<INI::INIFile> cfgfile = nullptr;
 INI::INIStructure cfgstruct;
 std::string cfgpath;
 
-// RD7 SuperReselution
-bool rd7_superreselution;
 u8 consoleModel = 0;
 u8 sysRegion = CFG_REGION_USA;
 bool is_citra = false;
@@ -64,8 +60,6 @@ std::string mt_gpu;
 std::string mt_cmd;
 std::string mt_lfr;
 
-bool shouldbe_disabled = false;
-int cnttttt = 0;
 int mt_screen;
 // int mt_width = mt_screen ? 320 : 400;
 float mt_txtSize;
@@ -80,8 +74,8 @@ C3D_RenderTarget *Top;
 C3D_RenderTarget *TopRight;
 C3D_RenderTarget *Bottom;
 
-#define DSEVENBLACK C2D_Color32(0, 0, 0, 255)
+#define DSEVENBLACK 0xff000000
-#define DSEVENWHITE C2D_Color32(255, 255, 255, 255)
+#define DSEVENWHITE 0xffffffff
 
 u64 delta_time;
 u64 last_tm;
@@ -94,12 +88,6 @@ int fadecolor = 0;
 bool waitFade = false;
 bool FadeExit = false;
 bool SceneFadeWait = false;
-// Sercices
-int sv_gfx = 0;
-int sv_dsp = 0;
-int sv_cfgu = 0;
-int sv_apt = 0;
-int sv_romfs = 0;
 
 std::vector<std::string> string_to_lines(std::string input_str) {
   std::vector<std::string> lines;
@@ -136,8 +124,7 @@ void Npifade() {
     // No fade
   }
   RenderD7::OnScreen(Top);
-  RenderD7::Draw::Rect(0, 0, RenderD7::IsRD7SR() ? 800 : 400, 240,
+  RenderD7::Draw::Rect(0, 0, 400, 240, ((fadealpha << 24) | 0x00000000));
-                       ((fadealpha << 24) | 0x00000000));
   RenderD7::OnScreen(Bottom);
   RenderD7::Draw::Rect(0, 0, 320, 240, ((fadealpha << 24) | 0x00000000));
 }
@@ -205,26 +192,17 @@ bool RenderD7::DrawImageFromSheet(RenderD7::Sheet *sheet, size_t index, float x,
 }
 void RenderD7::Init::NdspFirm() {
   if (access("sdmc:/3ds/dspfirm.cdc", F_OK) != -1) {
-    Result res;
+    rd7_security->SafeInit(ndspInit, ndspExit);
-    res = ndspInit();
-    sv_dsp = R_FAILED(res) ? 1 : 2;
     isndspinit = true;
     dspststus = "Initialisized success!";
   } else {
     dspststus = "Not found: dspfirm.cdc";
-    renderd7log.Write("RenderD7: SoundEngine Error! ndspfirm not found!");
+    RenderD7::AddToast(std::make_unique<RenderD7::DSP_NF>());
-    RenderD7::AddOvl(std::make_unique<RenderD7::DSP_NF>());
-  }
-}
-void RenderD7::Exit::NdspFirm() {
-  if (isndspinit) {
-    ndspExit();
   }
 }
+
 void RenderD7::Msg::Display(std::string titletxt, std::string subtext,
                             C3D_RenderTarget *target) {
-  shouldbe_disabled = true;
-  cnttttt = 0;
   C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
   C2D_TargetClear(Top, DSEVENBLACK);
   C2D_TargetClear(Bottom, DSEVENBLACK);
@@ -242,8 +220,6 @@ void RenderD7::Msg::Display(std::string titletxt, std::string subtext,
 void RenderD7::Msg::DisplayWithProgress(std::string titletext,
                                         std::string subtext, float current,
                                         float total, u32 prgbarcolor) {
-  shouldbe_disabled = true;
-  cnttttt = 0;
   RenderD7::ClearTextBufs();
   C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
   C2D_TargetClear(Top, DSEVENBLACK);
@@ -265,12 +241,9 @@ void RenderD7::Msg::DisplayWithProgress(std::string titletext,
   RenderD7::Draw::Rect(0, 0, 320, 240, RenderD7::Color::Hex("#111111"));
   C3D_FrameEnd(0);
 }
-void RenderD7::SetupLog() { renderd7log.Init("RenderD7/RenderD7.log"); }
 
 void RenderD7::Error::DisplayError(std::string toptext, std::string errortext,
                                    int timesec) {
-  shouldbe_disabled = true;
-  cnttttt = 0;
   RenderD7::ClearTextBufs();
   C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
   C2D_TargetClear(Top, DSEVENBLACK);
@@ -287,34 +260,24 @@ void RenderD7::Error::DisplayError(std::string toptext, std::string errortext,
   }
 }
 
-#include <renderd7/BitmapPrinter.hpp>
-
 void RenderD7::Error::DisplayFatalError(std::string toptext,
                                         std::string errortext) {
-  shouldbe_disabled = true;
-  cnttttt = 0;
   bool error___ = true;
   RenderD7::ClearTextBufs();
   C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
-  C2D_TargetClear(Top, DSEVENBLACK);
+  C2D_TargetClear(Top, RenderD7::Color::Hex("#000000"));
-  C2D_TargetClear(Bottom, DSEVENBLACK);
+  C2D_TargetClear(Bottom, RenderD7::Color::Hex("#000000"));
-  RenderD7::BitmapPrinter errorss(400, 240);
-  errorss.DrawRectFilled(0, 0, 400, 240, 0, 0, 0, 255);
-  errorss.DrawDebugText(4, 4, 2, RenderD7::Color::Hex("#ff0000"), toptext);
-  errorss.DrawDebugText(4, 26, 1, RenderD7::Color::Hex("#000000"), errortext);
-  errorss.DrawDebugText(4, 230, 1, RenderD7::Color::Hex("#000000"),
-                        "Press Start to Exit!");
-  RenderD7::Image img;
-  img.LoadFromBitmap(errorss.GetBitmap());
   RenderD7::OnScreen(Top);
-  img.Draw(0, 0);
+  RenderD7::Draw::TextCentered(0, 0, 0.7f, RenderD7::Color::Hex("#ffffff"),
-  /*RenderD7::Draw::TextCentered(0, 0, 0.7f, DSEVENWHITE, toptext, 400);
+                               toptext, 400);
-      RenderD7::Draw::TextCentered(0, 100, 0.6f, DSEVENWHITE, errortext, 400);
+  RenderD7::Draw::TextCentered(0, 100, 0.6f, RenderD7::Color::Hex("#ffffff"),
-      RenderD7::Draw::TextCentered(0, 200, 0.6f, DSEVENWHITE, "Press Start to
+                               errortext, 400);
-     Exit!", 400);*/
+  RenderD7::Draw::TextCentered(0, 200, 0.6f, RenderD7::Color::Hex("#ffffff"),
+                               "Press Start to Exit!", 400);
   C3D_FrameEnd(0);
   while (error___) {
     if (d7_hDown & KEY_START) {
+      error___ = false;
       RenderD7::ExitApp();
     }
   }
@@ -353,7 +316,8 @@ void frameloop() {
     last_time = osGetTime();
   }
   d11framerate = current_fps;
-  // for (int i = 0; i < 320; i++) mt_fpsgraph[i] = current_fps;
+  for (int i = 0; i < 320; i++)
+    mt_fpsgraph[i] = current_fps;
 }
 float getframerate() { return d11framerate; }
 
@@ -362,6 +326,7 @@ std::string RenderD7::GetFramerate() {
 }
 
 bool RenderD7::MainLoop() {
+  RenderD7::Ftrace::Beg("rd7-core", f2s(RenderD7::MainLoop));
   if (!aptMainLoop())
     return false;
 
@@ -384,29 +349,20 @@ bool RenderD7::MainLoop() {
   C2D_TargetClear(Top, C2D_Color32(0, 0, 0, 0));
   C2D_TargetClear(Bottom, C2D_Color32(0, 0, 0, 0));
   frameloop();
+  RenderD7::Ftrace::Beg("rd7sm", f2s(RenderD7::Scene::doDraw));
   RenderD7::Scene::doDraw();
+  RenderD7::Ftrace::End("rd7sm", f2s(RenderD7::Scene::doDraw));
+  RenderD7::Ftrace::Beg("rd7sm", f2s(RenderD7::Scene::doLogic));
   RenderD7::Scene::doLogic(d7_hDown, d7_hHeld, d7_hUp, d7_touch);
-  cnttttt++;
+  RenderD7::Ftrace::End("rd7sm", f2s(RenderD7::Scene::doLogic));
-  //Disably Overlays For one Frame
-  if (cnttttt > 1) {
-    shouldbe_disabled = false;
-    cnttttt = 0;
-  }
 
+  // Disably Overlays For one Frame
+  RenderD7::Ftrace::End("rd7-core", f2s(RenderD7::MainLoop));
   return running;
 }
 
 void RenderD7::ClearTextBufs(void) { C2D_TextBufClear(TextBuf); }
 
-void MetrikThread(RenderD7::Parameter param) {
-  while (true) {
-    RenderD7::DrawMetrikOvl();
-    RenderD7::Thread::sleep(
-        1000 * 1); // wait; also, this is needed to allow for concurrency (refer
-                   // to the documentation for m3d::Thread::sleep())
-  }
-}
-
 void RenderD7::Init::Graphics() {
   C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
   C2D_Init(size_t(maxobj__));
@@ -418,16 +374,13 @@ void RenderD7::Init::Graphics() {
   Font = C2D_FontLoadSystem(CFG_REGION_USA);
 }
 
-void RenderD7::Exit::Graphics() {
-  C2D_TextBufDelete(TextBuf);
-  C2D_Fini();
-  C3D_Fini();
-}
-
 Result RenderD7::Init::Main(std::string app_name) {
-  gfxInitDefault();
+  /// The only func that can be executed before Security
-  sv_gfx = 2;
+  RenderD7::Ftrace::Beg("rd7-core", f2s(RenderD7::Init::Main));
+  RenderD7::Init::Security();
+  rd7_security->SafeInit(gfxInitDefault, gfxExit);
   // consoleInit(GFX_TOP, NULL);
+  // Dont safinit this cause it has security
   Result res = cfguInit();
   if (R_SUCCEEDED(res)) {
     CFGU_SecureInfoGetRegion(&sysRegion);
@@ -435,17 +388,14 @@ Result RenderD7::Init::Main(std::string app_name) {
     cfguExit();
   }
   printf("cfgu\n");
-  if (rd7_superreselution) {
+
-    gfxSetWide(consoleModel != 3);
+  rd7_security->SafeInit(aptInit, aptExit);
-  }
+  rd7_security->SafeInit(romfsInit, romfsExit);
-  printf("rd7sr\n");
-  res = aptInit();
-  sv_apt = R_FAILED(res) ? 1 : 2;
-  res = romfsInit();
-  sv_romfs = R_FAILED(res) ? 1 : 2;
 
   C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
+  rd7_security->SafeExit(C3D_Fini);
   C2D_Init(C2D_DEFAULT_MAX_OBJECTS);
+  rd7_security->SafeExit(C2D_Fini);
   C2D_Prepare();
   Top = C2D_CreateScreenTarget(GFX_TOP, GFX_LEFT);
   TopRight = C2D_CreateScreenTarget(GFX_TOP, GFX_RIGHT);
@@ -454,11 +404,11 @@ Result RenderD7::Init::Main(std::string app_name) {
   Font = C2D_FontLoadSystem(CFG_REGION_USA);
   printf("Graphical Interface\n");
   last_tm = svcGetSystemTick();
+  RenderD7::Ftrace::Beg("rd7-core", "do_splash");
   if (rd7_do_splash)
     PushSplash();
+  RenderD7::Ftrace::End("rd7-core", "do_splash");
 
-  res = cfguInit();
-  sv_cfgu = R_FAILED(res) ? 1 : 2;
   printf("stuff\n");
   if (cobj___) {
     maxobj__ = cobj___;
@@ -482,24 +432,14 @@ Result RenderD7::Init::Main(std::string app_name) {
       renew = true;
   }
   printf("vercheck\n");
-  renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                    GetFileName<std::string>(__FILE__));
   if (!FS::FileExist(cfgpath + "/config.ini") || renew) {
     cfgfile = std::make_unique<INI::INIFile>(cfgpath + "/config.ini");
-    renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                      GetFileName<std::string>(__FILE__));
     cfgfile->read(cfgstruct);
-    renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                      GetFileName<std::string>(__FILE__));
     cfgstruct["info"]["version"] = CFGVER;
     cfgstruct["info"]["renderd7ver"] = RENDERD7VSTRING;
     cfgstruct["settings"]["doscreentimeout"] = "0";
     cfgstruct["settings"]["forcetimeoutLB"] = "1";
-    cfgstruct["settings"]["forceFrameRate"] = "60";
-    cfgstruct["settings"]["super-reselution"] = "0";
     cfgstruct["settings"]["renderer"] = "c3d_c2d";
-    renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                      GetFileName<std::string>(__FILE__));
     cfgstruct["metrik-settings"]["enableoverlay"] = "0";
     cfgstruct["metrik-settings"]["Screen"] = "0";
     cfgstruct["metrik-settings"]["txtColor"] = "#ffffff";
@@ -509,13 +449,8 @@ Result RenderD7::Init::Main(std::string app_name) {
     cfgstruct["metrik-settings"]["txtSize"] = "0.7f";
     cfgfile->write(cfgstruct);
   }
-  if (renew)
-    printf("renew\n");
-  renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                    GetFileName<std::string>(__FILE__));
   cfgfile = std::make_unique<INI::INIFile>(cfgpath + "/config.ini");
   cfgfile->read(cfgstruct);
-  std::string Fps = cfgstruct["settings"]["forceFrameRate"];
   ////C3D_FrameRate(RenderD7::Convert::StringtoFloat(Fps));
   metrikd = RenderD7::Convert::FloatToBool(RenderD7::Convert::StringtoFloat(
       cfgstruct["metrik-settings"]["enableoverlay"]));
@@ -530,9 +465,6 @@ Result RenderD7::Init::Main(std::string app_name) {
       RenderD7::Convert::StringtoFloat(cfgstruct["metrik-settings"]["txtSize"]);
   mt_screen =
       RenderD7::Convert::StringtoInt(cfgstruct["metrik-settings"]["Screen"]);
-  rd7_superreselution =
-      RenderD7::Convert::FloatToBool(RenderD7::Convert::StringtoFloat(
-          cfgstruct["settings"]["super-reselution"]));
   printf("read\n");
   // Check if citra
   s64 citracheck = 0;
@@ -542,14 +474,7 @@ Result RenderD7::Init::Main(std::string app_name) {
   // Speedup
   osSetSpeedupEnable(true);
   printf("boost\n");
-  if (!is_citra && rd7_superreselution) {
+  RenderD7::Ftrace::End("rd7-core", f2s(RenderD7::Init::Main));
-    if (consoleModel != 3)
-      gfxSetWide(true);
-  }
-  printf("rd7sr\n");
-  // consoleInit(GFX_BOTTOM, NULL);
-  printf("csv\n");
-
   // RenderD7::Msg::Display("RenderD7", "RenderD7 init success!\nWaiting for
   // MainLoop!", Top);
   return 0;
@@ -557,15 +482,15 @@ Result RenderD7::Init::Main(std::string app_name) {
 
 Result RenderD7::Init::Minimal(std::string app_name) {
   D_app_name = app_name;
-  Result res_;
+  RenderD7::Init::Security();
-  gfxInitDefault();
+  rd7_security->SafeInit(gfxInitDefault, gfxExit);
-  sv_gfx = 2;
+  rd7_security->SafeInit(romfsInit, romfsExit);
-  res_ = romfsInit();
-  sv_romfs = R_FAILED(res_) ? 1 : 2;
 
   osSetSpeedupEnable(true);
   C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
+  rd7_security->SafeExit(C3D_Fini);
   C2D_Init(C2D_DEFAULT_MAX_OBJECTS);
+  rd7_security->SafeExit(C2D_Fini);
   C2D_Prepare();
   Top = C2D_CreateScreenTarget(GFX_TOP, GFX_LEFT);
   TopRight = C2D_CreateScreenTarget(GFX_TOP, GFX_RIGHT);
@@ -601,24 +526,14 @@ Result RenderD7::Init::Minimal(std::string app_name) {
       renew = true;
   }
   printf("vercheck\n");
-  renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                    GetFileName<std::string>(__FILE__));
   if (!FS::FileExist(cfgpath + "/config.ini") || renew) {
     cfgfile = std::make_unique<INI::INIFile>(cfgpath + "/config.ini");
-    renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                      GetFileName<std::string>(__FILE__));
     cfgfile->read(cfgstruct);
-    renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                      GetFileName<std::string>(__FILE__));
     cfgstruct["info"]["version"] = CFGVER;
     cfgstruct["info"]["renderd7ver"] = RENDERD7VSTRING;
     cfgstruct["settings"]["doscreentimeout"] = "0";
     cfgstruct["settings"]["forcetimeoutLB"] = "1";
-    cfgstruct["settings"]["forceFrameRate"] = "60";
-    cfgstruct["settings"]["super-reselution"] = "0";
     cfgstruct["settings"]["renderer"] = "c3d_c2d";
-    renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                      GetFileName<std::string>(__FILE__));
     cfgstruct["metrik-settings"]["enableoverlay"] = "0";
     cfgstruct["metrik-settings"]["Screen"] = "0";
     cfgstruct["metrik-settings"]["txtColor"] = "#ffffff";
@@ -630,11 +545,8 @@ Result RenderD7::Init::Minimal(std::string app_name) {
   }
   if (renew)
     printf("renew\n");
-  renderd7log.Write("Point At: " + std::to_string(__LINE__) + " : " +
-                    GetFileName<std::string>(__FILE__));
   cfgfile = std::make_unique<INI::INIFile>(cfgpath + "/config.ini");
   cfgfile->read(cfgstruct);
-  std::string Fps = cfgstruct["settings"]["forceFrameRate"];
   // C3D_FrameRate(RenderD7::Convert::StringtoFloat(Fps));
   metrikd = RenderD7::Convert::FloatToBool(RenderD7::Convert::StringtoFloat(
       cfgstruct["metrik-settings"]["enableoverlay"]));
@@ -649,14 +561,7 @@ Result RenderD7::Init::Minimal(std::string app_name) {
       RenderD7::Convert::StringtoFloat(cfgstruct["metrik-settings"]["txtSize"]);
   mt_screen =
       RenderD7::Convert::StringtoInt(cfgstruct["metrik-settings"]["Screen"]);
-  rd7_superreselution =
-      RenderD7::Convert::FloatToBool(RenderD7::Convert::StringtoFloat(
-          cfgstruct["settings"]["super-reselution"]));
   printf("boost\n");
-  if (!is_citra && rd7_superreselution) {
-    if (consoleModel != 3)
-      gfxSetWide(true);
-  }
   return 0;
 }
 
@@ -676,42 +581,6 @@ Result RenderD7::Init::Reload() {
   return 0;
 }
 
-void RenderD7::ToggleRD7SR() {
-  shouldbe_disabled = true;
-  cnttttt = 0;
-  // Display black screen
-  C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
-  C2D_TargetClear(Top, RenderD7::Color::Hex("#000000"));
-  RenderD7::OnScreen(Top);
-  C3D_FrameEnd(0);
-  // Toggle 400px/800px mode
-  gfxSetWide(gfxIsWide() ? false : true);
-  rd7_superreselution = gfxIsWide();
-  RenderD7::Init::Reload();
-}
-
-bool RenderD7::IsRD7SR() { return gfxIsWide(); }
-
-void RenderD7::Exit::Main() {
-  cfgfile->write(cfgstruct);
-  C2D_TextBufDelete(TextBuf);
-  C2D_Fini();
-  C3D_Fini();
-  aptExit();
-  gfxExit();
-  romfsExit();
-  cfguExit();
-}
-
-void RenderD7::Exit::Minimal() {
-  cfgfile->write(cfgstruct);
-  C2D_TextBufDelete(TextBuf);
-  C2D_Fini();
-  C3D_Fini();
-  gfxExit();
-  romfsExit();
-}
-
 void RenderD7::DrawTObjects(std::vector<RenderD7::TObject> tobjects, u32 color,
                             u32 txtcolor, int selection, u32 selbgcolor,
                             u32 selcolor) {
@@ -724,25 +593,25 @@ void RenderD7::DrawTObjects(std::vector<RenderD7::TObject> tobjects, u32 color,
       RenderD7::Draw::Rect(tobjects[i].x, tobjects[i].y, tobjects[i].w,
                            tobjects[i].h, selcolor);
       RenderD7::Draw::Text(tobjects[i].x + (tobjects[i].w / 2) -
-                               RenderD7::Draw::GetTextHeight(
+                               RenderD7::Draw::GetTextWidth(tobjects[i].txtsize,
-                                   tobjects[i].txtsize, tobjects[i].text) +
+                                                            tobjects[i].text) /
-                               tobjects[i].correctx,
+                                   2,
                            tobjects[i].y + (tobjects[i].h / 2) -
                                RenderD7::Draw::GetTextHeight(
-                                   tobjects[i].txtsize, tobjects[i].text) +
+                                   tobjects[i].txtsize, tobjects[i].text) /
-                               tobjects[i].correcty,
+                                   2,
                            tobjects[i].txtsize, txtcolor, tobjects[i].text);
     } else {
       RenderD7::Draw::Rect(tobjects[i].x, tobjects[i].y - 1, tobjects[i].w,
                            tobjects[i].h, color);
       RenderD7::Draw::Text(tobjects[i].x + (tobjects[i].w / 2) -
-                               RenderD7::Draw::GetTextHeight(
+                               RenderD7::Draw::GetTextWidth(tobjects[i].txtsize,
-                                   tobjects[i].txtsize, tobjects[i].text) +
+                                                            tobjects[i].text) /
-                               tobjects[i].correctx,
+                                   2,
                            tobjects[i].y + (tobjects[i].h / 2) -
                                RenderD7::Draw::GetTextHeight(
-                                   tobjects[i].txtsize, tobjects[i].text) +
+                                   tobjects[i].txtsize, tobjects[i].text) /
-                               tobjects[i].correcty,
+                                   2,
                            tobjects[i].txtsize, txtcolor, tobjects[i].text);
     }
   }
@@ -765,20 +634,10 @@ void RenderD7::DrawTLBtns(std::vector<RenderD7::TLBtn> btns, u32 color,
 }
 
 void RenderD7::ExitApp() {
-  if (!rd7settings) {
+  if (waitFade) {
-    if (waitFade) {
+    FadeExit = true;
-      FadeExit = true;
+  } else
-    } else
+    running = false;
-      running = false;
-  } else {
-    // Normally Forbidden
-    fadein = false;
-    waitFade = false;
-    RenderD7::FadeIn();
-    RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
-        "RenderD7", "Exiting in Settings is Not Allowed!\nPress B to Get Out "
-                    "and then Exit."));
-  }
 }
 
 bool RenderD7::touchTObj(touchPosition touch, RenderD7::TObject button) {
@@ -810,62 +669,16 @@ void RenderD7::DrawSTObject(std::vector<RenderD7::TObject> tobject,
                        tobject[tobjectindex].w, tobject[tobjectindex].h, color);
   RenderD7::Draw::Text(
       tobject[tobjectindex].x + (tobject[tobjectindex].w / 2) -
-          RenderD7::Draw::GetTextHeight(tobject[tobjectindex].txtsize,
+          RenderD7::Draw::GetTextWidth(tobject[tobjectindex].txtsize,
-                                        tobject[tobjectindex].text) +
+                                       tobject[tobjectindex].text) /
-          tobject[tobjectindex].correctx,
+              2,
       tobject[tobjectindex].y + (tobject[tobjectindex].h / 2) -
           RenderD7::Draw::GetTextHeight(tobject[tobjectindex].txtsize,
-                                        tobject[tobjectindex].text) +
+                                        tobject[tobjectindex].text) /
-          tobject[tobjectindex].correcty,
+              2,
       tobject[tobjectindex].txtsize, txtcolor, tobject[tobjectindex].text);
 }
 
-bool dirEntryPredicate(const RenderD7::DirContent &lhs,
-                       const RenderD7::DirContent &rhs) {
-  if (!lhs.isDir && rhs.isDir)
-    return false;
-  if (lhs.isDir && !rhs.isDir)
-    return true;
-
-  return strcasecmp(lhs.name.c_str(), rhs.name.c_str()) < 0;
-}
-
-void RenderD7::GetDirContentsExt(std::vector<RenderD7::DirContent> &dircontent,
-                                 const std::vector<std::string> &extensions) {
-  struct stat st;
-
-  dircontent.clear();
-
-  DIR *pdir = opendir(".");
-
-  if (pdir != nullptr) {
-    while (true) {
-      RenderD7::DirContent dirEntry;
-
-      struct dirent *pent = readdir(pdir);
-      if (pent == NULL)
-        break;
-
-      stat(pent->d_name, &st);
-      dirEntry.name = pent->d_name;
-      dirEntry.isDir = (st.st_mode & S_IFDIR) ? true : false;
-
-      if (dirEntry.name.compare(".") != 0 &&
-          (dirEntry.isDir ||
-           RenderD7::NameIsEndingWith(dirEntry.name, extensions))) {
-        dircontent.push_back(dirEntry);
-      }
-    }
-
-    closedir(pdir);
-  }
-  sort(dircontent.begin(), dircontent.end(), dirEntryPredicate);
-}
-
-void RenderD7::GetDirContents(std::vector<RenderD7::DirContent> &dircontent) {
-  RenderD7::GetDirContentsExt(dircontent, {});
-}
-
 bool RenderD7::FS::FileExist(const std::string &path) {
   FILE *test = fopen(path.c_str(), "r");
   if (test != NULL) {
@@ -958,13 +771,6 @@ void RenderD7::DrawMetrikOvl() {
   RenderD7::Draw::Text(0, 90, mt_txtSize, mt_txtcolor, mt_cmd);
   RenderD7::Draw::Text(0, 110, mt_txtSize, mt_txtcolor, mt_lfr);
   RenderD7::Draw::Text(0, infoy, mt_txtSize, mt_txtcolor, info);
-
-  /*for (int z = 0; z < (int)mt_fpsgraph.size(); z++)
-  {
-              //mt_fpsgraph[z] = (int)d11framerate;
-      C2D_DrawLine(z, 239 - mt_fpsgraph[z], mt_txtcolor, z + 1, 239 -
-  mt_fpsgraph[z + 1], mt_txtcolor, 1, 1);
-  }*/
 }
 
 RenderD7::DSP_NF::DSP_NF() {}
@@ -974,7 +780,7 @@ void RenderD7::DSP_NF::Draw(void) const {
   RenderD7::Draw::Rect(0, msgposy, 400, 70, RenderD7::Color::Hex("#111111"));
   RenderD7::Draw::Rect(0, msgposy, 400, 25, RenderD7::Color::Hex("#222222"));
   RenderD7::Draw::Text(2, msgposy + 3, 0.7f, RenderD7::Color::Hex("#ffffff"),
-                       "Warning! Code: 00027");
+                       "RenderD7: Warning!");
   RenderD7::Draw::Text(2, msgposy + 30, 0.6f, RenderD7::Color::Hex("#ffffff"),
                        "You can't use Sound effects because the "
                        "file\n<<sdmc:/3ds/dspfirm.cdc>> was not found!");
@@ -993,32 +799,36 @@ void RenderD7::DSP_NF::Logic() {
 }
 
 void OvlHandler() {
-  if (!overlays.empty()) {
+  for (size_t i = 0; i < toast_overlays.size(); i++) {
-    overlays.top()->Draw();
+    if (toast_overlays[i]->IsKilled())
+      toast_overlays.erase(toast_overlays.begin() + i);
   }
-  if (!overlays.empty()) {
+  if ((int)toast_overlays.size() > 0) {
-    overlays.top()->Logic();
+    toast_overlays[0]->Draw();
+    toast_overlays[0]->Logic();
   }
-  if (!overlays.empty()) {
+  for (size_t i = 0; i < overlays.size(); i++) {
-    if (overlays.top()->IsKilled())
+    overlays[i]->Draw();
-      overlays.pop();
+    overlays[i]->Logic();
+    if (overlays[i]->IsKilled())
+      overlays.erase(overlays.begin() + i);
   }
 }
-int lp = 0;
+
 void RenderD7::FrameEnd() {
-  if (metrikd && !shouldbe_disabled)
+  C3D_FrameBegin(2);
+  if (metrikd)
     RenderD7::DrawMetrikOvl();
-  if (!shouldbe_disabled) {
+
-    OvlHandler();
+  RenderD7::Ftrace::Beg("rd7oh", f2s(OvlHandler));
-    Npifade();
+  OvlHandler();
-  }
+  RenderD7::Ftrace::End("rd7oh", f2s(OvlHandler));
-  lp++;
+  Npifade();
 
   C3D_FrameEnd(0);
 }
 
 RenderD7::RSettings::RSettings() {
-  aptSetHomeAllowed(false);
   RenderD7::FadeIn();
   cfgfile = std::make_unique<INI::INIFile>(cfgpath + "/config.ini");
   cfgfile->read(cfgstruct);
@@ -1027,10 +837,7 @@ RenderD7::RSettings::RSettings() {
   calculate_screens(lines, screen_index, screens);
 }
 
-RenderD7::RSettings::~RSettings() {
+RenderD7::RSettings::~RSettings() {}
-  cfgfile->write(cfgstruct);
-  aptSetHomeAllowed(false);
-}
 
 std::vector<std::string> StrHelper(std::string input) {
   std::string ss(input);
@@ -1050,16 +857,13 @@ void RenderD7::RSettings::Draw(void) const {
     RenderD7::Draw::Text(0, 0, 0.7f, DSEVENWHITE, "RenderD7->Settings");
     RenderD7::Draw::TextRight(400, 0, 0.7f, RenderD7::Color::Hex("#ffffff"),
                               RENDERD7VSTRING);
-    RenderD7::Draw::Text(0, 30, 0.7f, DSEVENBLACK, "RD7SR: " + rd7srstate);
+    RenderD7::Draw::Text(0, 30, 0.7f, DSEVENBLACK,
-    RenderD7::Draw::Text(0, 70, 0.7f, DSEVENBLACK,
                          "Metrik Overlay: " + mtovlstate);
-    RenderD7::Draw::Text(0, 90, 0.7f, DSEVENBLACK, "Force FPS: " + fpsstate);
+    RenderD7::Draw::Text(0, 50, 0.7f, DSEVENBLACK,
-    RenderD7::Draw::Text(0, 110, 0.7f, DSEVENBLACK,
                          "Metrik Screen: " + mtscreenstate);
-    /*RenderD7::Draw::Text(0, 130, 0.7f, DSEVENBLACK, "Metrik Text RGB: " +
+    RenderD7::Draw::Text(
-    mttxtcolstate); RenderD7::Draw::Text(0, 150, 0.7f, DSEVENBLACK, "Metrik
+        0, 70, 0.7f, DSEVENBLACK,
-    Alpha: " + mtcola); RenderD7::Draw::Text(0, 170, 0.7f, DSEVENBLACK, "Metrik
+        "Current: " + std::to_string(RenderD7::Memory::GetCurrent()) + "b");
-    Text Alpha: " + mttxtcola);*/
     RenderD7::OnScreen(Bottom);
     std::string verc = "Config Version: ";
     verc += CFGVER;
@@ -1075,29 +879,9 @@ void RenderD7::RSettings::Draw(void) const {
     RenderD7::Draw::Text(0, 0, 0.7f, DSEVENWHITE, "RenderD7->Services");
     RenderD7::Draw::TextRight(400, 0, 0.7f, RenderD7::Color::Hex("#ffffff"),
                               RENDERD7VSTRING);
-    RenderD7::Draw::Text(0, 30, 0.7f, DSEVENBLACK,
-                         "gfx: " + std::string(sv_gfx == 0   ? "Not Init"
-                                               : sv_gfx == 2 ? "Success"
-                                                             : "Failed"));
-    RenderD7::Draw::Text(0, 50, 0.7f, DSEVENBLACK,
-                         "Apt: " + std::string(sv_apt == 0   ? "Not Init"
-                                               : sv_apt == 2 ? "Success"
-                                                             : "Failed"));
-    RenderD7::Draw::Text(0, 70, 0.7f, DSEVENBLACK,
-                         "Romfs: " + std::string(sv_romfs == 0   ? "Not Init"
-                                                 : sv_romfs == 2 ? "Success"
-                                                                 : "Failed"));
-    RenderD7::Draw::Text(0, 90, 0.7f, DSEVENBLACK,
-                         "cfgu: " + std::string(sv_cfgu == 0   ? "Not Init"
-                                                : sv_cfgu == 2 ? "Success"
-                                                               : "Failed"));
-    RenderD7::Draw::Text(0, 110, 0.7f, DSEVENBLACK,
-                         "NDSP: " + std::string(sv_dsp == 0   ? "Not Init"
-                                                : sv_dsp == 2 ? "Success"
-                                                              : "Failed"));
     RenderD7::OnScreen(Bottom);
     RenderD7::Draw::Rect(0, 0, 320, 240, RenderD7::Color::Hex("#eeeeee"));
-    RenderD7::Draw::Text(0, 0, 0.7f, RenderD7::Color::Hex("#111111"),
+    RenderD7::Draw::Text(0, 0, 0.7f, RenderD7::Color::Hex("#ffffff"),
                          "Press B to Get back!");
 
   } else if (m_state == RCLOG) {
@@ -1121,7 +905,8 @@ void RenderD7::RSettings::Draw(void) const {
                               RENDERD7VSTRING);
     RenderD7::OnScreen(Bottom);
     RenderD7::Draw::Rect(0, 0, 320, 240, RenderD7::Color::Hex("#eeeeee"));
-    RenderD7::Draw::Text(0, 0, 0.7f, RenderD7::Color::Hex("#111111"),
+    RenderD7::Draw::Rect(0, 0, 400, 21, RenderD7::Color::Hex("#111111"));
+    RenderD7::Draw::Text(0, 0, 0.7f, RenderD7::Color::Hex("#ffffff"),
                          "Press B to Get back!");
 
   } else if (m_state == RINFO) {
@@ -1156,10 +941,76 @@ void RenderD7::RSettings::Draw(void) const {
     RenderD7::Draw::Rect(0, 0, 320, 240, RenderD7::Color::Hex("#eeeeee"));
     RenderD7::Draw::Text(0, 0, 0.7f, RenderD7::Color::Hex("#111111"),
                          "Press B to Get back!");
+  } else if (m_state == RFTRACE) {
+    RenderD7::OnScreen(Top);
+    RenderD7::Draw::Rect(0, 0, 400, 21, RenderD7::Color::Hex("#111111"));
+    RenderD7::Draw::Rect(0, 21, 400, 220, RenderD7::Color::Hex("#eeeeee"));
+    RenderD7::Draw::Text(5, 0, 0.7f, DSEVENWHITE, "RenderD7->FTrace");
+    RenderD7::Draw::TextRight(395, 0, 0.7f, RenderD7::Color::Hex("#ffffff"),
+                              RENDERD7VSTRING);
+    RenderD7::Draw::Rect(0, 219, 400, 21, RenderD7::Color::Hex("#111111"));
+    RenderD7::Draw::Text(
+        5, 220, 0.7f, RenderD7::Color::Hex("#ffffff"),
+        "Traces: " + std::to_string(ftrace_index + 1) + "/" +
+            std::to_string(RenderD7::Ftrace::rd7_traces.size()));
+    RenderD7::Draw::Rect(0, 21, 400, 19, RenderD7::Color::Hex("#aaaaaa"));
+    RenderD7::Draw::Text(10, 19, 0.7f, RenderD7::Color::Hex("#000000"),
+                         "Function:");
+    RenderD7::Draw::TextRight(390, 19, 0.7f, RenderD7::Color::Hex("#000000"),
+                              "Time (ms):");
+
+    for (int i = 0; i < 10; i++) {
+      if ((i % 2 == 0))
+        RenderD7::Draw::Rect(0, 40 + (i)*18, 400, 18,
+                             RenderD7::Color::Hex("#cccccc"));
+      else
+        RenderD7::Draw::Rect(0, 40 + (i)*18, 400, 18,
+                             RenderD7::Color::Hex("#bbbbbb"));
+    }
+
+    RenderD7::Ftrace::Beg("rd7ft", "display_traces");
+    int start_index = ftrace_index < 9 ? 0 : ftrace_index - 9;
+    auto it = RenderD7::Ftrace::rd7_traces.begin();
+    std::advance(it, start_index);
+    int ix = start_index;
+    std::string _fkey__ = "0";
+
+    while (ix < (int)RenderD7::Ftrace::rd7_traces.size() &&
+           ix < start_index + 10 && it != RenderD7::Ftrace::rd7_traces.end()) {
+      if (ix == ftrace_index) {
+        _fkey__ = it->first;
+        RenderD7::Draw::Rect(0, 40 + (ix - start_index) * 18, 400, 18,
+                             RenderD7::Color::Hex("#222222"));
+        RenderD7::Draw::Text(
+            10, 38 + (ix - start_index) * 18, 0.7f,
+            RenderD7::Color::Hex("#ffffff"),
+            RenderD7::ShortString(it->second.func_name, 0.7f, 250));
+        RenderD7::Draw::TextRight(390, 38 + (ix - start_index) * 18, 0.7f,
+                                  RenderD7::Color::Hex("#ffffff"),
+                                  RenderD7::MsTimeFmt(it->second.time_of));
+      } else {
+        RenderD7::Draw::Text(
+            10, 38 + (ix - start_index) * 18, 0.7f,
+            RenderD7::Color::Hex("#000000"),
+            RenderD7::ShortString(it->second.func_name, 0.7f, 250));
+        RenderD7::Draw::TextRight(390, 38 + (ix - start_index) * 18, 0.7f,
+                                  RenderD7::Color::Hex("#000000"),
+                                  RenderD7::MsTimeFmt(it->second.time_of));
+      }
+      ++it;
+      ++ix;
+    }
+
+    RenderD7::Ftrace::End("rd7ft", "display_traces");
+
+    RenderD7::OnScreen(Bottom);
+    RenderD7::Draw::Rect(0, 0, 320, 240, RenderD7::Color::Hex("#eeeeee"));
+    RenderD7::Draw::Rect(0, 0, 400, 21, RenderD7::Color::Hex("#111111"));
+    RenderD7::Draw::Text(0, 0, 0.7f, RenderD7::Color::Hex("#ffffff"),
+                         "Press B to Get back!");
   }
 }
 std::string RenderD7::Kbd(int lenght, SwkbdType tp) {
-  shouldbe_disabled = true;
   RenderD7::FrameEnd();
   SwkbdState state;
   char temp[lenght + 1] = {0};
@@ -1174,19 +1025,8 @@ std::string RenderD7::Kbd(int lenght, SwkbdType tp) {
 void RenderD7::RSettings::Logic(u32 hDown, u32 hHeld, u32 hUp,
                                 touchPosition touch) {
   if (m_state == RSETTINGS) {
-    rd7srstate = rd7_superreselution ? "true" : "false";
     mtovlstate = metrikd ? "true" : "false";
-    fpsstate = cfgstruct["settings"]["forceFrameRate"];
     mtscreenstate = mt_screen ? "Bottom" : "Top";
-    if (d7_hDown & KEY_TOUCH && RenderD7::touchTObj(d7_touch, buttons[0]) &&
-        !metrikd) {
-      RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
-          "RenderD7",
-          "RenderD7-Super-Reselution Does not\nWork Correctly yet!"));
-      RenderD7::ToggleRD7SR();
-      cfgstruct["settings"]["super-reselution"] =
-          rd7_superreselution ? "1" : "0";
-    }
     if (d7_hDown & KEY_TOUCH && RenderD7::touchTObj(d7_touch, buttons[1])) {
       m_state = RCLOG;
     }
@@ -1194,15 +1034,8 @@ void RenderD7::RSettings::Logic(u32 hDown, u32 hHeld, u32 hUp,
       metrikd = metrikd ? false : true;
       cfgstruct["metrik-settings"]["enableoverlay"] = metrikd ? "1" : "0";
     }
-    /*if (d7_hDown & KEY_TOUCH && RenderD7::touchTObj(d7_touch, buttons[3]) &&
-        !metrikd) {
-      cfgstruct["settings"]["forceFrameRate"] = Kbd(2, SWKBD_TYPE_NUMPAD);
-      // C3D_FrameRate(RenderD7::Convert::StringtoFloat(
-      // cfgstruct["settings"]["forceFrameRate"]));
-    }*/
     if (d7_hDown & KEY_TOUCH && RenderD7::touchTObj(d7_touch, buttons[4])) {
-      mt_screen = mt_screen ? 0 : 1;
+      m_state = RFTRACE;
-      cfgstruct["metrik-settings"]["screen"] = mt_screen ? "1" : "0";
     }
     /*if (d7_hDown & KEY_TOUCH && RenderD7::touchTObj(d7_touch, buttons[5])) {
       RenderD7::AddOvl(std::make_unique<RenderD7::DSP_NF>());
@@ -1229,6 +1062,19 @@ void RenderD7::RSettings::Logic(u32 hDown, u32 hHeld, u32 hUp,
       m_state = RSETTINGS;
     }
   }
+  if (m_state == RFTRACE) {
+    if (d7_hDown & KEY_DOWN) {
+      if (ftrace_index < (int)RenderD7::Ftrace::rd7_traces.size() - 1)
+        ftrace_index++;
+    }
+    if (d7_hDown & KEY_UP) {
+      if (ftrace_index > 0)
+        ftrace_index--;
+    }
+    if (d7_hDown & KEY_B) {
+      m_state = RSETTINGS;
+    }
+  }
   if (m_state == RCLOG) {
     if (d7_hDown & KEY_B) {
       m_state = RSETTINGS;
@@ -1255,7 +1101,11 @@ void RenderD7::LoadSettings() {
 }
 
 void RenderD7::AddOvl(std::unique_ptr<RenderD7::Ovl> overlay) {
-  overlays.push(std::move(overlay));
+  overlays.push_back(std::move(overlay));
+}
+
+void RenderD7::AddToast(std::unique_ptr<RenderD7::Ovl> overlay) {
+  toast_overlays.push_back(std::move(overlay));
 }
 
 void RenderD7::DoNpiIntro() {
@@ -1269,8 +1119,6 @@ void RenderD7::DoNpiIntro() {
   stream->ReadNext(nimg);
   while(true)
   {
-    shouldbe_disabled = true;
-    cnttttt = 0;
     C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
     C2D_TargetClear(Top, RenderD7::Color::Hex("#000000"));
     C2D_TargetClear(Bottom, RenderD7::Color::Hex("#000000"));
@@ -1291,14 +1139,14 @@ void RenderD7::DoNpiIntro() {
       break;
     C3D_FrameEnd(0);
   }*/
+  RenderD7::Ftrace::Beg("rd7-core", "load_nvid");
   auto images = LoadMemNVID(npi_intro, npi_intro_size);
+  RenderD7::Ftrace::End("rd7-core", "load_nvid");
   int c = 0;
   float xc = 0;
   RenderD7::Image img;
   uint64_t lastT = osGetTime();
   while (c < 59) {
-    shouldbe_disabled = true;
-    cnttttt = 0;
     C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
     C2D_TargetClear(Top, RenderD7::Color::Hex("#000000"));
     C2D_TargetClear(Bottom, RenderD7::Color::Hex("#000000"));
@@ -1336,3 +1184,20 @@ void RenderD7::FadeIn() {
 }
 
 void RenderD7::FadeDisplay() { Npifade(); }
+
+std::string RenderD7::ShortString(std::string in, float size, int maxlen,
+                                  C2D_Font font) {
+  if (RenderD7::Draw::GetTextWidth(size, in, font) > (float)maxlen) {
+    std::string out;
+    for (size_t i = 0; i < in.size(); i++) {
+      out += in[i];
+      if (RenderD7::Draw::GetTextWidth(size, out, font) +
+              RenderD7::Draw::GetTextWidth(size, "(...)", font) >
+          (float)maxlen) {
+        out += "(...)";
+        return out;
+      }
+    }
+  }
+  return in;
+}

tools/build_tools.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 #Build Tools
 echo "Generate Directorys"
 mkdir -p bin

tools/clear_tools.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 #Delete Tools
 echo "Delete Binary Directory"
 rm -rf bin

tools/rd7cc/source/main.cpp

@@ -1,10 +0,0 @@
-// rd7cc
-#include <fstream>
-#include <iostream>
-int main(int argc, char *argv[]) {
-  std::ofstream result("result.hpp");
-
-  result << "//Result" << std::endl;
-
-  result.close();
-}