Release 0.9.4

.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "name": "3DS | Windows",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "C:/devkitpro/libctru/include/**",
+                "C:/devkitpro/devkitARM/include/**",
+                "C:/devkitpro/devkitARM/arm-none-eabi/include/**",
+                "C:/devkitpro/portlibs/3ds/include/**",
+                "/opt/devkitpro/libctru/include/**",
+                "/opt/devkitpro/portlibs/**"
+                
+            ]
+        }
+    ],
+    "version": 4
+} 

.vscode/settings.json

@@ -0,0 +1,102 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "numeric": "cpp",
+        "type_traits": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "typeinfo": "cpp",
+        "utility": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "chrono": "cpp",
+        "codecvt": "cpp",
+        "condition_variable": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "deque": "cpp",
+        "forward_list": "cpp",
+        "map": "cpp",
+        "iomanip": "cpp",
+        "memory_resource": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "shared_mutex": "cpp",
+        "valarray": "cpp",
+        "random": "cpp",
+        "cuchar": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "numbers": "cpp",
+        "filesystem": "cpp",
+        "xstring": "cpp",
+        "charconv": "cpp",
+        "format": "cpp",
+        "ios": "cpp",
+        "list": "cpp",
+        "locale": "cpp",
+        "mutex": "cpp",
+        "stack": "cpp",
+        "stop_token": "cpp",
+        "thread": "cpp",
+        "xfacet": "cpp",
+        "xhash": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocbuf": "cpp",
+        "xlocinfo": "cpp",
+        "xlocmes": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xmemory": "cpp",
+        "xstddef": "cpp",
+        "xtr1common": "cpp",
+        "xtree": "cpp",
+        "xutility": "cpp",
+        "queue": "cpp",
+        "semaphore": "cpp",
+        "hash_map": "cpp",
+        "set": "cpp",
+        "unordered_set": "cpp",
+        "source_location": "cpp",
+        "future": "cpp",
+        "cfenv": "cpp",
+        "cinttypes": "cpp",
+        "typeindex": "cpp",
+        "variant": "cpp"
+    }
+}

Doxyfile

@@ -39,7 +39,7 @@ PROJECT_NAME           = Renderd7-nightly
 # control system is used.
 
 
-PROJECT_NUMBER         = "v0.7.0"
+PROJECT_NUMBER         = "v0.9.3"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

Makefile

@@ -9,8 +9,8 @@ endif
 include $(DEVKITARM)/3ds_rules
 
 export renderd7_MAJOR	:= 0
-export renderd7_MINOR	:= 8
+export renderd7_MINOR	:= 9
-export renderd7_PATCH	:= 0
+export renderd7_PATCH	:= 4
 
 VERSION	:=	$(renderd7_MAJOR).$(renderd7_MINOR).$(renderd7_PATCH)
 
@@ -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 external/libnsbmp/source
+SOURCES		:=	source external/source
 DATA		:=	data
 INCLUDES	:=	include
 
@@ -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,18 +1,41 @@
-# RenderD7
+# <img alt="LOGO" src="https://github.com/NPI-D7/RenderD7/blob/main/logo.png" height="90">
-RenderD7 is now LibRenderD7.
+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`
-git clone https://github.com/NPI-D7/RenderD7.git
+Finally put `-lrenderd7` to the First Place and add the path_to_your_libs
-cd RenderD7
+```
-export DEVKITARM=/opt/devkitpro/devkitARM/
+LIBS	:= -lrenderd7 -lcurl -lstdc++ -lm -lcitro2d -lcitro3d -lctru
-export DEVKITPRO=/opt/devkitpro/
+#---------------------------------------------------------------------------------
-make install
+# list of directories containing libraries, this must be the top level containing
-```
+# include and lib
-Make sure that `-lrenderd7` is before `-lcitro2d`, `-lcitro3d`, `-lctru`.
+#---------------------------------------------------------------------------------
-
+LIBDIRS	:= $(PORTLIBS) $(CTRULIB) ../path_to_your_libs
-# RenderD7 (https://npi-d7.github.io/RenderD7/)
+```
-Simple and Easey to use UI and Graphics helper.
+Make sure that `-lrenderd7` is before `-lcitro2d`, `-lcitro3d`, `-lctru`.
-Create DOCS
+Here an example tree
+```
+Example-App
+├── gfx
+├── libs
+│   ├── include
+│   │   ├── rd7.hpp
+│   │   └── renderd7
+│   └── lib
+│       ├── librenderd7.a
+│       └── librenderd7d.a
+├── Makefile
+├── romfs
+│   └── gfx
+└── src
+    └── main.cpp
+```
+# Credits
+- NPI-D7
+  - Tobi-D7 Main Dev
+
+Some Icons are From
+https://icons8.de/
+See Subfolder Readmes

