tobid7/renderd7
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format to LLVL

Browse Source
This commit is contained in:
tobid7vx 2022-11-12 23:19:41 +01:00
parent 36e5676d9f
commit 8b70d0e9b7
44 changed files with 4869 additions and 4889 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.vscode/settings.json vendored
View File

@ -57,6 +57,9 @@
"shared_mutex": "cpp", "shared_mutex": "cpp",
"valarray": "cpp", "valarray": "cpp",
"random": "cpp", "random": "cpp",
"cuchar": "cpp" "cuchar": "cpp",
"compare": "cpp",
"concepts": "cpp",
"numbers": "cpp"
} }
} }

178
include/renderd7/BitmapPrinter.hpp
View File

@ -7,101 +7,105 @@
#include <renderd7/Image.hpp> #include <renderd7/Image.hpp>
#include <renderd7/Time.hpp>
#include <renderd7/Screen.hpp> #include <renderd7/Screen.hpp>
#include <renderd7/Time.hpp>
#include <renderd7/Fonts/NFontApi.hpp> #include <renderd7/Fonts/NFontApi.hpp>
namespace RenderD7 namespace RenderD7 {
{ enum Encoder {
enum Encoder BITMAP, ///< Encode Data to Bitmap
{ DIRECT, ///< Encode Direct to Framebuffer(No Decoder Required)
BITMAP, ///< Encode Data to Bitmap C3D ///< Encode Directly to C3D_Tex (Just an Idea)
DIRECT, ///< Encode Direct to Framebuffer(No Decoder Required) };
C3D ///< Encode Directly to C3D_Tex (Just an Idea)
};
enum Decoder enum Decoder {
{ BITMAP2C3D, ///< Decode and Encode to C3D_Tex (Currently Fastest) (47,4ms)
BITMAP2C3D, ///< Decode and Encode to C3D_Tex (Currently Fastest) (47,4ms) BITMAP2PNG2C3D ///< Decode Bitmap end Convert to Png, then C3D (Very Slow)
BITMAP2PNG2C3D ///< Decode Bitmap end Convert to Png, then C3D (Very Slow) (201,4ms) ///< (201,4ms)
}; };
class BitmapPrinter class BitmapPrinter {
{ public:
public: BitmapPrinter(int w, int h);
BitmapPrinter(int w, int h); ~BitmapPrinter();
~BitmapPrinter(); bool DecodeFile(std::string file);
bool DecodeFile(std::string file);
void SetDecoder(Decoder deccc) { decc = deccc; }
void DrawPixel(int x, int y, u8 b, u8 g, u8 r, u8 a);
void DrawRect(int x, int y, int w, int h, u8 line_w, u8 b, u8 g, u8 r, u8 a);
void DrawRectFilled(int x, int y, int w, int h, u8 b, u8 g, u8 r, u8 a);
void UsePreMap(BMP map);
void UsePrePrintMap(BitmapPrinter printmap);
BMP GetBitmap(){ return bitmap; }
void SaveBmp(std::string name);
void SavePng(std::string name);
void CreateScreen(C3D_RenderTarget *target); void SetDecoder(Decoder deccc) { decc = deccc; }
bool DrawScreenDirectF(int framerate); void DrawPixel(int x, int y, u8 b, u8 g, u8 r, u8 a);
bool DrawScreenDirect(); void DrawRect(int x, int y, int w, int h, u8 line_w, u8 b, u8 g, u8 r, u8 a);
void DrawScreenF(int framerate); void DrawRectFilled(int x, int y, int w, int h, u8 b, u8 g, u8 r, u8 a);
void DrawScreen(); void UsePreMap(BMP map);
bool UpdateScreenF(int framerate); void UsePrePrintMap(BitmapPrinter printmap);
bool UpdateScreen(); BMP GetBitmap() { return bitmap; }
void Clear(u8 b = 0, u8 g = 0, u8 r = 0, u8 a = 255); void SaveBmp(std::string name);
void ClearBlank(); void SavePng(std::string name);
RenderD7::Image GetImage();
/// Test to Find out The Best Settings for BitmapPrinter
void Benchmark();
/// Setup the Benchmark
/// \param framerate The Fps of the ScreenUpdates
void SetupBenchmark(int framerate);
bool IsBenchmarkRunning() { return this->benchmark; }
void DrawDebugText(int x, int y, int t_size, u32 color, std::string text); void CreateScreen(C3D_RenderTarget *target);
void DrawText(int x, int y, float t_size, u32 color, std::string text, RenderD7::NFontApi font); bool DrawScreenDirectF(int framerate);
private: bool DrawScreenDirect();
//funcs void DrawScreenF(int framerate);
bool Decode(Decoder deccc); void DrawScreen();
void DrawDebugChar(u32 posX, u32 posY, int t_size, u32 color, char character); bool UpdateScreenF(int framerate);
void DrawChar(int posX, int posY, float t_size, u32 color, char character, RenderD7::NFontApi font); bool UpdateScreen();
//parameter void Clear(u8 b = 0, u8 g = 0, u8 r = 0, u8 a = 255);
int frame = 0; void ClearBlank();
RenderD7::Image renderframe; RenderD7::Image GetImage();
bool isscreen = false; /// Test to Find out The Best Settings for BitmapPrinter
C3D_RenderTarget* targetr; void Benchmark();
BMP bitmap = BMP(20, 20, true); //Need to Set e Predefined Bitmap. If not the System will Crash. /// Setup the Benchmark
BMP blank = BMP(20, 20, true); //Need to Set e Predefined Bitmap. If not the System will Crash. /// \param framerate The Fps of the ScreenUpdates
void SetupBenchmark(int framerate);
bool IsBenchmarkRunning() { return this->benchmark; }
/////////////////////////////////////////////////////////////////////////////////////////////////// void DrawDebugText(int x, int y, int t_size, u32 color, std::string text);
//Benchmark Stuff; void DrawText(int x, int y, float t_size, u32 color, std::string text,
int testfpsd; RenderD7::NFontApi font);
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; private:
int frameCounter = 0, fps = 0; // funcs
bool Decode(Decoder deccc);
void DrawDebugChar(u32 posX, u32 posY, int t_size, u32 color, char character);
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.
std::vector<float> hdttt; ///////////////////////////////////////////////////////////////////////////////////////////////////
std::vector<float> hdttt2; // Benchmark Stuff;
std::vector<float> hdttt3; int testfpsd;
std::vector<int> fpscountc; bool benchmark = false;
int renderedframes = 0; bool setupbenchmark;
int testfps = 60; float frametime = 0;
Encoder encc = Encoder::BITMAP; uint64_t lastTime = 0;
Decoder decc = Decoder::BITMAP2C3D; 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

50
include/renderd7/Color.hpp
View File

@ -1,31 +1,31 @@
#pragma once #pragma once
#include <string>
#include <unistd.h>
#include <memory>
#include <cstring> #include <cstring>
#include <functional> #include <functional>
#include <sstream> #include <memory>
#include <regex> #include <regex>
#include <sstream>
#include <string>
#include <unistd.h>
#define UNPACK_RGBA(col) (uint8_t) (col >> 24), (col >> 16), (col >> 8), (col) #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) #define UNPACK_BGRA(col) (uint8_t)(col >> 8), (col >> 16), (col >> 24), (col)
namespace RenderD7 namespace RenderD7 {
{ namespace Color {
namespace Color struct rgba {
{ uint8_t r, g, b, a;
struct rgba };
{ class RGBA {
uint8_t r, g, b, a; public:
}; RGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
class RGBA{ : m_r(r), m_g(g), m_b(b), m_a(a) {}
public: uint32_t toRGBA() const {
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){} return (m_r << 24) | (m_g << 16) | (m_b << 8) | m_a;
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; uint8_t m_r, m_g, m_b, m_a;
}; };
std::string RGB2Hex(int r, int g, int b); std::string RGB2Hex(int r, int g, int b);
uint32_t Hex(const std::string color, uint8_t a = 255); uint32_t Hex(const std::string color, uint8_t a = 255);
} } // namespace Color
} } // namespace RenderD7

45
include/renderd7/Draw.hpp
View File

@ -1,25 +1,28 @@
#pragma once #pragma once
#include <citro3d.h>
#include <citro2d.h>
#include <3ds.h> #include <3ds.h>
#include <citro2d.h>
#include <citro3d.h>
#include <string> #include <string>
namespace RenderD7 namespace RenderD7 {
{ namespace Draw {
namespace Draw bool Rect(float x, float y, float w, float h, u32 color);
{ bool NFRect(float p1x, float p1y, float w, float h, u32 color, float scale = 1);
bool Rect(float x, float y, float w, float h, u32 color); bool Px(float x, float y, u32 color);
bool NFRect(float p1x, float p1y, float w, float h, u32 color, float scale = 1); void TextCentered(float x, float y, float size, u32 color, std::string Text,
bool Px(float x, float y, u32 color); int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
void TextCentered(float x, float y, float size, u32 color, std::string Text, int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr); void Text(float x, float y, float size, u32 color, std::string Text,
void Text(float x, float y, float size, u32 color, std::string Text, int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr); int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
void TextRight(float x, float y, float size, u32 color, std::string Text, int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr); void TextRight(float x, float y, float size, u32 color, std::string Text,
float GetTextWidth(float size, std::string Text, C2D_Font fnt = nullptr); int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
void GetTextSize(float size, float *width, float *height, std::string Text, C2D_Font fnt = nullptr); float GetTextWidth(float size, std::string Text, C2D_Font fnt = nullptr);
float GetTextHeight(float size, std::string Text, C2D_Font fnt = nullptr); void GetTextSize(float size, float *width, float *height, std::string Text,
Result LoadFont(C2D_Font &fnt, const char * Path = ""); C2D_Font fnt = nullptr);
Result UnloadFont(C2D_Font &fnt); float GetTextHeight(float size, std::string Text, C2D_Font fnt = nullptr);
bool Circle(float x, float y, float radius, u32 color); Result LoadFont(C2D_Font &fnt, const char *Path = "");
bool Image(C2D_Image img, float x, float y, float scaleX = 1.0f, float scaleY = 1.0f); Result UnloadFont(C2D_Font &fnt);
} bool Circle(float x, float y, float radius, u32 color);
} bool Image(C2D_Image img, float x, float y, float scaleX = 1.0f,
float scaleY = 1.0f);
} // namespace Draw
} // namespace RenderD7

159
include/renderd7/FileSystem.hpp
View File

@ -1,116 +1,105 @@
//FileSystem based on libphyfs based on https://github.com/TurtleP/3ds-examples/blob/fs/physfs/fs/physfs/include/filesystem.h // FileSystem based on libphyfs based on
// https://github.com/TurtleP/3ds-examples/blob/fs/physfs/fs/physfs/include/filesystem.h
#pragma once #pragma once
#include <string> #include <string>
#include <vector> #include <vector>
#include <physfs.h> #include <physfs.h>
#define RD7_FSYS_GETINFO(path) ({ \ #define RD7_FSYS_GETINFO(path) \
RenderD7::FileSystem::Info inf; \ ({ \
RenderD7::FileSystem::GetInfo(path, inf); \ RenderD7::FileSystem::Info inf; \
inf; \ RenderD7::FileSystem::GetInfo(path, inf); \
}) inf; \
})
namespace RenderD7 namespace RenderD7 {
{ namespace FileSystem {
namespace FileSystem static constexpr auto MAX_STAMP = 0x20000000000000LL;
{
static constexpr auto MAX_STAMP = 0x20000000000000LL;
enum FileMode enum FileMode { FileMode_Open, FileMode_Read, FileMode_Write, FileMode_Closed };
{
FileMode_Open,
FileMode_Read,
FileMode_Write,
FileMode_Closed
};
enum FileType enum FileType {
{ FileType_File,
FileType_File, FileType_Directory,
FileType_Directory, FileType_SymLink,
FileType_SymLink, FileType_Other
FileType_Other };
};
struct File struct File {
{ PHYSFS_file *handle;
PHYSFS_file* handle; FileMode mode;
FileMode mode;
File() File() {
{ this->handle = nullptr;
this->handle = nullptr; this->mode = FileMode_Closed;
this->mode = FileMode_Closed; }
}
int64_t GetSize() int64_t GetSize() {
{ if (this->handle == nullptr)
if (this->handle == nullptr) return 0;
return 0;
return (int64_t)PHYSFS_fileLength(this->handle); return (int64_t)PHYSFS_fileLength(this->handle);
} }
}; };
struct Info struct Info {
{ int64_t size;
int64_t size; int64_t mod_time;
int64_t mod_time; FileType type;
FileType type; };
};
int Init(const char* argv); int Init(const char *argv);
void Initialize(); void Initialize();
/* /*
** mounts a specific directory for physfs to search in ** mounts a specific directory for physfs to search in
** this is typically a main directory ** this is typically a main directory
*/ */
bool SetSource(const char* source); bool SetSource(const char *source);
/* /*
** mounts a specific directory as a "save" directory ** mounts a specific directory as a "save" directory
** if appended, it will be added to the search path ** if appended, it will be added to the search path
*/ */
bool SetIdentity(const char* name, bool append); bool SetIdentity(const char *name, bool append);
static std::string savePath; static std::string savePath;
/* gets the last physfs error */ /* gets the last physfs error */
const char* GetPhysfsError(); const char *GetPhysfsError();
/* strips any duplicate slashes */ /* strips any duplicate slashes */
std::string Normalize(const std::string& input); std::string Normalize(const std::string &input);
/* gets the user directory from physfs */ /* gets the user directory from physfs */
std::string GetUserDirectory(); std::string GetUserDirectory();
/* gets the save directory */ /* gets the save directory */
std::string GetSaveDirectory(); std::string GetSaveDirectory();
/* sets up the writing directory for physfs */ /* sets up the writing directory for physfs */
bool SetupWriteDirectory(); bool SetupWriteDirectory();
/* gets a list of files in a directory */ /* gets a list of files in a directory */
void GetDirectoryItems(const char* directory, std::vector<std::string>& items); void GetDirectoryItems(const char *directory, std::vector<std::string> &items);
/* gets the size, mod_time, and type of a file */ /* gets the size, mod_time, and type of a file */
bool GetInfo(const char* filename, Info& info); bool GetInfo(const char *filename, Info &info);
/* creates a new directory */ /* creates a new directory */
bool CreateDirectory(const char* name); bool CreateDirectory(const char *name);
bool CloseFile(File& file); bool CloseFile(File &file);
/* creates a new file */ /* creates a new file */
bool OpenFile(File& file, const char* name, FileMode mode); bool OpenFile(File &file, const char *name, FileMode mode);
/* writes to a file */ /* writes to a file */
bool WriteFile(File& file, const void* data, int64_t size); bool WriteFile(File &file, const void *data, int64_t size);
/* reads a file's content */ /* reads a file's content */
int64_t ReadFile(File& file, void* destination, int64_t size); int64_t ReadFile(File &file, void *destination, int64_t size);
} } // namespace FileSystem
} } // namespace RenderD7

247
include/renderd7/Fonts/NFontApi.hpp
View File

@ -1,149 +1,142 @@
#pragma once #pragma once
#include <bitset>
#include <iostream> #include <iostream>
#include <string> #include <string>
#include <bitset>
#include <vector> #include <vector>
#include <renderd7/external/stb_truetype.h> #include <renderd7/external/stb_truetype.h>
#define MAXUNICODE 0x10FFFF #define MAXUNICODE 0x10FFFF
namespace RenderD7 namespace RenderD7 {
{ inline int utf8_decode(const char *o) {
inline int utf8_decode(const char* o) { static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF}; const unsigned char *s = (const unsigned char *)o;
const unsigned char *s = (const unsigned char *)o; unsigned int c = s[0];
unsigned int c = s[0]; unsigned int res = 0; /* final result */
unsigned int res = 0; /* final result */ if (c < 0x80) /* ascii? */
if (c < 0x80) /* ascii? */ res = c;
res = c; else {
else { int count = 0; /* to count number of continuation bytes */
int count = 0; /* to count number of continuation bytes */ while (c & 0x40) { /* still have continuation bytes? */
while (c & 0x40) { /* still have continuation bytes? */ int cc = s[++count]; /* read next byte */
int cc = s[++count]; /* read next byte */ if ((cc & 0xC0) != 0x80) /* not a continuation byte? */
if ((cc & 0xC0) != 0x80) /* not a continuation byte? */ return -1; /* invalid byte sequence */
return -1; /* invalid byte sequence */ res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */
res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */ c <<= 1; /* to test next bit */
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;
} }
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
inline std::string IntToUtf8(int convertval){ if (convertval == 0)
return " ";
// We only care about plane 1 right now, if ((convertval <= 0x7F) && (convertval > 0x00)) {
// 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 " ";
}
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()) #define I2U82I(val) RenderD7::utf8_decode(RenderD7::IntToUtf8(val).c_str())
class NFontApi class NFontApi {
{ public:
public: NFontApi();
NFontApi(); ~NFontApi();
~NFontApi(); void LoadTTF(std::string path);
void LoadTTF(std::string path); unsigned char *GetGlyphBitmap(char glyph);
unsigned char* GetGlyphBitmap(char glyph); std::string GetStatus() { return status; }
std::string GetStatus(){ return status; } float GetScale() { return scale; }
float GetScale() {return scale; } int GetGlyphWidth(char glyph);
int GetGlyphWidth(char glyph); int GetGlyphHeight(char glyph);
int GetGlyphHeight(char glyph); int GetLineHeight() { return l_h; }
int GetLineHeight(){ return l_h; } int GetBaseHeight() { return height; }
int GetBaseHeight(){ return height; }
private:
std::string status;
int height; private:
std::string status;
float scale; int height;
int b_w;
int b_h;
int l_h;
int w; float scale;
int h; int b_w;
int b_h;
int l_h;
int x0,y0,x1,y1; int w;
int ascent,baseline,decent,linegap; int h;
int linespace; int x0, y0, x1, y1;
int ascent, baseline, decent, linegap;
stbtt_fontinfo font; int linespace;
};
} stbtt_fontinfo font;
};
} // namespace RenderD7

66
include/renderd7/Image.hpp
View File

@ -7,42 +7,40 @@
#include <renderd7/bmp.hpp> #include <renderd7/bmp.hpp>
#include <renderd7/bmpconverter.hpp> #include <renderd7/bmpconverter.hpp>
#include <renderd7/external/lodepng.h>
#include <renderd7/Color.hpp>
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
#include <renderd7/Color.hpp>
#include <renderd7/external/lodepng.h>
namespace RenderD7 namespace RenderD7 {
{ /// Image Class
/// Image Class class Image {
class Image public:
{ Image() {}
public: ~Image();
Image(){}
~Image();
void Unload(); void Unload();
/// Load Image from Png /// Load Image from Png
/// \param path path to png file /// \param path path to png file
void LoadPng(const std::string path); void LoadPng(const std::string path);
/// Load the Image from buffer /// Load the Image from buffer
/// \param buffer the frame buffer /// \param buffer the frame buffer
void LoadPFromBuffer(const std::vector<u8> &buffer); void LoadPFromBuffer(const std::vector<u8> &buffer);
void LoadFromBitmap(BMP bitmap); void LoadFromBitmap(BMP bitmap);
/// Draw the Image directly /// Draw the Image directly
/// \param x The x position /// \param x The x position
/// \param y the y position /// \param y the y position
/// \param scaleX x scale from 0.0 to 1.0 /// \param scaleX x scale from 0.0 to 1.0
/// \param scaleY y 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); bool Draw(float x, float y, float scaleX = 1.0f, float scaleY = 1.0f);
/// \brief Get The Image /// \brief Get The Image
/// \return C2D_Image /// \return C2D_Image
C2D_Image Get(){return this->img;} C2D_Image Get() { return this->img; }
void FromSheet(RenderD7::Sheet sheet, size_t index); void FromSheet(RenderD7::Sheet sheet, size_t index);
/// \param img this is the C2D_Image /// \param img this is the C2D_Image
C2D_Image img; C2D_Image img;
/// \param loadet whether the image is loadet or not /// \param loadet whether the image is loadet or not
bool loadet = false; bool loadet = false;
}; };
} } // namespace RenderD7

28
include/renderd7/Ovl.hpp
View File

@ -1,17 +1,17 @@
#pragma once #pragma once
#include <memory> #include <memory>
namespace RenderD7 namespace RenderD7 {
{ class Ovl {
class Ovl { public:
public: virtual ~Ovl() {}
virtual ~Ovl(){} virtual void Draw() const = 0;
virtual void Draw() const = 0; virtual void Logic() = 0;
virtual void Logic() = 0; inline bool IsKilled() { return this->iskilled; }
inline bool IsKilled() {return this->iskilled; } inline void Kill() { iskilled = true; }
inline void Kill() { iskilled = true; }
private: private:
bool iskilled = false; bool iskilled = false;
}; };
void AddOvl(std::unique_ptr<RenderD7::Ovl> scene); void AddOvl(std::unique_ptr<RenderD7::Ovl> scene);
} } // namespace RenderD7

20
include/renderd7/Screen.hpp
View File

@ -1,15 +1,13 @@
#pragma once #pragma once
#include <citro3d.h>
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h>
extern C3D_RenderTarget *Top;
extern C3D_RenderTarget *TopRight;
extern C3D_RenderTarget *Bottom;
extern C3D_RenderTarget* Top; namespace RenderD7 {
extern C3D_RenderTarget* TopRight; /// Set current RenderScreen
extern C3D_RenderTarget* Bottom; /// \param target The RenderTarget Top, Bottom
void OnScreen(C3D_RenderTarget *target);
namespace RenderD7 } // namespace RenderD7
{
/// Set current RenderScreen
/// \param target The RenderTarget Top, Bottom
void OnScreen(C3D_RenderTarget *target);
}

36
include/renderd7/Sheet.hpp
View File

@ -2,22 +2,20 @@
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
namespace RenderD7 namespace RenderD7 {
{ /** The Spritesheet Class */
/** The Spritesheet Class */ class Sheet {
class Sheet public:
{ /// Construct sheet
public: Sheet();
/// Construct sheet // Deconstruct sheet
Sheet(); ~Sheet();
// Deconstruct sheet /// Load a Sritesheet
~Sheet(); /// \param path Path to the Spritesheet (.t3x)
/// Load a Sritesheet Result Load(const char *path);
/// \param path Path to the Spritesheet (.t3x) /// Unload the Spritesheet
Result Load(const char *path); void Free();
/// Unload the Spritesheet /// The Spritesheet
void Free(); C2D_SpriteSheet spritesheet;
/// The Spritesheet };
C2D_SpriteSheet spritesheet; } // namespace RenderD7
};
}

65
include/renderd7/Sprite.hpp
View File

@ -3,38 +3,37 @@
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
#include <renderd7/Sheet.hpp>
#include <renderd7/Image.hpp> #include <renderd7/Image.hpp>
#include <renderd7/Sheet.hpp>
namespace RenderD7 namespace RenderD7 {
{ /// Sprite Class
/// Sprite Class class Sprite {
class Sprite public:
{ /// \brief Construct Sprite
public: Sprite();
/// \brief Construct Sprite /// \brief Deconstruct Sprite
Sprite(); ~Sprite();
/// \brief Deconstruct Sprite /// \brief Load a Sprite From SpriteSheet
~Sprite(); /// \param sheet the Sheet to load from.(RenderD7::Sheet)
/// \brief Load a Sprite From SpriteSheet /// \param index the number of the Sprite in the Sheet
/// \param sheet the Sheet to load from.(RenderD7::Sheet) void FromSheet(RenderD7::Sheet *sheet, size_t index);
/// \param index the number of the Sprite in the Sheet /// \brief Load a Sprite From SpriteSheet
void FromSheet(RenderD7::Sheet *sheet, size_t index); /// \param img the Image to load from.(RenderD7::Image)
/// \brief Load a Sprite From SpriteSheet void FromImage(RenderD7::Image *img);
/// \param img the Image to load from.(RenderD7::Image) bool Draw();
void FromImage(RenderD7::Image *img); void SetCenter(float x, float y);
bool Draw(); void SetPos(float x, float y);
void SetCenter(float x, float y); void SetScale(float x, float y);
void SetPos(float x, float y); void SetRotation(float rotation);
void SetScale(float x, float y); void Rotate(float speed);
void SetRotation(float rotation); float getWidth();
void Rotate(float speed); float getHeigh();
float getWidth(); float getPosX();
float getHeigh(); float getPosY();
float getPosX();
float getPosY(); private:
private: C2D_ImageTint tint;
C2D_ImageTint tint; C2D_Sprite sprite;
C2D_Sprite sprite; };
}; } // namespace RenderD7
}

36
include/renderd7/SpriteAnimation.hpp
View File

@ -1,25 +1,25 @@
#pragma once #pragma once
#include <renderd7/Sprite.hpp>
#include <renderd7/Sheet.hpp> #include <renderd7/Sheet.hpp>
#include <renderd7/Sprite.hpp>
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
namespace RenderD7 namespace RenderD7 {
{ class SpriteSheetAnimation : public RenderD7::Sprite {
class SpriteSheetAnimation : public RenderD7::Sprite public:
{ SpriteSheetAnimation();
public: ~SpriteSheetAnimation();
SpriteSheetAnimation(); void Setup(RenderD7::Sheet *sheet, size_t imagecount, size_t startimage,
~SpriteSheetAnimation(); float frame_begin, float frame_finish);
void Setup(RenderD7::Sheet *sheet, size_t imagecount, size_t startimage, float frame_begin, float frame_finish); void Play(float timespeed);
void Play(float timespeed);
private: private:
size_t images; size_t images;
size_t imgs = 0; size_t imgs = 0;
float D_totaltime; float D_totaltime;
RenderD7::Sheet *sheet; RenderD7::Sheet *sheet;
float time; float time;
}; };
} } // namespace RenderD7

9
include/renderd7/Time.hpp
View File

@ -1,8 +1,7 @@
#pragma once #pragma once
#include <string> #include <string>
namespace RenderD7 namespace RenderD7 {
{ std::string FormatString(std::string fmt_str, ...);
std::string FormatString(std::string fmt_str, ...); std::string GetTimeStr(void);
std::string GetTimeStr(void); } // namespace RenderD7
}

35
include/renderd7/Toast.hpp
View File

@ -1,23 +1,22 @@
#pragma once #pragma once
#include <renderd7/Ovl.hpp>
#include <renderd7/Image.hpp>
#include <renderd7/BitmapPrinter.hpp> #include <renderd7/BitmapPrinter.hpp>
#include <renderd7/Color.hpp> #include <renderd7/Color.hpp>
#include <renderd7/Image.hpp>
#include <renderd7/Ovl.hpp>
#include <renderd7/Screen.hpp> #include <renderd7/Screen.hpp>
namespace RenderD7 namespace RenderD7 {
{ class Toast : public RenderD7::Ovl {
class Toast : public RenderD7::Ovl public:
{ Toast(std::string head, std::string msg);
public: void Draw(void) const override;
Toast(std::string head, std::string msg); void Logic() override;
void Draw(void) const override;
void Logic() override; private:
private: RenderD7::BitmapPrinter toast = RenderD7::BitmapPrinter(400, 70);
RenderD7::BitmapPrinter toast = RenderD7::BitmapPrinter(400, 70); RenderD7::Image *toastrendered;
RenderD7::Image *toastrendered; std::string head, msg;
std::string head, msg; int msgposy = 240;
int msgposy = 240; int delay = 0;
int delay = 0; };
}; } // namespace RenderD7
}

1351
include/renderd7/bmp.hpp
View File

File diff suppressed because it is too large Load Diff

12
include/renderd7/bmpconverter.hpp
View File

@ -3,12 +3,14 @@
#include <iostream> #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 BMP
unsigned decodeBMP(std::vector<unsigned char>& image, unsigned& w, unsigned& h, const std::vector<unsigned char>& bmp); // without alpha channel
unsigned decodeBMP(std::vector<unsigned char> &image, unsigned &w, unsigned &h,
const std::vector<unsigned char> &bmp);
std::vector<unsigned char> ConvertFile(std::string filename); std::vector<unsigned char> ConvertFile(std::string filename);
std::vector<unsigned char> ConvertData(std::vector<unsigned char> data); std::vector<unsigned char> ConvertData(std::vector<unsigned char> data);
} } // namespace BitmapConverter

299
include/renderd7/debugfont.h
View File

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

1206
include/renderd7/ini.hpp
View File

File diff suppressed because it is too large Load Diff

23
include/renderd7/lang.hpp
View File

@ -1,16 +1,15 @@
#pragma once #pragma once
#include <string>
#include <renderd7/external/json.hpp> #include <renderd7/external/json.hpp>
#include <string>
/// RenderD7::Lang /// RenderD7::Lang
namespace RenderD7::Lang namespace RenderD7::Lang {
{ /// Get the 3ds System Language
/// Get the 3ds System Language std::string getSys();
std::string getSys(); /// Get a translated string
/// Get a translated string /// \param key The Key so the code can find your string
/// \param key The Key so the code can find your string std::string get(const std::string &key);
std::string get(const std::string &key); /// Load the lang file from dir structure en/app.json for sample
/// Load the lang file from dir structure en/app.json for sample /// \param lang the folder name en, fr, de ... . I prefer geSys()
/// \param lang the folder name en, fr, de ... . I prefer geSys() void load(const std::string &lang);
void load(const std::string &lang); } // namespace RenderD7::Lang
} /// RenderD7::Lang

42
include/renderd7/log.hpp
View File

@ -6,25 +6,25 @@
#include <unistd.h> #include <unistd.h>
/** Log Class */ /** Log Class */
class Log class Log {
{ public:
public: /** Construct */
/** Construct */ Log();
Log(); /** Deconstruct */
/** Deconstruct */ ~Log();
~Log(); /// Init the log file
/// Init the log file /// \param filename name for the file
/// \param filename name for the file void Init(const char *filename);
void Init(const char *filename); /// Write Text to logfile
/// Write Text to logfile /// \param debug_text your text
/// \param debug_text your text void Write(std::string debug_text);
void Write(std::string debug_text); /// Get the date
/// Get the date std::string logDate(void);
std::string logDate(void); /// Format to logstyle
/// Format to logstyle /// \param fmt_str the formatted style
/// \param fmt_str the formatted style std::string format(const std::string &fmt_str, ...);
std::string format(const std::string& fmt_str, ...);
private: private:
/// \param filename the name of the logfile /// \param filename the name of the logfile
std::string filename; std::string filename;
}; };

180
include/renderd7/parameter.hpp
View File

@ -1,112 +1,118 @@
#pragma once #pragma once
#include <tuple> #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

484
include/renderd7/renderd7.hpp
View File

@ -1,54 +1,63 @@
#pragma once #pragma once
#include <3ds.h> #include <3ds.h>
#include <algorithm>
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
#include <memory>
#include <stack>
#include <string>
#include <functional>
#include <map>
#include <vector>
#include <dirent.h>
#include <unistd.h>
#include <stdio.h>
#include <cstring> #include <cstring>
#include <random> #include <dirent.h>
#include <sys/stat.h>
#include <algorithm>
#include <iostream>
#include <filesystem> #include <filesystem>
#include <functional>
#include <iostream>
#include <locale> #include <locale>
#include <map>
#include <memory>
#include <random>
#include <stack>
#include <stdio.h>
#include <string>
#include <sys/stat.h>
#include <time.h> #include <time.h>
#include <unistd.h>
#include <vector>
#include <codecvt> #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/bmp.hpp>
#include <renderd7/bmpconverter.hpp>
#include <renderd7/Toast.hpp>
#include <renderd7/Ovl.hpp>
#include <renderd7/BitmapPrinter.hpp> #include <renderd7/BitmapPrinter.hpp>
#include <renderd7/Color.hpp>
#include <renderd7/Draw.hpp>
#include <renderd7/Image.hpp> #include <renderd7/Image.hpp>
#include <renderd7/Ovl.hpp>
#include <renderd7/Screen.hpp>
#include <renderd7/Sheet.hpp>
#include <renderd7/Sprite.hpp> #include <renderd7/Sprite.hpp>
#include <renderd7/SpriteAnimation.hpp> #include <renderd7/SpriteAnimation.hpp>
#include <renderd7/Sheet.hpp>
#include <renderd7/Color.hpp>
#include <renderd7/Time.hpp> #include <renderd7/Time.hpp>
#include <renderd7/Screen.hpp> #include <renderd7/Toast.hpp>
#include <renderd7/Draw.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"
{ extern "C" {
#include <renderd7/external/fs.h> #include <renderd7/external/fs.h>
} }
#define RENDERD7VSTRING "0.8.0" #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 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 #define DEFAULT_CENTER 0.5f
/*extern C3D_RenderTarget* Top; /*extern C3D_RenderTarget* Top;
@ -63,220 +72,211 @@ extern touchPosition d7_touch;
extern std::string dspststus; extern std::string dspststus;
/// RenderD7 /// RenderD7
namespace RenderD7 namespace RenderD7 {
float GetDeltaTime();
enum kbd { SWKBD, BKBD };
enum kbd_type { NUMPAD, STANDARD };
struct TObject {
int x; // Position X
int y; // Position Y
int w; // Button Width
int h; // Button Height
std::string text = ""; // Text
float correctx = 0; // Correct X Position
float correcty = 0; // Correct Y Position
float txtsize = 0.7f; // Set Text Size
};
class Scene {
public:
static std::stack<std::unique_ptr<Scene>> scenes;
virtual ~Scene() {}
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 {
private:
enum RState { RSETTINGS, RINFO };
RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS;
std::string rd7srstate = "false";
std::string csvstate = "false";
std::string mtovlstate = "false";
std::string fpsstate = "60";
std::string mtscreenstate = "Top";
std::string mttxtcolstate = "#ffffff";
std::string mtcola = "255";
std::string mttxtcola = "255";
std::vector<RenderD7::TObject> buttons = {
{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();
class DSP_NF : public RenderD7::Ovl {
public:
DSP_NF();
void Draw(void) const override;
void Logic() override;
private:
int msgposy = 240;
int delay = 0;
};
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 Error
namespace Init {
Result Main(std::string app_name = "RD7Game");
Result Reload();
void Graphics();
void NdspFirm(bool useit = false);
} // namespace Init
namespace Exit {
void Main();
void NdspFirm();
void Graphics();
} // namespace Exit
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 Msg
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;
}
} // namespace Convert
struct DirContent {
std::string name;
std::string path;
bool isDir;
};
namespace FS {
bool FileExist(const std::string &path);
}
bool IsNdspInit();
void SetupLog(void);
std::string GetFramerate();
bool MainLoop();
void ExitApp();
void ClearTextBufs(void);
std::string Kbd(int lenght, SwkbdType tp);
void FrameEnd();
void ToggleRD7SR();
bool IsRD7SR();
struct TLBtn {
int x; // Position X
int y; // Position Y
int w; // Button Width
int h; // Button Height
};
struct ScrollList1 {
std::string Text = "";
};
struct ScrollList2 {
float x;
float y;
float w;
float h;
std::string Text = "";
};
/*enum ListType
{ {
float GetDeltaTime(); ONE,
enum kbd{ TWO
SWKBD, };*/
BKBD void DrawList1(RenderD7::ScrollList1 &l, float txtsize, C3D_RenderTarget *t);
}; void DrawTObjects(std::vector<RenderD7::TObject> tobjects, u32 color,
enum kbd_type u32 txtcolor, int selection = -1,
{ u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"),
NUMPAD, u32 selcolor = RenderD7::Color::Hex("#000000"));
STANDARD void DrawSTObject(std::vector<RenderD7::TObject> tobject, int tobjectindex,
}; u32 color, u32 txtcolor);
struct TObject bool touchTObj(touchPosition touch, RenderD7::TObject button);
{ bool touchTLBtn(touchPosition touch, RenderD7::TLBtn button);
int x; //Position X void DrawTLBtns(std::vector<RenderD7::TLBtn> btns, u32 color,
int y; //Position Y int selection = -1,
int w; //Button Width u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"),
int h; //Button Height u32 selcolor = RenderD7::Color::Hex("#000000"));
std::string text = ""; //Text
float correctx = 0; //Correct X Position
float correcty = 0; //Correct Y Position
float txtsize = 0.7f; //Set Text Size
};
class Scene { struct Checkbox {
public: float x, y, s;
static std::stack<std::unique_ptr<Scene>> scenes; bool is_chexked = false;
virtual ~Scene() {} u32 outcol, incol, chcol;
virtual void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) = 0; };
virtual void Draw() const = 0; void DrawCheckbox(Checkbox box);
//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 class Console {
{ public:
private: Console();
enum RState { Console(int x, int y, int w, int h, u8 a = 255);
RSETTINGS, Console(int x, int y, int w, int h, RenderD7::Color::rgba col);
RINFO Console(int x, int y, int w, int h, std::string name,
}; RenderD7::Color::rgba col = {255, 255, 255, 255},
RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS; 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();
std::string rd7srstate = "false"; private:
std::string csvstate = "false"; std::vector<std::string> m_lines;
std::string mtovlstate = "false"; int x, y, w, h;
std::string fpsstate = "60"; std::string m_name = "";
std::string mtscreenstate = "Top"; C3D_RenderTarget *cscreen;
std::string mttxtcolstate = "#ffffff"; bool m_nconsole = false;
std::string mtcola = "255"; bool m_mconsole = false;
std::string mttxtcola = "255"; RenderD7::Color::rgba color = {255, 255, 255, 255};
RenderD7::Color::rgba outlinecol = {222, 222, 222, 255};
RenderD7::Color::rgba barcolor = {0, 0, 0, 255};
};
void GetDirContentsExt(std::vector<RenderD7::DirContent> &dircontent,
std::vector<RenderD7::TObject> buttons = const std::vector<std::string> &extensions);
{ void GetDirContents(std::vector<RenderD7::DirContent> &dircontent);
{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(); } // namespace RenderD7
class DSP_NF : public RenderD7::Ovl
{
public:
DSP_NF();
void Draw(void) const override;
void Logic() override;
private:
int msgposy = 240;
int delay = 0;
};
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
{
std::string name;
std::string path;
bool isDir;
};
namespace FS
{
bool FileExist(const std::string& path);
}
bool IsNdspInit();
void SetupLog(void);
std::string GetFramerate();
bool MainLoop();
void ExitApp();
void ClearTextBufs(void);
std::string Kbd(int lenght, SwkbdType tp);
void FrameEnd();
void ToggleRD7SR();
bool IsRD7SR();
struct TLBtn
{
int x; //Position X
int y; //Position Y
int w; //Button Width
int h; //Button Height
};
struct ScrollList1
{
std::string Text = "";
};
struct ScrollList2
{
float x;
float y;
float w;
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);
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};
};
void GetDirContentsExt(std::vector<RenderD7::DirContent> &dircontent, const std::vector<std::string> &extensions);
void GetDirContents(std::vector<RenderD7::DirContent> &dircontent);
} /// RenderD7

33
include/renderd7/sound.hpp
View File

@ -6,23 +6,22 @@
/** Sound Class */ /** Sound Class */
class sound { class sound {
public: 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 */ /** deconstruct the sound */
~sound(); ~sound();
/** play the sound */ /** play the sound */
void play(); void play();
/** stop the sound */ /** stop the sound */
void stop(); void stop();
private: private:
/// \param dataSize the Size of the filedata /// \param dataSize the Size of the filedata
u32 dataSize; u32 dataSize;
ndspWaveBuf waveBuf; ndspWaveBuf waveBuf;
u8* data = NULL; u8 *data = NULL;
int chnl; int chnl;
}; };

50
include/renderd7/stringtool.hpp
View File

@ -1,44 +1,40 @@
#pragma once #pragma once
#include <string>
#include <iostream>
#include <iomanip> #include <iomanip>
#include <iostream>
#include <string>
namespace RenderD7 namespace RenderD7 {
{ inline bool NameIsEndingWith(const std::string &name,
inline bool NameIsEndingWith(const std::string &name, const std::vector<std::string> &extensions) const std::vector<std::string> &extensions) {
{ if (name.substr(0, 2) == "._")
if (name.substr(0, 2) == "._") return false; return false;
if (name.size() == 0) return false; if (name.size() == 0)
return false;
if (extensions.size() == 0) return true; if (extensions.size() == 0)
return true;
for(int i = 0; i < (int)extensions.size(); i++) { for (int i = 0; i < (int)extensions.size(); i++) {
const std::string ext = extensions.at(i); const std::string ext = extensions.at(i);
if (strcasecmp(name.c_str() + name.size() - ext.size(), ext.c_str()) == 0) return true; if (strcasecmp(name.c_str() + name.size() - ext.size(), ext.c_str()) == 0)
} return true;
return false;
} }
return false;
} }
template<class T> } // namespace RenderD7
T GetFileName(T const & path, T const & delims = "/\\") template <class T> T GetFileName(T const &path, T const &delims = "/\\") {
{
return path.substr(path.find_last_of(delims) + 1); 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('.')); typename T::size_type const p(filename.find_last_of('.'));
return p > 0 && p != T::npos ? filename.substr(0, p) : filename; return p > 0 && p != T::npos ? filename.substr(0, p) : filename;
} }
template< typename T > template <typename T> std::string Int_To_Hex(T i) {
std::string Int_To_Hex( T i )
{
std::stringstream stream; std::stringstream stream;
stream << "0x" stream << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex
<< std::setfill ('0') << std::setw(sizeof(T)*2) << i;
<< std::hex << i;
return stream.str(); return stream.str();
} }

207
include/renderd7/thread.hpp
View File

@ -2,118 +2,135 @@
#include <3ds.h> #include <3ds.h>
#include <atomic> #include <atomic>
#include <functional> #include <functional>
#include <string>
#include <renderd7/parameter.hpp> #include <renderd7/parameter.hpp>
#include <string>
using CTRU_Thread = Thread; using CTRU_Thread = Thread;
#define THREAD_STACK_SIZE 0x1000 #define THREAD_STACK_SIZE 0x1000
namespace RenderD7 { namespace RenderD7 {
namespace Threads namespace Threads {
{ inline bool threadrunning = false;
inline bool threadrunning = false;
struct Thread struct Thread {
{ Handle handle;
Handle handle; void (*ep)(void);
void (*ep)(void); bool finished;
bool finished; void *stacktop;
void* stacktop; };
};
bool Create(); bool Create();
bool Join(); bool Join();
void Exit(); void Exit();
} } // namespace Threads
class Thread { class Thread {
public: public:
/** /**
* @brief Default constructor * @brief Default constructor
* @note This should only be called when calling m3d::Thread::initialize() before calling m3d::Thread::start() * @note This should only be called when calling m3d::Thread::initialize()
*/ * before calling m3d::Thread::start()
Thread(); */
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 Constructs 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
*/
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 Initializes the thread * @brief Destructs the thread
* @param t_function The thread function */
* @param t_parameter The parameter to pass to the function virtual ~Thread();
* @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 Sets the size of the stack that gets allocated for the next thread that get's started * @brief Initializes the thread
* @param t_stackSize The allocated space in bytes (rounded to multiples of 8 bytes) * @param t_function The thread function
*/ * @param t_parameter The parameter to pass to the function
void setStackSize(unsigned long long int t_stackSize); * @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 Starts the thread. To restart it, call Thread::join() before * @brief Sets the size of the stack that gets allocated for the next thread
* @param t_detached Whether the thread should start detached or not * that get's started
*/ * @param t_stackSize The allocated space in bytes (rounded to multiples of 8
void start(bool t_detached = false); * bytes)
*/
void setStackSize(unsigned long long int t_stackSize);
/** /**
* @brief Detaches the thread * @brief Starts the thread. To restart it, call Thread::join() before
*/ * @param t_detached Whether the thread should start detached or not
void kill(); */
void start(bool t_detached = false);
/** /**
* @brief Waits for the thread to finish * @brief Detaches the thread
* @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 Sleeps for the given time * @brief Puts the thread to sleep
* @param t_milliseconds The time to sleep in milliseconds *
*/ * This is needed if you have multiple threads running at the same time. It
static void sleep(int t_milliseconds); * 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();
private: /**
struct ThreadData { * @brief Sleeps for the given time
RenderD7::Parameter m_parameter; * @param t_milliseconds The time to sleep in milliseconds
std::function<void(RenderD7::Parameter)> m_function; */
std::atomic<bool>* m_running; static void sleep(int t_milliseconds);
};
static void threadFunction(void* t_arg); private:
/* data */ struct ThreadData {
int m_priority, m_stackSize; RenderD7::Parameter m_parameter;
bool m_started; std::function<void(RenderD7::Parameter)> m_function;
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 */
int m_priority, m_stackSize;
bool m_started;
std::atomic<bool> m_running;
RenderD7::Thread::ThreadData m_data;
CTRU_Thread m_thread;
};
} // namespace RenderD7

25
include/renderd7/tween.hpp
View File

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

803
source/BitmapPrinter.cpp
View File

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

34
source/Color.cpp
View File

@ -1,22 +1,24 @@
#include <renderd7/Color.hpp> #include <renderd7/Color.hpp>
#define RGBA8(r, g, b, a) ((((r) & 0xFF) << 0) | (((g) & 0xFF) << 8) | (((b) & 0xFF) << 16) | (((a) & 0xFF) << 24)) #define RGBA8(r, g, b, a) \
((((r)&0xFF) << 0) | (((g)&0xFF) << 8) | (((b)&0xFF) << 16) | \
(((a)&0xFF) << 24))
uint32_t RenderD7::Color::Hex(const std::string color, uint8_t a) uint32_t RenderD7::Color::Hex(const std::string color, uint8_t a) {
{ if (color.length() < 7 ||
if (color.length() < 7 || std::regex_search(color.substr(1), std::regex("[^0-9A-Fa-f]"))) { // invalid color. std::regex_search(color.substr(1),
return RenderD7::Color::Hex("#000000", 0); std::regex("[^0-9A-Fa-f]"))) { // invalid color.
} return RenderD7::Color::Hex("#000000", 0);
int r = std::stoi(color.substr(1, 2), nullptr, 16); }
int g = std::stoi(color.substr(3, 2), nullptr, 16); int r = std::stoi(color.substr(1, 2), nullptr, 16);
int b = std::stoi(color.substr(5, 2), nullptr, 16); int g = std::stoi(color.substr(3, 2), nullptr, 16);
return RGBA8(r, g, b, a); int b = std::stoi(color.substr(5, 2), nullptr, 16);
return RGBA8(r, g, b, a);
} }
std::string RenderD7::Color::RGB2Hex(int r, int g, int b) std::string RenderD7::Color::RGB2Hex(int r, int g, int b) {
{ std::stringstream ss;
std::stringstream ss; ss << "#";
ss << "#"; ss << std::hex << (r << 16 | g << 8 | b);
ss << std::hex << (r << 16 | g << 8 | b ); return ss.str();
return ss.str();
} }

305
source/Draw.cpp
View File

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

536
source/FileSystem.cpp
View File

@ -1,324 +1,344 @@
#include <renderd7/FileSystem.hpp>
#include <3ds.h> #include <3ds.h>
#include <cstring> #include <cstring>
//Debugging #include <renderd7/FileSystem.hpp>
// Debugging
#include <memory> #include <memory>
#include <renderd7/Ovl.hpp> #include <renderd7/Ovl.hpp>
#include <renderd7/Toast.hpp> #include <renderd7/Toast.hpp>
const char* RenderD7::FileSystem::GetPhysfsError() const char *RenderD7::FileSystem::GetPhysfsError() {
{ return PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode());
return PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode());
} }
std::string RenderD7::FileSystem::Normalize(const std::string& input) std::string RenderD7::FileSystem::Normalize(const std::string &input) {
{ std::string out;
std::string out; bool seenSep = false, isSep = false;
bool seenSep = false, isSep = false;
for (size_t i = 0; i < input.size(); ++i) for (size_t i = 0; i < input.size(); ++i) {
{ isSep = (input[i] == '/');
isSep = (input[i] == '/');
if (!isSep || !seenSep) if (!isSep || !seenSep)
out += input[i]; out += input[i];
seenSep = isSep; seenSep = isSep;
} }
return out; return out;
} }
void RenderD7::FileSystem::Initialize() void RenderD7::FileSystem::Initialize() { RenderD7::FileSystem::savePath = ""; }
{
RenderD7::FileSystem::savePath = ""; int RenderD7::FileSystem::Init(const char *argv) {
int res = PHYSFS_init(argv);
if (res != 1) {
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
}
return res;
} }
int RenderD7::FileSystem::Init(const char* argv) bool RenderD7::FileSystem::SetSource(const char *source) {
{ if (!PHYSFS_isInit())
int res = PHYSFS_init(argv); RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
if (res != 1) "PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
{ return false;
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
} std::string searchPath = source;
if (!PHYSFS_mount(searchPath.c_str(), NULL, 1))
return res; RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
return true;
} }
bool RenderD7::FileSystem::SetSource(const char* source) bool RenderD7::FileSystem::SetIdentity(const char *name, bool append) {
{ if (!PHYSFS_isInit())
if (!PHYSFS_isInit()) RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); "PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false; return false;
std::string searchPath = source; std::string old = RenderD7::FileSystem::savePath;
if (!PHYSFS_mount(searchPath.c_str(), NULL, 1))
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
return true; RenderD7::FileSystem::savePath = RenderD7::FileSystem::Normalize(
RenderD7::FileSystem::GetUserDirectory() + "/save/" + name);
printf("Save Path set to %s\n", savePath.c_str());
if (!old.empty())
PHYSFS_unmount(old.c_str());
int success = PHYSFS_mount(savePath.c_str(), NULL, append);
printf("Save Path mounted %d\n", success);
PHYSFS_setWriteDir(nullptr);
return true;
} }
bool RenderD7::FileSystem::SetIdentity(const char* name, bool append) std::string RenderD7::FileSystem::GetSaveDirectory() {
{ return RenderD7::FileSystem::Normalize(
if (!PHYSFS_isInit()) RenderD7::FileSystem::GetUserDirectory() + "/save");
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); }
return false;
std::string old = RenderD7::FileSystem::savePath; bool RenderD7::FileSystem::SetupWriteDirectory() {
if (!PHYSFS_isInit())
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
RenderD7::FileSystem::savePath = RenderD7::FileSystem::Normalize(RenderD7::FileSystem::GetUserDirectory() + "/save/" + name); if (RenderD7::FileSystem::savePath.empty())
printf("Save Path set to %s\n", savePath.c_str()); RenderD7::AddOvl(
std::make_unique<RenderD7::Toast>("PHYSFS-Error", "Path is Empty"));
return false;
if (!old.empty()) std::string tmpWritePath = RenderD7::FileSystem::savePath;
PHYSFS_unmount(old.c_str()); std::string tmpDirectoryPath = RenderD7::FileSystem::savePath;
int success = PHYSFS_mount(savePath.c_str(), NULL, append); if (RenderD7::FileSystem::savePath.find(
printf("Save Path mounted %d\n", success); RenderD7::FileSystem::GetUserDirectory()) == 0) {
tmpWritePath = RenderD7::FileSystem::GetUserDirectory();
tmpDirectoryPath =
savePath.substr(RenderD7::FileSystem::GetUserDirectory().length());
/* strip leading '/' characters from the path we want to create */
size_t startPosition = tmpDirectoryPath.find_first_not_of('/');
if (startPosition != std::string::npos)
tmpDirectoryPath = tmpDirectoryPath.substr(startPosition);
}
if (!PHYSFS_setWriteDir(tmpWritePath.c_str())) {
printf("Failed to set write dir to %s\n", tmpWritePath.c_str());
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error",
RenderD7::FormatString("Failed to set write dir to %s\n",
tmpWritePath.c_str())));
return false;
}
if (!RenderD7::FileSystem::CreateDirectory(tmpDirectoryPath.c_str())) {
printf("Failed to create dir %s\n", tmpDirectoryPath.c_str());
/* clear the write directory in case of error */
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FormatString("Failed to create dir %s\n",
tmpDirectoryPath.c_str())));
PHYSFS_setWriteDir(nullptr); PHYSFS_setWriteDir(nullptr);
return false;
}
return true; if (!PHYSFS_setWriteDir(savePath.c_str())) {
printf("Failed to set write dir to %s\n", savePath.c_str());
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error",
RenderD7::FormatString("Failed to set write dir to %s\n",
savePath.c_str())));
return false;
}
if (!PHYSFS_mount(savePath.c_str(), nullptr, 0)) {
printf("Failed to mount write dir (%s)\n",
RenderD7::FileSystem::GetPhysfsError());
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error",
RenderD7::FormatString("Failed to mount write dir (%s)\n",
RenderD7::FileSystem::GetPhysfsError())));
/* clear the write directory in case of error */
PHYSFS_setWriteDir(nullptr);
return false;
}
return true;
} }
std::string RenderD7::FileSystem::GetSaveDirectory() std::string RenderD7::FileSystem::GetUserDirectory() {
{ return RenderD7::FileSystem::Normalize(
return RenderD7::FileSystem::Normalize(RenderD7::FileSystem::GetUserDirectory() + "/save"); PHYSFS_getPrefDir("npi-d7", "renderd7"));
} }
bool RenderD7::FileSystem::SetupWriteDirectory() bool RenderD7::FileSystem::GetInfo(const char *filename,
{ RenderD7::FileSystem::Info &info) {
if (!PHYSFS_isInit()) if (!PHYSFS_isInit())
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
return false; "PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
if (RenderD7::FileSystem::savePath.empty()) PHYSFS_Stat stat = {};
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", "Path is Empty"));
return false;
std::string tmpWritePath = RenderD7::FileSystem::savePath; if (!PHYSFS_stat(filename, &stat))
std::string tmpDirectoryPath = RenderD7::FileSystem::savePath; RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
if (RenderD7::FileSystem::savePath.find(RenderD7::FileSystem::GetUserDirectory()) == 0) info.mod_time =
{ std::min<int64_t>(stat.modtime, RenderD7::FileSystem::MAX_STAMP);
tmpWritePath = RenderD7::FileSystem::GetUserDirectory(); info.size = std::min<int64_t>(stat.filesize, RenderD7::FileSystem::MAX_STAMP);
tmpDirectoryPath = savePath.substr(RenderD7::FileSystem::GetUserDirectory().length());
/* strip leading '/' characters from the path we want to create */ if (stat.filetype == PHYSFS_FILETYPE_REGULAR)
size_t startPosition = tmpDirectoryPath.find_first_not_of('/'); info.type = RenderD7::FileSystem::FileType_File;
else if (stat.filetype == PHYSFS_FILETYPE_DIRECTORY)
info.type = RenderD7::FileSystem::FileType_Directory;
else if (stat.filetype == PHYSFS_FILETYPE_SYMLINK)
info.type = RenderD7::FileSystem::FileType_SymLink;
else
info.type = RenderD7::FileSystem::FileType_Other;
if (startPosition != std::string::npos) return true;
tmpDirectoryPath = tmpDirectoryPath.substr(startPosition);
}
if (!PHYSFS_setWriteDir(tmpWritePath.c_str()))
{
printf("Failed to set write dir to %s\n", tmpWritePath.c_str());
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Failed to set write dir to %s\n", tmpWritePath.c_str())));
return false;
}
if (!RenderD7::FileSystem::CreateDirectory(tmpDirectoryPath.c_str()))
{
printf("Failed to create dir %s\n", tmpDirectoryPath.c_str());
/* clear the write directory in case of error */
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Failed to create dir %s\n", tmpDirectoryPath.c_str())));
PHYSFS_setWriteDir(nullptr);
return false;
}
if (!PHYSFS_setWriteDir(savePath.c_str()))
{
printf("Failed to set write dir to %s\n", savePath.c_str());
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Failed to set write dir to %s\n", savePath.c_str())));
return false;
}
if (!PHYSFS_mount(savePath.c_str(), nullptr, 0))
{
printf("Failed to mount write dir (%s)\n", RenderD7::FileSystem::GetPhysfsError());
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Failed to mount write dir (%s)\n", RenderD7::FileSystem::GetPhysfsError())));
/* clear the write directory in case of error */
PHYSFS_setWriteDir(nullptr);
return false;
}
return true;
} }
std::string RenderD7::FileSystem::GetUserDirectory() void RenderD7::FileSystem::GetDirectoryItems(const char *path,
{ std::vector<std::string> &items) {
return RenderD7::FileSystem::Normalize(PHYSFS_getPrefDir("npi-d7", "renderd7")); if (!PHYSFS_isInit())
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return;
char **results = PHYSFS_enumerateFiles(path);
if (results == nullptr)
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return;
for (char **item = results; *item != 0; item++)
items.push_back(*item);
PHYSFS_freeList(results);
} }
bool RenderD7::FileSystem::GetInfo(const char* filename, RenderD7::FileSystem::Info& info) bool RenderD7::FileSystem::OpenFile(File &file, const char *name,
{ FileMode mode) {
if (!PHYSFS_isInit()) if (mode == FileMode_Closed)
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
return false; "PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
PHYSFS_Stat stat = {}; if (!PHYSFS_isInit())
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
if (!PHYSFS_stat(filename, &stat)) if (file.handle)
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); RenderD7::FileSystem::CloseFile(file);
return false;
info.mod_time = std::min<int64_t>(stat.modtime, RenderD7::FileSystem::MAX_STAMP); if (mode == FileMode_Read && !PHYSFS_exists(name)) {
info.size = std::min<int64_t>(stat.filesize, RenderD7::FileSystem::MAX_STAMP); printf("Could not open file %s, does not exist.\n", name);
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error",
RenderD7::FormatString("Could not open file %s, does not exist.\n",
name)));
return false;
}
if (stat.filetype == PHYSFS_FILETYPE_REGULAR) if ((mode == FileMode_Write) &&
info.type = RenderD7::FileSystem::FileType_File; (PHYSFS_getWriteDir() == nullptr &&
else if (stat.filetype == PHYSFS_FILETYPE_DIRECTORY) RenderD7::FileSystem::SetupWriteDirectory())) {
info.type = RenderD7::FileSystem::FileType_Directory; printf("Could not set write directory.\n");
else if (stat.filetype == PHYSFS_FILETYPE_SYMLINK) RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
info.type = RenderD7::FileSystem::FileType_SymLink; "PHYSFS-Error",
else RenderD7::FormatString("Could not set write directory.\n")));
info.type = RenderD7::FileSystem::FileType_Other; return false;
}
return true; PHYSFS_getLastErrorCode();
switch (mode) {
case FileMode_Read:
file.handle = PHYSFS_openRead(name);
break;
case FileMode_Write:
file.handle = PHYSFS_openWrite(name);
break;
default:
break;
}
if (!file.handle) {
const char *error = RenderD7::FileSystem::GetPhysfsError();
if (error == nullptr)
error = "unknown error";
printf("Could not open file %s (%s)\n", name, error);
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error",
RenderD7::FormatString("Could not open file %s (%s)\n", name, error)));
return false;
}
file.mode = mode;
return true;
} }
void RenderD7::FileSystem::GetDirectoryItems(const char* path, std::vector<std::string>& items) bool RenderD7::FileSystem::CloseFile(File &file) {
{ if (file.handle == nullptr || !PHYSFS_close(file.handle))
if (!PHYSFS_isInit()) return false;
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return;
char** results = PHYSFS_enumerateFiles(path); file.handle = nullptr;
if (results == nullptr) return true;
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return;
for (char** item = results; *item != 0; item++)
items.push_back(*item);
PHYSFS_freeList(results);
} }
bool RenderD7::FileSystem::OpenFile(File& file, const char* name, FileMode mode) bool RenderD7::FileSystem::CreateDirectory(const char *name) {
{ if (!PHYSFS_isInit())
if (mode == FileMode_Closed) RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); "PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false; return false;
if (!PHYSFS_isInit()) if (PHYSFS_getWriteDir() == nullptr &&
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); !RenderD7::FileSystem::SetupWriteDirectory())
return false; RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
if (file.handle) if (!PHYSFS_mkdir(name))
RenderD7::FileSystem::CloseFile(file); RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
if (mode == FileMode_Read && !PHYSFS_exists(name)) return true;
{
printf("Could not open file %s, does not exist.\n", name);
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Could not open file %s, does not exist.\n", name)));
return false;
}
if ((mode == FileMode_Write) &&
(PHYSFS_getWriteDir() == nullptr && RenderD7::FileSystem::SetupWriteDirectory()))
{
printf("Could not set write directory.\n");
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Could not set write directory.\n")));
return false;
}
PHYSFS_getLastErrorCode();
switch (mode)
{
case FileMode_Read:
file.handle = PHYSFS_openRead(name);
break;
case FileMode_Write:
file.handle = PHYSFS_openWrite(name);
break;
default:
break;
}
if (!file.handle)
{
const char* error = RenderD7::FileSystem::GetPhysfsError();
if (error == nullptr)
error = "unknown error";
printf("Could not open file %s (%s)\n", name, error);
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Could not open file %s (%s)\n", name, error)));
return false;
}
file.mode = mode;
return true;
} }
bool RenderD7::FileSystem::CloseFile(File& file) int64_t RenderD7::FileSystem::ReadFile(File &file, void *destination,
{ int64_t size) {
if (file.handle == nullptr || !PHYSFS_close(file.handle)) if (!file.handle || file.mode != FileMode_Read) {
return false; printf("File is not opened for reading.\n");
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", "File is not opened for reading.\n"));
return 0;
}
file.handle = nullptr; if (size > file.GetSize())
size = file.GetSize();
else if (size < 0) {
printf("Invalid read size %lld\n", size);
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error",
RenderD7::FormatString("Invalid read size %lld\n", size)));
return 0;
}
return true; return PHYSFS_readBytes(file.handle, destination, (PHYSFS_uint64)size);
} }
bool RenderD7::FileSystem::CreateDirectory(const char* name) bool RenderD7::FileSystem::WriteFile(File &file, const void *data,
{ int64_t size) {
if (!PHYSFS_isInit()) if (!file.handle || file.mode != FileMode_Write) {
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); printf("File is not opened for writing.\n");
return false; RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"PHYSFS-Error", "File is not opened for writing.\n"));
return false;
}
if (PHYSFS_getWriteDir() == nullptr && !RenderD7::FileSystem::SetupWriteDirectory()) int64_t written = PHYSFS_writeBytes(file.handle, data, (PHYSFS_uint64)size);
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
if (!PHYSFS_mkdir(name)) if (written != size) {
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError())); RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
return false; "PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
}
return true; return true;
}
int64_t RenderD7::FileSystem::ReadFile(File& file, void* destination, int64_t size)
{
if (!file.handle || file.mode != FileMode_Read)
{
printf("File is not opened for reading.\n");
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", "File is not opened for reading.\n"));
return 0;
}
if (size > file.GetSize())
size = file.GetSize();
else if (size < 0)
{
printf("Invalid read size %lld\n", size);
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FormatString("Invalid read size %lld\n", size)));
return 0;
}
return PHYSFS_readBytes(file.handle, destination, (PHYSFS_uint64)size);
}
bool RenderD7::FileSystem::WriteFile(File& file, const void* data, int64_t size)
{
if (!file.handle || file.mode != FileMode_Write)
{
printf("File is not opened for writing.\n");
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", "File is not opened for writing.\n"));
return false;
}
int64_t written = PHYSFS_writeBytes(file.handle, data, (PHYSFS_uint64)size);
if (written != size){
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("PHYSFS-Error", RenderD7::FileSystem::GetPhysfsError()));
return false;
}
return true;
} }

