Merge branch 'master' into bottom-screen

.clang-format

@@ -1,6 +1,6 @@
 BasedOnStyle: Google
 IndentWidth: 4
-ColumnLimit: 120
+ColumnLimit: 150
 AccessModifierOffset: -2
 TabWidth: 4
 NamespaceIndentation: All

include/cpu_dynarmic.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <span>
+
 #include "dynarmic/interface/A32/a32.h"
 #include "dynarmic/interface/A32/config.h"
 #include "dynarmic/interface/exclusive_monitor.h"
@@ -132,17 +134,11 @@ public:
         return jit->Regs()[index];
     }
 
-    std::array<u32, 16>& regs() {
+	std::span<u32, 16> regs() { return jit->Regs(); }
-        return jit->Regs();
-    }
 
 	// Get reference to array of FPRs. This array consists of the FPRs as single precision values
 	// Hence why its base type is u32
-    // Note: Dynarmic keeps 64 VFP registers as VFPv3 extends the VFP register set to 64 registers.
+	std::span<u32, 32> fprs() { return std::span(jit->ExtRegs()).first<32>(); }
-    // However the 3DS ARM11 is an ARMv6k processor with VFPv2, so only the first 32 registers are actually used
-    std::array<u32, 64>& fprs() {
-        return jit->ExtRegs();
-    }
 
     void setCPSR(u32 value) {
         jit->SetCpsr(value);

include/kernel/kernel.hpp

@@ -2,10 +2,12 @@
 #include <array>
 #include <cassert>
 #include <limits>
+#include <span>
 #include <string>
 #include <vector>
-#include "kernel_types.hpp"
+
 #include "helpers.hpp"
+#include "kernel_types.hpp"
 #include "logger.hpp"
 #include "memory.hpp"
 #include "resource_limits.hpp"
@@ -14,7 +16,7 @@
 class CPU;
 
 class Kernel {
-	std::array<u32, 16>& regs;
+	std::span<u32, 16> regs;
 	CPU& cpu;
 	Memory& mem;
 

include/opengl.hpp

@@ -30,6 +30,19 @@
 
 #include "gl3w.h"
 
+// Check if we have C++20. If yes, we can add C++20 std::span support
+#ifdef _MSVC_LANG // MSVC does not properly define __cplusplus without a compiler flag...
+#if _MSVC_LANG >= 202002L
+#define OPENGL_HAVE_CPP20
+#endif
+#elif __cplusplus >= 202002L
+#define OPENGL_HAVE_CPP20
+#endif // MSVC_LANG
+
+#ifdef OPENGL_HAVE_CPP20
+#include <span>
+#endif
+
 // Uncomment the following define if you want GL objects to automatically free themselves when their lifetime ends
 // #define OPENGL_DESTRUCTORS
 
@@ -399,6 +412,19 @@ namespace OpenGL {
 		void bufferVertsSub(VertType* vertices, int vertCount, GLintptr offset = 0) {
 			glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(VertType) * vertCount, vertices);
 		}
+
+        // If C++20 is available, add overloads that take std::span instead of raw pointers
+#ifdef OPENGL_HAVE_CPP20
+		template <typename VertType>
+		void bufferVerts(std::span<const VertType> vertices, GLenum usage = GL_DYNAMIC_DRAW) {
+			glBufferData(GL_ARRAY_BUFFER, sizeof(VertType) * vertices.size(), vertices.data(), usage);
+		}
+
+		template <typename VertType>
+		void bufferVertsSub(std::span<const VertType> vertices, GLintptr offset = 0) {
+			glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(VertType) * vertices.size(), vertices.data());
+		}
+#endif
 	};
 
     enum DepthFunc {

include/renderer_gl/renderer_gl.hpp

@@ -1,5 +1,7 @@
 #pragma once
 #include <array>
+#include <span>
+
 #include "helpers.hpp"
 #include "logger.hpp"
 #include "opengl.hpp"
@@ -67,7 +69,7 @@ class Renderer {
 	void setupBlending();
 	void bindDepthBuffer();
 
-public:
+  public:
 	Renderer(GPU& gpu, const std::array<u32, regNum>& internalRegs) : gpu(gpu), regs(internalRegs) {}
 
 	void reset();
@@ -76,7 +78,7 @@ public:
 	void getGraphicsContext();                                                                      // Set up graphics context for rendering
 	void clearBuffer(u32 startAddress, u32 endAddress, u32 value, u32 control);                     // Clear a GPU buffer in VRAM
 	void displayTransfer(u32 inputAddr, u32 outputAddr, u32 inputSize, u32 outputSize, u32 flags);  // Perform display transfer
-	void drawVertices(OpenGL::Primitives primType, Vertex* vertices, u32 count); // Draw the given vertices
+	void drawVertices(OpenGL::Primitives primType, std::span<const Vertex> vertices);               // Draw the given vertices
 
 	void setFBSize(u32 width, u32 height) {
 		fbSize.x() = width;

include/services/service_manager.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include <array>
 #include <optional>
+#include <span>
+
 #include "kernel_types.hpp"
 #include "logger.hpp"
 #include "memory.hpp"
@@ -14,16 +16,16 @@
 #include "services/cfg.hpp"
 #include "services/dlp_srvr.hpp"
 #include "services/dsp.hpp"
-#include "services/hid.hpp"
 #include "services/frd.hpp"
 #include "services/fs.hpp"
 #include "services/gsp_gpu.hpp"
 #include "services/gsp_lcd.hpp"
+#include "services/hid.hpp"
 #include "services/ldr_ro.hpp"
 #include "services/mic.hpp"
+#include "services/ndm.hpp"
 #include "services/nfc.hpp"
 #include "services/nim.hpp"
-#include "services/ndm.hpp"
 #include "services/ptm.hpp"
 #include "services/y2r.hpp"
 
@@ -31,7 +33,7 @@
 class Kernel;
 
 class ServiceManager {
-	std::array<u32, 16>& regs;
+	std::span<u32, 16> regs;
 	Memory& mem;
 	Kernel& kernel;
 
@@ -69,8 +71,8 @@ class ServiceManager {
 	void registerClient(u32 messagePointer);
 	void subscribe(u32 messagePointer);
 
-public:
+  public:
-	ServiceManager(std::array<u32, 16>& regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel);
+	ServiceManager(std::span<u32, 16> regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel);
 	void reset();
 	void initializeFS() { fs.initializeFilesystem(); }
 	void handleSyncRequest(u32 messagePointer);

src/core/PICA/gpu.cpp

@@ -1,7 +1,10 @@
 #include "PICA/gpu.hpp"
+
+#include <array>
+#include <cstdio>
+
 #include "PICA/float_types.hpp"
 #include "PICA/regs.hpp"
-#include <cstdio>
 
 using namespace Floats;
 
@@ -41,7 +44,7 @@ void GPU::drawArrays(bool indexed) {
 		drawArrays<false>();
 }
 
-Vertex* vertices = new Vertex[Renderer::vertexBufferSize];
+static std::array<Vertex, Renderer::vertexBufferSize> vertices;
 
 template <bool indexed>
 void GPU::drawArrays() {
@@ -205,7 +208,7 @@ void GPU::drawArrays() {
 		OpenGL::Triangle, OpenGL::TriangleStrip, OpenGL::TriangleFan, OpenGL::Triangle
 	};
 	const auto shape = primTypes[primType];
-	renderer.drawVertices(shape, vertices, vertexCount);
+	renderer.drawVertices(shape, std::span(vertices).first(vertexCount));
 }
 
 Vertex GPU::getImmediateModeVertex() {

src/core/PICA/regs.cpp

@@ -157,7 +157,7 @@ void GPU::writeInternalReg(u32 index, u32 value, u32 mask) {
 						// If we've reached 3 verts, issue a draw call
 						// Handle rendering depending on the primitive type
 						if (immediateModeVertIndex == 3) {
-							renderer.drawVertices(OpenGL::Triangle, &immediateModeVertices[0], 3);
+							renderer.drawVertices(OpenGL::Triangle, immediateModeVertices);
 
 							switch (primType) {
 								// Triangle or geometry primitive. Draw a triangle and discard all vertices

src/core/kernel/threads.cpp

@@ -1,8 +1,10 @@
 #include <cassert>
 #include <cstring>
-#include "kernel.hpp"
+
 #include "arm_defs.hpp"
-// This header needs to be included because I did stupid forward decl hack so the kernel and CPU can both access each other
+#include "kernel.hpp"
+// This header needs to be included because I did stupid forward decl hack so the kernel and CPU can both access each
+// other
 #include "cpu.hpp"
 #include "resource_limits.hpp"
 
@@ -20,14 +22,14 @@ void Kernel::switchThread(int newThreadIndex) {
 	}
 
 	// Backup context
-	std::memcpy(&oldThread.gprs[0], &cpu.regs()[0], 16 * sizeof(u32)); // Backup the 16 GPRs
+	std::memcpy(oldThread.gprs.data(), cpu.regs().data(), cpu.regs().size_bytes());  // Backup the 16 GPRs
-	std::memcpy(&oldThread.fprs[0], &cpu.fprs()[0], 32 * sizeof(u32)); // Backup the 32 FPRs
+	std::memcpy(oldThread.fprs.data(), cpu.fprs().data(), cpu.fprs().size_bytes());  // Backup the 32 FPRs
 	oldThread.cpsr = cpu.getCPSR();                                                  // Backup CPSR
 	oldThread.fpscr = cpu.getFPSCR();                                                // Backup FPSCR
 
 	// Load new context
-	std::memcpy(&cpu.regs()[0], &newThread.gprs[0], 16 * sizeof(u32)); // Load 16 GPRs
+	std::memcpy(cpu.regs().data(), newThread.gprs.data(), cpu.regs().size_bytes());  // Load 16 GPRs
-	std::memcpy(&cpu.fprs()[0], &newThread.fprs[0], 32 * sizeof(u32)); // Load 32 FPRs
+	std::memcpy(cpu.fprs().data(), newThread.fprs.data(), cpu.fprs().size_bytes());  // Load 32 FPRs
 	cpu.setCPSR(newThread.cpsr);                                                     // Load CPSR
 	cpu.setFPSCR(newThread.fpscr);                                                   // Load FPSCR
 	cpu.setTLSBase(newThread.tlsBase);  // Load CP15 thread-local-storage pointer register

src/core/renderer_gl/renderer_gl.cpp

@@ -237,6 +237,15 @@ void Renderer::initGraphicsContext() {
 	reset();
 }
 
+// TODO: Maybe merge this with drawVertices
+void Renderer::getGraphicsContext() {
+	OpenGL::disableScissor();
+
+	vbo.bind();
+	vao.bind();
+	triangleProgram.use();
+}
+
 // Set up the OpenGL blending context to match the emulated PICA
 void Renderer::setupBlending() {
 	const bool blendingEnabled = (regs[PICAInternalRegs::ColourOperation] & (1 << 8)) != 0;
@@ -282,13 +291,7 @@ void Renderer::setupBlending() {
 	}
 }
 
-void Renderer::drawVertices(OpenGL::Primitives primType, Vertex* vertices, u32 count) {
+void Renderer::drawVertices(OpenGL::Primitives primType, std::span<const Vertex> vertices) {
-	OpenGL::disableScissor();
-
-	vbo.bind();
-	vao.bind();
-	triangleProgram.use();
-
 	// Adjust alpha test if necessary
 	const u32 alphaControl = regs[PICAInternalRegs::AlphaTestConfig];
 	if (alphaControl != oldAlphaControl) {
@@ -375,8 +378,8 @@ void Renderer::drawVertices(OpenGL::Primitives primType, Vertex* vertices, u32 c
 		}
 	}
 
-	vbo.bufferVertsSub(vertices, count);
+	vbo.bufferVertsSub(vertices);
-	OpenGL::draw(primType, count);
+	OpenGL::draw(primType, vertices.size());
 }
 
 constexpr u32 topScreenBuffer = 0x1f000000;

src/core/services/service_manager.cpp

@@ -1,9 +1,11 @@
 #include "services/service_manager.hpp"
+
 #include <map>
+
 #include "ipc.hpp"
 #include "kernel.hpp"
 
-ServiceManager::ServiceManager(std::array<u32, 16>& regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel)
+ServiceManager::ServiceManager(std::span<u32, 16> regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel)
 	: regs(regs), mem(mem), kernel(kernel), ac(mem), am(mem), boss(mem), act(mem), apt(mem, kernel), cam(mem),
 	  cecd(mem, kernel), cfg(mem), dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), frd(mem), fs(mem, kernel),
 	  gsp_gpu(mem, gpu, kernel, currentPID), gsp_lcd(mem), ldr(mem), mic(mem), nfc(mem, kernel), nim(mem), ndm(mem),