assets/build_assets.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+echo "Create Directorys"
+mkdir -p build
+mkdir -p code
+
+echo "Generating Spritesheets"
+cd resources
+
+for file in *.t3s
+do
+    filename=$(basename "$file" .t3s).t3x
+    tex3ds -o "../build/$filename" -i "${file}"
+done
+
+echo "Converting Spritesheets into C++ Code"
+cd ../code
+
+for file in ../build/*.t3x
+do
+    name="${file##*/}"
+    name="${name%.*}"
+    ../../tools/bin/file2array "${file}" "${name}"
+done
+
+echo "Convert Npi-Intro to C++ Code"
+../../tools/bin/file2array ../splash/npi_intro.nvid npi_intro
+
+echo "Fix The Output of file2array"
+for file in ./*.cpp
+do
+    ../../tools/bin/rd7f2afix "${file}" "renderd7"
+done
+echo "Finished!"

assets/clear_assets.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+echo "Deleting Directorys"
+rm -rf build
+rm -rf code
+
+echo "Finished!"

assets/resources/battery/README.md

@@ -0,0 +1,2 @@
+# Source
+https://icons8.de/

assets/resources/battery_icons.t3s

@@ -0,0 +1,11 @@
+--atlas -f rgba -z auto
+
+battery/battery_full.png
+battery/battery_nearfull.png
+battery/battery_half.png
+battery/battery_low.png
+battery/battery_verylow.png
+battery/battery_warning.png
+battery/battery_charging.png
+battery/battery_empty.png
+battery/battery_dead.png

assets/resources/renderd7_logo.t3s

@@ -0,0 +1,3 @@
+--atlas -f rgba -z auto
+
+renderd7_logo/renderd7_logo.png

assets/resources/ui_elements.t3s

@@ -0,0 +1,19 @@
+--atlas -f rgba -z auto
+
+ui_elements/high_volume.png
+ui_elements/mid_volume.png
+ui_elements/low_volume.png
+ui_elements/speaker_v1.png
+ui_elements/no_sound.png
+ui_elements/speaker.png
+
+ui_elements/wifi_connected.png
+ui_elements/wifi_disconnected.png
+ui_elements/wifi_off.png
+
+ui_elements/good_connection.png
+ui_elements/mid_connection.png
+ui_elements/bad_connection.png
+ui_elements/no_connection.png
+
+ui_elements/headphones.png

assets/resources/ui_elements/README.md

@@ -0,0 +1,2 @@
+# Source
+https://icons8.de/

cformat.sh

@@ -0,0 +1,8 @@
+#!/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
+    echo "Formatting $file..."
+    clang-format -i --style=LLVM $file
+  fi
+done

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!"

external/libnsbmp/COPYING

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

external/source/fs.c

@@ -1,386 +0,0 @@
-#include <renderd7/external/fs.h>
-
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <stdlib.h>
-
-#define WORKING_DIR	"/"
-
-void Utils_U8_To_U16(u16 *buf, const u8 *input, size_t bufsize) {
-	ssize_t units = utf8_to_utf16(buf, input, bufsize);
-
-	if (units < 0)
-		units = 0;
-
-	buf[units] = 0;
-}
-
-FS_Archive archive, sdmc_archive, nand_archive;
-
-Result FS_OpenArchive(FS_Archive *archive, FS_ArchiveID archiveID) {
-	Result ret = 0;
-
-	if (R_FAILED(ret = FSUSER_OpenArchive(archive, archiveID, fsMakePath(PATH_EMPTY, ""))))
-		return ret;
-
-	return 0;
-}
-
-Result FS_CloseArchive(FS_Archive archive) {
-	Result ret = 0;
-
-	if (R_FAILED(ret = FSUSER_CloseArchive(archive)))
-		return ret;
-
-	return 0;
-}
-
-Result FS_OpenDir(Handle *handle, FS_Archive archive, const char *path) {
-	Result ret = 0;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_OpenDirectory(handle, archive, fsMakePath(PATH_UTF16, path_u16))))
-		return ret;
-
-	return 0;
-}
-
-Result FS_OpenFile(Handle *handle, FS_Archive archive, const char *path, u32 flags, u32 attributes) {
-	Result ret = 0;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_OpenFile(handle, archive, fsMakePath(PATH_UTF16, path_u16), flags, attributes)))
-		return ret;
-
-	return 0;
-}
-
-Result FS_MakeDir(FS_Archive archive, const char *path) {
-	Result ret = 0;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_CreateDirectory(archive, fsMakePath(PATH_UTF16, path_u16), 0)))
-		return ret;
-
-	return 0;
-}
-
-Result FS_CreateFile(FS_Archive archive, const char *path, u64 size) {
-	Result ret = 0;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_CreateFile(archive, fsMakePath(PATH_UTF16, path_u16), 0, size)))
-		return ret;
-
-	return 0;
-}
-
-Result FS_RecursiveMakeDir(FS_Archive archive, const char *path) {
-	Result ret = 0;
-	char buf[256];
-	char *p = NULL;
-	size_t len;
-
-	snprintf(buf, sizeof(buf), "%s", path);
-	len = strlen(buf);
-
-	if (buf[len - 1] == '/')
-		buf[len - 1] = 0;
-
-	for (p = buf + 1; *p; p++) {
-		if (*p == '/') {
-			*p = 0;
-
-			if (!FS_DirExists(archive, buf))
-				ret = FS_MakeDir(archive, buf);
-
-			*p = '/';
-		}
-
-		if (!FS_DirExists(archive, buf))
-			ret = FS_MakeDir(archive, buf);
-	}
-
-	return ret;
-}
-
-bool FS_FileExists(FS_Archive archive, const char *path) {
-	Handle handle;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(FSUSER_OpenFile(&handle, archive, fsMakePath(PATH_UTF16, path_u16), FS_OPEN_READ, 0)))
-		return false;
-
-	if (R_FAILED(FSFILE_Close(handle)))
-		return false;
-
-	return true;
-}
-
-bool FS_DirExists(FS_Archive archive, const char *path) {
-	Handle handle;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(FSUSER_OpenDirectory(&handle, archive, fsMakePath(PATH_UTF16, path_u16))))
-		return false;
-
-	if (R_FAILED(FSDIR_Close(handle)))
-		return false;
-
-	return true;
-}
-
-Result FS_GetFileSize(FS_Archive archive, const char *path, u64 *size) {
-	Result ret = 0;
-	Handle handle;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_OpenFile(&handle, archive, fsMakePath(PATH_UTF16, path_u16), FS_OPEN_READ, 0)))
-		return ret;
-
-	if (R_FAILED(ret = FSFILE_GetSize(handle, size))) {
-		FSFILE_Close(handle);
-		return ret;
-	}
-
-	if (R_FAILED(ret = FSFILE_Close(handle)))
-		return ret;
-
-	return 0;
-}
-
-u64 FS_GetFreeStorage(FS_SystemMediaType media_type) {
-	FS_ArchiveResource resource = {0};
-
-	if (R_SUCCEEDED(FSUSER_GetArchiveResource(&resource, media_type)))
-		return (((u64)resource.freeClusters * (u64)resource.clusterSize));
-
-	return 0;
-}
-
-u64 FS_GetTotalStorage(FS_SystemMediaType media_type) {
-	FS_ArchiveResource resource = {0};
-
-	if (R_SUCCEEDED(FSUSER_GetArchiveResource(&resource, media_type)))
-		return (((u64)resource.totalClusters * (u64)resource.clusterSize));
-
-	return 0;
-}
-
-u64 FS_GetUsedStorage(FS_SystemMediaType media_type) {
-	return 0;//(FS_GetTotalStorage(media_type) - FS_GetUsedStorage(media_type));
-}
-
-Result FS_RemoveFile(FS_Archive archive, const char *path) {
-	Result ret = 0;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_DeleteFile(archive, fsMakePath(PATH_UTF16, path_u16))))
-		return ret;
-
-	return 0;
-}
-
-Result FS_RemoveDir(FS_Archive archive, const char *path) {
-	Result ret = 0;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_DeleteDirectory(archive, fsMakePath(PATH_UTF16, path_u16))))
-		return ret;
-
-	return 0;
-}
-
-Result FS_RemoveDirRecursive(FS_Archive archive, const char *path) {
-	Result ret = 0;
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_DeleteDirectoryRecursively(archive, fsMakePath(PATH_UTF16, path_u16))))
-		return ret;
-
-	return 0;
-}
-
-Result FS_RenameFile(FS_Archive archive, const char *old_filename, const char *new_filename) {
-	Result ret = 0;
-
-	u16 old_filename_u16[strlen(old_filename) + 1];
-	Utils_U8_To_U16(old_filename_u16, (const u8 *)old_filename, strlen(old_filename) + 1);
-
-	u16 new_filename_u16[strlen(new_filename) + 1];
-	Utils_U8_To_U16(new_filename_u16, (const u8 *)new_filename, strlen(new_filename) + 1);
-
-	if (R_FAILED(ret = FSUSER_RenameFile(archive, fsMakePath(PATH_UTF16, old_filename_u16), archive, fsMakePath(PATH_UTF16, new_filename_u16))))
-		return ret;
-
-	return 0;
-}
-
-Result FS_RenameDir(FS_Archive archive, const char *old_dirname, const char *new_dirname) {
-	Result ret = 0;
-
-	u16 old_dirname_u16[strlen(old_dirname) + 1];
-	Utils_U8_To_U16(old_dirname_u16, (const u8 *)old_dirname, strlen(old_dirname) + 1);
-
-	u16 new_dirname_u16[strlen(new_dirname) + 1];
-	Utils_U8_To_U16(new_dirname_u16, (const u8 *)new_dirname, strlen(new_dirname) + 1);
-
-	if (R_FAILED(ret = FSUSER_RenameDirectory(archive, fsMakePath(PATH_UTF16, old_dirname_u16), archive, fsMakePath(PATH_UTF16, new_dirname_u16))))
-		return ret;
-
-	return 0;
-}
-
-Result FS_Read(FS_Archive archive, const char *path, u64 size, void *buf) {
-	Result ret = 0;
-	Handle handle;
-
-	u32 bytes_read = 0;
-
-	if (R_FAILED(ret = FS_OpenFile(&handle, archive, path, FS_OPEN_READ, 0)))
-		return ret;
-
-	if (R_FAILED(ret = FSFILE_Read(handle, &bytes_read, 0, buf, size))) {
-		FSFILE_Close(handle);
-		return ret;
-	}
-
-	if (R_FAILED(ret = FSFILE_Close(handle)))
-		return ret;
-
-	return 0;
-}
-
-Result FS_Write(FS_Archive archive, const char *path, const void *buf, u32 size) {
-	Result ret = 0;
-	Handle handle;
-	u32 bytes_written = 0;
-
-	if (FS_FileExists(archive, path))
-		FS_RemoveFile(archive, path);
-
-	u16 path_u16[strlen(path) + 1];
-	Utils_U8_To_U16(path_u16, (const u8 *)path, strlen(path) + 1);
-
-	if (R_FAILED(ret = FSUSER_CreateFile(archive, fsMakePath(PATH_UTF16, path_u16), 0, size)))
-		return ret;
-
-	if (R_FAILED(ret = FSUSER_OpenFile(&handle, archive, fsMakePath(PATH_UTF16, path_u16), FS_OPEN_WRITE, 0)))
-		return ret;
-
-	if (R_FAILED(ret = FSFILE_Write(handle, &bytes_written, 0, buf, size, FS_WRITE_FLUSH))) {
-		FSFILE_Close(handle);
-		return ret;
-	}
-
-	if (R_FAILED(ret = FSFILE_Close(handle)))
-		return ret;
-
-	return 0;
-}
-
-char *FS_GetFileTimestamp(const char *path) {
-	static char timeStr[60];
-	u64 mtime = 0;
-
-	if (R_SUCCEEDED(archive_getmtime(path, &mtime))) {
-		time_t mt = mtime;
-		struct tm *timeStruct = gmtime(&mt);
-
-		int hours = timeStruct->tm_hour;
-		int minutes = timeStruct->tm_min;
-
-		int day = timeStruct->tm_mday;
-		int month = timeStruct->tm_mon + 1; // January being 0
-		int year = timeStruct->tm_year + 1900;
-
-		snprintf(timeStr, 60, "%d/%d/%d %2i:%02i", year, month, day, hours, minutes);
-	}
-	else
-		return NULL;
-
-	return timeStr;
-}
-
-FS_Path getPathInfo(const char * path, FS_ArchiveID * archive) {
-	*archive = ARCHIVE_SDMC;
-	FS_Path filePath = {0};
-	unsigned int prefixlen = 0;
-
-	if (!strncmp(path, "sdmc:/", 6)) {
-		prefixlen = 5;
-	} else if (*path != '/') {
-		//if the path is local (doesnt start with a slash), it needs to be appended to the working dir to be valid
-		char * actualPath = NULL;
-		asprintf(&actualPath, "%s%s", WORKING_DIR, path);
-		filePath = fsMakePath(PATH_ASCII, actualPath);
-		free(actualPath);
-	}
-
-	//if the filePath wasnt set above, set it
-	if (filePath.size == 0) {
-		filePath = fsMakePath(PATH_ASCII, path+prefixlen);
-	}
-
-	return filePath;
-}
-Result makeDirs(const char * path) {
-	Result ret = 0;
-	FS_ArchiveID archiveID;
-	FS_Path filePath = getPathInfo(path, &archiveID);
-	FS_Archive archive;
-
-	ret = FSUSER_OpenArchive(&archive, archiveID, fsMakePath(PATH_EMPTY, ""));
-
-	for (char * slashpos = strchr(path+1, '/'); slashpos != NULL; slashpos = strchr(slashpos+1, '/')) {
-		char bak = *(slashpos);
-		*(slashpos) = '\0';
-		Handle dirHandle;
-
-		ret = FSUSER_OpenDirectory(&dirHandle, archive, filePath);
-		if (R_SUCCEEDED(ret))	FSDIR_Close(dirHandle);
-		else	ret = FSUSER_CreateDirectory(archive, filePath, FS_ATTRIBUTE_DIRECTORY);
-
-		*(slashpos) = bak;
-	}
-
-	FSUSER_CloseArchive(archive);
-
-	return ret;
-}
-
-Result openFile(Handle* fileHandle, const char * path, bool write) {
-	FS_ArchiveID archive;
-	FS_Path filePath = getPathInfo(path, &archive);
-	u32 flags = (write ? (FS_OPEN_CREATE | FS_OPEN_WRITE) : FS_OPEN_READ);
-
-	Result ret = 0;
-	ret = makeDirs(strdup(path));
-	ret = FSUSER_OpenFileDirectly(fileHandle, archive, fsMakePath(PATH_EMPTY, ""), filePath, flags, 0);
-	if (write)	ret = FSFILE_SetSize(*fileHandle, 0); //truncate the file to remove previous contents before writing
-
-	return ret;
-}

extlibs/external.md

@@ -1 +0,0 @@
-External Librarys

include/rd7.hpp

@@ -1,4 +1,5 @@
 #pragma once
 
+#include <renderd7/StealConsole.hpp>
 #include <renderd7/bmp.hpp>
 #include <renderd7/renderd7.hpp>

include/renderd7/BitmapPrinter.hpp

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

@@ -1,23 +0,0 @@
-#pragma once
-#include <renderd7/Time.hpp>
-
-namespace rnd7 {
-    class Clock {
-    public:
-        Clock() {};
-
-        virtual ~Clock() {};
-
-        
-        virtual Time getCurrentTime() const { return Time{}; };
-
-        Time getElapsedTime() const;
-
-        Time restart();
-
-    protected:
-
-        Time m_startTime; ///< Time of last reset, in microseconds
-    };
-
-}

include/renderd7/Color.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#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)
+
+namespace RenderD7 {
+namespace Color {
+/// @brief RGBA Struct
+struct rgba {
+  /// @brief rgba Colors
+  uint8_t r, g, b, a;
+};
+/// @brief RGBA Class
+class RGBA {
+public:
+  /// @brief Construct
+  /// @param r
+  /// @param g
+  /// @param b
+  /// @param a
+  RGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+      : m_r(r), m_g(g), m_b(b), m_a(a) {}
+  /// @brief Get as Uint32
+  /// @return color
+  uint32_t toRGBA() const {
+    return (m_r << 24) | (m_g << 16) | (m_b << 8) | m_a;
+  }
+
+  uint8_t m_r, m_g, m_b, m_a;
+};
+/// @brief Convert RGB to Hex
+/// @param r
+/// @param g
+/// @param b
+/// @return Hex-String
+std::string RGB2Hex(int r, int g, int b);
+/// @brief Hex to U32
+/// @param color
+/// @param a
+/// @return Color32
+uint32_t Hex(const std::string &color, uint8_t a = 255);
+} // namespace Color
+} // namespace RenderD7

include/renderd7/Draw.hpp

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

@@ -0,0 +1,23 @@
+// 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>
+
+namespace RenderD7 {
+namespace FileSystem {
+/// @brief A Directory Entry
+struct Entry {
+  /// @brief Patf of The Entry
+  std::string path;
+  /// @brief Name of The Entry
+  std::string name;
+  /// @brief Directory or File
+  bool dir = false;
+};
+/// @brief Gets All Entrys of A Directory into a Vector
+/// @param path The Path of the Directory
+/// @return The Vector of found Entrys
+std::vector<RenderD7::FileSystem::Entry> GetDirContent(std::string path);
+} // namespace FileSystem
+} // namespace RenderD7

include/renderd7/Fonts/NFontApi.hpp

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

@@ -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/Image.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include <citro2d.h>
+#include <citro3d.h>
+#include <memory>
+
+#include <renderd7/Sheet.hpp>
+#include <renderd7/bmp.hpp>
+#include <renderd7/bmpconverter.hpp>
+
+#include <cassert>
+#include <cstring>
+#include <renderd7/Color.hpp>
+#include <renderd7/external/lodepng.h>
+
+namespace RenderD7 {
+/// Image Class
+class Image {
+public:
+  /// @brief Constructor
+  Image() {}
+  /// @brief Deconstructor
+  ~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 FromSheet(RenderD7::Sheet sheet, size_t index);
+  /// \param img this is the C2D_Image
+  C2D_Image img;
+  /// \param loadet whether the image is loadet or not
+  bool loadet = false;
+};
+} // 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

@@ -0,0 +1,30 @@
+#pragma once
+#include <memory>
+
+namespace RenderD7 {
+/// @brief The Overlay Class (Used for Toasts for example)
+class Ovl {
+public:
+  /// @brief Deconstructor
+  virtual ~Ovl() {}
+  /// @brief Function Called to Draw this
+  virtual void Draw() const = 0;
+  /// @brief Logic of the Overlay
+  virtual void Logic() = 0;
+  /// @brief Should the overlay be killed
+  /// @return Killed or Not
+  inline bool IsKilled() { return this->iskilled; }
+  /// @brief Kill The Overlay
+  inline void Kill() { iskilled = true; }
+
+private:
+  /// @param iskilled For IsKilled();
+  bool iskilled = false;
+};
+/// @brief Add an Overlay to the Screen
+/// @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/ResultDecoder.hpp

@@ -0,0 +1,51 @@
+#pragma once
+#include <3ds.h>
+#include <string>
+
+namespace RenderD7 {
+/// @brief Decoder for 3ds Result Codes
+class ResultDecoder {
+public:
+  /// @brief Constructor
+  ResultDecoder() {}
+  /// @brief Deconstructor
+  ~ResultDecoder() {}
+  /// @brief Load a Result into Decoder
+  /// @param rescode Result Code
+  void Load(Result rescode);
+  /// @brief Load A Hex Converted Code into Decoder
+  /// @param rescode Result-Hex Code
+  void Load(std::string rescode);
+  /// @brief Get Hex Code
+  /// @return Hex-Code
+  std::string GetCode();
+  /// @brief Get Level Name
+  /// @return Level Name
+  std::string GetLevel();
+  /// @brief Get Level Value
+  /// @return Level Value
+  int GetLevelInt();
+  /// @brief Get The Mosule Name
+  /// @return Module Name
+  std::string GetModule();
+  /// @brief Get The Module Value
+  /// @return Module Value
+  int GetModuleInt();
+  /// @brief Get The Description
+  /// @return Description
+  std::string GetDescription();
+  /// @brief Get The Description Valur
+  /// @return Description Value
+  int GetDescriptionInt();
+  /// @brief Get the Summary
+  /// @return Summary
+  std::string GetSummary();
+  /// @brief Get the Summary Value
+  /// @return Summary Value
+  int GetSummaryInt();
+
+private:
+  /// @param m_rescode Result code
+  Result m_rescode;
+};
+} // namespace RenderD7

include/renderd7/Screen.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include <citro2d.h>
+#include <citro3d.h>
+
+/// \param Top Tob-Screen Target
+extern C3D_RenderTarget *Top;
+/// \param TopRight Top-Right-Screen Target (Never atually used)
+extern C3D_RenderTarget *TopRight;
+/// \param Bottom Bottom-Screen Target
+extern C3D_RenderTarget *Bottom;
+
+namespace RenderD7 {
+/// @brief Begin Drawing On Specific Screen
+/// @param target The Screen Target (Top, Bottom or TopTight)
+void OnScreen(C3D_RenderTarget *target);
+} // 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/Sheet.hpp

@@ -0,0 +1,22 @@
+#pragma once
+#include <citro2d.h>
+#include <citro3d.h>
+
+namespace RenderD7 {
+/// @brief SpriteSheet Class
+class Sheet {
+public:
+  /// @brief Constructor
+  Sheet();
+  /// @brief Deconstructor
+  ~Sheet();
+  /// @brief Load A Spritesheet File
+  /// @param path Path to the t3x
+  /// @return Result Code
+  Result Load(const char *path);
+  /// @brief Unload the Sheet
+  void Free();
+  /// \param spritesheet The Sheet
+  C2D_SpriteSheet spritesheet;
+};
+} // namespace RenderD7

include/renderd7/Sprite.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <citro2d.h>
+#include <citro3d.h>
+
+#include <renderd7/Image.hpp>
+#include <renderd7/Sheet.hpp>
+
+namespace RenderD7 {
+/// @brief Sprite Class
+class Sprite {
+public:
+  /// \brief Construct Sprite
+  Sprite();
+  /// \brief Deconstruct Sprite
+  ~Sprite();
+  /// \brief Load a Sprite From SpriteSheet
+  /// \param sheet the Sheet to load from.(RenderD7::Sheet)
+  /// \param index the number of the Sprite in the Sheet
+  void FromSheet(RenderD7::Sheet *sheet, size_t index);
+  /// \brief Load a Sprite From SpriteSheet
+  /// \param img the Image to load from.(RenderD7::Image)
+  void FromImage(RenderD7::Image *img);
+  /// @brief Draw the Sprite
+  /// @return success ?
+  bool Draw();
+  /// @brief Set the Center Position
+  /// @param x X Pos
+  /// @param y Y Pos
+  void SetCenter(float x, float y);
+  /// @brief Set the Sprite's Position
+  /// @param x X Pos
+  /// @param y Y Pos
+  void SetPos(float x, float y);
+  /// @brief Set The Sprite's Scale
+  /// @param x Scale on X-Axis
+  /// @param y Scale on Y-Axis
+  void SetScale(float x, float y);
+  /// @brief Set the Sprite's Rotation
+  /// @param rotation ratation
+  void SetRotation(float rotation);
+  /// @brief Rotate the Sprite
+  /// @param speed Speed to Rotate
+  void Rotate(float speed);
+  /// @brief Get Tje Sprite's Width
+  /// @return Width
+  float getWidth();
+  /// @brief Get the Sprite's Height
+  /// @return Height
+  float getHeight();
+  /// @brief Get The Sprite's X Position
+  /// @return X Position
+  float getPosX();
+  /// @brief Get the Sprite's Y Position
+  /// @return Y Position
+  float getPosY();
+
+private:
+  /// @param tint ImageTint (unused)
+  C2D_ImageTint tint;
+  /// @param sprite The Sprite
+  C2D_Sprite sprite;
+};
+} // namespace RenderD7

include/renderd7/SpriteAnimation.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <renderd7/Sheet.hpp>
+#include <renderd7/Sprite.hpp>
+
+#include <citro2d.h>
+#include <citro3d.h>
+
+namespace RenderD7 {
+/// @brief SpriteSheetAnimation Class
+class SpriteSheetAnimation : public RenderD7::Sprite {
+public:
+  /// @brief Constructor
+  SpriteSheetAnimation();
+  /// @brief Deconstructor
+  ~SpriteSheetAnimation();
+  /// @brief Setup an Animation
+  /// @param sheet Input Spritesheet
+  /// @param imagecount Count of Images
+  /// @param startimage Where to Start the Loop
+  /// @param frame_begin Current Time (Should be 0)
+  /// @param frame_finish Time Length
+  void Setup(RenderD7::Sheet *sheet, size_t imagecount, size_t startimage,
+             float frame_begin, float frame_finish);
+  /// @brief Play the Animation
+  /// @param timespeed Speed of the animation
+  void Play(float timespeed);
+
+private:
+  /// @param images Count of Images
+  size_t images;
+  /// @param imgs Another Count of images ???
+  size_t imgs = 0;
+  /// @param D_totaltime Current Time
+  float D_totaltime;
+  /// @param sheet The Sheet of Images
+  RenderD7::Sheet *sheet;
+  /// @param time Total Time from frame_finish
+  float time;
+};
+} // namespace RenderD7

include/renderd7/StealConsole.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <sstream>
+#include <string>
+
+namespace RenderD7 {
+/// @brief StealConsole Class
+class StealConsole {
+public:
+  /// @brief Constructor
+  StealConsole();
+  /// @brief Deconstructor
+  ~StealConsole();
+  /// @brief The Stolen Stdout
+  /// @return Stdout as string
+  std::string GetStdout();
+
+private:
+  /// @param stolen_stdout Stolen Stdout
+  std::stringstream stolen_stdout;
+};
+} // namespace RenderD7

include/renderd7/Tasks.hpp

@@ -0,0 +1,13 @@
+#pragma once
+#include <3ds.h>
+#include <vector>
+
+namespace RenderD7 {
+namespace Tasks {
+/// @brief Push A Task
+/// @param entrypoint Function of Your Task
+void create(ThreadFunc entrypoint);
+/// @brief Destroy all Tasks
+void destroy(void);
+} // namespace Tasks
+} // namespace RenderD7

include/renderd7/Time.hpp

@@ -1,82 +1,13 @@
-namespace rnd7 {
+#pragma once
-class Time {
+#include <string>
-    public:
 
-        Time();
+namespace RenderD7 {
-
+/// @brief Format a String
-        float asSeconds() const;
+/// @param fmt_str Format To
-
+/// @param ... Additional Args
-        int asMilliseconds() const;
+/// @return Formatted String
-
+std::string FormatString(std::string fmt_str, ...);
-        long asMicroseconds() const;
+/// @brief Get Current Time as String
-
+/// @return Time-String
-        static const Time Zero_;
+std::string GetTimeStr(void);
-
+} // namespace RenderD7
-    private:
-
-        friend Time seconds(float);
-
-        friend Time milliseconds(int);
-
-        friend Time microseconds(long);
-
-        explicit Time(long microseconds);
-
-    private:
-
-        long m_microseconds; ///< Time value stored as microseconds
-    };
-
-    Time seconds(float amount);
-
-    Time milliseconds(int amount);
-
-    Time microseconds(long amount);
-
-    bool operator==(Time left, Time right);
-
-    bool operator!=(Time left, Time right);
-
-    bool operator<(Time left, Time right);
-
-    bool operator>(Time left, Time right);
-    bool operator<=(Time left, Time right);
-
-    bool operator>=(Time left, Time right);
-
-    Time operator-(Time right);
-    Time operator+(Time left, Time right);
-
-    Time &operator+=(Time &left, Time right);
-
-    Time operator-(Time left, Time right);
-
-    Time &operator-=(Time &left, Time right);
-
-    Time operator*(Time left, float right);
-
-    Time operator*(Time left, long right);
-
-    Time operator*(float left, Time right);
-
-    Time operator*(long left, Time right);
-
-    Time &operator*=(Time &left, float right);
-
-    Time &operator*=(Time &left, long right);
-
-    Time operator/(Time left, float right);
-
-    Time operator/(Time left, long right);
-
-    Time &operator/=(Time &left, float right);
-
-    Time &operator/=(Time &left, long right);
-
-    float operator/(Time left, Time right);
-
-    Time operator%(Time left, Time right);
-
-    Time &operator%=(Time &left, Time right);
-
-} 

include/renderd7/Toast.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include <renderd7/BitmapPrinter.hpp>
+#include <renderd7/Color.hpp>
+#include <renderd7/Image.hpp>
+#include <renderd7/Ovl.hpp>
+#include <renderd7/Screen.hpp>
+
+namespace RenderD7 {
+/// @brief Toast Class
+class Toast : public RenderD7::Ovl {
+public:
+  /// @brief Constructor
+  /// @param head Displayed String in Head
+  /// @param msg Displayed String in Message Box
+  Toast(std::string head, std::string msg);
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
+
+private:
+  /// @param head The Header Text
+  /// @param nsg The Message-Box Text
+  std::string head, msg;
+  /// @param msgposy Position Y of The Toast
+  int msgposy = 240;
+  /// @param delay Delay of the Toast
+  int delay = 0;
+};
+} // namespace RenderD7

include/renderd7/battery_icons.hpp

@@ -0,0 +1,5 @@
+#pragma once
+#include <cstddef>
+
+extern unsigned char battery_icons[];
+extern size_t battery_icons_size;

include/renderd7/bmpconverter.hpp

@@ -3,12 +3,19 @@
 
 #include <iostream>
 
-namespace BitmapConverter{
+namespace BitmapConverter {
-//returns 0 if all went ok, non-0 if error
+/// 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
+/// output image is always given in RGBA (with alpha channel), even if it's a
-unsigned decodeBMP(std::vector<unsigned char>& image, unsigned& w, unsigned& h, const std::vector<unsigned char>& bmp);
+/// 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

@@ -0,0 +1,187 @@
+/*
+  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/external/fs.h

@@ -1,29 +0,0 @@
-
-
-#include <3ds.h>
-
-extern FS_Archive archive, sdmc_archive, nand_archive;
-
-Result FS_OpenArchive(FS_Archive *archive, FS_ArchiveID id);
-Result FS_CloseArchive(FS_Archive archive);
-Result FS_OpenDir(Handle *handle, FS_Archive archive, const char *path);
-Result FS_OpenFile(Handle *handle, FS_Archive archive, const char *path, u32 flags, u32 attributes);
-Result FS_MakeDir(FS_Archive archive, const char *path);
-Result FS_CreateFile(FS_Archive archive, const char *path, u64 size);
-Result FS_RecursiveMakeDir(FS_Archive archive, const char *path);
-bool FS_FileExists(FS_Archive archive, const char *path);
-bool FS_DirExists(FS_Archive archive, const char *path);
-Result FS_GetFileSize(FS_Archive archive, const char *path, u64 *size);
-u64 FS_GetFreeStorage(FS_SystemMediaType media_type);
-u64 FS_GetTotalStorage(FS_SystemMediaType media_type);
-u64 FS_GetUsedStorage(FS_SystemMediaType media_type);
-Result FS_RemoveFile(FS_Archive archive, const char *path);
-Result FS_RemoveDir(FS_Archive archive, const char *path);
-Result FS_RemoveDirRecursive(FS_Archive archive, const char *path);
-Result FS_RenameFile(FS_Archive archive, const char *old_filename, const char *new_filename);
-Result FS_RenameDir(FS_Archive archive, const char *old_dirname, const char *new_dirname);
-Result FS_Read(FS_Archive archive, const char *path, u64 size, void *buf);
-Result FS_Write(FS_Archive archive, const char *path, const void *buf, u32 size);
-char *FS_GetFileTimestamp(const char *path);
-Result makeDirs(const char * path);
-Result openFile(Handle* fileHandle, const char * path, bool write);

include/renderd7/external/jpgd.h

@@ -0,0 +1,422 @@
+// jpgd.h - C++ class for JPEG decompression.
+// Richard Geldreich <richgel99@gmail.com>
+// See jpgd.cpp for license (Public Domain or Apache 2.0).
+#ifndef JPEG_DECODER_H
+#define JPEG_DECODER_H
+
+#include <assert.h>
+#include <cinttypes>
+#include <setjmp.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef _MSC_VER
+#define JPGD_NORETURN __declspec(noreturn)
+#elif defined(__GNUC__)
+#define JPGD_NORETURN __attribute__((noreturn))
+#else
+#define JPGD_NORETURN
+#endif
+
+#define JPGD_HUFF_TREE_MAX_LENGTH 512
+#define JPGD_HUFF_CODE_SIZE_MAX_LENGTH 256
+
+namespace jpgd {
+typedef unsigned char uint8;
+typedef signed short int16;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+typedef signed int int32;
+
+// Loads a JPEG image from a memory buffer or a file.
+// req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
+// On return, width/height will be set to the image's dimensions, and
+// actual_comps will be set to the either 1 (grayscale) or 3 (RGB). Notes: For
+// more control over where and how the source data is read, see the
+// decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder
+// class directly. Requesting a 8 or 32bpp image is currently a little faster
+// than 24bpp because the jpeg_decoder class itself currently always unpacks to
+// either 8 or 32bpp.
+unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data,
+                                                 int src_data_size, int *width,
+                                                 int *height, int *actual_comps,
+                                                 int req_comps,
+                                                 uint32_t flags = 0);
+unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename,
+                                               int *width, int *height,
+                                               int *actual_comps, int req_comps,
+                                               uint32_t flags = 0);
+
+// Success/failure error codes.
+enum jpgd_status {
+  JPGD_SUCCESS = 0,
+  JPGD_FAILED = -1,
+  JPGD_DONE = 1,
+  JPGD_BAD_DHT_COUNTS = -256,
+  JPGD_BAD_DHT_INDEX,
+  JPGD_BAD_DHT_MARKER,
+  JPGD_BAD_DQT_MARKER,
+  JPGD_BAD_DQT_TABLE,
+  JPGD_BAD_PRECISION,
+  JPGD_BAD_HEIGHT,
+  JPGD_BAD_WIDTH,
+  JPGD_TOO_MANY_COMPONENTS,
+  JPGD_BAD_SOF_LENGTH,
+  JPGD_BAD_VARIABLE_MARKER,
+  JPGD_BAD_DRI_LENGTH,
+  JPGD_BAD_SOS_LENGTH,
+  JPGD_BAD_SOS_COMP_ID,
+  JPGD_W_EXTRA_BYTES_BEFORE_MARKER,
+  JPGD_NO_ARITHMITIC_SUPPORT,
+  JPGD_UNEXPECTED_MARKER,
+  JPGD_NOT_JPEG,
+  JPGD_UNSUPPORTED_MARKER,
+  JPGD_BAD_DQT_LENGTH,
+  JPGD_TOO_MANY_BLOCKS,
+  JPGD_UNDEFINED_QUANT_TABLE,
+  JPGD_UNDEFINED_HUFF_TABLE,
+  JPGD_NOT_SINGLE_SCAN,
+  JPGD_UNSUPPORTED_COLORSPACE,
+  JPGD_UNSUPPORTED_SAMP_FACTORS,
+  JPGD_DECODE_ERROR,
+  JPGD_BAD_RESTART_MARKER,
+  JPGD_BAD_SOS_SPECTRAL,
+  JPGD_BAD_SOS_SUCCESSIVE,
+  JPGD_STREAM_READ,
+  JPGD_NOTENOUGHMEM,
+  JPGD_TOO_MANY_SCANS
+};
+
+// Input stream interface.
+// Derive from this class to read input data from sources other than files or
+// memory. Set m_eof_flag to true when no more data is available. The decoder is
+// rather greedy: it will keep on calling this method until its internal input
+// buffer is full, or until the EOF flag is set. It the input stream contains
+// data after the JPEG stream's EOI (end of image) marker it will probably be
+// pulled into the internal buffer. Call the get_total_bytes_read() method to
+// determine the actual size of the JPEG stream after successful decoding.
+class jpeg_decoder_stream {
+public:
+  jpeg_decoder_stream() {}
+  virtual ~jpeg_decoder_stream() {}
+
+  // The read() method is called when the internal input buffer is empty.
+  // Parameters:
+  // pBuf - input buffer
+  // max_bytes_to_read - maximum bytes that can be written to pBuf
+  // pEOF_flag - set this to true if at end of stream (no more bytes remaining)
+  // Returns -1 on error, otherwise return the number of bytes actually written
+  // to the buffer (which may be 0). Notes: This method will be called in a loop
+  // until you set *pEOF_flag to true or the internal buffer is full.
+  virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0;
+};
+
+// stdio FILE stream class.
+class jpeg_decoder_file_stream : public jpeg_decoder_stream {
+  jpeg_decoder_file_stream(const jpeg_decoder_file_stream &);
+  jpeg_decoder_file_stream &operator=(const jpeg_decoder_file_stream &);
+
+  FILE *m_pFile;
+  bool m_eof_flag, m_error_flag;
+
+public:
+  jpeg_decoder_file_stream();
+  virtual ~jpeg_decoder_file_stream();
+
+  bool open(const char *Pfilename);
+  void close();
+
+  virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
+};
+
+// Memory stream class.
+class jpeg_decoder_mem_stream : public jpeg_decoder_stream {
+  const uint8 *m_pSrc_data;
+  uint m_ofs, m_size;
+
+public:
+  jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) {}
+  jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size)
+      : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) {}
+
+  virtual ~jpeg_decoder_mem_stream() {}
+
+  bool open(const uint8 *pSrc_data, uint size);
+  void close() {
+    m_pSrc_data = NULL;
+    m_ofs = 0;
+    m_size = 0;
+  }
+
+  virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
+};
+
+// Loads JPEG file from a jpeg_decoder_stream.
+unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream,
+                                                 int *width, int *height,
+                                                 int *actual_comps,
+                                                 int req_comps,
+                                                 uint32_t flags = 0);
+
+enum {
+  JPGD_IN_BUF_SIZE = 8192,
+  JPGD_MAX_BLOCKS_PER_MCU = 10,
+  JPGD_MAX_HUFF_TABLES = 8,
+  JPGD_MAX_QUANT_TABLES = 4,
+  JPGD_MAX_COMPONENTS = 4,
+  JPGD_MAX_COMPS_IN_SCAN = 4,
+  JPGD_MAX_BLOCKS_PER_ROW = 16384,
+  JPGD_MAX_HEIGHT = 32768,
+  JPGD_MAX_WIDTH = 32768
+};
+
+typedef int16 jpgd_quant_t;
+typedef int16 jpgd_block_coeff_t;
+
+class jpeg_decoder {
+public:
+  enum { cFlagBoxChromaFiltering = 1, cFlagDisableSIMD = 2 };
+
+  // Call get_error_code() after constructing to determine if the stream is
+  // valid or not. You may call the get_width(), get_height(), etc. methods
+  // after the constructor is called. You may then either destruct the object,
+  // or begin decoding the image by calling begin_decoding(), then decode() on
+  // each scanline.
+  jpeg_decoder(jpeg_decoder_stream *pStream, uint32_t flags = 0);
+
+  ~jpeg_decoder();
+
+  // Call this method after constructing the object to begin decompression.
+  // If JPGD_SUCCESS is returned you may then call decode() on each scanline.
+
+  int begin_decoding();
+
+  // Returns the next scan line.
+  // For grayscale images, pScan_line will point to a buffer containing 8-bit
+  // pixels (get_bytes_per_pixel() will return 1). Otherwise, it will always
+  // point to a buffer containing 32-bit RGBA pixels (A will always be 255, and
+  // get_bytes_per_pixel() will return 4). Returns JPGD_SUCCESS if a scan line
+  // has been returned. Returns JPGD_DONE if all scan lines have been returned.
+  // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more
+  // info.
+  int decode(const void **pScan_line, uint *pScan_line_len);
+
+  inline jpgd_status get_error_code() const { return m_error_code; }
+
+  inline int get_width() const { return m_image_x_size; }
+  inline int get_height() const { return m_image_y_size; }
+
+  inline int get_num_components() const { return m_comps_in_frame; }
+
+  inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; }
+  inline int get_bytes_per_scan_line() const {
+    return m_image_x_size * get_bytes_per_pixel();
+  }
+
+  // Returns the total number of bytes actually consumed by the decoder (which
+  // should equal the actual size of the JPEG file).
+  inline int get_total_bytes_read() const { return m_total_bytes_read; }
+
+private:
+  jpeg_decoder(const jpeg_decoder &);
+  jpeg_decoder &operator=(const jpeg_decoder &);
+
+  typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int);
+
+  struct huff_tables {
+    bool ac_table;
+    uint look_up[256];
+    uint look_up2[256];
+    uint8 code_size[JPGD_HUFF_CODE_SIZE_MAX_LENGTH];
+    uint tree[JPGD_HUFF_TREE_MAX_LENGTH];
+  };
+
+  struct coeff_buf {
+    uint8 *pData;
+    int block_num_x, block_num_y;
+    int block_len_x, block_len_y;
+    int block_size;
+  };
+
+  struct mem_block {
+    mem_block *m_pNext;
+    size_t m_used_count;
+    size_t m_size;
+    char m_data[1];
+  };
+
+  jmp_buf m_jmp_state;
+  uint32_t m_flags;
+  mem_block *m_pMem_blocks;
+  int m_image_x_size;
+  int m_image_y_size;
+  jpeg_decoder_stream *m_pStream;
+
+  int m_progressive_flag;
+
+  uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES];
+  uint8 *m_huff_num[JPGD_MAX_HUFF_TABLES]; // pointer to number of Huffman codes
+                                           // per bit size
+  uint8 *
+      m_huff_val[JPGD_MAX_HUFF_TABLES]; // pointer to Huffman codes per bit size
+  jpgd_quant_t
+      *m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables
+  int m_scan_type; // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no
+                   // longer supported)
+  int m_comps_in_frame;                   // # of components in frame
+  int m_comp_h_samp[JPGD_MAX_COMPONENTS]; // component's horizontal sampling
+                                          // factor
+  int m_comp_v_samp[JPGD_MAX_COMPONENTS]; // component's vertical sampling
+                                          // factor
+  int m_comp_quant[JPGD_MAX_COMPONENTS];  // component's quantization table
+                                          // selector
+  int m_comp_ident[JPGD_MAX_COMPONENTS];  // component's ID
+  int m_comp_h_blocks[JPGD_MAX_COMPONENTS];
+  int m_comp_v_blocks[JPGD_MAX_COMPONENTS];
+  int m_comps_in_scan;                     // # of components in scan
+  int m_comp_list[JPGD_MAX_COMPS_IN_SCAN]; // components in this scan
+  int m_comp_dc_tab[JPGD_MAX_COMPONENTS]; // component's DC Huffman coding table
+                                          // selector
+  int m_comp_ac_tab[JPGD_MAX_COMPONENTS]; // component's AC Huffman coding table
+                                          // selector
+  int m_spectral_start;                   // spectral selection start
+  int m_spectral_end;                     // spectral selection end
+  int m_successive_low;                   // successive approximation low
+  int m_successive_high;                  // successive approximation high
+  int m_max_mcu_x_size;                   // MCU's max. X size in pixels
+  int m_max_mcu_y_size;                   // MCU's max. Y size in pixels
+  int m_blocks_per_mcu;
+  int m_max_blocks_per_row;
+  int m_mcus_per_row, m_mcus_per_col;
+  int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU];
+  int m_total_lines_left; // total # lines left in image
+  int m_mcu_lines_left;   // total # lines left in this MCU
+  int m_num_buffered_scanlines;
+  int m_real_dest_bytes_per_scan_line;
+  int m_dest_bytes_per_scan_line; // rounded up
+  int m_dest_bytes_per_pixel;     // 4 (RGB) or 1 (Y)
+  huff_tables *m_pHuff_tabs[JPGD_MAX_HUFF_TABLES];
+  coeff_buf *m_dc_coeffs[JPGD_MAX_COMPONENTS];
+  coeff_buf *m_ac_coeffs[JPGD_MAX_COMPONENTS];
+  int m_eob_run;
+  int m_block_y_mcu[JPGD_MAX_COMPONENTS];
+  uint8 *m_pIn_buf_ofs;
+  int m_in_buf_left;
+  int m_tem_flag;
+
+  uint8 m_in_buf_pad_start[64];
+  uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128];
+  uint8 m_in_buf_pad_end[64];
+
+  int m_bits_left;
+  uint m_bit_buf;
+  int m_restart_interval;
+  int m_restarts_left;
+  int m_next_restart_num;
+  int m_max_mcus_per_row;
+  int m_max_blocks_per_mcu;
+
+  int m_max_mcus_per_col;
+  uint m_last_dc_val[JPGD_MAX_COMPONENTS];
+  jpgd_block_coeff_t *m_pMCU_coefficients;
+  int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU];
+  uint8 *m_pSample_buf;
+  uint8 *m_pSample_buf_prev;
+  int m_crr[256];
+  int m_cbb[256];
+  int m_crg[256];
+  int m_cbg[256];
+  uint8 *m_pScan_line_0;
+  uint8 *m_pScan_line_1;
+  jpgd_status m_error_code;
+  int m_total_bytes_read;
+
+  bool m_ready_flag;
+  bool m_eof_flag;
+  bool m_sample_buf_prev_valid;
+  bool m_has_sse2;
+
+  inline int check_sample_buf_ofs(int ofs) const {
+    assert(ofs >= 0);
+    assert(ofs < m_max_blocks_per_row * 64);
+    return ofs;
+  }
+  void free_all_blocks();
+  JPGD_NORETURN void stop_decoding(jpgd_status status);
+  void *alloc(size_t n, bool zero = false);
+  void *alloc_aligned(size_t nSize, uint32_t align = 16, bool zero = false);
+  void word_clear(void *p, uint16 c, uint n);
+  void prep_in_buffer();
+  void read_dht_marker();
+  void read_dqt_marker();
+  void read_sof_marker();
+  void skip_variable_marker();
+  void read_dri_marker();
+  void read_sos_marker();
+  int next_marker();
+  int process_markers();
+  void locate_soi_marker();
+  void locate_sof_marker();
+  int locate_sos_marker();
+  void init(jpeg_decoder_stream *pStream, uint32_t flags);
+  void create_look_ups();
+  void fix_in_buffer();
+  void transform_mcu(int mcu_row);
+  coeff_buf *coeff_buf_open(int block_num_x, int block_num_y, int block_len_x,
+                            int block_len_y);
+  inline jpgd_block_coeff_t *coeff_buf_getp(coeff_buf *cb, int block_x,
+                                            int block_y);
+  void load_next_row();
+  void decode_next_row();
+  void make_huff_table(int index, huff_tables *pH);
+  void check_quant_tables();
+  void check_huff_tables();
+  bool calc_mcu_block_order();
+  int init_scan();
+  void init_frame();
+  void process_restart();
+  void decode_scan(pDecode_block_func decode_block_func);
+  void init_progressive();
+  void init_sequential();
+  void decode_start();
+  void decode_init(jpeg_decoder_stream *pStream, uint32_t flags);
+  void H2V2Convert();
+  uint32_t H2V2ConvertFiltered();
+  void H2V1Convert();
+  void H2V1ConvertFiltered();
+  void H1V2Convert();
+  void H1V2ConvertFiltered();
+  void H1V1Convert();
+  void gray_convert();
+  void find_eoi();
+  inline uint get_char();
+  inline uint get_char(bool *pPadding_flag);
+  inline void stuff_char(uint8 q);
+  inline uint8 get_octet();
+  inline uint get_bits(int num_bits);
+  inline uint get_bits_no_markers(int numbits);
+  inline int huff_decode(huff_tables *pH);
+  inline int huff_decode(huff_tables *pH, int &extrabits);
+
+  // Clamps a value between 0-255.
+  static inline uint8 clamp(int i) {
+    if (static_cast<uint>(i) > 255)
+      i = (((~i) >> 31) & 0xFF);
+    return static_cast<uint8>(i);
+  }
+  int decode_next_mcu_row();
+
+  static void decode_block_dc_first(jpeg_decoder *pD, int component_id,
+                                    int block_x, int block_y);
+  static void decode_block_dc_refine(jpeg_decoder *pD, int component_id,
+                                     int block_x, int block_y);
+  static void decode_block_ac_first(jpeg_decoder *pD, int component_id,
+                                    int block_x, int block_y);
+  static void decode_block_ac_refine(jpeg_decoder *pD, int component_id,
+                                     int block_x, int block_y);
+};
+
+} // namespace jpgd
+
+#endif // JPEG_DECODER_H

include/renderd7/external/jpgd_idct.h

@@ -0,0 +1,478 @@
+// Copyright 2009 Intel Corporation
+// All Rights Reserved
+//
+// Permission is granted to use, copy, distribute and prepare derivative works
+// of this software for any purpose and without fee, provided, that the above
+// copyright notice and this statement appear in all copies.  Intel makes no
+// representations about the suitability of this software for any purpose.  THIS
+// SOFTWARE IS PROVIDED "AS IS." INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER
+// INDIRECT DAMAGES, FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR
+// INFRINGEMENT OF ANY PROPRIETARY RIGHTS, AND INCLUDING THE WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  Intel does not assume
+// any responsibility for any errors which may appear in this software nor any
+// responsibility to update it.
+//
+// From:
+// https://software.intel.com/sites/default/files/m/d/4/1/d/8/UsingIntelAVXToImplementIDCT-r1_5.pdf
+// https://software.intel.com/file/29048
+//
+// Requires SSE
+//
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+#include <immintrin.h>
+
+#ifdef _MSC_VER
+#define JPGD_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+#else
+#define JPGD_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+
+#include <cinttypes>
+
+#define BITS_INV_ACC 4
+#define SHIFT_INV_ROW 16 - BITS_INV_ACC
+#define SHIFT_INV_COL 1 + BITS_INV_ACC
+const short IRND_INV_ROW = 1024 * (6 - BITS_INV_ACC); // 1 << (SHIFT_INV_ROW-1)
+const short IRND_INV_COL = 16 * (BITS_INV_ACC - 3);   // 1 << (SHIFT_INV_COL-1)
+const short IRND_INV_CORR = IRND_INV_COL - 1; // correction -1.0 and round
+
+JPGD_SIMD_ALIGN(short, shortM128_one_corr[8]) = {1, 1, 1, 1, 1, 1, 1, 1};
+JPGD_SIMD_ALIGN(short, shortM128_round_inv_row[8]) = {
+    IRND_INV_ROW, 0, IRND_INV_ROW, 0, IRND_INV_ROW, 0, IRND_INV_ROW, 0};
+JPGD_SIMD_ALIGN(short, shortM128_round_inv_col[8]) = {
+    IRND_INV_COL, IRND_INV_COL, IRND_INV_COL, IRND_INV_COL,
+    IRND_INV_COL, IRND_INV_COL, IRND_INV_COL, IRND_INV_COL};
+JPGD_SIMD_ALIGN(short, shortM128_round_inv_corr[8]) = {
+    IRND_INV_CORR, IRND_INV_CORR, IRND_INV_CORR, IRND_INV_CORR,
+    IRND_INV_CORR, IRND_INV_CORR, IRND_INV_CORR, IRND_INV_CORR};
+JPGD_SIMD_ALIGN(short, shortM128_tg_1_16[8]) = {
+    13036, 13036, 13036, 13036,
+    13036, 13036, 13036, 13036}; // tg * (2<<16) + 0.5
+JPGD_SIMD_ALIGN(short, shortM128_tg_2_16[8]) = {
+    27146, 27146, 27146, 27146,
+    27146, 27146, 27146, 27146}; // tg * (2<<16) + 0.5
+JPGD_SIMD_ALIGN(short, shortM128_tg_3_16[8]) = {
+    -21746, -21746, -21746, -21746,
+    -21746, -21746, -21746, -21746}; // tg * (2<<16) + 0.5
+JPGD_SIMD_ALIGN(short, shortM128_cos_4_16[8]) = {
+    -19195, -19195, -19195, -19195,
+    -19195, -19195, -19195, -19195}; // cos * (2<<16) + 0.5
+
+//-----------------------------------------------------------------------------
+// Table for rows 0,4 - constants are multiplied on cos_4_16
+// w15 w14 w11 w10 w07 w06 w03 w02
+// w29 w28 w25 w24 w21 w20 w17 w16
+// w31 w30 w27 w26 w23 w22 w19 w18
+// movq -> w05 w04 w01 w00
+JPGD_SIMD_ALIGN(short, shortM128_tab_i_04[]) = {
+    16384,  21407,  16384,  8867,
+    16384,  -8867,  16384,  -21407,  // w13 w12 w09 w08
+    16384,  8867,   -16384, -21407,  // w07 w06 w03 w02
+    -16384, 21407,  16384,  -8867,   // w15 w14 w11 w10
+    22725,  19266,  19266,  -4520,   // w21 w20 w17 w16
+    12873,  -22725, 4520,   -12873,  // w29 w28 w25 w24
+    12873,  4520,   -22725, -12873,  // w23 w22 w19 w18
+    4520,   19266,  19266,  -22725}; // w31 w30 w27 w26
+
+// Table for rows 1,7 - constants are multiplied on cos_1_16
+// movq -> w05 w04 w01 w00
+JPGD_SIMD_ALIGN(short, shortM128_tab_i_17[]) = {
+    22725,  29692,  22725,  12299,
+    22725,  -12299, 22725,  -29692,  // w13 w12 w09 w08
+    22725,  12299,  -22725, -29692,  // w07 w06 w03 w02
+    -22725, 29692,  22725,  -12299,  // w15 w14 w11 w10
+    31521,  26722,  26722,  -6270,   // w21 w20 w17 w16
+    17855,  -31521, 6270,   -17855,  // w29 w28 w25 w24
+    17855,  6270,   -31521, -17855,  // w23 w22 w19 w18
+    6270,   26722,  26722,  -31521}; // w31 w30 w27 w26
+
+// Table for rows 2,6 - constants are multiplied on cos_2_16
+// movq -> w05 w04 w01 w00
+JPGD_SIMD_ALIGN(short, shortM128_tab_i_26[]) = {
+    21407,  27969,  21407,  11585,
+    21407,  -11585, 21407,  -27969,  // w13 w12 w09 w08
+    21407,  11585,  -21407, -27969,  // w07 w06 w03 w02
+    -21407, 27969,  21407,  -11585,  // w15 w14 w11 w10
+    29692,  25172,  25172,  -5906,   // w21 w20 w17 w16
+    16819,  -29692, 5906,   -16819,  // w29 w28 w25 w24
+    16819,  5906,   -29692, -16819,  // w23 w22 w19 w18
+    5906,   25172,  25172,  -29692}; // w31 w30 w27 w26
+// Table for rows 3,5 - constants are multiplied on cos_3_16
+// movq -> w05 w04 w01 w00
+JPGD_SIMD_ALIGN(short, shortM128_tab_i_35[]) = {
+    19266,  25172,  19266,  10426,
+    19266,  -10426, 19266,  -25172,  // w13 w12 w09 w08
+    19266,  10426,  -19266, -25172,  // w07 w06 w03 w02
+    -19266, 25172,  19266,  -10426,  // w15 w14 w11 w10
+    26722,  22654,  22654,  -5315,   // w21 w20 w17 w16
+    15137,  -26722, 5315,   -15137,  // w29 w28 w25 w24
+    15137,  5315,   -26722, -15137,  // w23 w22 w19 w18
+    5315,   22654,  22654,  -26722}; // w31 w30 w27 w26
+
+JPGD_SIMD_ALIGN(short, shortM128_128[8]) = {128, 128, 128, 128,
+                                            128, 128, 128, 128};
+
+void idctSSEShortU8(const short *pInput, uint8_t *pOutputUB) {
+  __m128i r_xmm0, r_xmm4;
+  __m128i r_xmm1, r_xmm2, r_xmm3, r_xmm5, r_xmm6, r_xmm7;
+  __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+  short *pTab_i_04 = shortM128_tab_i_04;
+  short *pTab_i_26 = shortM128_tab_i_26;
+
+  // Get pointers for this input and output
+  pTab_i_04 = shortM128_tab_i_04;
+  pTab_i_26 = shortM128_tab_i_26;
+
+  // Row 1 and Row 3
+  r_xmm0 = _mm_load_si128((__m128i *)pInput);
+  r_xmm4 = _mm_load_si128((__m128i *)(&pInput[2 * 8]));
+
+  // *** Work on the data in xmm0
+  // low shuffle mask = 0xd8 = 11 01 10 00
+  // get short 2 and short 0 into ls 32-bits
+  r_xmm0 = _mm_shufflelo_epi16(r_xmm0, 0xd8);
+
+  // copy short 2 and short 0 to all locations
+  r_xmm1 = _mm_shuffle_epi32(r_xmm0, 0);
+
+  // add to those copies
+  r_xmm1 = _mm_madd_epi16(r_xmm1, *((__m128i *)pTab_i_04));
+
+  // shuffle mask = 0x55 = 01 01 01 01
+  // copy short 3 and short 1 to all locations
+  r_xmm3 = _mm_shuffle_epi32(r_xmm0, 0x55);
+
+  // high shuffle mask = 0xd8 = 11 01 10 00
+  // get short 6 and short 4 into bit positions 64-95
+  // get short 7 and short 5 into bit positions 96-127
+  r_xmm0 = _mm_shufflehi_epi16(r_xmm0, 0xd8);
+
+  // add to short 3 and short 1
+  r_xmm3 = _mm_madd_epi16(r_xmm3, *((__m128i *)&pTab_i_04[16]));
+
+  // shuffle mask = 0xaa = 10 10 10 10
+  // copy short 6 and short 4 to all locations
+  r_xmm2 = _mm_shuffle_epi32(r_xmm0, 0xaa);
+
+  // shuffle mask = 0xaa = 11 11 11 11
+  // copy short 7 and short 5 to all locations
+  r_xmm0 = _mm_shuffle_epi32(r_xmm0, 0xff);
+
+  // add to short 6 and short 4
+  r_xmm2 = _mm_madd_epi16(r_xmm2, *((__m128i *)&pTab_i_04[8]));
+
+  // *** Work on the data in xmm4
+  // high shuffle mask = 0xd8 11 01 10 00
+  // get short 6 and short 4 into bit positions 64-95
+  // get short 7 and short 5 into bit positions 96-127
+  r_xmm4 = _mm_shufflehi_epi16(r_xmm4, 0xd8);
+
+  // (xmm0 short 2 and short 0 plus pSi) + some constants
+  r_xmm1 = _mm_add_epi32(r_xmm1, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_shufflelo_epi16(r_xmm4, 0xd8);
+  r_xmm0 = _mm_madd_epi16(r_xmm0, *((__m128i *)&pTab_i_04[24]));
+  r_xmm5 = _mm_shuffle_epi32(r_xmm4, 0);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm4, 0xaa);
+  r_xmm5 = _mm_madd_epi16(r_xmm5, *((__m128i *)&shortM128_tab_i_26[0]));
+  r_xmm1 = _mm_add_epi32(r_xmm1, r_xmm2);
+  r_xmm2 = r_xmm1;
+  r_xmm7 = _mm_shuffle_epi32(r_xmm4, 0x55);
+  r_xmm6 = _mm_madd_epi16(r_xmm6, *((__m128i *)&shortM128_tab_i_26[8]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm3);
+  r_xmm4 = _mm_shuffle_epi32(r_xmm4, 0xff);
+  r_xmm2 = _mm_sub_epi32(r_xmm2, r_xmm0);
+  r_xmm7 = _mm_madd_epi16(r_xmm7, *((__m128i *)&shortM128_tab_i_26[16]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm1);
+  r_xmm2 = _mm_srai_epi32(r_xmm2, 12);
+  r_xmm5 = _mm_add_epi32(r_xmm5, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_madd_epi16(r_xmm4, *((__m128i *)&shortM128_tab_i_26[24]));
+  r_xmm5 = _mm_add_epi32(r_xmm5, r_xmm6);
+  r_xmm6 = r_xmm5;
+  r_xmm0 = _mm_srai_epi32(r_xmm0, 12);
+  r_xmm2 = _mm_shuffle_epi32(r_xmm2, 0x1b);
+  row0 = _mm_packs_epi32(r_xmm0, r_xmm2);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm7);
+  r_xmm6 = _mm_sub_epi32(r_xmm6, r_xmm4);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm5);
+  r_xmm6 = _mm_srai_epi32(r_xmm6, 12);
+  r_xmm4 = _mm_srai_epi32(r_xmm4, 12);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm6, 0x1b);
+  row2 = _mm_packs_epi32(r_xmm4, r_xmm6);
+
+  // Row 5 and row 7
+  r_xmm0 = _mm_load_si128((__m128i *)(&pInput[4 * 8]));
+  r_xmm4 = _mm_load_si128((__m128i *)(&pInput[6 * 8]));
+
+  r_xmm0 = _mm_shufflelo_epi16(r_xmm0, 0xd8);
+  r_xmm1 = _mm_shuffle_epi32(r_xmm0, 0);
+  r_xmm1 = _mm_madd_epi16(r_xmm1, *((__m128i *)pTab_i_04));
+  r_xmm3 = _mm_shuffle_epi32(r_xmm0, 0x55);
+  r_xmm0 = _mm_shufflehi_epi16(r_xmm0, 0xd8);
+  r_xmm3 = _mm_madd_epi16(r_xmm3, *((__m128i *)&pTab_i_04[16]));
+  r_xmm2 = _mm_shuffle_epi32(r_xmm0, 0xaa);
+  r_xmm0 = _mm_shuffle_epi32(r_xmm0, 0xff);
+  r_xmm2 = _mm_madd_epi16(r_xmm2, *((__m128i *)&pTab_i_04[8]));
+  r_xmm4 = _mm_shufflehi_epi16(r_xmm4, 0xd8);
+  r_xmm1 = _mm_add_epi32(r_xmm1, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_shufflelo_epi16(r_xmm4, 0xd8);
+  r_xmm0 = _mm_madd_epi16(r_xmm0, *((__m128i *)&pTab_i_04[24]));
+  r_xmm5 = _mm_shuffle_epi32(r_xmm4, 0);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm4, 0xaa);
+  r_xmm5 = _mm_madd_epi16(r_xmm5, *((__m128i *)&shortM128_tab_i_26[0]));
+  r_xmm1 = _mm_add_epi32(r_xmm1, r_xmm2);
+  r_xmm2 = r_xmm1;
+  r_xmm7 = _mm_shuffle_epi32(r_xmm4, 0x55);
+  r_xmm6 = _mm_madd_epi16(r_xmm6, *((__m128i *)&shortM128_tab_i_26[8]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm3);
+  r_xmm4 = _mm_shuffle_epi32(r_xmm4, 0xff);
+  r_xmm2 = _mm_sub_epi32(r_xmm2, r_xmm0);
+  r_xmm7 = _mm_madd_epi16(r_xmm7, *((__m128i *)&shortM128_tab_i_26[16]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm1);
+  r_xmm2 = _mm_srai_epi32(r_xmm2, 12);
+  r_xmm5 = _mm_add_epi32(r_xmm5, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_madd_epi16(r_xmm4, *((__m128i *)&shortM128_tab_i_26[24]));
+  r_xmm5 = _mm_add_epi32(r_xmm5, r_xmm6);
+  r_xmm6 = r_xmm5;
+  r_xmm0 = _mm_srai_epi32(r_xmm0, 12);
+  r_xmm2 = _mm_shuffle_epi32(r_xmm2, 0x1b);
+  row4 = _mm_packs_epi32(r_xmm0, r_xmm2);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm7);
+  r_xmm6 = _mm_sub_epi32(r_xmm6, r_xmm4);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm5);
+  r_xmm6 = _mm_srai_epi32(r_xmm6, 12);
+  r_xmm4 = _mm_srai_epi32(r_xmm4, 12);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm6, 0x1b);
+  row6 = _mm_packs_epi32(r_xmm4, r_xmm6);
+
+  // Row 4 and row 2
+  pTab_i_04 = shortM128_tab_i_35;
+  pTab_i_26 = shortM128_tab_i_17;
+  r_xmm0 = _mm_load_si128((__m128i *)(&pInput[3 * 8]));
+  r_xmm4 = _mm_load_si128((__m128i *)(&pInput[1 * 8]));
+
+  r_xmm0 = _mm_shufflelo_epi16(r_xmm0, 0xd8);
+  r_xmm1 = _mm_shuffle_epi32(r_xmm0, 0);
+  r_xmm1 = _mm_madd_epi16(r_xmm1, *((__m128i *)pTab_i_04));
+  r_xmm3 = _mm_shuffle_epi32(r_xmm0, 0x55);
+  r_xmm0 = _mm_shufflehi_epi16(r_xmm0, 0xd8);
+  r_xmm3 = _mm_madd_epi16(r_xmm3, *((__m128i *)&pTab_i_04[16]));
+  r_xmm2 = _mm_shuffle_epi32(r_xmm0, 0xaa);
+  r_xmm0 = _mm_shuffle_epi32(r_xmm0, 0xff);
+  r_xmm2 = _mm_madd_epi16(r_xmm2, *((__m128i *)&pTab_i_04[8]));
+  r_xmm4 = _mm_shufflehi_epi16(r_xmm4, 0xd8);
+  r_xmm1 = _mm_add_epi32(r_xmm1, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_shufflelo_epi16(r_xmm4, 0xd8);
+  r_xmm0 = _mm_madd_epi16(r_xmm0, *((__m128i *)&pTab_i_04[24]));
+  r_xmm5 = _mm_shuffle_epi32(r_xmm4, 0);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm4, 0xaa);
+  r_xmm5 = _mm_madd_epi16(r_xmm5, *((__m128i *)&pTab_i_26[0]));
+  r_xmm1 = _mm_add_epi32(r_xmm1, r_xmm2);
+  r_xmm2 = r_xmm1;
+  r_xmm7 = _mm_shuffle_epi32(r_xmm4, 0x55);
+  r_xmm6 = _mm_madd_epi16(r_xmm6, *((__m128i *)&pTab_i_26[8]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm3);
+  r_xmm4 = _mm_shuffle_epi32(r_xmm4, 0xff);
+  r_xmm2 = _mm_sub_epi32(r_xmm2, r_xmm0);
+  r_xmm7 = _mm_madd_epi16(r_xmm7, *((__m128i *)&pTab_i_26[16]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm1);
+  r_xmm2 = _mm_srai_epi32(r_xmm2, 12);
+  r_xmm5 = _mm_add_epi32(r_xmm5, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_madd_epi16(r_xmm4, *((__m128i *)&pTab_i_26[24]));
+  r_xmm5 = _mm_add_epi32(r_xmm5, r_xmm6);
+  r_xmm6 = r_xmm5;
+  r_xmm0 = _mm_srai_epi32(r_xmm0, 12);
+  r_xmm2 = _mm_shuffle_epi32(r_xmm2, 0x1b);
+  row3 = _mm_packs_epi32(r_xmm0, r_xmm2);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm7);
+  r_xmm6 = _mm_sub_epi32(r_xmm6, r_xmm4);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm5);
+  r_xmm6 = _mm_srai_epi32(r_xmm6, 12);
+  r_xmm4 = _mm_srai_epi32(r_xmm4, 12);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm6, 0x1b);
+  row1 = _mm_packs_epi32(r_xmm4, r_xmm6);
+
+  // Row 6 and row 8
+  r_xmm0 = _mm_load_si128((__m128i *)(&pInput[5 * 8]));
+  r_xmm4 = _mm_load_si128((__m128i *)(&pInput[7 * 8]));
+
+  r_xmm0 = _mm_shufflelo_epi16(r_xmm0, 0xd8);
+  r_xmm1 = _mm_shuffle_epi32(r_xmm0, 0);
+  r_xmm1 = _mm_madd_epi16(r_xmm1, *((__m128i *)pTab_i_04));
+  r_xmm3 = _mm_shuffle_epi32(r_xmm0, 0x55);
+  r_xmm0 = _mm_shufflehi_epi16(r_xmm0, 0xd8);
+  r_xmm3 = _mm_madd_epi16(r_xmm3, *((__m128i *)&pTab_i_04[16]));
+  r_xmm2 = _mm_shuffle_epi32(r_xmm0, 0xaa);
+  r_xmm0 = _mm_shuffle_epi32(r_xmm0, 0xff);
+  r_xmm2 = _mm_madd_epi16(r_xmm2, *((__m128i *)&pTab_i_04[8]));
+  r_xmm4 = _mm_shufflehi_epi16(r_xmm4, 0xd8);
+  r_xmm1 = _mm_add_epi32(r_xmm1, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_shufflelo_epi16(r_xmm4, 0xd8);
+  r_xmm0 = _mm_madd_epi16(r_xmm0, *((__m128i *)&pTab_i_04[24]));
+  r_xmm5 = _mm_shuffle_epi32(r_xmm4, 0);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm4, 0xaa);
+  r_xmm5 = _mm_madd_epi16(r_xmm5, *((__m128i *)&pTab_i_26[0]));
+  r_xmm1 = _mm_add_epi32(r_xmm1, r_xmm2);
+  r_xmm2 = r_xmm1;
+  r_xmm7 = _mm_shuffle_epi32(r_xmm4, 0x55);
+  r_xmm6 = _mm_madd_epi16(r_xmm6, *((__m128i *)&pTab_i_26[8]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm3);
+  r_xmm4 = _mm_shuffle_epi32(r_xmm4, 0xff);
+  r_xmm2 = _mm_sub_epi32(r_xmm2, r_xmm0);
+  r_xmm7 = _mm_madd_epi16(r_xmm7, *((__m128i *)&pTab_i_26[16]));
+  r_xmm0 = _mm_add_epi32(r_xmm0, r_xmm1);
+  r_xmm2 = _mm_srai_epi32(r_xmm2, 12);
+  r_xmm5 = _mm_add_epi32(r_xmm5, *((__m128i *)shortM128_round_inv_row));
+  r_xmm4 = _mm_madd_epi16(r_xmm4, *((__m128i *)&pTab_i_26[24]));
+  r_xmm5 = _mm_add_epi32(r_xmm5, r_xmm6);
+  r_xmm6 = r_xmm5;
+  r_xmm0 = _mm_srai_epi32(r_xmm0, 12);
+  r_xmm2 = _mm_shuffle_epi32(r_xmm2, 0x1b);
+  row5 = _mm_packs_epi32(r_xmm0, r_xmm2);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm7);
+  r_xmm6 = _mm_sub_epi32(r_xmm6, r_xmm4);
+  r_xmm4 = _mm_add_epi32(r_xmm4, r_xmm5);
+  r_xmm6 = _mm_srai_epi32(r_xmm6, 12);
+  r_xmm4 = _mm_srai_epi32(r_xmm4, 12);
+  r_xmm6 = _mm_shuffle_epi32(r_xmm6, 0x1b);
+  row7 = _mm_packs_epi32(r_xmm4, r_xmm6);
+
+  r_xmm1 = _mm_load_si128((__m128i *)shortM128_tg_3_16);
+  r_xmm2 = row5;
+  r_xmm3 = row3;
+  r_xmm0 = _mm_mulhi_epi16(row5, r_xmm1);
+
+  r_xmm1 = _mm_mulhi_epi16(r_xmm1, r_xmm3);
+  r_xmm5 = _mm_load_si128((__m128i *)shortM128_tg_1_16);
+  r_xmm6 = row7;
+  r_xmm4 = _mm_mulhi_epi16(row7, r_xmm5);
+
+  r_xmm0 = _mm_adds_epi16(r_xmm0, r_xmm2);
+  r_xmm5 = _mm_mulhi_epi16(r_xmm5, row1);
+  r_xmm1 = _mm_adds_epi16(r_xmm1, r_xmm3);
+  r_xmm7 = row6;
+
+  r_xmm0 = _mm_adds_epi16(r_xmm0, r_xmm3);
+  r_xmm3 = _mm_load_si128((__m128i *)shortM128_tg_2_16);
+  r_xmm2 = _mm_subs_epi16(r_xmm2, r_xmm1);
+  r_xmm7 = _mm_mulhi_epi16(r_xmm7, r_xmm3);
+  r_xmm1 = r_xmm0;
+  r_xmm3 = _mm_mulhi_epi16(r_xmm3, row2);
+  r_xmm5 = _mm_subs_epi16(r_xmm5, r_xmm6);
+  r_xmm4 = _mm_adds_epi16(r_xmm4, row1);
+  r_xmm0 = _mm_adds_epi16(r_xmm0, r_xmm4);
+  r_xmm0 = _mm_adds_epi16(r_xmm0, *((__m128i *)shortM128_one_corr));
+  r_xmm4 = _mm_subs_epi16(r_xmm4, r_xmm1);
+  r_xmm6 = r_xmm5;
+  r_xmm5 = _mm_subs_epi16(r_xmm5, r_xmm2);
+  r_xmm5 = _mm_adds_epi16(r_xmm5, *((__m128i *)shortM128_one_corr));
+  r_xmm6 = _mm_adds_epi16(r_xmm6, r_xmm2);
+
+  // Intermediate results, needed later
+  __m128i temp3, temp7;
+  temp7 = r_xmm0;
+
+  r_xmm1 = r_xmm4;
+  r_xmm0 = _mm_load_si128((__m128i *)shortM128_cos_4_16);
+  r_xmm4 = _mm_adds_epi16(r_xmm4, r_xmm5);
+  r_xmm2 = _mm_load_si128((__m128i *)shortM128_cos_4_16);
+  r_xmm2 = _mm_mulhi_epi16(r_xmm2, r_xmm4);
+
+  // Intermediate results, needed later
+  temp3 = r_xmm6;
+
+  r_xmm1 = _mm_subs_epi16(r_xmm1, r_xmm5);
+  r_xmm7 = _mm_adds_epi16(r_xmm7, row2);
+  r_xmm3 = _mm_subs_epi16(r_xmm3, row6);
+  r_xmm6 = row0;
+  r_xmm0 = _mm_mulhi_epi16(r_xmm0, r_xmm1);
+  r_xmm5 = row4;
+  r_xmm5 = _mm_adds_epi16(r_xmm5, r_xmm6);
+  r_xmm6 = _mm_subs_epi16(r_xmm6, row4);
+  r_xmm4 = _mm_adds_epi16(r_xmm4, r_xmm2);
+
+  r_xmm4 = _mm_or_si128(r_xmm4, *((__m128i *)shortM128_one_corr));
+  r_xmm0 = _mm_adds_epi16(r_xmm0, r_xmm1);
+  r_xmm0 = _mm_or_si128(r_xmm0, *((__m128i *)shortM128_one_corr));
+
+  r_xmm2 = r_xmm5;
+  r_xmm5 = _mm_adds_epi16(r_xmm5, r_xmm7);
+  r_xmm1 = r_xmm6;
+  r_xmm5 = _mm_adds_epi16(r_xmm5, *((__m128i *)shortM128_round_inv_col));
+  r_xmm2 = _mm_subs_epi16(r_xmm2, r_xmm7);
+  r_xmm7 = temp7;
+  r_xmm6 = _mm_adds_epi16(r_xmm6, r_xmm3);
+  r_xmm6 = _mm_adds_epi16(r_xmm6, *((__m128i *)shortM128_round_inv_col));
+  r_xmm7 = _mm_adds_epi16(r_xmm7, r_xmm5);
+  r_xmm7 = _mm_srai_epi16(r_xmm7, SHIFT_INV_COL);
+  r_xmm1 = _mm_subs_epi16(r_xmm1, r_xmm3);
+  r_xmm1 = _mm_adds_epi16(r_xmm1, *((__m128i *)shortM128_round_inv_corr));
+  r_xmm3 = r_xmm6;
+  r_xmm2 = _mm_adds_epi16(r_xmm2, *((__m128i *)shortM128_round_inv_corr));
+  r_xmm6 = _mm_adds_epi16(r_xmm6, r_xmm4);
+
+  // Store results for row 0
+  //_mm_store_si128((__m128i *) pOutput, r_xmm7);
+  __m128i r0 = r_xmm7;
+
+  r_xmm6 = _mm_srai_epi16(r_xmm6, SHIFT_INV_COL);
+  r_xmm7 = r_xmm1;
+  r_xmm1 = _mm_adds_epi16(r_xmm1, r_xmm0);
+
+  // Store results for row 1
+  //_mm_store_si128((__m128i *) (&pOutput[1*8]), r_xmm6);
+  __m128i r1 = r_xmm6;
+
+  r_xmm1 = _mm_srai_epi16(r_xmm1, SHIFT_INV_COL);
+  r_xmm6 = temp3;
+  r_xmm7 = _mm_subs_epi16(r_xmm7, r_xmm0);
+  r_xmm7 = _mm_srai_epi16(r_xmm7, SHIFT_INV_COL);
+
+  // Store results for row 2
+  //_mm_store_si128((__m128i *) (&pOutput[2*8]), r_xmm1);
+  __m128i r2 = r_xmm1;
+
+  r_xmm5 = _mm_subs_epi16(r_xmm5, temp7);
+  r_xmm5 = _mm_srai_epi16(r_xmm5, SHIFT_INV_COL);
+
+  // Store results for row 7
+  //_mm_store_si128((__m128i *) (&pOutput[7*8]), r_xmm5);
+  __m128i r7 = r_xmm5;
+
+  r_xmm3 = _mm_subs_epi16(r_xmm3, r_xmm4);
+  r_xmm6 = _mm_adds_epi16(r_xmm6, r_xmm2);
+  r_xmm2 = _mm_subs_epi16(r_xmm2, temp3);
+  r_xmm6 = _mm_srai_epi16(r_xmm6, SHIFT_INV_COL);
+  r_xmm2 = _mm_srai_epi16(r_xmm2, SHIFT_INV_COL);
+
+  // Store results for row 3
+  //_mm_store_si128((__m128i *) (&pOutput[3*8]), r_xmm6);
+  __m128i r3 = r_xmm6;
+
+  r_xmm3 = _mm_srai_epi16(r_xmm3, SHIFT_INV_COL);
+
+  // Store results for rows 4, 5, and 6
+  //_mm_store_si128((__m128i *) (&pOutput[4*8]), r_xmm2);
+  //_mm_store_si128((__m128i *) (&pOutput[5*8]), r_xmm7);
+  //_mm_store_si128((__m128i *) (&pOutput[6*8]), r_xmm3);
+
+  __m128i r4 = r_xmm2;
+  __m128i r5 = r_xmm7;
+  __m128i r6 = r_xmm3;
+
+  r0 = _mm_add_epi16(*(const __m128i *)shortM128_128, r0);
+  r1 = _mm_add_epi16(*(const __m128i *)shortM128_128, r1);
+  r2 = _mm_add_epi16(*(const __m128i *)shortM128_128, r2);
+  r3 = _mm_add_epi16(*(const __m128i *)shortM128_128, r3);
+  r4 = _mm_add_epi16(*(const __m128i *)shortM128_128, r4);
+  r5 = _mm_add_epi16(*(const __m128i *)shortM128_128, r5);
+  r6 = _mm_add_epi16(*(const __m128i *)shortM128_128, r6);
+  r7 = _mm_add_epi16(*(const __m128i *)shortM128_128, r7);
+
+  ((__m128i *)pOutputUB)[0] = _mm_packus_epi16(r0, r1);
+  ((__m128i *)pOutputUB)[1] = _mm_packus_epi16(r2, r3);
+  ((__m128i *)pOutputUB)[2] = _mm_packus_epi16(r4, r5);
+  ((__m128i *)pOutputUB)[3] = _mm_packus_epi16(r6, r7);
+}

include/renderd7/external/jpge.h

@@ -0,0 +1,186 @@
+// jpge.h - C++ class for JPEG compression.
+// Public Domain or Apache 2.0, Richard Geldreich <richgel99@gmail.com>
+// Alex Evans: Added RGBA support, linear memory allocator.
+#ifndef JPEG_ENCODER_H
+#define JPEG_ENCODER_H
+
+namespace jpge {
+typedef unsigned char uint8;
+typedef signed short int16;
+typedef signed int int32;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+typedef unsigned int uint;
+
+// JPEG chroma subsampling factors. Y_ONLY (grayscale images) and H2V2 (color
+// images) are the most common.
+enum subsampling_t { Y_ONLY = 0, H1V1 = 1, H2V1 = 2, H2V2 = 3 };
+
+// JPEG compression parameters structure.
+struct params {
+  inline params()
+      : m_quality(85), m_subsampling(H2V2), m_no_chroma_discrim_flag(false),
+        m_two_pass_flag(false), m_use_std_tables(false) {}
+
+  inline bool check() const {
+    if ((m_quality < 1) || (m_quality > 100))
+      return false;
+    if ((uint)m_subsampling > (uint)H2V2)
+      return false;
+    return true;
+  }
+
+  // Quality: 1-100, higher is better. Typical values are around 50-95.
+  int m_quality;
+
+  // m_subsampling:
+  // 0 = Y (grayscale) only
+  // 1 = YCbCr, no subsampling (H1V1, YCbCr 1x1x1, 3 blocks per MCU)
+  // 2 = YCbCr, H2V1 subsampling (YCbCr 2x1x1, 4 blocks per MCU)
+  // 3 = YCbCr, H2V2 subsampling (YCbCr 4x1x1, 6 blocks per MCU-- very common)
+  subsampling_t m_subsampling;
+
+  // Disables CbCr discrimination - only intended for testing.
+  // If true, the Y quantization table is also used for the CbCr channels.
+  bool m_no_chroma_discrim_flag;
+
+  bool m_two_pass_flag;
+
+  // By default we use the same quantization tables as mozjpeg's default.
+  // Set to true to use the traditional tables from JPEG Annex K.
+  bool m_use_std_tables;
+};
+
+// Writes JPEG image to a file.
+// num_channels must be 1 (Y) or 3 (RGB), image pitch must be
+// width*num_channels.
+bool compress_image_to_jpeg_file(const char *pFilename, int width, int height,
+                                 int num_channels, const uint8 *pImage_data,
+                                 const params &comp_params = params());
+
+// Writes JPEG image to memory buffer.
+// On entry, buf_size is the size of the output buffer pointed at by pBuf, which
+// should be at least ~1024 bytes. If return value is true, buf_size will be set
+// to the size of the compressed data.
+bool compress_image_to_jpeg_file_in_memory(
+    void *pBuf, int &buf_size, int width, int height, int num_channels,
+    const uint8 *pImage_data, const params &comp_params = params());
+
+// Output stream abstract class - used by the jpeg_encoder class to write to the
+// output stream. put_buf() is generally called with len==JPGE_OUT_BUF_SIZE
+// bytes, but for headers it'll be called with smaller amounts.
+class output_stream {
+public:
+  virtual ~output_stream(){};
+  virtual bool put_buf(const void *Pbuf, int len) = 0;
+  template <class T> inline bool put_obj(const T &obj) {
+    return put_buf(&obj, sizeof(T));
+  }
+};
+
+// Lower level jpeg_encoder class - useful if more control is needed than the
+// above helper functions.
+class jpeg_encoder {
+public:
+  jpeg_encoder();
+  ~jpeg_encoder();
+
+  // Initializes the compressor.
+  // pStream: The stream object to use for writing compressed data.
+  // params - Compression parameters structure, defined above.
+  // width, height  - Image dimensions.
+  // channels - May be 1, or 3. 1 indicates grayscale, 3 indicates RGB source
+  // data. Returns false on out of memory or if a stream write fails.
+  bool init(output_stream *pStream, int width, int height, int src_channels,
+            const params &comp_params = params());
+
+  const params &get_params() const { return m_params; }
+
+  // Deinitializes the compressor, freeing any allocated memory. May be called
+  // at any time.
+  void deinit();
+
+  uint get_total_passes() const { return m_params.m_two_pass_flag ? 2 : 1; }
+  inline uint get_cur_pass() { return m_pass_num; }
+
+  // Call this method with each source scanline.
+  // width * src_channels bytes per scanline is expected (RGB or Y format).
+  // You must call with NULL after all scanlines are processed to finish
+  // compression. Returns false on out of memory or if a stream write fails.
+  bool process_scanline(const void *pScanline);
+
+private:
+  jpeg_encoder(const jpeg_encoder &);
+  jpeg_encoder &operator=(const jpeg_encoder &);
+
+  typedef int32 sample_array_t;
+
+  output_stream *m_pStream;
+  params m_params;
+  uint8 m_num_components;
+  uint8 m_comp_h_samp[3], m_comp_v_samp[3];
+  int m_image_x, m_image_y, m_image_bpp, m_image_bpl;
+  int m_image_x_mcu, m_image_y_mcu;
+  int m_image_bpl_xlt, m_image_bpl_mcu;
+  int m_mcus_per_row;
+  int m_mcu_x, m_mcu_y;
+  uint8 *m_mcu_lines[16];
+  uint8 m_mcu_y_ofs;
+  sample_array_t m_sample_array[64];
+  int16 m_coefficient_array[64];
+  int32 m_quantization_tables[2][64];
+  uint m_huff_codes[4][256];
+  uint8 m_huff_code_sizes[4][256];
+  uint8 m_huff_bits[4][17];
+  uint8 m_huff_val[4][256];
+  uint32 m_huff_count[4][256];
+  int m_last_dc_val[3];
+  enum { JPGE_OUT_BUF_SIZE = 2048 };
+  uint8 m_out_buf[JPGE_OUT_BUF_SIZE];
+  uint8 *m_pOut_buf;
+  uint m_out_buf_left;
+  uint32 m_bit_buffer;
+  uint m_bits_in;
+  uint8 m_pass_num;
+  bool m_all_stream_writes_succeeded;
+
+  void optimize_huffman_table(int table_num, int table_len);
+  void emit_byte(uint8 i);
+  void emit_word(uint i);
+  void emit_marker(int marker);
+  void emit_jfif_app0();
+  void emit_dqt();
+  void emit_sof();
+  void emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag);
+  void emit_dhts();
+  void emit_sos();
+  void emit_markers();
+  void compute_huffman_table(uint *codes, uint8 *code_sizes, uint8 *bits,
+                             uint8 *val);
+  void compute_quant_table(int32 *dst, int16 *src);
+  void adjust_quant_table(int32 *dst, int32 *src);
+  void first_pass_init();
+  bool second_pass_init();
+  bool jpg_open(int p_x_res, int p_y_res, int src_channels);
+  void load_block_8_8_grey(int x);
+  void load_block_8_8(int x, int y, int c);
+  void load_block_16_8(int x, int c);
+  void load_block_16_8_8(int x, int c);
+  void load_quantized_coefficients(int component_num);
+  void flush_output_buffer();
+  void put_bits(uint bits, uint len);
+  void code_coefficients_pass_one(int component_num);
+  void code_coefficients_pass_two(int component_num);
+  void code_block(int component_num);
+  void process_mcu_row();
+  bool terminate_pass_one();
+  bool terminate_pass_two();
+  bool process_end_of_image();
+  void load_mcu(const void *src);
+  void clear();
+  void init();
+};
+
+} // namespace jpge
+
+#endif // JPEG_ENCODER

include/renderd7/external/libnsbmp/libnsbmp.h

@@ -1,250 +0,0 @@
-/*
- * Copyright 2006 Richard Wilson <richard.wilson@netsurf-browser.org>
- * Copyright 2008 Sean Fox <dyntryx@gmail.com>
- *
- * This file is part of NetSurf's libnsbmp, http://www.netsurf-browser.org/
- * Licenced under the MIT License,
- *                http://www.opensource.org/licenses/mit-license.php
- */
-
-/**
- * \file
- * Bitmap file decoding interface.
- */
-
-#ifndef libnsbmp_h_
-#define libnsbmp_h_
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stddef.h>
-
-/* bmp flags */
-#define BMP_NEW			0
-/** image is opaque (as opposed to having an alpha mask) */
-#define BMP_OPAQUE		(1 << 0)
-/** memory should be wiped */
-#define BMP_CLEAR_MEMORY	(1 << 1)
-
-/**
- * error return values
- */
-typedef enum {
-        BMP_OK = 0,
-        BMP_INSUFFICIENT_MEMORY = 1,
-        BMP_INSUFFICIENT_DATA = 2,
-        BMP_DATA_ERROR = 3
-} bmp_result;
-
-/**
- * encoding types
- */
-typedef enum {
-        BMP_ENCODING_RGB = 0,
-        BMP_ENCODING_RLE8 = 1,
-        BMP_ENCODING_RLE4 = 2,
-        BMP_ENCODING_BITFIELDS = 3
-} bmp_encoding;
-
-/* API for Bitmap callbacks */
-typedef void* (*bmp_bitmap_cb_create)(int width, int height, unsigned int state);
-typedef void (*bmp_bitmap_cb_destroy)(void *bitmap);
-typedef unsigned char* (*bmp_bitmap_cb_get_buffer)(void *bitmap);
-typedef size_t (*bmp_bitmap_cb_get_bpp)(void *bitmap);
-
-/**
- * The Bitmap callbacks function table
- */
-typedef struct bmp_bitmap_callback_vt_s {
-        /** Callback to allocate bitmap storage. */
-        bmp_bitmap_cb_create bitmap_create;
-        /** Called to free bitmap storage. */
-        bmp_bitmap_cb_destroy bitmap_destroy;
-        /** Return a pointer to the pixel data in a bitmap. */
-        bmp_bitmap_cb_get_buffer bitmap_get_buffer;
-        /** Find the width of a pixel row in bytes. */
-        bmp_bitmap_cb_get_bpp bitmap_get_bpp;
-} bmp_bitmap_callback_vt;
-
-/**
- * bitmap image
- */
-typedef struct bmp_image {
-        /** callbacks for bitmap functions */
-        bmp_bitmap_callback_vt bitmap_callbacks;
-        /** pointer to BMP data */
-        uint8_t *bmp_data;
-        /** width of BMP (valid after _analyse) */
-        uint32_t width;
-        /** heigth of BMP (valid after _analyse) */
-        uint32_t height;
-        /** whether the image has been decoded */
-        bool decoded;
-        /** decoded image */
-        void *bitmap;
-
-        /* Internal members are listed below */
-        /** total number of bytes of BMP data available */
-        uint32_t buffer_size;
-        /** pixel encoding type */
-        bmp_encoding encoding;
-        /** offset of bitmap data */
-        uint32_t bitmap_offset;
-        /** bits per pixel */
-        uint16_t bpp;
-        /** number of colours */
-        uint32_t colours;
-        /** colour table */
-        uint32_t *colour_table;
-        /** whether to use bmp's limited transparency */
-        bool limited_trans;
-        /** colour to display for "transparent" pixels when using limited
-         * transparency
-         */
-        uint32_t trans_colour;
-        /** scanlines are top to bottom */
-        bool reversed;
-        /** image is part of an ICO, mask follows */
-        bool ico;
-        /** true if the bitmap does not contain an alpha channel */
-        bool opaque;
-        /** four bitwise mask */
-        uint32_t mask[4];
-        /** four bitwise shifts */
-        int32_t shift[4];
-        /** colour representing "transparency" in the bitmap */
-        uint32_t transparent_index;
-} bmp_image;
-
-typedef struct ico_image {
-        bmp_image bmp;
-        struct ico_image *next;
-} ico_image;
-
-/**
- * icon image collection
- */
-typedef struct ico_collection {
-        /** callbacks for bitmap functions */
-        bmp_bitmap_callback_vt bitmap_callbacks;
-        /** width of largest BMP */
-        uint16_t width;
-        /** heigth of largest BMP */
-        uint16_t height;
-
-        /* Internal members are listed below */
-        /** pointer to ICO data */
-        uint8_t *ico_data;
-        /** total number of bytes of ICO data available */
-        uint32_t buffer_size;
-        /** root of linked list of images */
-        ico_image *first;
-} ico_collection;
-
-/**
- * Initialises bitmap ready for analysing the bitmap.
- *
- * \param bmp The Bitmap to initialise
- * \param callbacks The callbacks the library will call on operations.
- * \return BMP_OK on success or appropriate error code.
- */
-bmp_result bmp_create(bmp_image *bmp, bmp_bitmap_callback_vt *callbacks);
-
-/**
- * Initialises icon ready for analysing the icon
- *
- * \param bmp The Bitmap to initialise
- * \param callbacks The callbacks the library will call on operations.
- * \return BMP_OK on success or appropriate error code.
- */
-bmp_result ico_collection_create(ico_collection *ico,
-                                 bmp_bitmap_callback_vt *callbacks);
-
-/**
- * Analyse a BMP prior to decoding.
- *
- * This will scan the data provided and perform checks to ensure the data is a
- * valid BMP and prepare the bitmap image structure ready for decode.
- *
- * This function must be called and resturn BMP_OK before bmp_decode() as it
- * prepares the bmp internal state for the decode process.
- *
- * \param bmp the BMP image to analyse.
- * \param size The size of data in cdata.
- * \param data The bitmap source data.
- * \return BMP_OK on success or error code on faliure.
- */
-bmp_result bmp_analyse(bmp_image *bmp, size_t size, uint8_t *data);
-
-/**
- * Analyse an ICO prior to decoding.
- *
- * This function will scan the data provided and perform checks to ensure the
- * data is a valid ICO.
- *
- * This function must be called before ico_find().
- *
- * \param ico the ICO image to analyse
- * \param size The size of data in cdata.
- * \param data The bitmap source data.
- * \return BMP_OK on success
- */
-bmp_result ico_analyse(ico_collection *ico, size_t size, uint8_t *data);
-
-/**
- * Decode a BMP
- *
- * This function decodes the BMP data such that bmp->bitmap is a valid
- * image. The state of bmp->decoded is set to TRUE on exit such that it
- * can easily be identified which BMPs are in a fully decoded state.
- *
- * \param bmp the BMP image to decode
- * \return BMP_OK on success
- */
-bmp_result bmp_decode(bmp_image *bmp);
-
-/**
- * Decode a BMP using "limited transparency"
- *
- * Bitmaps do not have native transparency support.  However, there is a
- * "trick" that is used in some instances in which the first pixel of the
- * bitmap becomes the "transparency index".  The decoding application can
- * replace this index with whatever background colour it chooses to
- * create the illusion of transparency.
- *
- * When to use transparency is at the discretion of the decoding
- * application.
- *
- * \param bmp the BMP image to decode
- * \param colour the colour to use as "transparent"
- * \return BMP_OK on success
- */
-bmp_result bmp_decode_trans(bmp_image *bmp, uint32_t transparent_colour);
-
-/**
- * Finds the closest BMP within an ICO collection
- *
- * This function finds the BMP with dimensions as close to a specified set
- * as possible from the images in the collection.
- *
- * \param ico the ICO collection to examine
- * \param width the preferred width (0 to use ICO header width)
- * \param height the preferred height (0 to use ICO header height)
- */
-bmp_image *ico_find(ico_collection *ico, uint16_t width, uint16_t height);
-
-/**
- * Finalise a BMP prior to destruction.
- *
- * \param bmp the BMP image to finalise.
- */
-void bmp_finalise(bmp_image *bmp);
-
-/**
- * Finalise an ICO prior to destruction.
- *
- * \param ico the ICO image to finalise,
- */
-void ico_finalise(ico_collection *ico);
-
-#endif