457
source/Image.cpp
View File

@ -4,252 +4,257 @@
extern bool usedbgmsg; extern bool usedbgmsg;
static u32 GetNextPowerOf2(u32 v) { static u32 GetNextPowerOf2(u32 v) {
v--; v--;
v |= v >> 1; v |= v >> 1;
v |= v >> 2; v |= v >> 2;
v |= v >> 4; v |= v >> 4;
v |= v >> 8; v |= v >> 8;
v |= v >> 16; v |= v >> 16;
v++; v++;
return (v >= 64 ? v : 64); return (v >= 64 ? v : 64);
} }
static bool C3DTexToC2DImage(C2D_Image *texture, u32 width, u32 height, u8 *buf) { static bool C3DTexToC2DImage(C2D_Image *texture, u32 width, u32 height,
if (width >= 1024 || height >= 1024) u8 *buf) {
return false; if (width >= 1024 || height >= 1024)
C3D_Tex *tex = new C3D_Tex[sizeof(C3D_Tex)];
Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture[sizeof(Tex3DS_SubTexture)];
subtex->width = static_cast<u16>(width);
subtex->height = static_cast<u16>(height);
// RGBA -> ABGR
for (u32 row = 0; row < subtex->width; row++) {
for (u32 col = 0; col < subtex->height; col++) {
u32 z = (row + col * subtex->width) * 4;
u8 r = *(u8 *)(buf + z);
u8 g = *(u8 *)(buf + z + 1);
u8 b = *(u8 *)(buf + z + 2);
u8 a = *(u8 *)(buf + z + 3);
*(buf + z) = a;
*(buf + z + 1) = b;
*(buf + z + 2) = g;
*(buf + z + 3) = r;
}
}
u32 w_pow2 = GetNextPowerOf2(subtex->width);
u32 h_pow2 = GetNextPowerOf2(subtex->height);
subtex->left = 0.f;
subtex->top = 1.f;
subtex->right = (subtex->width /static_cast<float>(w_pow2));
subtex->bottom = (1.0 - (subtex->height / static_cast<float>(h_pow2)));
C3D_TexInit(tex, static_cast<u16>(w_pow2), static_cast<u16>(h_pow2), GPU_RGBA8);
C3D_TexSetFilter(tex, GPU_NEAREST, GPU_NEAREST);
std::memset(tex->data, 0, tex->size);
for (u32 x = 0; x < subtex->width; x++) {
for (u32 y = 0; y < subtex->height; y++) {
u32 dst_pos = ((((y >> 3) * (w_pow2 >> 3) + (x >> 3)) << 6) + ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) * 4;
u32 src_pos = (y * subtex->width + x) * 4;
std::memcpy(&(static_cast<u8 *>(tex->data))[dst_pos], &(static_cast<u8 *>(buf))[src_pos], 4);
}
}
C3D_TexFlush(tex);
tex->border = RenderD7::Color::Hex("#000000", 0);
C3D_TexSetWrap(tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
if (tex && subtex) {
texture->tex = tex;
texture->subtex = subtex;
return true;
}
return false; return false;
C3D_Tex *tex = new C3D_Tex[sizeof(C3D_Tex)];
Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture[sizeof(Tex3DS_SubTexture)];
subtex->width = static_cast<u16>(width);
subtex->height = static_cast<u16>(height);
// RGBA -> ABGR
for (u32 row = 0; row < subtex->width; row++) {
for (u32 col = 0; col < subtex->height; col++) {
u32 z = (row + col * subtex->width) * 4;
u8 r = *(u8 *)(buf + z);
u8 g = *(u8 *)(buf + z + 1);
u8 b = *(u8 *)(buf + z + 2);
u8 a = *(u8 *)(buf + z + 3);
*(buf + z) = a;
*(buf + z + 1) = b;
*(buf + z + 2) = g;
*(buf + z + 3) = r;
}
}
u32 w_pow2 = GetNextPowerOf2(subtex->width);
u32 h_pow2 = GetNextPowerOf2(subtex->height);
subtex->left = 0.f;
subtex->top = 1.f;
subtex->right = (subtex->width / static_cast<float>(w_pow2));
subtex->bottom = (1.0 - (subtex->height / static_cast<float>(h_pow2)));
C3D_TexInit(tex, static_cast<u16>(w_pow2), static_cast<u16>(h_pow2),
GPU_RGBA8);
C3D_TexSetFilter(tex, GPU_NEAREST, GPU_NEAREST);
std::memset(tex->data, 0, tex->size);
for (u32 x = 0; x < subtex->width; x++) {
for (u32 y = 0; y < subtex->height; y++) {
u32 dst_pos = ((((y >> 3) * (w_pow2 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
4;
u32 src_pos = (y * subtex->width + x) * 4;
std::memcpy(&(static_cast<u8 *>(tex->data))[dst_pos],
&(static_cast<u8 *>(buf))[src_pos], 4);
}
}
C3D_TexFlush(tex);
tex->border = RenderD7::Color::Hex("#000000", 0);
C3D_TexSetWrap(tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
if (tex && subtex) {
texture->tex = tex;
texture->subtex = subtex;
return true;
}
return false;
} }
extern "C" extern "C" {
{ #include <renderd7/external/libnsbmp/libnsbmp.h>
#include <renderd7/external/libnsbmp/libnsbmp.h>
} }
static const u32 BYTES_PER_PIXEL = 4; static const u32 BYTES_PER_PIXEL = 4;
#define MAX_IMAGE_BYTES (48 * 1024 * 1024) #define MAX_IMAGE_BYTES (48 * 1024 * 1024)
namespace LIBBMP { namespace LIBBMP {
static void *bitmap_create(int width, int height, [[maybe_unused]] unsigned int state) { static void *bitmap_create(int width, int height,
/* ensure a stupidly large (>50Megs or so) bitmap is not created */ [[maybe_unused]] unsigned int state) {
if ((static_cast<long long>(width) * static_cast<long long>(height)) > (MAX_IMAGE_BYTES/BYTES_PER_PIXEL)) /* ensure a stupidly large (>50Megs or so) bitmap is not created */
return nullptr; if ((static_cast<long long>(width) * static_cast<long long>(height)) >
(MAX_IMAGE_BYTES / BYTES_PER_PIXEL))
return std::calloc(width * height, BYTES_PER_PIXEL); return nullptr;
return std::calloc(width * height, BYTES_PER_PIXEL);
}
static unsigned char *bitmap_get_buffer(void *bitmap) {
assert(bitmap);
return static_cast<unsigned char *>(bitmap);
}
static size_t bitmap_get_bpp([[maybe_unused]] void *bitmap) {
return BYTES_PER_PIXEL;
}
static void bitmap_destroy(void *bitmap) {
assert(bitmap);
std::free(bitmap);
}
} // namespace LIBBMP
unsigned Image_to_C3D(C2D_Image img, const std::vector<unsigned char> &bmpc) {
bmp_bitmap_callback_vt bitmap_callbacks = {
LIBBMP::bitmap_create, LIBBMP::bitmap_destroy, LIBBMP::bitmap_get_buffer,
LIBBMP::bitmap_get_bpp};
bmp_result code = BMP_OK;
bmp_image bmp;
bmp_create(&bmp, &bitmap_callbacks);
code = bmp_analyse(&bmp, bmpc.size(), (u8 *)bmpc.data());
if (code != BMP_OK) {
bmp_finalise(&bmp);
return 1;
}
code = bmp_decode(&bmp);
if (code != BMP_OK) {
if ((code != BMP_INSUFFICIENT_DATA) && (code != BMP_DATA_ERROR)) {
bmp_finalise(&bmp);
return 2;
} }
static unsigned char *bitmap_get_buffer(void *bitmap) { /* skip if the decoded image would be ridiculously large */
assert(bitmap); if ((bmp.width * bmp.height) > 200000) {
return static_cast<unsigned char *>(bitmap); bmp_finalise(&bmp);
return 3;
} }
}
static size_t bitmap_get_bpp([[maybe_unused]] void *bitmap) { C2D_Image *texture = new C2D_Image();
return BYTES_PER_PIXEL; bool ret = C3DTexToC2DImage(texture, static_cast<u32>(bmp.width),
static_cast<u32>(bmp.height),
static_cast<u8 *>(bmp.bitmap));
bmp_finalise(&bmp);
delete texture;
if (!ret) {
return 4;
}
return 0;
}
void RenderD7::Image::LoadPng(const std::string path) {
if (usedbgmsg) {
// RenderD7::Msg::Display("RenderD7", "Loading Png:" + path, Top);
}
std::vector<u8> ImageBuffer;
unsigned width, height;
if (loadet) {
C3D_TexDelete(this->img.tex);
loadet = false;
}
lodepng::decode(ImageBuffer, width, height, path);
this->img.tex = new C3D_Tex;
this->img.subtex =
new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
width / 1024.0f, 1.0f - (height / 1024.0f)});
C3D_TexInit(this->img.tex, 1024, 1024, GPU_RGBA8);
C3D_TexSetFilter(this->img.tex, GPU_LINEAR, GPU_LINEAR);
this->img.tex->border = 0xFFFFFFFF;
C3D_TexSetWrap(this->img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
for (u32 x = 0; x < width && x < 1024; x++) {
for (u32 y = 0; y < height && y < 1024; y++) {
const u32 dstPos = ((((y >> 3) * (1024 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
4;
const u32 srcPos = (y * width + x) * 4;
((uint8_t *)this->img.tex->data)[dstPos + 0] =
ImageBuffer.data()[srcPos + 3];
((uint8_t *)this->img.tex->data)[dstPos + 1] =
ImageBuffer.data()[srcPos + 2];
((uint8_t *)this->img.tex->data)[dstPos + 2] =
ImageBuffer.data()[srcPos + 1];
((uint8_t *)this->img.tex->data)[dstPos + 3] =
ImageBuffer.data()[srcPos + 0];
} }
}
static void bitmap_destroy(void *bitmap) { loadet = true;
assert(bitmap); }
std::free(bitmap);
RenderD7::Image::~Image() {
if (loadet)
C3D_TexDelete(img.tex);
loadet = false;
}
void RenderD7::Image::Unload() {
if (loadet)
C3D_TexDelete(img.tex);
loadet = false;
}
void RenderD7::Image::LoadPFromBuffer(const std::vector<u8> &buffer) {
std::vector<u8> ImageBuffer;
if (loadet) {
C3D_TexDelete(this->img.tex);
loadet = false;
}
unsigned width, height;
lodepng::decode(ImageBuffer, width, height, buffer);
img.tex = new C3D_Tex;
img.subtex =
new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
width / 512.0f, 1.0f - (height / 512.0f)});
C3D_TexInit(img.tex, 512, 512, GPU_RGBA8);
C3D_TexSetFilter(img.tex, GPU_LINEAR, GPU_LINEAR);
img.tex->border = 0xFFFFFFFF;
C3D_TexSetWrap(img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
for (u32 x = 0; x < width && x < 512; x++) {
for (u32 y = 0; y < height && y < 512; y++) {
const u32 dstPos = ((((y >> 3) * (512 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
4;
const u32 srcPos = (y * width + x) * 4;
((uint8_t *)img.tex->data)[dstPos + 0] = ImageBuffer.data()[srcPos + 3];
((uint8_t *)img.tex->data)[dstPos + 1] = ImageBuffer.data()[srcPos + 2];
((uint8_t *)img.tex->data)[dstPos + 2] = ImageBuffer.data()[srcPos + 1];
((uint8_t *)img.tex->data)[dstPos + 3] = ImageBuffer.data()[srcPos + 0];
} }
}
} }
void RenderD7::Image::FromSheet(RenderD7::Sheet sheet, size_t index) {}
unsigned Image_to_C3D(C2D_Image img, const std::vector<unsigned char>& bmpc) { bool RenderD7::Image::Draw(float x, float y, float scaleX, float scaleY) {
bmp_bitmap_callback_vt bitmap_callbacks = { if (loadet)
LIBBMP::bitmap_create, return C2D_DrawImageAt(this->img, x, y, 0.5f, nullptr, scaleX, scaleY);
LIBBMP::bitmap_destroy, return false;
LIBBMP::bitmap_get_buffer,
LIBBMP::bitmap_get_bpp
};
bmp_result code = BMP_OK;
bmp_image bmp;
bmp_create(&bmp, &bitmap_callbacks);
code = bmp_analyse(&bmp, bmpc.size(), (u8*)bmpc.data());
if (code != BMP_OK) {
bmp_finalise(&bmp);
return 1;
}
code = bmp_decode(&bmp);
if (code != BMP_OK) {
if ((code != BMP_INSUFFICIENT_DATA) && (code != BMP_DATA_ERROR)) {
bmp_finalise(&bmp);
return 2;
}
/* skip if the decoded image would be ridiculously large */
if ((bmp.width * bmp.height) > 200000) {
bmp_finalise(&bmp);
return 3;
}
}
C2D_Image* texture = new C2D_Image();
bool ret = C3DTexToC2DImage(texture, static_cast<u32>(bmp.width), static_cast<u32>(bmp.height), static_cast<u8 *>(bmp.bitmap));
bmp_finalise(&bmp);
delete texture;
if (!ret)
{
return 4;
}
return 0;
} }
void RenderD7::Image::LoadPng(const std::string path) void RenderD7::Image::LoadFromBitmap(BMP bitmap) {
{ loadet = false;
if (usedbgmsg) unsigned error = Image_to_C3D(this->img, bitmap.DATA());
{ if (error == 0) {
//RenderD7::Msg::Display("RenderD7", "Loading Png:" + path, Top); this->loadet = true;
} }
std::vector<u8> ImageBuffer;
unsigned width, height;
if (loadet)
{
C3D_TexDelete(this->img.tex);
loadet = false;
}
lodepng::decode(ImageBuffer, width, height, path);
this->img.tex = new C3D_Tex; if (error) {
this->img.subtex = new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f, width / 1024.0f, 1.0f - (height / 1024.0f)});
C3D_TexInit(this->img.tex, 1024, 1024, GPU_RGBA8);
C3D_TexSetFilter(this->img.tex, GPU_LINEAR, GPU_LINEAR);
this->img.tex->border = 0xFFFFFFFF;
C3D_TexSetWrap(this->img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
for (u32 x = 0; x < width && x < 1024; x++) {
for (u32 y = 0; y < height && y < 1024; y++) {
const u32 dstPos = ((((y >> 3) * (1024 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | ((y & 2) << 2) |
((x & 4) << 2) | ((y & 4) << 3))) * 4;
const u32 srcPos = (y * width + x) * 4;
((uint8_t *)this->img.tex->data)[dstPos + 0] = ImageBuffer.data()[srcPos + 3];
((uint8_t *)this->img.tex->data)[dstPos + 1] = ImageBuffer.data()[srcPos + 2];
((uint8_t *)this->img.tex->data)[dstPos + 2] = ImageBuffer.data()[srcPos + 1];
((uint8_t *)this->img.tex->data)[dstPos + 3] = ImageBuffer.data()[srcPos + 0];
}
}
loadet = true;
}
RenderD7::Image::~Image()
{
if(loadet) C3D_TexDelete(img.tex);
loadet = false;
}
void RenderD7::Image::Unload()
{
if(loadet) C3D_TexDelete(img.tex);
loadet = false;
}
void RenderD7::Image::LoadPFromBuffer(const std::vector<u8> &buffer)
{
std::vector<u8> ImageBuffer;
if (loadet)
{
C3D_TexDelete(this->img.tex);
loadet = false;
}
unsigned width, height;
lodepng::decode(ImageBuffer, width, height, buffer);
img.tex = new C3D_Tex;
img.subtex = new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f, width / 512.0f, 1.0f - (height / 512.0f)});
C3D_TexInit(img.tex, 512, 512, GPU_RGBA8);
C3D_TexSetFilter(img.tex, GPU_LINEAR, GPU_LINEAR);
img.tex->border = 0xFFFFFFFF;
C3D_TexSetWrap(img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
for (u32 x = 0; x < width && x < 512; x++) {
for (u32 y = 0; y < height && y < 512; y++) {
const u32 dstPos = ((((y >> 3) * (512 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | ((y & 2) << 2) |
((x & 4) << 2) | ((y & 4) << 3))) * 4;
const u32 srcPos = (y * width + x) * 4;
((uint8_t *)img.tex->data)[dstPos + 0] = ImageBuffer.data()[srcPos + 3];
((uint8_t *)img.tex->data)[dstPos + 1] = ImageBuffer.data()[srcPos + 2];
((uint8_t *)img.tex->data)[dstPos + 2] = ImageBuffer.data()[srcPos + 1];
((uint8_t *)img.tex->data)[dstPos + 3] = ImageBuffer.data()[srcPos + 0];
}
}
}
void RenderD7::Image::FromSheet(RenderD7::Sheet sheet, size_t index)
{
}
bool RenderD7::Image::Draw(float x, float y, float scaleX, float scaleY)
{
if(loadet) return C2D_DrawImageAt(this->img, x, y, 0.5f, nullptr, scaleX, scaleY);
return false;
}
void RenderD7::Image::LoadFromBitmap(BMP bitmap)
{
loadet = false;
unsigned error = Image_to_C3D(this->img, bitmap.DATA());
if (error == 0)
{
this->loadet = true;
}
if(error) {
std::cout << "BMP decoding error " << error << std::endl; std::cout << "BMP decoding error " << error << std::endl;
RenderD7::AddOvl(std::make_unique<RenderD7::Toast>("Bmp - Error", "Code: " + std::to_string(error))); RenderD7::AddOvl(std::make_unique<RenderD7::Toast>(
"Bmp - Error", "Code: " + std::to_string(error)));
} }
} }

116
source/NFontApi.cpp
View File

@ -1,76 +1,66 @@
#include <renderd7/Fonts/NFontApi.hpp> #include <renderd7/Fonts/NFontApi.hpp>
#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation #define STB_TRUETYPE_IMPLEMENTATION // force following include to generate
// implementation
#include <renderd7/external/stb_truetype.h> #include <renderd7/external/stb_truetype.h>
#define STB_IMAGE_WRITE_IMPLEMENTATION #define STB_IMAGE_WRITE_IMPLEMENTATION
#include <renderd7/external/stb_image_write.h> #include <renderd7/external/stb_image_write.h>
RenderD7::NFontApi::NFontApi() RenderD7::NFontApi::NFontApi() {}
{
RenderD7::NFontApi::~NFontApi() {}
void RenderD7::NFontApi::LoadTTF(std::string path) {
/////READ FILE
unsigned char *buffer;
long size = 0;
FILE *ttf__ = fopen(path.c_str(), "rb");
fseek(ttf__, 0, SEEK_END);
size = ftell(ttf__);
fseek(ttf__, 0, SEEK_SET);
buffer = (unsigned char *)malloc(size);
fread(buffer, size, 1, ttf__);
fclose(ttf__);
/////Setup Font
if (!stbtt_InitFont(&font, buffer, 0)) {
printf("failed\n");
status += "failed\n";
return;
}
status += "success!\n";
b_h = 128;
b_w = 512;
l_h = 24; /* line height */
scale = stbtt_ScaleForPixelHeight(&font, l_h);
stbtt_GetFontVMetrics(&font, &ascent, &decent, &linegap);
linespace = scale * (ascent - decent + linegap);
baseline = (int)(ascent * scale);
height = (int)((ascent - decent) * scale);
} }
RenderD7::NFontApi::~NFontApi() unsigned char *RenderD7::NFontApi::GetGlyphBitmap(char glyph) {
{ // stbtt_GetGlyphBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
w = x1 - x0;
h = y1 - y0;
unsigned char *bitmap;
bitmap = stbtt_GetCodepointBitmap(&font, scale, scale, glyph, &w, &h, 0, 0);
return bitmap;
} }
void RenderD7::NFontApi::LoadTTF(std::string path) int RenderD7::NFontApi::GetGlyphHeight(char glyph) {
{ stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
/////READ FILE w = x1 - x0;
unsigned char* buffer; h = y1 - y0;
long size = 0; return h;
FILE *ttf__ = fopen(path.c_str(), "rb");
fseek(ttf__, 0, SEEK_END);
size = ftell(ttf__);
fseek(ttf__, 0, SEEK_SET);
buffer = (unsigned char*)malloc(size);
fread(buffer, size, 1, ttf__);
fclose(ttf__);
/////Setup Font
if (!stbtt_InitFont(&font, buffer, 0))
{
printf("failed\n");
status+="failed\n";
return;
}
status+="success!\n";
b_h = 128;
b_w = 512;
l_h = 24; /* line height */
scale = stbtt_ScaleForPixelHeight(&font, l_h);
stbtt_GetFontVMetrics(&font, &ascent,&decent,&linegap);
linespace = scale * (ascent - decent + linegap);
baseline = (int) (ascent*scale);
height = (int) ((ascent - decent)*scale);
} }
unsigned char* RenderD7::NFontApi::GetGlyphBitmap(char glyph) int RenderD7::NFontApi::GetGlyphWidth(char glyph) {
{ stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
//stbtt_GetGlyphBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1); w = x1 - x0;
stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1); h = y1 - y0;
w = x1-x0; return w;
h = y1-y0;
unsigned char* bitmap;
bitmap = stbtt_GetCodepointBitmap(&font, scale, scale, glyph, &w, &h, 0, 0);
return bitmap;
}
int RenderD7::NFontApi::GetGlyphHeight(char glyph)
{
stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
w = x1-x0;
h = y1-y0;
return h;
}
int RenderD7::NFontApi::GetGlyphWidth(char glyph)
{
stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
w = x1-x0;
h = y1-y0;
return w;
} }

7
source/Screen.cpp
View File

@ -2,8 +2,7 @@
extern bool currentScreen; extern bool currentScreen;
void RenderD7::OnScreen(C3D_RenderTarget *target) void RenderD7::OnScreen(C3D_RenderTarget *target) {
{ C2D_SceneBegin(target);
C2D_SceneBegin(target); currentScreen = (target == Top || target == TopRight) ? 1 : 0;
currentScreen = (target == Top || target == TopRight) ? 1 : 0;
} }

22
source/Sheet.cpp
View File

@ -1,21 +1,15 @@
#include <renderd7/Sheet.hpp> #include <renderd7/Sheet.hpp>
RenderD7::Sheet::Sheet() RenderD7::Sheet::Sheet() {
{ //
//
} }
RenderD7::Sheet::~Sheet() RenderD7::Sheet::~Sheet() {
{ //
//
} }
Result RenderD7::Sheet::Load(const char *path) Result RenderD7::Sheet::Load(const char *path) {
{ this->spritesheet = C2D_SpriteSheetLoad(path);
this->spritesheet = C2D_SpriteSheetLoad(path); return 0;
return 0;
} }
void RenderD7::Sheet::Free() void RenderD7::Sheet::Free() { C2D_SpriteSheetFree(this->spritesheet); }
{
C2D_SpriteSheetFree(this->spritesheet);
}

72
source/Sprite.cpp
View File

@ -1,60 +1,36 @@
#include <renderd7/Sprite.hpp> #include <renderd7/Sprite.hpp>
RenderD7::Sprite::Sprite() RenderD7::Sprite::Sprite() {
{ //
//
} }
RenderD7::Sprite::~Sprite() RenderD7::Sprite::~Sprite() {
{ //
//
} }
void RenderD7::Sprite::FromSheet(RenderD7::Sheet *sheet, size_t index) void RenderD7::Sprite::FromSheet(RenderD7::Sheet *sheet, size_t index) {
{ C2D_SpriteFromSheet(&this->sprite, sheet->spritesheet, index);
C2D_SpriteFromSheet(&this->sprite, sheet->spritesheet, index);
} }
bool RenderD7::Sprite::Draw() bool RenderD7::Sprite::Draw() { return C2D_DrawSprite(&this->sprite); }
{ void RenderD7::Sprite::SetCenter(float x, float y) {
return C2D_DrawSprite(&this->sprite); C2D_SpriteSetCenter(&this->sprite, x, y);
} }
void RenderD7::Sprite::SetCenter(float x, float y) void RenderD7::Sprite::SetPos(float x, float y) {
{ C2D_SpriteSetPos(&this->sprite, x, y);
C2D_SpriteSetCenter(&this->sprite, x, y);
} }
void RenderD7::Sprite::SetPos(float x, float y) void RenderD7::Sprite::SetRotation(float rotation) {
{ C2D_SpriteSetRotation(&this->sprite, rotation);
C2D_SpriteSetPos(&this->sprite, x, y);
} }
void RenderD7::Sprite::SetRotation(float rotation) void RenderD7::Sprite::Rotate(float speed) {
{ C2D_SpriteRotateDegrees(&this->sprite, speed);
C2D_SpriteSetRotation(&this->sprite, rotation);
} }
void RenderD7::Sprite::Rotate(float speed) float RenderD7::Sprite::getHeigh() { return this->sprite.params.pos.h; }
{ float RenderD7::Sprite::getWidth() { return this->sprite.params.pos.w; }
C2D_SpriteRotateDegrees(&this->sprite, speed); float RenderD7::Sprite::getPosX() { return this->sprite.params.pos.x; }
} float RenderD7::Sprite::getPosY() { return this->sprite.params.pos.y; }
float RenderD7::Sprite::getHeigh()
{ void RenderD7::Sprite::FromImage(RenderD7::Image *img) {
return this->sprite.params.pos.h; C2D_SpriteFromImage(&this->sprite, img->img);
}
float RenderD7::Sprite::getWidth()
{
return this->sprite.params.pos.w;
}
float RenderD7::Sprite::getPosX()
{
return this->sprite.params.pos.x;
}
float RenderD7::Sprite::getPosY()
{
return this->sprite.params.pos.y;
} }
void RenderD7::Sprite::FromImage(RenderD7::Image *img) void RenderD7::Sprite::SetScale(float x, float y) {
{ C2D_SpriteScale(&this->sprite, x, y);
C2D_SpriteFromImage(&this->sprite, img->img);
}
void RenderD7::Sprite::SetScale(float x, float y)
{
C2D_SpriteScale(&this->sprite, x, y);
} }

57
source/SpriteSheetAnimation.cpp
View File

@ -3,39 +3,36 @@
extern Log renderd7log; extern Log renderd7log;
RenderD7::SpriteSheetAnimation::SpriteSheetAnimation() RenderD7::SpriteSheetAnimation::SpriteSheetAnimation() {
{ renderd7log.Write("SpriteSheetAnimation createt!");
renderd7log.Write("SpriteSheetAnimation createt!");
} }
RenderD7::SpriteSheetAnimation::~SpriteSheetAnimation() RenderD7::SpriteSheetAnimation::~SpriteSheetAnimation() {
{ //
//
} }
void RenderD7::SpriteSheetAnimation::Setup(RenderD7::Sheet *sheet, size_t imagecount, size_t startimage, float frame_begin, float frame_finish) void RenderD7::SpriteSheetAnimation::Setup(RenderD7::Sheet *sheet,
{ size_t imagecount, size_t startimage,
D_totaltime = frame_begin; float frame_begin,
renderd7log.Write("frame_begin success"); float frame_finish) {
this->images = imagecount; D_totaltime = frame_begin;
renderd7log.Write("imagecount success"); renderd7log.Write("frame_begin success");
this->sheet = sheet; this->images = imagecount;
renderd7log.Write("sheet success"); renderd7log.Write("imagecount success");
this->time = frame_finish; this->sheet = sheet;
renderd7log.Write("frame_finish success"); renderd7log.Write("sheet success");
RenderD7::SpriteSheetAnimation::FromSheet(this->sheet, startimage); this->time = frame_finish;
renderd7log.Write("frame_finish success");
RenderD7::SpriteSheetAnimation::FromSheet(this->sheet, startimage);
} }
void RenderD7::SpriteSheetAnimation::Play(float timespeed) void RenderD7::SpriteSheetAnimation::Play(float timespeed) {
{ D_totaltime += timespeed;
D_totaltime += timespeed; if (D_totaltime >= time) {
if (D_totaltime >= time) D_totaltime -= time;
{ imgs++;
D_totaltime -= time; if (imgs == images) {
imgs++; imgs = 0;
if (imgs == images)
{
imgs = 0;
}
} }
RenderD7::SpriteSheetAnimation::FromSheet(sheet, imgs); }
//RenderD7::SpriteSheetAnimation::Draw(); RenderD7::SpriteSheetAnimation::FromSheet(sheet, imgs);
// RenderD7::SpriteSheetAnimation::Draw();
} }

47
source/Time.cpp
View File

@ -1,31 +1,30 @@
#include <renderd7/Time.hpp>
#include <memory>
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <unistd.h>
#include <fstream> #include <fstream>
#include <memory>
#include <renderd7/Time.hpp>
#include <stdarg.h>
#include <stdio.h>
#include <string.h> #include <string.h>
#include <string> #include <string>
#include <time.h>
#include <unistd.h>
std::string RenderD7::FormatString(std::string fmt_str, ...) {
std::string RenderD7::FormatString(std::string fmt_str, ...) va_list ap;
{ char *fp = NULL;
va_list ap; va_start(ap, fmt_str);
char* fp = NULL; vasprintf(&fp, fmt_str.c_str(), ap);
va_start(ap, fmt_str); va_end(ap);
vasprintf(&fp, fmt_str.c_str(), ap); std::unique_ptr<char, decltype(free) *> formatted(fp, free);
va_end(ap); return std::string(formatted.get());
std::unique_ptr<char, decltype(free)*> formatted(fp, free);
return std::string(formatted.get());
} }
std::string RenderD7::GetTimeStr(void) std::string RenderD7::GetTimeStr(void) {
{ time_t unixTime;
time_t unixTime; struct tm timeStruct;
struct tm timeStruct; time(&unixTime);
time(&unixTime); localtime_r(&unixTime, &timeStruct);
localtime_r(&unixTime, &timeStruct); return FormatString("%04i-%02i-%02i_%02i-%02i-%02i",
return FormatString("%04i-%02i-%02i_%02i-%02i-%02i", timeStruct.tm_year + 1900, timeStruct.tm_mon + 1, timeStruct.tm_mday, timeStruct.tm_year + 1900, timeStruct.tm_mon + 1,
timeStruct.tm_hour, timeStruct.tm_min, timeStruct.tm_sec); timeStruct.tm_mday, timeStruct.tm_hour, timeStruct.tm_min,
timeStruct.tm_sec);
} }

61
source/Toast.cpp
View File

@ -1,37 +1,38 @@
#include <renderd7/Toast.hpp>
#include <renderd7/Draw.hpp> #include <renderd7/Draw.hpp>
#include <renderd7/Toast.hpp>
RenderD7::Toast::Toast(std::string head, std::string msg) RenderD7::Toast::Toast(std::string head, std::string msg) {
{ this->head = head;
this->head = head; this->msg = msg;
this->msg = msg; /*this->toast = RenderD7::BitmapPrinter(400, 70);
/*this->toast = RenderD7::BitmapPrinter(400, 70); this->toast.ClearBlank();
this->toast.ClearBlank(); this->toast.DrawRectFilled(0, 0, 400, 70, 40, 40, 40, 255);
this->toast.DrawRectFilled(0, 0, 400, 70, 40, 40, 40, 255); this->toast.DrawRectFilled(0, 0, 400, 25, 70, 70, 70, 255);
this->toast.DrawRectFilled(0, 0, 400, 25, 70, 70, 70, 255); this->toast.DrawDebugText(4, 5, 0, RenderD7::Color::Hex("#ffffff"),
this->toast.DrawDebugText(4, 5, 0, RenderD7::Color::Hex("#ffffff"), this->head); this->head); this->toast.DrawDebugText(4, 40, 0,
this->toast.DrawDebugText(4, 40, 0, RenderD7::Color::Hex("#ffffff"), this->msg); RenderD7::Color::Hex("#ffffff"), this->msg);
this->toastrendered->LoadPFromBuffer(BitmapConverter::ConvertData(toast.GetBitmap().DATA()));*/ this->toastrendered->LoadPFromBuffer(BitmapConverter::ConvertData(toast.GetBitmap().DATA()));*/
} }
void RenderD7::Toast::Draw(void) const void RenderD7::Toast::Draw(void) const {
{ RenderD7::OnScreen(Top);
RenderD7::OnScreen(Top); RenderD7::Draw::Rect(0, msgposy, 400, 70, RenderD7::Color::Hex("#111111"));
RenderD7::Draw::Rect(0, msgposy, 400, 70, RenderD7::Color::Hex("#111111")); RenderD7::Draw::Rect(0, msgposy, 400, 25, RenderD7::Color::Hex("#222222"));
RenderD7::Draw::Rect(0, msgposy, 400, 25, RenderD7::Color::Hex("#222222")); RenderD7::Draw::Text(2, msgposy + 3, 0.7f, RenderD7::Color::Hex("#ffffff"),
RenderD7::Draw::Text(2, msgposy+3, 0.7f, RenderD7::Color::Hex("#ffffff"), head); head);
RenderD7::Draw::Text(2, msgposy+30, 0.6f, RenderD7::Color::Hex("#ffffff"), msg); RenderD7::Draw::Text(2, msgposy + 30, 0.6f, RenderD7::Color::Hex("#ffffff"),
//toastrendered->Draw(0, msgposy); msg);
// toastrendered->Draw(0, msgposy);
} }
void RenderD7::Toast::Logic() void RenderD7::Toast::Logic() {
{ this->delay++ /*=1*(int)RenderD7::GetDeltaTime()*/;
this->delay++/*=1*(int)RenderD7::GetDeltaTime()*/; if (msgposy > 170 && delay < 2 * 60)
if (msgposy > 170 && delay < 2*60) msgposy--/*=(int)RenderD7::GetDeltaTime()*/; msgposy-- /*=(int)RenderD7::GetDeltaTime()*/;
if (delay >= 5*60) if (delay >= 5 * 60) {
{ msgposy++ /*=(int)RenderD7::GetDeltaTime*/;
msgposy++/*=(int)RenderD7::GetDeltaTime*/; if (msgposy > 400)
if(msgposy > 400) this->Kill(); this->Kill();
} }
} }

98
source/bmpconverter.cpp
View File

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

139
source/lang.cpp
View File

@ -1,98 +1,97 @@
#include <3ds.h>
#include <renderd7/lang.hpp> #include <renderd7/lang.hpp>
#include <stdio.h> #include <stdio.h>
#include <unistd.h>
#include <stdlib.h> #include <stdlib.h>
#include <3ds.h> #include <unistd.h>
static nlohmann::json appJson; static nlohmann::json appJson;
std::string RenderD7::Lang::getSys() std::string RenderD7::Lang::getSys() {
{
u8 language = 1;
CFGU_GetSystemLanguage(&language);
switch(language) { u8 language = 1;
case 0: CFGU_GetSystemLanguage(&language);
return "jp"; // Japanese
break;
case 1: switch (language) {
return "en"; // English case 0:
break; return "jp"; // Japanese
break;
case 2: case 1:
return "fr"; // French return "en"; // English
break; break;
case 3: case 2:
return "de"; // German return "fr"; // French
break; break;
case 4: case 3:
return "it"; // Italian return "de"; // German
break; break;
case 5: case 4:
return "es"; // Spanish return "it"; // Italian
break; break;
case 6: case 5:
return "zh-CN"; // Chinese (Simplified) return "es"; // Spanish
break; break;
// case 7: case 6:
// return "ko"; // Korean return "zh-CN"; // Chinese (Simplified)
// break; break;
// case 8: // case 7:
// return "nl"; // Dutch // return "ko"; // Korean
// break; // break;
case 9: // case 8:
return "pt"; // Portuguese // return "nl"; // Dutch
break; // break;
case 10: case 9:
return "ru"; // Russian return "pt"; // Portuguese
break; break;
case 11: case 10:
return "zh-TW"; // Chinese (Traditional) return "ru"; // Russian
break; break;
default: case 11:
return "en"; // Fall back to English if missing return "zh-TW"; // Chinese (Traditional)
break; break;
}
default:
return "en"; // Fall back to English if missing
break;
}
} }
std::string RenderD7::Lang::get(const std::string &key) { std::string RenderD7::Lang::get(const std::string &key) {
if (!appJson.contains(key)) return key; if (!appJson.contains(key))
return key;
return appJson.at(key).get_ref<const std::string&>(); return appJson.at(key).get_ref<const std::string &>();
} }
void RenderD7::Lang::load(const std::string &lang) { void RenderD7::Lang::load(const std::string &lang) {
FILE *values; FILE *values;
if (access(("romfs:/lang/" + lang + "/app.json").c_str(), F_OK) == 0) { if (access(("romfs:/lang/" + lang + "/app.json").c_str(), F_OK) == 0) {
values = fopen(("romfs:/lang/" + lang + "/app.json").c_str(), "rt"); values = fopen(("romfs:/lang/" + lang + "/app.json").c_str(), "rt");
if (values) { if (values) {
appJson = nlohmann::json::parse(values, nullptr, false); appJson = nlohmann::json::parse(values, nullptr, false);
fclose(values); fclose(values);
} }
if (appJson.is_discarded()) if (appJson.is_discarded())
appJson = { }; appJson = {};
return; return;
} else { } else {
values = fopen("romfs:/lang/en/app.json", "rt"); values = fopen("romfs:/lang/en/app.json", "rt");
if (values) { if (values) {
appJson = nlohmann::json::parse(values, nullptr, false); appJson = nlohmann::json::parse(values, nullptr, false);
fclose(values); fclose(values);
} }
if (appJson.is_discarded()) if (appJson.is_discarded())
appJson = { }; appJson = {};
return; return;
} }
} }

90
source/log.cpp
View File

@ -2,62 +2,50 @@
#include <memory> #include <memory>
std::string Log::format(const std::string& fmt_str, ...) std::string Log::format(const std::string &fmt_str, ...) {
{ va_list ap;
va_list ap; char *fp = NULL;
char* fp = NULL; va_start(ap, fmt_str);
va_start(ap, fmt_str); vasprintf(&fp, fmt_str.c_str(), ap);
vasprintf(&fp, fmt_str.c_str(), ap); va_end(ap);
va_end(ap); std::unique_ptr<char, decltype(free) *> formatted(fp, free);
std::unique_ptr<char, decltype(free)*> formatted(fp, free); return std::string(formatted.get());
return std::string(formatted.get());
} }
std::string Log::logDate(void) std::string Log::logDate(void) {
{ time_t unixTime;
time_t unixTime; struct tm timeStruct;
struct tm timeStruct; time(&unixTime);
time(&unixTime); localtime_r(&unixTime, &timeStruct);
localtime_r(&unixTime, &timeStruct); return format("%04i-%02i-%02i_%02i-%02i-%02i", timeStruct.tm_year + 1900,
return format("%04i-%02i-%02i_%02i-%02i-%02i", timeStruct.tm_year + 1900, timeStruct.tm_mon + 1, timeStruct.tm_mday, timeStruct.tm_mon + 1, timeStruct.tm_mday, timeStruct.tm_hour,
timeStruct.tm_hour, timeStruct.tm_min, timeStruct.tm_sec); timeStruct.tm_min, timeStruct.tm_sec);
} }
Log::Log() Log::Log() {}
{
void Log::Init(const char *filename) {
printf("%s\n", filename);
std::string fn = filename;
std::string name = fn + ".txt";
this->filename = name.c_str();
if ((access(name.c_str(), F_OK) == 0)) {
} else {
FILE *logfile = fopen((name.c_str()), "w");
fclose(logfile);
}
} }
void Log::Init(const char *filename) void Log::Write(std::string debug_text) {
{ printf("%s\n", debug_text.c_str());
printf("%s\n", filename); std::ofstream logFile;
std::string fn = filename; logFile.open((this->filename), std::ofstream::app);
std::string name = fn + ".txt"; std::string writeDebug = "[";
this->filename = name.c_str(); writeDebug += logDate();
if ((access(name.c_str(), F_OK) == 0)) writeDebug += "] ";
{ writeDebug += debug_text.c_str();
logFile << writeDebug << std::endl;
} logFile.close();
else
{
FILE* logfile = fopen((name.c_str()), "w");
fclose(logfile);
}
}
void Log::Write(std::string debug_text)
{
printf("%s\n", debug_text.c_str());
std::ofstream logFile;
logFile.open((this->filename), std::ofstream::app);
std::string writeDebug = "[";
writeDebug += logDate();
writeDebug += "] ";
writeDebug += debug_text.c_str();
logFile << writeDebug << std::endl;
logFile.close();
}
Log::~Log()
{
} }
Log::~Log() {}

1679
source/renderd7.cpp
View File

File diff suppressed because it is too large Load Diff

190
source/sound.cpp
View File

@ -10,121 +10,125 @@ using std::string;
// Reference: http://yannesposito.com/Scratch/en/blog/2010-10-14-Fun-with-wav/ // Reference: http://yannesposito.com/Scratch/en/blog/2010-10-14-Fun-with-wav/
typedef struct _WavHeader { typedef struct _WavHeader {
char magic[4]; // "RIFF" char magic[4]; // "RIFF"
u32 totallength; // Total file length, minus 8. u32 totallength; // Total file length, minus 8.
char wavefmt[8]; // Should be "WAVEfmt " char wavefmt[8]; // Should be "WAVEfmt "
u32 format; // 16 for PCM format u32 format; // 16 for PCM format
u16 pcm; // 1 for PCM format u16 pcm; // 1 for PCM format
u16 channels; // Channels u16 channels; // Channels
u32 frequency; // Sampling frequency u32 frequency; // Sampling frequency
u32 bytes_per_second; u32 bytes_per_second;
u16 bytes_by_capture; u16 bytes_by_capture;
u16 bits_per_sample; u16 bits_per_sample;
char data[4]; // "data" char data[4]; // "data"
u32 bytes_in_data; u32 bytes_in_data;
} WavHeader; } WavHeader;
static_assert(sizeof(WavHeader) == 44, "WavHeader size is not 44 bytes."); static_assert(sizeof(WavHeader) == 44, "WavHeader size is not 44 bytes.");
sound::sound(const string& path, int channel, bool toloop) { sound::sound(const string &path, int channel, bool toloop) {
if (isndspinit){ if (isndspinit) {
ndspSetOutputMode(NDSP_OUTPUT_STEREO); ndspSetOutputMode(NDSP_OUTPUT_STEREO);
ndspSetOutputCount(2); // Num of buffers ndspSetOutputCount(2); // Num of buffers
// Reading wav file // Reading wav file
FILE* fp = fopen(path.c_str(), "rb"); FILE *fp = fopen(path.c_str(), "rb");
if (!fp) { if (!fp) {
printf("Could not open the WAV file: %s\n", path.c_str()); printf("Could not open the WAV file: %s\n", path.c_str());
return; return;
} }
WavHeader wavHeader; WavHeader wavHeader;
size_t read = fread(&wavHeader, 1, sizeof(wavHeader), fp); size_t read = fread(&wavHeader, 1, sizeof(wavHeader), fp);
if (read != sizeof(wavHeader)) { if (read != sizeof(wavHeader)) {
// Short read. // Short read.
printf("WAV file header is too short: %s\n", path.c_str()); printf("WAV file header is too short: %s\n", path.c_str());
fclose(fp); fclose(fp);
return; return;
} }
// Verify the header. // Verify the header.
static const char RIFF_magic[4] = {'R','I','F','F'}; static const char RIFF_magic[4] = {'R', 'I', 'F', 'F'};
if (memcmp(wavHeader.magic, RIFF_magic, sizeof(wavHeader.magic)) != 0) { if (memcmp(wavHeader.magic, RIFF_magic, sizeof(wavHeader.magic)) != 0) {
// Incorrect magic number. // Incorrect magic number.
printf("Wrong file format.\n"); printf("Wrong file format.\n");
fclose(fp); fclose(fp);
return; return;
} }
if (wavHeader.totallength == 0 || if (wavHeader.totallength == 0 ||
(wavHeader.channels != 1 && wavHeader.channels != 2) || (wavHeader.channels != 1 && wavHeader.channels != 2) ||
(wavHeader.bits_per_sample != 8 && wavHeader.bits_per_sample != 16)) { (wavHeader.bits_per_sample != 8 && wavHeader.bits_per_sample != 16)) {
// Unsupported WAV file. // Unsupported WAV file.
printf("Corrupted wav file.\n"); printf("Corrupted wav file.\n");
fclose(fp); fclose(fp);
return; return;
} }
// Get the file size. // Get the file size.
fseek(fp, 0, SEEK_END); fseek(fp, 0, SEEK_END);
dataSize = ftell(fp) - sizeof(wavHeader); dataSize = ftell(fp) - sizeof(wavHeader);
// Allocating and reading samples // Allocating and reading samples
data = static_cast<u8*>(linearAlloc(dataSize)); data = static_cast<u8 *>(linearAlloc(dataSize));
fseek(fp, 44, SEEK_SET); fseek(fp, 44, SEEK_SET);
fread(data, 1, dataSize, fp); fread(data, 1, dataSize, fp);
fclose(fp); fclose(fp);
dataSize /= 2; // FIXME: 16-bit or stereo? dataSize /= 2; // FIXME: 16-bit or stereo?
// Find the right format // Find the right format
u16 ndspFormat; u16 ndspFormat;
if (wavHeader.bits_per_sample == 8) { if (wavHeader.bits_per_sample == 8) {
ndspFormat = (wavHeader.channels == 1) ? ndspFormat = (wavHeader.channels == 1) ? NDSP_FORMAT_MONO_PCM8
NDSP_FORMAT_MONO_PCM8 : : NDSP_FORMAT_STEREO_PCM8;
NDSP_FORMAT_STEREO_PCM8; } else {
} else { ndspFormat = (wavHeader.channels == 1) ? NDSP_FORMAT_MONO_PCM16
ndspFormat = (wavHeader.channels == 1) ? : NDSP_FORMAT_STEREO_PCM16;
NDSP_FORMAT_MONO_PCM16 : }
NDSP_FORMAT_STEREO_PCM16;
}
ndspChnReset(channel); ndspChnReset(channel);
ndspChnSetInterp(channel, NDSP_INTERP_NONE); ndspChnSetInterp(channel, NDSP_INTERP_NONE);
ndspChnSetRate(channel, float(wavHeader.frequency)); ndspChnSetRate(channel, float(wavHeader.frequency));
ndspChnSetFormat(channel, ndspFormat); ndspChnSetFormat(channel, ndspFormat);
// Create and play a wav buffer // Create and play a wav buffer
memset(&waveBuf, 0, sizeof(waveBuf)); memset(&waveBuf, 0, sizeof(waveBuf));
waveBuf.data_vaddr = reinterpret_cast<u32*>(data); waveBuf.data_vaddr = reinterpret_cast<u32 *>(data);
waveBuf.nsamples = dataSize / (wavHeader.bits_per_sample >> 3); waveBuf.nsamples = dataSize / (wavHeader.bits_per_sample >> 3);
waveBuf.looping = toloop; waveBuf.looping = toloop;
waveBuf.status = NDSP_WBUF_FREE; waveBuf.status = NDSP_WBUF_FREE;
chnl = channel;} chnl = channel;
}
} }
sound::~sound() { sound::~sound() {
if (isndspinit){ if (isndspinit) {
waveBuf.data_vaddr = 0; waveBuf.data_vaddr = 0;
waveBuf.nsamples = 0; waveBuf.nsamples = 0;
waveBuf.looping = false; waveBuf.looping = false;
waveBuf.status = 0; waveBuf.status = 0;
ndspChnWaveBufClear(chnl); ndspChnWaveBufClear(chnl);
if (data) { if (data) {
linearFree(data); linearFree(data);
}} }
}
} }
void sound::play() { void sound::play() {
if (isndspinit){ if (isndspinit) {
if (!data) return; if (!data)
DSP_FlushDataCache(data, dataSize); return;
ndspChnWaveBufAdd(chnl, &waveBuf);} DSP_FlushDataCache(data, dataSize);
ndspChnWaveBufAdd(chnl, &waveBuf);
}
} }
void sound::stop() { void sound::stop() {
if (isndspinit){ if (isndspinit) {
if (!data) return; if (!data)
ndspChnWaveBufClear(chnl);} return;
ndspChnWaveBufClear(chnl);
}
} }

154
source/thread.cpp
View File

@ -1,81 +1,79 @@
#include <renderd7/thread.hpp> #include <renderd7/thread.hpp>
namespace RenderD7 { namespace RenderD7 {
void Threads::Exit() void Threads::Exit() {}
{ Thread::Thread() : m_started(false), m_running(false) { /* do nothing */
}
Thread::Thread() :
m_started(false),
m_running(false) { /* do nothing */ }
Thread::Thread(std::function<void(RenderD7::Parameter)> t_function, RenderD7::Parameter t_parameter, bool t_autostart, bool t_detached, unsigned long long int t_stackSize) :
m_started(false),
m_running(false) {
initialize(t_function, t_parameter, t_autostart, t_detached, t_stackSize);
}
Thread::~Thread() {
join();
if (m_started) threadFree(m_thread);
}
void Thread::initialize(std::function<void(RenderD7::Parameter)> t_function, RenderD7::Parameter t_parameter, bool t_autostart, bool t_detached, unsigned long long int t_stackSize) {
m_stackSize = t_stackSize;
m_data.m_parameter = t_parameter;
m_data.m_function = t_function;
m_data.m_running = &m_running;
if (t_autostart) {
start(t_detached);
}
}
void Thread::setStackSize(unsigned long long int t_stackSize) {
m_stackSize = t_stackSize;
}
void Thread::start(bool t_detached) {
if (!m_running) {
m_started = true;
m_running = true;
s32 prio;
svcGetThreadPriority(&prio, CUR_THREAD_HANDLE);
m_thread = threadCreate(threadFunction, &m_data, m_stackSize, prio + 1, -2, t_detached);
}
}
void Thread::kill() {
threadDetach(m_thread);
m_running = false;
m_started = false;
}
void Thread::join(long long unsigned int t_timeout) {
if (m_running) {
threadJoin(m_thread, t_timeout);
threadFree(m_thread);
m_running = false;
m_started = false;
}
}
bool Thread::isRunning() {
return m_running;
}
void Thread::sleep() {
svcSleepThread(0);
}
void Thread::sleep(int t_milliseconds) {
svcSleepThread(1000000 * t_milliseconds);
}
// private methods
void Thread::threadFunction(void* arg) {
RenderD7::Thread::ThreadData data = *static_cast<RenderD7::Thread::ThreadData*>(arg);
data.m_function(data.m_parameter);
*data.m_running = false;
}
} }
Thread::Thread(std::function<void(RenderD7::Parameter)> t_function,
RenderD7::Parameter t_parameter, bool t_autostart,
bool t_detached, unsigned long long int t_stackSize)
: m_started(false), m_running(false) {
initialize(t_function, t_parameter, t_autostart, t_detached, t_stackSize);
}
Thread::~Thread() {
join();
if (m_started)
threadFree(m_thread);
}
void Thread::initialize(std::function<void(RenderD7::Parameter)> t_function,
RenderD7::Parameter t_parameter, bool t_autostart,
bool t_detached, unsigned long long int t_stackSize) {
m_stackSize = t_stackSize;
m_data.m_parameter = t_parameter;
m_data.m_function = t_function;
m_data.m_running = &m_running;
if (t_autostart) {
start(t_detached);
}
}
void Thread::setStackSize(unsigned long long int t_stackSize) {
m_stackSize = t_stackSize;
}
void Thread::start(bool t_detached) {
if (!m_running) {
m_started = true;
m_running = true;
s32 prio;
svcGetThreadPriority(&prio, CUR_THREAD_HANDLE);
m_thread = threadCreate(threadFunction, &m_data, m_stackSize, prio + 1, -2,
t_detached);
}
}
void Thread::kill() {
threadDetach(m_thread);
m_running = false;
m_started = false;
}
void Thread::join(long long unsigned int t_timeout) {
if (m_running) {
threadJoin(m_thread, t_timeout);
threadFree(m_thread);
m_running = false;
m_started = false;
}
}
bool Thread::isRunning() { return m_running; }
void Thread::sleep() { svcSleepThread(0); }
void Thread::sleep(int t_milliseconds) {
svcSleepThread(1000000 * t_milliseconds);
}
// private methods
void Thread::threadFunction(void *arg) {
RenderD7::Thread::ThreadData data =
*static_cast<RenderD7::Thread::ThreadData *>(arg);
data.m_function(data.m_parameter);
*data.m_running = false;
}
} // namespace RenderD7