273 lines
7.2 KiB
C++
273 lines
7.2 KiB
C++
/**
|
|
* This file is part of RenderD7
|
|
* Copyright (C) 2021-2024 NPI-D7, tobid7
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <arpa/inet.h>
|
|
#include <malloc.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <renderd7/FileSystem.hpp>
|
|
#include <renderd7/external/json.hpp>
|
|
#include <renderd7/renderd7.hpp>
|
|
|
|
/// Base ///
|
|
static RenderD7::Thread rd7i_idb_server; // Protected
|
|
std::string rd7i_app_name;
|
|
std::string rd7i_config_path;
|
|
nlohmann::json rd7i_config;
|
|
u8 rd7i_console_model = 0;
|
|
u8 rd7i_system_region = CFG_REGION_USA;
|
|
bool rd7i_is_citra = false;
|
|
bool rd7i_settings = false;
|
|
R7Vec2 rd7i_hid_touch_pos;
|
|
C2D_TextBuf rd7i_text_buffer;
|
|
C2D_Font rd7i_base_font;
|
|
C2D_TextBuf rd7i_d2_dimbuf;
|
|
bool rd7i_is_ndsp = false;
|
|
bool rd7i_running = false;
|
|
std::stack<std::unique_ptr<RenderD7::Scene>> RenderD7::Scene::scenes;
|
|
std::unique_ptr<RenderD7::Scene> rd7i_fade_scene;
|
|
std::vector<std::unique_ptr<RenderD7::Ovl>> rd7i_overlays;
|
|
unsigned int rd7i_frames = 0;
|
|
u64 rd7i_last_time = 0;
|
|
float rd7i_framerate = 0.0f;
|
|
u32 rd7i_mt_color = 0xaa000000;
|
|
u32 rd7i_mt_txtcolor = 0xbbffffff;
|
|
bool rd7i_mt_screen;
|
|
float rd7i_mt_txtSize;
|
|
bool rd7i_metrikd = false;
|
|
bool rd7i_ftraced = false;
|
|
bool rd7i_current_screen = false;
|
|
u64 rd7i_delta_time;
|
|
u64 rd7i_last_tm;
|
|
float rd7i_dtm;
|
|
float rd7i_time;
|
|
bool rd7i_fadeout = false, rd7i_fadein = false, rd7i_fadeout2 = false,
|
|
rd7i_fadein2 = false;
|
|
int rd7i_fadealpha = 0;
|
|
int rd7i_fadecolor = 0;
|
|
bool rd7i_wait_fade = false;
|
|
bool rd7i_fade_exit = false;
|
|
bool rd7i_fade_scene_wait = false;
|
|
bool rd7i_idb_running = false;
|
|
bool rd7i_graphics_on = false;
|
|
float rd7_draw2_tsm = 1.2f;
|
|
bool rd7i_amdt = false;
|
|
|
|
/// Global ///
|
|
// Outdated HidApi (HidV2Patched)
|
|
u32 d7_hDown;
|
|
u32 d7_hHeld;
|
|
u32 d7_hUp;
|
|
u32 d7_hRepeat; // Inofficial lol
|
|
touchPosition d7_touch;
|
|
|
|
// Outdated Screens
|
|
C3D_RenderTarget *Top;
|
|
C3D_RenderTarget *TopRight;
|
|
C3D_RenderTarget *Bottom;
|
|
|
|
// Modern Global Api
|
|
int rd7_max_objects = C2D_DEFAULT_MAX_OBJECTS;
|
|
bool rd7_do_splash = false;
|
|
bool rd7_enable_scene_system = true;
|
|
bool rd7_debugging = false;
|
|
C3D_RenderTarget *rd7_top;
|
|
C3D_RenderTarget *rd7_top_right;
|
|
C3D_RenderTarget *rd7_bottom;
|
|
|
|
class Logger {
|
|
public:
|
|
Logger() = default;
|
|
virtual ~Logger() = default;
|
|
|
|
static void log(const std::string &prefix, const std::string &message) {
|
|
std::cout << "[" << prefix << "]: " << message << std::endl;
|
|
}
|
|
};
|
|
|
|
#define rd7_err(x) Logger::log("ERROR", x)
|
|
#define rd7_wrn(x) Logger::log("WARNING", x)
|
|
|
|
class tcp_server {
|
|
public:
|
|
tcp_server(const std::string &ip, int port) {
|
|
sockfd = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (sockfd < 0) {
|
|
rd7_err("Unable to create socket!");
|
|
return;
|
|
}
|
|
server.sin_family = AF_INET;
|
|
server.sin_port = port;
|
|
server.sin_addr.s_addr = inet_addr(ip.c_str());
|
|
|
|
e = bind(sockfd, (struct sockaddr *)&server, sizeof(server));
|
|
if (e == -1) {
|
|
rd7_err("Unable to bind!");
|
|
return;
|
|
}
|
|
e = listen(sockfd, 10);
|
|
if (e == 0) {
|
|
printf("[+]Listening...\n");
|
|
} else {
|
|
rd7_err("Error in Binding");
|
|
return;
|
|
}
|
|
addr_size = sizeof(new_addr);
|
|
new_sock = accept(sockfd, (struct sockaddr *)&new_addr, &addr_size);
|
|
std::cout << "Connected" << std::endl;
|
|
}
|
|
~tcp_server() {
|
|
// Nothing here
|
|
}
|
|
|
|
bool reconnect() {
|
|
close(new_sock);
|
|
new_sock = accept(sockfd, (struct sockaddr *)&new_addr, &addr_size);
|
|
return true;
|
|
}
|
|
|
|
size_t snd(void *ptr, size_t size) { return send(new_sock, ptr, size, 0); }
|
|
|
|
size_t rec(void *ptr, size_t size) { return recv(new_sock, ptr, size, 0); }
|
|
|
|
private:
|
|
int e, sockfd, new_sock;
|
|
struct sockaddr_in server, new_addr;
|
|
socklen_t addr_size;
|
|
};
|
|
|
|
#define stupid(x) &x, sizeof(x)
|
|
#define rd7i_reacttion(x) \
|
|
({ \
|
|
int code = x; \
|
|
server.snd(stupid(code)); \
|
|
})
|
|
|
|
struct pak32 {
|
|
pak32() {}
|
|
pak32(const std::string &n0, float n1, unsigned char n2, unsigned char n3,
|
|
bool n4, bool n5, bool n6, float n7, float n8, float n9, float n10,
|
|
unsigned int n11, unsigned int n12, unsigned int n13,
|
|
unsigned int n14) {
|
|
magic = 0x44772277;
|
|
for (int i = 0; i < 64; i++) app_name[i] = (char)0;
|
|
int l = n0.length();
|
|
if (l > 64) l = 64;
|
|
for (int i = 0; i < l; i++) app_name[i] = n0[i];
|
|
framerate = n1;
|
|
console_model = n2;
|
|
system_region = n3;
|
|
is_citra = n4;
|
|
ndsp_support = n5;
|
|
in_settings = n6;
|
|
deltatime = n7;
|
|
rtime = n8;
|
|
cpu = n9;
|
|
gpu = n10;
|
|
mem_alloc = n11;
|
|
mem_dalloc = n12;
|
|
mem_ialloc = n13;
|
|
tbs = n14;
|
|
}
|
|
uint32_t magic;
|
|
char app_name[64];
|
|
float framerate;
|
|
unsigned char console_model;
|
|
unsigned char system_region;
|
|
bool is_citra;
|
|
bool ndsp_support;
|
|
bool in_settings;
|
|
float deltatime;
|
|
float rtime;
|
|
float cpu;
|
|
float gpu;
|
|
unsigned int mem_alloc;
|
|
unsigned int mem_dalloc;
|
|
unsigned int mem_ialloc;
|
|
unsigned int tbs;
|
|
};
|
|
|
|
#define SOC_ALIGN 0x1000
|
|
#define SOC_BUFFERSIZE 0x100000
|
|
|
|
static u32 *SOC_buffer = NULL;
|
|
static bool rd7i_idb_fp = false;
|
|
|
|
void KillIdbServer() {
|
|
rd7i_idb_fp = true;
|
|
socExit();
|
|
}
|
|
|
|
void ServerThread(RenderD7::Parameter param) {
|
|
Result ret;
|
|
SOC_buffer = (u32 *)memalign(SOC_ALIGN, SOC_BUFFERSIZE);
|
|
|
|
if (SOC_buffer == NULL) {
|
|
return;
|
|
}
|
|
|
|
// Now intialise soc:u service
|
|
if ((ret = socInit(SOC_buffer, SOC_BUFFERSIZE)) != 0) {
|
|
return;
|
|
}
|
|
rd7i_idb_running = true;
|
|
atexit(KillIdbServer);
|
|
tcp_server server("0.0.0.0", 4727);
|
|
int cmd = 0;
|
|
while (true && !rd7i_idb_fp) {
|
|
size_t r = server.rec(&cmd, sizeof(int));
|
|
if (r == 0) {
|
|
server.reconnect();
|
|
}
|
|
if (cmd == 1) {
|
|
rd7i_reacttion(1);
|
|
auto pak = pak32(
|
|
rd7i_app_name, rd7i_framerate, rd7i_console_model, rd7i_system_region,
|
|
rd7i_is_citra, rd7i_is_ndsp, rd7i_settings, rd7i_dtm, rd7i_time,
|
|
C3D_GetProcessingTime(), C3D_GetDrawingTime(),
|
|
RenderD7::Memory::GetTotalAllocated(),
|
|
RenderD7::Memory::GetTotalFreed(), RenderD7::Memory::GetCurrent(),
|
|
C2D_TextBufGetNumGlyphs(rd7i_text_buffer));
|
|
server.snd(stupid(pak));
|
|
} else if (cmd == 2) {
|
|
rd7i_reacttion(2);
|
|
std::vector<RenderD7::FileSystem::Entry> el =
|
|
RenderD7::FileSystem::GetDirContent("sdmc:/");
|
|
size_t buf = el.size() * sizeof(RenderD7::FileSystem::Entry);
|
|
server.snd(stupid(buf));
|
|
server.snd(el.data(), buf);
|
|
|
|
} else if (cmd == 3) {
|
|
rd7i_reacttion(3);
|
|
RenderD7::ExitApp();
|
|
} else {
|
|
rd7i_reacttion(1234);
|
|
}
|
|
}
|
|
rd7i_idb_running = false;
|
|
}
|
|
|
|
void IdbServer() {
|
|
rd7i_idb_server.initialize(ServerThread);
|
|
rd7i_idb_server.start(true);
|
|
}
|