include/renderd7/external/libnsbmp/log.h

@@ -1,27 +0,0 @@
-/*
- * Copyright 2003 James Bursa <bursa@users.sourceforge.net>
- * Copyright 2004 John Tytgat <John.Tytgat@aaug.net>
- *
- * This file is part of NetSurf, http://www.netsurf-browser.org/
- * Licenced under the MIT License,
- *                http://www.opensource.org/licenses/mit-license.php
- */
-
-#include <stdio.h>
-
-#ifndef _LIBNSBMP_LOG_H_
-#define _LIBNSBMP_LOG_H_
-
-#ifdef NDEBUG
-#  define LOG(x) ((void) 0)
-#else
-#  ifdef __GNUC__
-#    define LOG(x) do { printf x, fputc('\n', stdout)); } while (0)
-#  elif defined(__CC_NORCROFT)
-#    define LOG(x) do { printf x, fputc('\n', stdout)); } while (0)
-#  else
-#    define LOG(x) do { printf x, fputc('\n', stdout)); } while (0)
-#  endif
-#endif
-
-#endif

include/renderd7/external/nvid.hpp

@@ -0,0 +1,222 @@
+#pragma once
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <memory.h>
+#include <memory>
+#include <renderd7/external/jpgd.h>
+#include <renderd7/external/jpge.h>
+#include <sstream>
+#include <vector>
+
+struct NVID_Header {
+  char magic[4];       // Magic
+  int framerate;       // Only Up to 60
+  int width;           // Width
+  int height;          // Height
+  uint32_t framecount; // Count of Frames
+};
+
+struct NVID_Frame {
+  char magic[4];      // Magic
+  uint32_t framesize; // Size of Frame
+};
+
+struct NVID_Image {
+  int framenum; // Register of Frame
+  int w;        // Width of Frame
+  int h;        // Height of Frame
+  int bpp;      // bpp of Frame
+  void *pBuf;   // Buffer
+};
+
+inline void CreateHeader(NVID_Header &header) {
+  header.magic[0] = 'N';
+  header.magic[1] = 'V';
+  header.magic[2] = 'I';
+  header.magic[3] = 'D';
+}
+
+inline void CreateFrame(NVID_Frame &frame) {
+  frame.magic[0] = 'N';
+  frame.magic[1] = 'F';
+  frame.magic[2] = 'R';
+  frame.magic[3] = 'M';
+}
+
+inline bool CheckHeader(NVID_Header &header) {
+  if (header.magic[0] == 'N' && header.magic[1] == 'V' &&
+      header.magic[2] == 'I' && header.magic[3] == 'D')
+    return true;
+
+  return false;
+}
+
+inline bool CheckFrame(NVID_Frame &frame) {
+  if (frame.magic[0] == 'N' && frame.magic[1] == 'F' && frame.magic[2] == 'R' &&
+      frame.magic[3] == 'M')
+    return true;
+
+  return false;
+}
+
+inline std::vector<std::unique_ptr<NVID_Image>>
+LoadNVID(const std::string &path) {
+  std::vector<std::unique_ptr<NVID_Image>> res;
+  std::ifstream nvid_file(path, std::ios::binary | std::ios::in);
+  if (!nvid_file) {
+    std::cerr << "Failed to open NVID file: " << path << std::endl;
+    return res;
+  }
+
+  NVID_Header header;
+  nvid_file.read(reinterpret_cast<char *>(&header), sizeof(header));
+  if (!CheckHeader(header)) {
+    std::cerr << "Invalid NVID header" << std::endl;
+    return res;
+  }
+
+  for (int i = 0; i < (int)header.framecount; i++) {
+    NVID_Frame frame;
+    nvid_file.read(reinterpret_cast<char *>(&frame), sizeof(frame));
+    if (!CheckFrame(frame)) {
+      std::cerr << "Invalid NVID frame" << std::endl;
+      return res;
+    }
+
+    std::vector<uint8_t> compressed_data(frame.framesize);
+    nvid_file.read(reinterpret_cast<char *>(compressed_data.data()),
+                   compressed_data.size());
+
+    int width, height, components;
+    unsigned char *decompressed_data = jpgd::decompress_jpeg_image_from_memory(
+        compressed_data.data(), compressed_data.size(), &width, &height,
+        &components, 3);
+    if (!decompressed_data) {
+      std::cerr << "Failed to decompress JPEG data" << std::endl;
+      return res;
+    }
+
+    auto image = std::make_unique<NVID_Image>();
+    image->bpp = components;
+    image->w = width;
+    image->h = height;
+    image->framenum = i;
+    image->pBuf = decompressed_data;
+
+    res.push_back(std::move(image));
+  }
+
+  return res;
+}
+
+inline std::vector<std::unique_ptr<NVID_Image>> LoadMemNVID(const void *data,
+                                                            size_t size) {
+  std::vector<std::unique_ptr<NVID_Image>> res;
+  std::istringstream nvid_stream(
+      std::string(reinterpret_cast<const char *>(data), size));
+  NVID_Header header;
+  nvid_stream.read(reinterpret_cast<char *>(&header), sizeof(header));
+  if (!CheckHeader(header)) {
+    std::cerr << "Invalid NVID header" << std::endl;
+    return res;
+  }
+  for (int i = 0; i < (int)header.framecount; i++) {
+    NVID_Frame frame;
+    nvid_stream.read(reinterpret_cast<char *>(&frame), sizeof(frame));
+    if (!CheckFrame(frame)) {
+      std::cerr << "Invalid NVID frame" << std::endl;
+      return res;
+    }
+    std::vector<uint8_t> compressed_data(frame.framesize);
+    nvid_stream.read(reinterpret_cast<char *>(compressed_data.data()),
+                     compressed_data.size());
+    int width, height, components;
+    unsigned char *decompressed_data = jpgd::decompress_jpeg_image_from_memory(
+        compressed_data.data(), compressed_data.size(), &width, &height,
+        &components, 3);
+    if (!decompressed_data) {
+      std::cerr << "Failed to decompress JPEG data" << std::endl;
+      return res;
+    }
+    auto image = std::make_unique<NVID_Image>();
+    image->bpp = components;
+    image->w = width;
+    image->h = height;
+    image->framenum = i;
+    image->pBuf = decompressed_data;
+    res.push_back(std::move(image));
+  }
+  return res;
+}
+
+class NVID_Stream {
+public:
+  NVID_Stream(const std::string &path)
+      : file_(path, std::ios::binary | std::ios::in) {
+    if (!file_) {
+      std::cout << "Failed to open NVID file: " << path << std::endl;
+      return;
+    } else {
+      file_.read(reinterpret_cast<char *>(&header_), sizeof(header_));
+      if (!CheckHeader(header_)) {
+        std::cout << "Invalid NVID header" << std::endl;
+        return;
+      }
+    }
+  }
+
+  NVID_Stream(const void *data, std::size_t size) {
+    if (!data || size < sizeof(header_)) {
+      std::cout << "Invalid NVID data" << std::endl;
+      return;
+    } else {
+      memcpy(&header_, data, sizeof(header_));
+      if (!CheckHeader(header_)) {
+        std::cout << "Invalid NVID header" << std::endl;
+        return;
+      }
+    }
+  }
+
+  ~NVID_Stream() { file_.close(); }
+
+  bool ReadNext(NVID_Image &image) {
+    if (!file_) {
+      return false;
+    }
+
+    NVID_Frame frame;
+    file_.read(reinterpret_cast<char *>(&frame), sizeof(frame));
+    if (!CheckFrame(frame)) {
+      std::cout << "Invalid NVID frame" << std::endl;
+      return false;
+    }
+
+    std::vector<uint8_t> compressed_data(frame.framesize);
+    file_.read(reinterpret_cast<char *>(compressed_data.data()),
+               compressed_data.size());
+
+    int width, height, components;
+    unsigned char *decompressed_data = jpgd::decompress_jpeg_image_from_memory(
+        compressed_data.data(), compressed_data.size(), &width, &height,
+        &components, 3);
+    if (!decompressed_data) {
+      std::cout << "Failed to decompress JPEG data" << std::endl;
+      return false;
+    }
+
+    image.bpp = components;
+    image.w = width;
+    image.h = height;
+    image.framenum = current_frame_++;
+    image.pBuf = decompressed_data;
+
+    return true;
+  }
+
+private:
+  std::ifstream file_;
+  NVID_Header header_;
+  int current_frame_ = 0;
+};

