Merge pull request #120 from Wunkolo/renderer-null

Add a `null` rendering backend

src/config.cpp

@@ -1,6 +1,7 @@
 #include "config.hpp"
 
 #include <fstream>
+#include <string>
 
 #include "helpers.hpp"
 #include "toml.hpp"
@@ -9,6 +10,8 @@
 // We are legally allowed, as per the author's wish, to use the above code without any licensing restrictions
 // However we still want to follow the license as closely as possible and offer the proper attributions.
 
+EmulatorConfig::EmulatorConfig(const std::filesystem::path& path) { load(path); }
+
 void EmulatorConfig::load(const std::filesystem::path& path) {
 	// If the configuration file does not exist, create it and return
 	std::error_code error;
@@ -31,6 +34,17 @@ void EmulatorConfig::load(const std::filesystem::path& path) {
 		if (gpuResult.is_ok()) {
 			auto gpu = gpuResult.unwrap();
 
+			// Get renderer
+			auto rendererName = toml::find_or<std::string>(gpu, "Renderer", "OpenGL");
+			auto configRendererType = Renderer::typeFromString(rendererName);
+
+			if (configRendererType.has_value()) {
+				rendererType = configRendererType.value();
+			} else {
+				Helpers::warn("Invalid renderer specified: %s\n", rendererName.c_str());
+				rendererType = RendererType::OpenGL;
+			}
+
 			shaderJitEnabled = toml::find_or<toml::boolean>(gpu, "EnableShaderJIT", false);
 		}
 	}
@@ -43,7 +57,7 @@ void EmulatorConfig::save(const std::filesystem::path& path) {
 	if (std::filesystem::exists(path, error)) {
 		try {
 			data = toml::parse<toml::preserve_comments>(path);
-		} catch (std::exception& ex) {
+		} catch (const std::exception& ex) {
 			Helpers::warn("Exception trying to parse config file. Exception: %s\n", ex.what());
 			return;
 		}
@@ -55,6 +69,7 @@ void EmulatorConfig::save(const std::filesystem::path& path) {
 	}
 
 	data["GPU"]["EnableShaderJIT"] = shaderJitEnabled;
+	data["GPU"]["Renderer"] = std::string(Renderer::typeToString(rendererType));
 
 	std::ofstream file(path, std::ios::out);
 	file << data;

src/core/PICA/gpu.cpp

@@ -7,7 +7,7 @@
 
 #include "PICA/float_types.hpp"
 #include "PICA/regs.hpp"
-
+#include "renderer_null/renderer_null.hpp"
 #ifdef PANDA3DS_ENABLE_OPENGL
 #include "renderer_gl/renderer_gl.hpp"
 #endif
@@ -20,10 +20,27 @@ GPU::GPU(Memory& mem, EmulatorConfig& config) : mem(mem), config(config) {
 	vram = new u8[vramSize];
 	mem.setVRAM(vram);  // Give the bus a pointer to our VRAM
 
-	// TODO: Configurable backend
+	switch (config.rendererType) {
+		case RendererType::Null: {
+			renderer.reset(new RendererNull(*this, regs));
+			break;
+		}
 #ifdef PANDA3DS_ENABLE_OPENGL
-	renderer.reset(new RendererGL(*this, regs));
+		case RendererType::OpenGL: {
+			renderer.reset(new RendererGL(*this, regs));
+			break;
+		}
 #endif
+
+		case RendererType::Vulkan: {
+			Helpers::panic("Vulkan is not supported yet, please pick another renderer");
+		}
+
+		default: {
+			Helpers::panic("Rendering backend not supported: %s", Renderer::typeToString(config.rendererType));
+			break;
+		}
+	}
 }
 
 void GPU::reset() {

src/core/renderer_gl/renderer_gl.cpp

@@ -14,6 +14,8 @@ using namespace Floats;
 using namespace Helpers;
 using namespace PICA;
 
+RendererGL::~RendererGL() {}
+
 void RendererGL::reset() {
 	depthBufferCache.reset();
 	colourBufferCache.reset();

src/core/renderer_null/renderer_null.cpp

@@ -0,0 +1,12 @@
+#include "renderer_null/renderer_null.hpp"
+
+RendererNull::RendererNull(GPU& gpu, const std::array<u32, regNum>& internalRegs) : Renderer(gpu, internalRegs) {}
+RendererNull::~RendererNull() {}
+
+void RendererNull::reset() {}
+void RendererNull::display() {}
+void RendererNull::initGraphicsContext() {}
+void RendererNull::clearBuffer(u32 startAddress, u32 endAddress, u32 value, u32 control) {}
+void RendererNull::displayTransfer(u32 inputAddr, u32 outputAddr, u32 inputSize, u32 outputSize, u32 flags) {}
+void RendererNull::drawVertices(PICA::PrimType primType, std::span<const PICA::Vertex> vertices) {}
+void RendererNull::screenshot(const std::string& name) {}

src/emulator.cpp

@@ -14,7 +14,9 @@ __declspec(dllexport) DWORD AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif
 
-Emulator::Emulator() : kernel(cpu, memory, gpu), cpu(memory, kernel), gpu(memory, config), memory(cpu.getTicksRef()) {
+Emulator::Emulator()
+	: config(std::filesystem::current_path() / "config.toml"), kernel(cpu, memory, gpu), cpu(memory, kernel), gpu(memory, config),
+	  memory(cpu.getTicksRef()) {
 	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) {
 		Helpers::panic("Failed to initialize SDL2");
 	}
@@ -26,24 +28,26 @@ Emulator::Emulator() : kernel(cpu, memory, gpu), cpu(memory, kernel), gpu(memory
 	}
 
 #ifdef PANDA3DS_ENABLE_OPENGL
-	// Request OpenGL 4.1 Core (Max available on MacOS)
-	// MacOS gets mad if we don't explicitly demand a core profile
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
-	window = SDL_CreateWindow("Alber", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL);
+	if (config.rendererType == RendererType::OpenGL) {
+		// Request OpenGL 4.1 Core (Max available on MacOS)
+		// MacOS gets mad if we don't explicitly demand a core profile
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+		window = SDL_CreateWindow("Alber", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL);
 
-	if (window == nullptr) {
-		Helpers::panic("Window creation failed: %s", SDL_GetError());
-	}
+		if (window == nullptr) {
+			Helpers::panic("Window creation failed: %s", SDL_GetError());
+		}
 
-	glContext = SDL_GL_CreateContext(window);
-	if (glContext == nullptr) {
-		Helpers::panic("OpenGL context creation failed: %s", SDL_GetError());
-	}
+		glContext = SDL_GL_CreateContext(window);
+		if (glContext == nullptr) {
+			Helpers::panic("OpenGL context creation failed: %s", SDL_GetError());
+		}
 
-	if (!gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress))) {
-		Helpers::panic("OpenGL init failed: %s", SDL_GetError());
+		if (!gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress))) {
+			Helpers::panic("OpenGL init failed: %s", SDL_GetError());
+		}
 	}
 #endif
 
@@ -56,7 +60,6 @@ Emulator::Emulator() : kernel(cpu, memory, gpu), cpu(memory, kernel), gpu(memory
 		}
 	}
 
-	config.load(std::filesystem::current_path() / "config.toml");
 	reset(ReloadOption::NoReload);
 }
 

src/main.cpp

@@ -1,9 +1,9 @@
 #include "emulator.hpp"
 
-int main (int argc, char *argv[]) {
-    Emulator emu;
+int main(int argc, char *argv[]) {
+	Emulator emu;
 
-    emu.initGraphicsContext();
+	emu.initGraphicsContext();
 
 	if (argc > 1) {
 		auto romPath = std::filesystem::current_path() / argv[1];

src/renderer.cpp

@@ -1,4 +1,35 @@
 #include "renderer.hpp"
 
+#include <algorithm>
+#include <unordered_map>
+
 Renderer::Renderer(GPU& gpu, const std::array<u32, regNum>& internalRegs) : gpu(gpu), regs(internalRegs) {}
-Renderer::~Renderer() {}
+Renderer::~Renderer() {}
+
+std::optional<RendererType> Renderer::typeFromString(std::string inString) {
+	// Transform to lower-case to make the setting case-insensitive
+	std::transform(inString.begin(), inString.end(), inString.begin(), [](unsigned char c) { return std::tolower(c); });
+
+	// Huge table of possible names and misspellings
+	// Please stop misspelling Vulkan as Vulcan
+	static const std::unordered_map<std::string, RendererType> map = {
+		{"null", RendererType::Null}, {"nil", RendererType::Null},      {"none", RendererType::Null},
+		{"gl", RendererType::OpenGL}, {"ogl", RendererType::OpenGL},    {"opengl", RendererType::OpenGL},
+		{"vk", RendererType::Vulkan}, {"vulkan", RendererType::Vulkan}, {"vulcan", RendererType::Vulkan},
+	};
+
+	if (auto search = map.find(inString); search != map.end()) {
+		return search->second;
+	}
+
+	return std::nullopt;
+}
+
+const char* Renderer::typeToString(RendererType rendererType) {
+	switch (rendererType) {
+		case RendererType::Null: return "null";
+		case RendererType::OpenGL: return "opengl";
+		case RendererType::Vulkan: return "vulkan";
+		default: return "Invalid";
+	}
+}