Switch out math_util.hpp

CMakeLists.txt

@@ -158,7 +158,7 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/termcolor.hpp
                  include/crypto/aes_engine.hpp include/metaprogramming.hpp include/PICA/pica_vertex.hpp
                  include/config.hpp include/services/ir_user.hpp include/http_server.hpp include/cheats.hpp
                  include/action_replay.hpp include/renderer_sw/renderer_sw.hpp include/compiler_builtins.hpp
-                 include/fs/romfs.hpp include/fs/ivfc.hpp
+                 include/fs/romfs.hpp include/fs/ivfc.hpp include/math_util.hpp
 )
 
 set(THIRD_PARTY_SOURCE_FILES third_party/imgui/imgui.cpp

include/math_util.hpp

@@ -1,80 +1,73 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project / 2023 Panda3DS Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
 #pragma once
-#include <array>
+
+#include <cstdlib>
+#include <type_traits>
 
 namespace Math {
-	// Abstraction for GLSL vectors
-	template <typename T, int size>
-	class Vector {
-		// A GLSL vector can only have 2, 3 or 4 elements
-		static_assert(size == 2 || size == 3 || size == 4);
-		T m_storage[size];
 
-	  public:
-		T& r() { return m_storage[0]; }
-		T& g() { return m_storage[1]; }
-		T& b() {
-			static_assert(size >= 3, "Out of bounds OpenGL::Vector access");
-			return m_storage[2];
-		}
-		T& a() {
-			static_assert(size >= 4, "Out of bounds OpenGL::Vector access");
-			return m_storage[3];
-		}
-
-		T& x() { return r(); }
-		T& y() { return g(); }
-		T& z() { return b(); }
-		T& w() { return a(); }
-		T& operator[](size_t index) { return m_storage[index]; }
-		const T& operator[](size_t index) const { return m_storage[index]; }
-
-		T& u() { return r(); }
-		T& v() { return g(); }
-
-		T& s() { return r(); }
-		T& t() { return g(); }
-		T& p() { return b(); }
-		T& q() { return a(); }
-
-		Vector(std::array<T, size> list) { std::copy(list.begin(), list.end(), &m_storage[0]); }
-
-		Vector() {}
-	};
-
-	using vec2 = Vector<float, 2>;
-	using vec3 = Vector<float, 3>;
-	using vec4 = Vector<float, 4>;
-
-	using dvec2 = Vector<double, 2>;
-	using dvec3 = Vector<double, 3>;
-	using dvec4 = Vector<double, 4>;
-
-	using ivec2 = Vector<int, 2>;
-	using ivec3 = Vector<int, 3>;
-	using ivec4 = Vector<int, 4>;
-
-	using uvec2 = Vector<unsigned int, 2>;
-	using uvec3 = Vector<unsigned int, 3>;
-	using uvec4 = Vector<unsigned int, 4>;
-
-	// A 2D rectangle, meant to be used for stuff like scissor rects or viewport rects
-	// We're never supporting 3D rectangles, because rectangles were never meant to be 3D in the first place
-	template <typename T>
+template <class T>
 struct Rectangle {
-		Vector<T, 2> start;
-		Vector<T, 2> end;
+    T left{};
+    T top{};
+    T right{};
+    T bottom{};
 
-		Rectangle() : start({0}), end({0}) {}
-		Rectangle(T x0, T y0, T x1, T y1) : start({x0, y0}), end({x1, y1}) {}
+    constexpr Rectangle() = default;
 
-		T getWidth() const {
-			return std::abs(end.x() - start.x());
+    constexpr Rectangle(T left, T top, T right, T bottom)
+        : left(left), top(top), right(right), bottom(bottom) {}
+
+    [[nodiscard]] constexpr bool operator==(const Rectangle<T>& rhs) const {
+        return (left == rhs.left) && (top == rhs.top) && (right == rhs.right) &&
+               (bottom == rhs.bottom);
     }
 
-		T getHeight() const {
-			return std::abs(end.y() - start.y());
+    [[nodiscard]] constexpr bool operator!=(const Rectangle<T>& rhs) const {
+        return !operator==(rhs);
+    }
+
+    [[nodiscard]] constexpr Rectangle<T> operator*(const T value) const {
+        return Rectangle{left * value, top * value, right * value, bottom * value};
+    }
+    
+    [[nodiscard]] constexpr Rectangle<T> operator/(const T value) const {
+        return Rectangle{left / value, top / value, right / value, bottom / value};
+    }
+
+    [[nodiscard]] T getWidth() const {
+        return std::abs(static_cast<std::make_signed_t<T>>(right - left));
+    }
+    
+    [[nodiscard]] T getHeight() const {
+        return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
+    }
+
+    [[nodiscard]] T getArea() const {
+        return getWidth() * getHeight();
+    }
+    
+    [[nodiscard]] Rectangle<T> translateX(const T x) const {
+        return Rectangle{left + x, top, right + x, bottom};
+    }
+    
+    [[nodiscard]] Rectangle<T> translateY(const T y) const {
+        return Rectangle{left, top + y, right, bottom + y};
+    }
+
+    [[nodiscard]] Rectangle<T> scale(const float s) const {
+        return Rectangle{left, top, static_cast<T>(left + getWidth() * s),
+                         static_cast<T>(top + getHeight() * s)};
     }
 };
 
-	using Rect = Rectangle<unsigned int>;
-}
+template <typename T>
+Rectangle(T, T, T, T) -> Rectangle<T>;
+
+template <typename T>
+using Rect = Rectangle<T>;
+
+} // end namespace Math

include/renderer_gl/surfaces.hpp

@@ -11,7 +11,7 @@ using Interval = boost::icl::right_open_interval<T>;
 struct ColourBuffer {
     u32 location;
     PICA::ColorFmt format;
-    Math::uvec2 size;
+    OpenGL::uvec2 size;
     bool valid;
 
     // Range of VRAM taken up by buffer
@@ -91,7 +91,7 @@ struct ColourBuffer {
 		}
 	}
 
-	Math::Rect getSubRect(u32 inputAddress, u32 width, u32 height) {
+	Math::Rect<u32> getSubRect(u32 inputAddress, u32 width, u32 height) {
 		// PICA textures have top-left origin while OpenGL has bottom-left origin.
 		// Flip the rectangle on the x axis to account for this.
 		const u32 startOffset = (inputAddress - location) / sizePerPixel(format);
@@ -113,7 +113,7 @@ struct ColourBuffer {
 struct DepthBuffer {
     u32 location;
     PICA::DepthFmt format;
-    Math::uvec2 size; // Implicitly set to the size of the framebuffer
+    OpenGL::uvec2 size; // Implicitly set to the size of the framebuffer
     bool valid;
 
     // Range of VRAM taken up by buffer

include/renderer_gl/textures.hpp

@@ -14,7 +14,7 @@ struct Texture {
     u32 location;
     u32 config; // Magnification/minification filter, wrapping configs, etc
     PICA::TextureFmt format;
-    Math::uvec2 size;
+    OpenGL::uvec2 size;
     bool valid;
 
     // Range of VRAM taken up by buffer

src/core/renderer_gl/renderer_gl.cpp

@@ -7,6 +7,7 @@
 #include "PICA/float_types.hpp"
 #include "PICA/gpu.hpp"
 #include "PICA/regs.hpp"
+#include "math_util.hpp"
 
 CMRC_DECLARE(RendererGL);
 
@@ -603,7 +604,7 @@ void RendererGL::displayTransfer(u32 inputAddr, u32 outputAddr, u32 inputSize, u
 	}
 
 	auto srcFramebuffer = getColourBuffer(inputAddr, inputFormat, inputWidth, inputHeight);
-	Math::Rect srcRect = srcFramebuffer.getSubRect(inputAddr, outputWidth, outputHeight);
+	Math::Rect<u32> srcRect = srcFramebuffer.getSubRect(inputAddr, outputWidth, outputHeight);
 
 	// Apply scaling for the destination rectangle.
 	if (scaling == PICA::Scaling::X || scaling == PICA::Scaling::XY) {
@@ -614,15 +615,16 @@ void RendererGL::displayTransfer(u32 inputAddr, u32 outputAddr, u32 inputSize, u
 		outputHeight >>= 1;
 	}
 
-	auto dstFramebuffer = getColourBuffer(outputAddr, outputFormat, outputWidth, outputHeight);
-	Math::Rect dstRect = dstFramebuffer.getSubRect(outputAddr, outputWidth, outputHeight);
+	auto destFramebuffer = getColourBuffer(outputAddr, outputFormat, outputWidth, outputHeight);
+	Math::Rect<u32> destRect = destFramebuffer.getSubRect(outputAddr, outputWidth, outputHeight);
 
 	// Blit the framebuffers
 	srcFramebuffer.fbo.bind(OpenGL::ReadFramebuffer);
-	dstFramebuffer.fbo.bind(OpenGL::DrawFramebuffer);
-	glBlitFramebuffer(srcRect.start.x(), srcRect.start.y(), srcRect.end.x(), srcRect.end.y(),
-					  dstRect.start.x(), dstRect.start.y(), dstRect.end.x(), dstRect.end.y(),
-					  GL_COLOR_BUFFER_BIT, GL_LINEAR);
+	destFramebuffer.fbo.bind(OpenGL::DrawFramebuffer);
+	glBlitFramebuffer(
+		srcRect.left, srcRect.top, srcRect.right, srcRect.bottom, destRect.left, destRect.top, destRect.right, destRect.bottom, GL_COLOR_BUFFER_BIT,
+		GL_LINEAR
+	);
 }
 
 ColourBuffer RendererGL::getColourBuffer(u32 addr, PICA::ColorFmt format, u32 width, u32 height) {