include/renderd7/lang.hpp

@@ -1,16 +1,18 @@
 #pragma once
-#include <string>
 #include <renderd7/external/json.hpp>
+#include <string>
 
-/// RenderD7::Lang
+namespace RenderD7 {
-namespace RenderD7::Lang
+namespace Lang {
-{
+/// @brief Get 3ds System lang! [en] by default
-    /// Get the 3ds System Language
+/// @return Sytemlang as string
-    std::string getSys();
+std::string getSys();
-    /// Get a translated string
+/// @brief Get The Translation String
-    /// \param key The Key so the code can find your string
+/// @param key Key of Translation
-    std::string get(const std::string &key);
+/// @return The Translated String
-        /// Load the lang file from dir structure en/app.json for sample
+std::string get(const std::string &key);
-        /// \param lang the folder name en, fr, de ... . I prefer geSys()
+/// @brief Load A Language json
-	void load(const std::string &lang);
+/// @param lang The Language Key [en], [de], etc, or getSys()
-} /// RenderD7::Lang
+void load(const std::string &lang);
+} // namespace Lang
+} // namespace RenderD7

include/renderd7/log.hpp

@@ -5,26 +5,29 @@
 #include <time.h>
 #include <unistd.h>
 
-/** Log Class */
+/// @brief Log Class
-class Log
+class Log {
-{
+public:
-	public:
+  /// @brief Constructor
-                /** Construct */
+  Log();
-		Log();
+  /// @brief Deconstructor
-                /** Deconstruct */
+  ~Log();
-		~Log();
+  /// @brief Init the Logger
-                /// Init the log file
+  /// @param filename Filename[_data_time.log]
-                /// \param filename name for the file
+  void Init(const char *filename);
-		void Init(const char *filename);
+  /// @brief Write a String to the File
-                /// Write Text to logfile
+  /// @param debug_text string
-                /// \param debug_text your text
+  void Write(std::string debug_text);
-		void Write(std::string debug_text);
+  /// @brief Get the Date
-                /// Get the date
+  /// @return Date as string fmt[data_time]
-		std::string logDate(void);
+  std::string logDate(void);
-                /// Format to logstyle
+  /// @brief Format a string like sprintf
-                /// \param fmt_str the formatted style
+  /// @param fmt_str the string wich defines the fmt
-		std::string format(const std::string& fmt_str, ...);
+  /// @param ... Additional Data
-	private:
+  /// @return Formatted String
-                /// \param filename the name of the logfile
+  std::string format(const std::string &fmt_str, ...);
-		std::string filename;
+
+private:
+  /// \param filename the name of the logfile
+  std::string filename;
 };

include/renderd7/npi_intro.hpp

@@ -0,0 +1,5 @@
+#pragma once
+#include <cstddef>
+
+extern unsigned char npi_intro[];
+extern size_t npi_intro_size;

include/renderd7/parameter.hpp

@@ -1,112 +1,118 @@
 #pragma once
 #include <tuple>
 
-namespace RenderD7{
+namespace RenderD7 {
-    class Parameter
+class Parameter {
-    {
+private:
-    private:
+  using id = size_t;
-        using id = size_t;
 
-        template<typename T>
+  template <typename T> struct type {
-        struct type { static void id() { } };
+    static void id() {}
+  };
 
-        template<typename T>
+  template <typename T> static id type_id() {
-        static id type_id() { return reinterpret_cast<id>(&type<T>::id); }
+    return reinterpret_cast<id>(&type<T>::id);
+  }
 
-        template<typename T>
+  template <typename T> using decay = typename std::decay<T>::type;
-        using decay = typename std::decay<T>::type;
 
-        template<typename T>
+  template <typename T>
-        using none = typename std::enable_if<!std::is_same<Parameter, T>::value>::type;
+  using none =
+      typename std::enable_if<!std::is_same<Parameter, T>::value>::type;
 
-        struct base
+  struct base {
-        {
+    virtual ~base() {}
-            virtual ~base() { }
+    virtual bool is(id) const = 0;
-            virtual bool is(id) const = 0;
+    virtual base *copy() const = 0;
-            virtual base *copy() const = 0;
+  } *p = nullptr;
-        } *p = nullptr;
 
-        template<typename T>
+  template <typename T> struct data : base, std::tuple<T> {
-        struct data : base, std::tuple<T>
+    using std::tuple<T>::tuple;
-        {
-            using std::tuple<T>::tuple;
 
-            T       &get()      & { return std::get<0>(*this); }
+    T &get() & { return std::get<0>(*this); }
-            T const &get() const& { return std::get<0>(*this); }
+    T const &get() const & { return std::get<0>(*this); }
 
-            bool is(id i) const override { return i == type_id<T>(); }
+    bool is(id i) const override { return i == type_id<T>(); }
-            base *copy()  const override { return new data{get()}; }
+    base *copy() const override { return new data{get()}; }
-        };
+  };
 
-        template<typename T>
+  template <typename T> T &stat() { return static_cast<data<T> &>(*p).get(); }
-        T &stat() { return static_cast<data<T>&>(*p).get(); }
 
-        template<typename T>
+  template <typename T> T const &stat() const {
-        T const &stat() const { return static_cast<data<T> const&>(*p).get(); }
+    return static_cast<data<T> const &>(*p).get();
+  }
 
-        template<typename T>
+  template <typename T> T &dyn() { return dynamic_cast<data<T> &>(*p).get(); }
-        T &dyn() { return dynamic_cast<data<T>&>(*p).get(); }
 
-        template<typename T>
+  template <typename T> T const &dyn() const {
-        T const &dyn() const { return dynamic_cast<data<T> const&>(*p).get(); }
+    return dynamic_cast<data<T> const &>(*p).get();
+  }
 
-    public:
+public:
-        /**
+  /**
-         * @brief Default constructor
+   * @brief Default constructor
-         */
+   */
-         Parameter() { }
+  Parameter() {}
 
-         /**
+  /**
-          * @brief Destructs the Parameter
+   * @brief Destructs the Parameter
-          */
+   */
-        ~Parameter() { delete p; }
+  ~Parameter() { delete p; }
 
-        /**
+  /**
-         * @brief Copy constructor
+   * @brief Copy constructor
-         * @param s The Parameter to copy
+   * @param s The Parameter to copy
-         */
+   */
-        Parameter(Parameter &&s) : p{s.p} { s.p = nullptr; }
+  Parameter(Parameter &&s) : p{s.p} { s.p = nullptr; }
 
-        /**
+  /**
-         * @brief Const copy constructor
+   * @brief Const copy constructor
-         * @param s The Parameter to copy
+   * @param s The Parameter to copy
-         */
+   */
-        Parameter(Parameter const &s) : p{s.p->copy()} { }
+  Parameter(Parameter const &s) : p{s.p->copy()} {}
 
-        /**
+  /**
-         * @brief Initializes the Parameter with the given value
+   * @brief Initializes the Parameter with the given value
-         * @param x The value to initialize the Parameter with
+   * @param x The value to initialize the Parameter with
-         */
+   */
-        template<typename T, typename U = decay<T>, typename = none<U>>
+  template <typename T, typename U = decay<T>, typename = none<U>>
-        Parameter(T &&x) : p{new data<U>{std::forward<T>(x)}} { }
+  Parameter(T &&x) : p{new data<U>{std::forward<T>(x)}} {}
 
-        /**
+  /**
-         * @brief Overloads the assignment operator
+   * @brief Overloads the assignment operator
-         * @param s The value to set the Parameter to
+   * @param s The value to set the Parameter to
-         */
+   */
-        Parameter &operator=(Parameter s) { swap(*this, s); return *this; }
+  Parameter &operator=(Parameter s) {
+    swap(*this, s);
+    return *this;
+  }
 
-        friend void swap(Parameter &s, Parameter &r) { std::swap(s.p, r.p); }
+  friend void swap(Parameter &s, Parameter &r) { std::swap(s.p, r.p); }
 
-        /**
+  /**
-         * @brief Clears the Parameter
+   * @brief Clears the Parameter
-         */
+   */
-        void clear() { delete p; p = nullptr; }
+  void clear() {
+    delete p;
+    p = nullptr;
+  }
 
-        /**
+  /**
-         * @brief Checks whether the Parameter is the given type
+   * @brief Checks whether the Parameter is the given type
-         * @tparam T The type to check
+   * @tparam T The type to check
-         * @return   Whether the Parameter has the given type or not
+   * @return   Whether the Parameter has the given type or not
-         */
+   */
-        template<typename T>
+  template <typename T> bool is() const {
-        bool is() const { return p ? p->is(type_id<T>()) : false; }
+    return p ? p->is(type_id<T>()) : false;
+  }
 
-        /**
+  /**
-         * @brief Returns the value of the Parameter
+   * @brief Returns the value of the Parameter
-         * @tparam T The type of the Parameter
+   * @tparam T The type of the Parameter
-         * @return The value of the Parameter
+   * @return The value of the Parameter
-         * @warning If the type of the Parameter doesn't match the type of it's stored value, it will result in undefined behaviour.
+   * @warning If the type of the Parameter doesn't match the type of it's stored
-         */
+   * value, it will result in undefined behaviour.
-        template<typename T> T &get() & { return stat<T>(); }
+   */
-    };
+  template <typename T> T &get() & { return stat<T>(); }
-} 
+};
+} // namespace RenderD7

include/renderd7/renderd7.hpp

@@ -1,448 +1,420 @@
 #pragma once
+/// c++ Includes
+#include <algorithm>
+#include <codecvt>
+#include <cstring>
+#include <filesystem>
+#include <functional>
+#include <iostream>
+#include <locale>
+#include <map>
+#include <memory>
+#include <random>
+#include <stack>
+#include <string>
+#include <vector>
+/// c includes
+#include <dirent.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+/// 3ds Includes
 #include <3ds.h>
 #include <citro2d.h>
 #include <citro3d.h>
-#include <memory>
+/// RenderD7 Includes
-#include <stack>
+#include <renderd7/BitmapPrinter.hpp>
-#include <string>
+#include <renderd7/Color.hpp>
-#include <functional>
+#include <renderd7/Draw.hpp>
-#include <map>
+#include <renderd7/FunctionTrace.hpp>
-#include <vector>
+#include <renderd7/Hardware.hpp>
-#include <dirent.h>
+#include <renderd7/Image.hpp>
-#include <unistd.h>
+#include <renderd7/Memory.hpp>
-#include <stdio.h>
+#include <renderd7/Ovl.hpp>
-#include <cstring>
+#include <renderd7/ResultDecoder.hpp>
-#include <random>
+#include <renderd7/Screen.hpp>
-#include <sys/stat.h>
+#include <renderd7/Security.hpp>
-#include <algorithm>
+#include <renderd7/Sheet.hpp>
-#include <iostream>
+#include <renderd7/Sprite.hpp>
-#include <filesystem>
+#include <renderd7/SpriteAnimation.hpp>
-#include <locale>
+#include <renderd7/Tasks.hpp>
-#include <time.h>
+#include <renderd7/Time.hpp>
-
+#include <renderd7/Toast.hpp>
-#include <codecvt>
-
-#include <renderd7/external/lodepng.h>
-#include <renderd7/lang.hpp>
-#include <renderd7/parameter.hpp>
-#include <renderd7/thread.hpp>
-#include <renderd7/ini.hpp>
-#include <renderd7/stringtool.hpp>
-#include <renderd7/Clock.hpp>
 #include <renderd7/bmp.hpp>
 #include <renderd7/bmpconverter.hpp>
+#include <renderd7/external/lodepng.h>
+#include <renderd7/ini.hpp>
+#include <renderd7/lang.hpp>
+#include <renderd7/parameter.hpp>
+#include <renderd7/stringtool.hpp>
+#include <renderd7/thread.hpp>
 
-extern "C"
+#define RENDERD7VSTRING "0.9.4"
-{
+#define CHANGELOG                                                              \
-    #include <renderd7/external/fs.h>
+  "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 "                                                            \
+  "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 RENDERD7VSTRING "0.8.0"
-#define CHANGELOG "0.8.0: Implement BitmapPrinter\n0.7.3: Implement Over Render Overlay Framework\n0.7.2: Implement MT to csv file saving. Add RGB2HEX. \n0.7.1: Add the New Overlay Handler. Its Just in code and does nothing yet. \n0.7.0: Made Big Progress In the MT Ovl but it still crashes On a Scnd C3D_FrameEnd(). Implement 800px but doesn't work that good. \n0.6.2: Fix Crash when exiting trouth Home Menu.  \n0.6.10: rewrite Threadsystem, Improve framerate\n0.6.02: Fix Code in lang.hpp\nadd Draw Text Left Function.\nadd changelog\n0.6.01: add Threading system."
 #define DEFAULT_CENTER 0.5f
 
-extern C3D_RenderTarget* Top;
+#define RD7_DEPRECATED // __attribute__ ((deprecated))
-extern C3D_RenderTarget* TopRight;
-extern C3D_RenderTarget* Bottom;
 
+/// @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;
+
 /// RenderD7
-namespace RenderD7
+namespace RenderD7 {
-{
+/// @brief Get Deltatime
-    float GetDeltaTime();
+/// @return Deltatime
-    enum kbd{
+float GetDeltaTime();
-         SWKBD,
+/// @brief Keyboard
-         BKBD
+enum kbd {
-    };
+  /// @brief libctru Keyboard
-    enum kbd_type
+  SWKBD,
-    {
+  /// @brief Unk (Not Usable)
-         NUMPAD,
+  BKBD
-         STANDARD
+};
-    };
+/// @brief Keyboar Type
-    struct TObject
+enum kbd_type { NUMPAD, STANDARD };
-    {
+/// @brief A Button
-        int x; //Position X
+struct TObject {
-        int y; //Position Y
+  int x;                 ///< Position X
-        int w; //Button Width
+  int y;                 ///< Position Y
-        int h; //Button Height
+  int w;                 ///< Button Width
-        std::string text = ""; //Text
+  int h;                 ///< Button Height
-        float correctx = 0; //Correct X Position
+  std::string text = ""; ///< Text
-        float correcty = 0; //Correct Y Position
+  float txtsize = 0.7f;  ///< Set Text Size
-        float txtsize = 0.7f;  //Set Text Size
+};
-    };
+/// @brief Scene Class
-    /// Set current RenderScreen
+class Scene {
-    /// \param target The RenderTarget Top, Bottom
+public:
-    void OnScreen(C3D_RenderTarget *target);
+  /// @brief Stack of the Scenes
-    /** The Spritesheet Class */
+  static std::stack<std::unique_ptr<Scene>> scenes;
-    class Sheet
+  /// @brief Deconstructor
-    {
+  virtual ~Scene() {}
-        public:
+  /// @brief Logic To Overide
-        /// Construct sheet
+  /// @param hDown Key Down
-        Sheet();
+  /// @param hHeld Key Held
-        // Deconstruct sheet
+  /// @param hUp Key Up
-        ~Sheet();
+  /// @param touch Touch Position
-        /// Load a Sritesheet
+  virtual void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) = 0;
-        /// \param path Path to the Spritesheet (.t3x)
+  /// @brief Draw Func to Override
-        Result Load(const char *path);
+  virtual void Draw() const = 0;
-        /// Unload the Spritesheet
+  /// @brief Push a Scene to Stack
-        void Free();
+  /// @param scene Scene to Push
-        /// The Spritesheet
+  /// @param fade FadeEffect (Not Correctly Implementet yet)
-        C2D_SpriteSheet spritesheet;
+  static void Load(std::unique_ptr<Scene> scene, bool fade = false);
-    };
+  /// @brief Go Back a Scene
-    /// Image Class
+  static void Back();
-    class Image
+  /// @brief do the Draw (Called in RenderD7::MainLoop())
-    {
+  static void doDraw();
-        public:
+  /// @brief do the Logic (Called in RenderD7::MainLoop())
-        ~Image();
+  /// @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);
+};
 
-        void Unload();
+/// @brief Integrated Setting Menu of RenderD7
-        /// Load Image from Png
+class RSettings : public RenderD7::Scene {
-        /// \param path path to png file
+private:
-        void LoadPng(const std::string path);
+  /// @brief Calculate the Changelog Screen Stuff
-        /// Load the Image from buffer
+  /// @param lines vector of Lines
-        /// \param buffer the frame buffer
+  /// @param screen_index Current Screen
-        void LoadPFromBuffer(const std::vector<u8> &buffer);
+  /// @param screens Count of Possible Screens
-        void LoadFromBitmap(BMP bitmap);
+  void calculate_screens(const std::vector<std::string> &lines,
-        /// Draw the Image directly
+                         int &screen_index, int &screens);
-        /// \param x The x position
+  /// @brief State (Define for Menus)
-        /// \param y the y position
+  enum RState {
-        /// \param scaleX x scale from 0.0 to 1.0
+    RSETTINGS,
-        /// \param scaleY y scale from 0.0 to 1.0
+    RINFO,
-        bool Draw(float x, float y, float scaleX = 1.0f, float scaleY = 1.0f);
+    RSERVICES,
-        /// \brief Get The Image
+    RCLOG,
-        /// \return C2D_Image
+    RMCONFIG,
-        C2D_Image Get(){return this->img;}
+    RFTRACE,
+    RSECM,
+    RCREDITS
+  };
+  /// @param m_state Current menu State (Default=MainMenu aka RSETTINGS)
+  RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS;
 
-        void FromSheet(RenderD7::Sheet sheet, size_t index);
+  /// @param screens Count of Changelog Screens
-        /// \param img this is the C2D_Image
+  int screens = 0;
-        C2D_Image img;
+  /// @param screen_index Current Changelog Screen
-        /// \param loadet whether the image is loadet or not
+  int screen_index = 0;
-        bool loadet = false;
+  /// @param lines Vector of Changelog-Lines
-    };
+  std::vector<std::string> lines;
-    /// Sprite Class
+  /// @brief Position in FTrace Menu
-    class Sprite
+  int ftrace_index = 0;
-    {
-        public:
-        /// \brief Construct Sprite
-        Sprite();
-        /// \brief Deconstruct Sprite
-        ~Sprite();
-        /// \brief Load a Sprite From SpriteSheet
-        /// \param sheet the Sheet to load from.(RenderD7::Sheet)
-        /// \param index the number of the Sprite in the Sheet
-        void FromSheet(RenderD7::Sheet *sheet, size_t index);
-        /// \brief Load a Sprite From SpriteSheet
-        /// \param img the Image to load from.(RenderD7::Image)
-        void FromImage(RenderD7::Image *img);
-        bool Draw();
-        void SetCenter(float x, float y);
-        void SetPos(float x, float y);
-        void SetScale(float x, float y);
-        void SetRotation(float rotation);
-        void Rotate(float speed);
-        float getWidth();
-        float getHeigh();
-        float getPosX();
-        float getPosY();
-        private:
-        C2D_ImageTint tint;
-        C2D_Sprite sprite;
-    };
 
-    class Scene {
+  /// @param mtovlstate State of Metricks Overlay
-    public:
+  std::string mtovlstate = "false";
-        static std::stack<std::unique_ptr<Scene>> scenes;
+  /// @param mtscreenstate Screen the Overlay is Set to
-    	virtual ~Scene() {}
+  std::string mtscreenstate = "Top";
-    	virtual void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) = 0;
-    	virtual void Draw() const = 0;
-        //virtual void Ovl() const = 0;
-        static void Load(std::unique_ptr<Scene> scene, bool fade = false);
-        static void Back();
-        static void doDraw();
-        static void doLogic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch);
-        //static void HandleOvl();
-    };
 
-    class RSettings : public RenderD7::Scene
+  /// @param buttons Vector of Buttons
-    {
+  std::vector<RenderD7::TObject> buttons = {
-    private:
+      {20, 35, 120, 35, "NotYET"},      {20, 85, 120, 35, "Changelog"},
-        enum RState {
+      {20, 135, 120, 35, "Metrik-Ovl"}, {20, 185, 120, 35, "Tasks"},
-            RSETTINGS,
+      {180, 35, 120, 35, "FTrace"},     {180, 85, 120, 35, "Credits"},
-            RINFO
+      {180, 135, 120, 35, "Info"},      {180, 185, 120, 35, "Security"}};
-        };
-        RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS;
 
-        std::string rd7srstate = "false";
+public:
-        std::string csvstate = "false";
+  /// @brief Constructor
-        std::string mtovlstate = "false";
+  RSettings();
-        std::string fpsstate = "60";
+  /// @brief Override for Draw
-        std::string mtscreenstate = "Top";
+  /// @param
-        std::string mttxtcolstate = "#ffffff";
+  void Draw(void) const override;
-        std::string mtcola = "255";
+  /// @brief Deconstructor
-        std::string mttxtcola = "255";
+  ~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;
+};
 
-        
+/// @brief Show Up the RenderD7-Settings Menu
-        std::vector<RenderD7::TObject> buttons = 
+void LoadSettings();
-        {
-            {20, 35, 120, 35, "RD7SR", -11, 10},
-            {20, 85, 120, 35, "MT_CSV", -15, 9},
-            {20, 135, 120, 35, "MT_OVL", -19, 10},
-            {20, 185, 120, 35, "FPS", 6, 10},
-            {180, 35, 120, 35, "MTSCREEN", -29, 10},
-            {180, 85, 120, 35, "DSPERR", -13, 10},
-            {180, 135, 120, 35, "INFO", 2, 10},
-            {180, 185, 120, 35, "", -13, 10}
-        };
-    public:
-        RSettings();
-        void Draw(void) const override;
-        ~RSettings();
-        void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) override;
-    };
 
-    void LoadSettings();
+/// @brief DspNotFound Error Toast (Deprectated)
+class DSP_NF : public RenderD7::Ovl {
+public:
+  /// @brief Constructor
+  DSP_NF();
+  /// @brief Override for Draw
+  void Draw(void) const override;
+  /// @brief Override for Logic
+  void Logic() override;
 
-    class Ovl {
+private:
-        public:
+  /// @param msgposy Y Position of Toast
-        virtual ~Ovl(){}
+  int msgposy = 240;
-        virtual void Draw() const = 0;
+  /// @param delay Delay of Toast
-        virtual void Logic() = 0;
+  int delay = 0;
-        inline bool IsKilled() {return this->iskilled; }
+};
-        inline void Kill() { iskilled = true; }
-        private:
-        bool iskilled = false;
-    };
 
-    class DSP_NF : public RenderD7::Ovl
+/// @brief Get A Rendom Int
-    {
+/// @param b From
-        public:
+/// @param e To
-        DSP_NF();
+/// @return Random Int
-        void Draw(void) const override;
+int GetRandomInt(int b, int e);
-        void Logic() override;
+/// @brief Short a String with (..,)
-        private:
+/// @param in Input string
-        int msgposy = 240;
+/// @param size Size of Input Text
-        int delay = 0;
+/// @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
+/// @param sheet Spritesheet
+/// @param index Image index Value
+/// @param x Pos X
+/// @param y Pos Y
+/// @param scaleX Scale on X-Axis
+/// @param scaleY Scale on Y-Axis
+/// @return success ?
+bool DrawImageFromSheet(RenderD7::Sheet *sheet, size_t index, float x, float y,
+                        float scaleX = 1.0, float scaleY = 1.0);
+/// @brief Display the Npi-D7 Video Intro (NVID)
+void DoNpiIntro();
+/// @brief Fade In
+/// @param duration Duration in Frames
+void FadeIn();
+/// @brief Fade Out
+/// @param duration Duration in Frames
+void FadeOut();
+/// @brief Display Fade Effects
+void FadeDisplay();
 
-    class Toast : public RenderD7::Ovl
+namespace Error {
-    {
+/// @brief DEPRECATED Display Error for n Seconds
-        public:
+/// @param toptext Head Text
-        Toast(std::string head, std::string msg);
+/// @param errortext Error Text
-        void Draw(void) const override;
+/// @param timesec Time n to Display in Seconds
-        void Logic() override;
+void DisplayError(std::string toptext, std::string errortext, int timesec = 3);
-        private:
+/// @brief Display A Fatal Error
-        std::string head, msg;
+/// @param toptext Head Text
-        int msgposy = 240;
+/// @param errortext Error Text
-        int delay = 0;
+void DisplayFatalError(std::string toptext, std::string errortext);
-    };
+} // namespace Error
 
-    void AddOvl(std::unique_ptr<RenderD7::Ovl> scene);
+namespace Init {
-    namespace Color
+/// @brief Init Default RenderD7
-    {
+/// @param app_name Name of Your App
-        struct rgba
+/// @return ResCode
-        {
+Result Main(std::string app_name = "RD7Game");
-            u8 r, g, b, a;
+/// @brief Init Minimal RenderD7 (For better Hax2.x support)
-        };
+/// @param app_name Name of Your App
-        class RGBA{
+/// @return ResCode
-            public:
+Result Minimal(std::string app_name = "RD7Game");
-            RGBA(u8 r, u8 g, u8 b, u8 a) : m_r(r),m_g(g),m_b(b),m_a(a){}
+/// @brief Reload the Graphics Engine
-            u32 toRGBA() const {return (m_r << 24) | (m_g << 16) | (m_b << 8) | m_a;}
+/// @return ResCode
-            
+Result Reload();
-            u8 m_r, m_g ,m_b, m_a;
+/// @brief Init Graphics Only (NOT SUPPORTET use Reload)
-        };
+void Graphics();
-        std::string RGB2Hex(int r, int g, int b);
+/// @brief Init Ndsp for Sounds
-        u32 Hex(const std::string color, u8 a = 255);
+void NdspFirm();
-    }
+} // namespace Init
-    int GetRandomInt(int b, int e);
-    void DrawMetrikOvl();
-    bool DrawImageFromSheet(RenderD7::Sheet* sheet, size_t index, float x, float y, float scaleX = 1.0, float scaleY = 1.0);
-    namespace Error
-    {
-        void DisplayError(std::string toptext, std::string errortext, int timesec = 3);
-        void DisplayFatalError(std::string toptext, std::string errortext);
-    }
-    namespace Init
-    {
-        Result Main(std::string app_name = "RD7Game");
-        Result Reload();
-        void Graphics();
-        void NdspFirm(bool useit = false);
-    }
-    namespace Exit
-    {
-        void Main();
-        void NdspFirm();
-        void Graphics();
-    }
-    namespace Msg
-    {
-        void Display(std::string titletxt, std::string subtext, C3D_RenderTarget *target);
-        void DisplayWithProgress(std::string titletext, std::string subtext, float current, float total, u32 prgbarcolor);
-    }
-    
-    namespace Convert
-    {
-        inline float StringtoFloat(std::string inp){return std::atof(inp.c_str());}
-        inline int StringtoInt(std::string inp){return std::atoi(inp.c_str());}
-        inline bool FloatToBool(float inp){if(inp == 1)return true; else return false;}
-    }
 
-    struct DirContent
+namespace Msg {
-    {
+/// @brief Display A Message
-        std::string name;
+/// @param titletxt Header Text
-        std::string path;
+/// @param subtext Message Text
-        bool isDir;
+/// @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 FS
+namespace Convert {
-    {
+/// @brief Convert a String to Flaot
-        bool FileExist(const std::string& path);
+/// @param inp Input String
-    }
+/// @return Float
-    
+inline float StringtoFloat(std::string inp) { return std::atof(inp.c_str()); }
-    bool IsNdspInit();
+/// @brief Convert String to Int
-    void SetupLog(void);
+/// @param inp Input String
-    std::string GetFramerate();
+/// @return Int
-    bool MainLoop();
+inline int StringtoInt(std::string inp) { return std::atoi(inp.c_str()); }
-    void ExitApp();
+/// @brief Convert a Float to Bool
-    
+/// @param inp Input Float
-    void ClearTextBufs(void);
+/// @return Bool
-   
+inline bool FloatToBool(float inp) { return (inp == 1 ? true : false); }
-    std::string Kbd(int lenght, SwkbdType tp);
+} // namespace Convert
-    bool DrawRect(float x, float y, float w, float h, u32 color);
-    bool DrawNFRect(float p1x, float p1y, float w, float h, u32 color, float scale = 1);
-    bool DrawPx(float x, float y, u32 color);
-    void DrawTextCentered(float x, float y, float size, u32 color, std::string Text, int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
-	void DrawText(float x, float y, float size, u32 color, std::string Text, int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
-    void DrawTextLeft(float x, float y, float size, u32 color, std::string Text, int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
-	float GetTextWidth(float size, std::string Text, C2D_Font fnt = nullptr);
-	void GetTextSize(float size, float *width, float *height, std::string Text, C2D_Font fnt = nullptr);
-	float GetTextHeight(float size, std::string Text, C2D_Font fnt = nullptr);
-    Result loadFont(C2D_Font &fnt, const char * Path = "");
-	Result unloadFont(C2D_Font &fnt);
-    bool DrawCircle(float x, float y, float radius, u32 color);
-    bool DrawImage(C2D_Image img, float x, float y, float scaleX = 1.0f, float scaleY = 1.0f);
-    void FrameEnd();
-    void ToggleRD7SR();
-    bool IsRD7SR();
 
-    class SpriteSheetAnimation : public RenderD7::Sprite
+namespace FS {
-    {
+/// @brief Check if File exists
-        public:
+/// @param path Path to the File
-        SpriteSheetAnimation();
+/// @return exists or not
-        ~SpriteSheetAnimation();
+bool FileExist(const std::string &path);
-        void Setup(RenderD7::Sheet *sheet, size_t imagecount, size_t startimage, float frame_begin, float frame_finish);
+} // namespace FS
-        void Play(float timespeed);
-        private:
-        size_t images;
-        size_t imgs = 0;
-        float D_totaltime;
-        RenderD7::Sheet *sheet;
-        float time;
-    };
-    
 
-    struct TLBtn
+/// @brief Check if Ndsp is Init
-    {
+/// @return is or not
-        int x; //Position X
+bool IsNdspInit();
-        int y; //Position Y
+/// @brief Get Current Framerate as String
-        int w; //Button Width
+/// @return Framerate String
-        int h; //Button Height
+std::string GetFramerate();
-    };
+/// @brief MainLoop of RenderD7s
+/// @return Is Still Running or not
+bool MainLoop();
+/// @brief Exit App (brak the MainLoop)
+void ExitApp();
 
-    struct ScrollList1 
+/// @brief Clear the Citro2D TextBuffers
-    {
+/// @param
-        std::string Text = "";
+void ClearTextBufs(void);
-    };
 
-    struct ScrollList2 
+/// @brief Open A Keyboard (SWKBD)
-    {
+/// @param lenght Length of the string
-        float x;
+/// @param tp Type of The Keyboard
-        float y;
+/// @return the string if pressed Ok
-        float w;
+std::string Kbd(int lenght, SwkbdType tp);
-        float h;
-        std::string Text = "";
-    };
-    /*enum ListType
-    {
-        ONE,
-        TWO
-    };*/
-    void DrawList1(RenderD7::ScrollList1 &l, float txtsize, C3D_RenderTarget *t);
-    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"));
-    void DrawSTObject(std::vector<RenderD7::TObject> tobject, int tobjectindex, u32 color, u32 txtcolor);
-    bool touchTObj(touchPosition touch, RenderD7::TObject button);
-    bool touchTLBtn(touchPosition touch, RenderD7::TLBtn button);
-    void DrawTLBtns(std::vector<RenderD7::TLBtn> btns, u32 color,  int selection = -1, u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"), u32 selcolor = RenderD7::Color::Hex("#000000"));
-    
-    struct Checkbox
-    {
-        float x, y, s;
-        bool is_chexked = false;
-        u32 outcol, incol, chcol;
-    };
-    void DrawCheckbox(Checkbox box);
-    std::string FormatString(std::string fmt_str, ...);
-    std::string GetTimeStr(void);
-    class Console
-    {
-         public:
-           Console();
-           Console(int x, int y, int w, int h, u8 a = 255);
-           Console(int x, int y, int w, int h, RenderD7::Color::rgba col);
-           Console(int x, int y, int w, int h, std::string name, RenderD7::Color::rgba col = {255, 255, 255, 255}, RenderD7::Color::rgba barcol = {0, 0, 0, 255}, RenderD7::Color::rgba outlinecol = {222, 222, 222, 255});
-           void On(C3D_RenderTarget *t_cscreen);
-           bool Update();
-           ~Console();
-         private:
-           std::vector<std::string> m_lines;
-           int x, y, w, h;
-           std::string m_name = "";
-           C3D_RenderTarget *cscreen;
-           bool m_nconsole = false;
-           bool m_mconsole = false;
-           RenderD7::Color::rgba color = {255, 255, 255, 255};
-           RenderD7::Color::rgba outlinecol = {222, 222, 222, 255};
-           RenderD7::Color::rgba barcolor = {0, 0, 0, 255};
-    };
 
-    bool NameIsEndingWith(const std::string &name, const std::vector<std::string> &extensions);
+/// @brief Draw Overlays And end the Frame. DO NEVER USE C3D_FRAMEEND cause it
-    void GetDirContentsExt(std::vector<RenderD7::DirContent> &dircontent, const std::vector<std::string> &extensions);
+/// breaks Overlay crash Security
-    void GetDirContents(std::vector<RenderD7::DirContent> &dircontent);
+void FrameEnd();
 
-    class BitmapPrinter
+/// @brief Textless Button
-    {
+struct TLBtn {
-        public:
+  int x; ///< Position X
-        BitmapPrinter(int w, int h);
+  int y; ///< Position Y
-        ~BitmapPrinter();
+  int w; ///< Button Width
-        bool DecodeFile(std::string file);
+  int h; ///< Button Height
-        
+};
-        bool DecodeMem(std::vector<unsigned char> buffer);
+/// @brief Draw Buttons
-        void DrawPixel(int x, int y, u8 b, u8 g, u8 r, u8 a);
+/// @param tobjects Vector of Buttons
-        void DrawRect(int x, int y, int w, int h, u8 line_w, u8 b, u8 g, u8 r, u8 a);
+/// @param color Color of the Buttons
-        void DrawRectFilled(int x, int y, int w, int h, u8 b, u8 g, u8 r, u8 a);
+/// @param txtcolor Color of The Text
-        void UsePreMap(BMP map);
+/// @param selection Positon of Selection
-        void UsePrePrintMap(BitmapPrinter printmap);
+/// @param selbgcolor Selection BackgroundColor
-        BMP GetBitmap(){ return bitmap; }
+/// @param selcolor Selection Color
-        void SaveBmp(std::string name);
+void DrawTObjects(std::vector<RenderD7::TObject> tobjects, u32 color,
-        void SavePng(std::string name);
+                  u32 txtcolor, int selection = -1,
-
+                  u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"),
-        void CreateScreen(C3D_RenderTarget *target);
+                  u32 selcolor = RenderD7::Color::Hex("#000000"));
-        void DrawScreen(int framerate);
+/// @brief Draw A Single Button
-        void Clear(u8 b = 0, u8 g = 0, u8 r = 0, u8 a = 255);
+/// @param tobject Button
-        void ClearBlank();
+/// @param tobjectindex Button Index
-        RenderD7::Image GetImage();
+/// @param color Color of the Button
-        private:
+/// @param txtcolor Color of The Text
-        int frame = 0;
+void DrawSTObject(std::vector<RenderD7::TObject> tobject, int tobjectindex,
-        RenderD7::Image renderframe;
+                  u32 color, u32 txtcolor);
-        bool isscreen = false;
+/// @brief Touched A Button
-        C3D_RenderTarget* targetr;
+/// @param touch Touch Position
-        BMP bitmap = NULL;
+/// @param button Button
-        BMP blank = NULL;
+/// @return is touched or not
-    };
+bool touchTObj(touchPosition touch, RenderD7::TObject button);
-} /// RenderD7
+/// @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"));
+} // namespace RenderD7

include/renderd7/renderd7_logo.hpp

@@ -0,0 +1,5 @@
+#pragma once
+#include <cstddef>
+
+extern unsigned char renderd7_logo[];
+extern size_t renderd7_logo_size;

include/renderd7/sound.hpp

@@ -6,23 +6,25 @@
 /** Sound Class */
 class sound {
 public:
-        /// \brief Construct new Soundeffect
+  /// \brief Construct new Soundeffect
-        /// \param path Path to the .wav file
+  /// \param path Path to the .wav file
-        /// \param channel the channel 1-23
+  /// \param channel the channel 1-23
-        /// \param toloop true:loop the sound, false: don't loop
+  /// \param toloop true:loop the sound, false: don't loop
-	sound(const std::string& path, int channel = 1, bool toloop = false);
+  sound(const std::string &path, int channel = 1, bool toloop = false);
-        /** deconstruct the sound */
+  /// @brief Deconstructor
-	~sound();
+  ~sound();
-        /** play the sound */
+  /// @brief Play the sound
-	void play();
+  void play();
-        /** stop the sound */
+  /// @brief Stop the sound
-	void stop();
+  void stop();
 
 private:
-	/// \param dataSize the Size of the filedata
+  /// \param dataSize Size of the filedata
-	u32 dataSize;
+  u32 dataSize;
-	ndspWaveBuf waveBuf;
+  /// \param waveBuf For ndsp
-	u8* data = NULL;
+  ndspWaveBuf waveBuf;
-	int chnl;
+  /// \param data Memmory data of the sound
+  uint8_t *data = NULL;
+  /// \param chnl Channel of the sound
+  int chnl;
 };
-

include/renderd7/stringtool.hpp

@@ -1,11 +1,81 @@
-template<class T>
+#pragma once
-T GetFileName(T const & path, T const & delims = "/\\")
+#include <iomanip>
-{
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace RenderD7 {
+/// @brief Check if A String ends with
+/// @param name Input String
+/// @param extensions Extensions to Check for
+/// @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.size() == 0)
+    return false;
+
+  if (extensions.size() == 0)
+    return true;
+
+  for (int i = 0; i < (int)extensions.size(); i++) {
+    const std::string ext = extensions.at(i);
+    if (strcasecmp(name.c_str() + name.size() - ext.size(), ext.c_str()) == 0)
+      return true;
+  }
+
+  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 = "/\\") {
   return path.substr(path.find_last_of(delims) + 1);
 }
-template<class T>
+template <class T> T remove_ext(T const &filename) {
-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) {
+  std::stringstream stream;
+  stream << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex
+         << i;
+  return stream.str();
+}

include/renderd7/thread.hpp

@@ -2,118 +2,121 @@
 #include <3ds.h>
 #include <atomic>
 #include <functional>
-#include <string>
 #include <renderd7/parameter.hpp>
+#include <string>
 
 using CTRU_Thread = Thread;
 
 #define THREAD_STACK_SIZE 0x1000
 
 namespace RenderD7 {
-    namespace Threads
+class Thread {
-    {
+public:
-        inline bool threadrunning = false;
+  /**
+   * @brief Default constructor
+   * @note This should only be called when calling m3d::Thread::initialize()
+   * before calling m3d::Thread::start()
+   */
+  Thread();
 
-        struct Thread
+  /**
-        {
+   * @brief Constructs the thread
-            Handle handle;
+   * @param t_function  The thread function
-            void (*ep)(void);
+   * @param t_parameter The parameter to pass to the function
-            bool finished;
+   * @param t_autostart Whether the thread should start instantly
-            void* stacktop;
+   * @param t_detached  Whether the thread starts detached or not
-        };
+   * @param t_stackSize The stacksize allocated for the thread in bytes (rounded
+   * to multiples of 8 bytes)
+   * @note t_function needs to be of type `void` and take one (and only one)
+   * parameter of type m3d::Parameter
+   * @warning If the thread priority is lower than the priority of the calling
+   * thread, the thread will never get executed. Use
+   * m3d::Thread::getCurrentPriority() to get the priority of the current thread
+   */
+  Thread(std::function<void(RenderD7::Parameter)> t_function,
+         RenderD7::Parameter t_parameter = nullptr, bool t_autostart = false,
+         bool t_detached = false,
+         unsigned long long int t_stackSize = 4 * 1024);
 
-        bool Create();
+  /**
-        bool Join();
+   * @brief Destructs the thread
-        void Exit();
+   */
-    }
+  virtual ~Thread();
-    class Thread {
-    public:
-        /**
-         * @brief Default constructor
-         * @note This should only be called when calling m3d::Thread::initialize() before calling m3d::Thread::start()
-         */
-        Thread();
-        
-        /**
-         * @brief Constructs the thread
-         * @param t_function  The thread function
-         * @param t_parameter The parameter to pass to the function
-         * @param t_autostart Whether the thread should start instantly
-         * @param t_detached  Whether the thread starts detached or not
-         * @param t_stackSize The stacksize allocated for the thread in bytes (rounded to multiples of 8 bytes)
-         * @note t_function needs to be of type `void` and take one (and only one) parameter of type m3d::Parameter
-         * @warning If the thread priority is lower than the priority of the calling thread, the thread will never get executed. Use m3d::Thread::getCurrentPriority() to get the priority of the current thread
-         */
-        Thread(std::function<void(RenderD7::Parameter)> t_function, RenderD7::Parameter t_parameter = nullptr, bool t_autostart = false, bool t_detached = false, unsigned long long int t_stackSize = 4 * 1024);
 
-        /**
+  /**
-        * @brief Destructs the thread
+   * @brief Initializes the thread
-        */
+   * @param t_function  The thread function
-        virtual ~Thread();
+   * @param t_parameter The parameter to pass to the function
+   * @param t_autostart Whether the thread should start instantly
+   * @param t_detached  Whether the thread starts detached or not
+   * @param t_stackSize The stacksize allocated for the thread in bytes (rounded
+   * to multiples of 8 bytes)
+   * @note t_function needs to be of type `void` and take one (and only one)
+   * parameter of type m3d::Parameter
+   * @warning If the thread priority is lower than the priority of the calling
+   * thread, the thread will never get executed. Use
+   * m3d::Thread::getCurrentPriority() to get the priority of the current thread
+   */
+  void initialize(std::function<void(RenderD7::Parameter)> t_function,
+                  RenderD7::Parameter t_parameter = nullptr,
+                  bool t_autostart = false, bool t_detached = false,
+                  unsigned long long int t_stackSize = 4 * 1024);
 
-        /**
+  /**
-         * @brief Initializes the thread
+   * @brief Sets the size of the stack that gets allocated for the next thread
-         * @param t_function  The thread function
+   * that get's started
-         * @param t_parameter The parameter to pass to the function
+   * @param t_stackSize The allocated space in bytes (rounded to multiples of 8
-         * @param t_autostart Whether the thread should start instantly
+   * bytes)
-         * @param t_detached  Whether the thread starts detached or not
+   */
-         * @param t_stackSize The stacksize allocated for the thread in bytes (rounded to multiples of 8 bytes)
+  void setStackSize(unsigned long long int t_stackSize);
-         * @note t_function needs to be of type `void` and take one (and only one) parameter of type m3d::Parameter
-         * @warning If the thread priority is lower than the priority of the calling thread, the thread will never get executed. Use m3d::Thread::getCurrentPriority() to get the priority of the current thread
-         */
-        void initialize(std::function<void(RenderD7::Parameter)> t_function, RenderD7::Parameter t_parameter = nullptr, bool t_autostart = false, bool t_detached = false, unsigned long long int t_stackSize = 4 * 1024);
 
-        /**
+  /**
-         * @brief Sets the size of the stack that gets allocated for the next thread that get's started
+   * @brief Starts the thread. To restart it, call Thread::join() before
-         * @param t_stackSize The allocated space in bytes (rounded to multiples of 8 bytes)
+   * @param t_detached Whether the thread should start detached or not
-         */
+   */
-        void setStackSize(unsigned long long int t_stackSize);
+  void start(bool t_detached = false);
 
-        /**
+  /**
-         * @brief Starts the thread. To restart it, call Thread::join() before
+   * @brief Detaches the thread
-         * @param t_detached Whether the thread should start detached or not
+   */
-         */
+  void kill();
-        void start(bool t_detached = false);
 
-        /**
+  /**
-         * @brief Detaches the thread
+   * @brief Waits for the thread to finish
-         */
+   * @param t_timeout The timeout in nanoseconds. Leave it for no timeout
-        void kill();
+   */
+  void join(long long unsigned int t_timeout = U64_MAX);
 
-        /**
+  bool isRunning();
-         * @brief Waits for the thread to finish
-         * @param t_timeout The timeout in nanoseconds. Leave it for no timeout
-         */
-        void join(long long unsigned int t_timeout = U64_MAX);
 
-        bool isRunning();
+  /**
+   * @brief Puts the thread to sleep
+   *
+   * This is needed if you have multiple threads running at the same time. It
+   * doesn't affect the execution-time of the thread, it just makes it possible
+   * for the other threads to get their chance to shine.
+   */
+  static void sleep();
 
-        /**
+  /**
-         * @brief Puts the thread to sleep
+   * @brief Sleeps for the given time
-         *
+   * @param t_milliseconds The time to sleep in milliseconds
-         * This is needed if you have multiple threads running at the same time. It doesn't affect the execution-time of the thread, it just makes it possible for the other threads to get their chance to shine.
+   */
-         */
+  static void sleep(int t_milliseconds);
-        static void sleep();
 
-        /**
+private:
-         * @brief Sleeps for the given time
+  struct ThreadData {
-         * @param t_milliseconds The time to sleep in milliseconds
+    RenderD7::Parameter m_parameter;
-         */
+    std::function<void(RenderD7::Parameter)> m_function;
-        static void sleep(int t_milliseconds);
+    std::atomic<bool> *m_running;
+  };
 
-    private:
+  static void threadFunction(void *t_arg);
-        struct ThreadData {
+  /* data */
-            RenderD7::Parameter m_parameter;
+  int m_priority, m_stackSize;
-            std::function<void(RenderD7::Parameter)> m_function;
+  bool m_started;
-            std::atomic<bool>* m_running;
+  std::atomic<bool> m_running;
-        };
+  RenderD7::Thread::ThreadData m_data;
-
+  CTRU_Thread m_thread;
-        static void threadFunction(void* t_arg);
+};
-        /* data */
+} // namespace RenderD7
-        int m_priority, m_stackSize;
-        bool m_started;
-        std::atomic<bool> m_running;
-        RenderD7::Thread::ThreadData m_data;
-        CTRU_Thread m_thread;
-    };
-}

include/renderd7/tween.hpp

@@ -1,17 +0,0 @@
-#include <renderd7/Clock.hpp>
-
-namespace rnd7{
-    enum class TweenType : int {Position = 1, Color, Alpha};
-
-    enum class TweenLoop : int {None = 1, Loop = 2,};
-
-    enum class TweenDirection : int {Current, Forward, Backward};
-
-    enum class TweenState : int {Playing = 1, Stopped};
-    class Tween
-    {
-        public:
-        Tween(float from, float to, float duration, TweenLoop loop, TweenState state);
-
-    };
-}

include/renderd7/ui_elements.hpp

@@ -0,0 +1,5 @@
+#pragma once
+#include <cstddef>
+
+extern unsigned char ui_elements[];
+extern size_t ui_elements_size;

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
+#---------------------------------------------------------------------------------------