From e6137d78747c5d53ee34ddb30e752fe4dcff29a3 Mon Sep 17 00:00:00 2001 From: emufan4568 Date: Sun, 21 Aug 2022 12:22:58 +0300 Subject: [PATCH] renderer_opengl: Remove GLvec* types * The common types already exist and provide all the functionality required, why invent new types? --- src/common/vector_math.h | 43 ++++++++ .../renderer_opengl/gl_rasterizer.cpp | 96 +++++++++-------- .../renderer_opengl/gl_rasterizer.h | 35 +++--- .../renderer_opengl/gl_shader_manager.cpp | 5 +- .../renderer_opengl/gl_shader_manager.h | 100 +++++++++--------- src/video_core/renderer_opengl/pica_to_gl.h | 35 ++---- 6 files changed, 170 insertions(+), 144 deletions(-) diff --git a/src/common/vector_math.h b/src/common/vector_math.h index 8c14cf410f..627baeb6d3 100644 --- a/src/common/vector_math.h +++ b/src/common/vector_math.h @@ -31,6 +31,7 @@ #pragma once #include +#include #include #include @@ -60,6 +61,10 @@ public: return &x; } + const T* AsArray() const { + return &x; + } + constexpr Vec2() = default; constexpr Vec2(const T& x_, const T& y_) : x(x_), y(y_) {} @@ -123,6 +128,14 @@ public: return x * x + y * y; } + [[nodiscard]] constexpr bool operator!=(const Vec2& other) const { + return std::memcmp(AsArray(), other.AsArray(), sizeof(Vec2)) != 0; + } + + [[nodiscard]] constexpr bool operator==(const Vec2& other) const { + return std::memcmp(AsArray(), other.AsArray(), sizeof(Vec2)) == 0; + } + // Only implemented for T=float [[nodiscard]] float Length() const; [[nodiscard]] float Normalize(); // returns the previous length, which is often useful @@ -184,6 +197,8 @@ template } using Vec2f = Vec2; +using Vec2i = Vec2; +using Vec2u = Vec2; template <> inline float Vec2::Length() const { @@ -216,6 +231,10 @@ public: return &x; } + const T* AsArray() const { + return &x; + } + constexpr Vec3() = default; constexpr Vec3(const T& x_, const T& y_, const T& z_) : x(x_), y(y_), z(z_) {} @@ -280,6 +299,14 @@ public: return *this; } + [[nodiscard]] constexpr bool operator!=(const Vec3& other) const { + return std::memcmp(AsArray(), other.AsArray(), sizeof(Vec3)) != 0; + } + + [[nodiscard]] constexpr bool operator==(const Vec3& other) const { + return std::memcmp(AsArray(), other.AsArray(), sizeof(Vec3)) == 0; + } + [[nodiscard]] constexpr T Length2() const { return x * x + y * y + z * z; } @@ -412,6 +439,8 @@ inline float Vec3::Normalize() { } using Vec3f = Vec3; +using Vec3i = Vec3; +using Vec3u = Vec3; template class Vec4 { @@ -434,6 +463,10 @@ public: return &x; } + const T* AsArray() const { + return &x; + } + constexpr Vec4() = default; constexpr Vec4(const T& x_, const T& y_, const T& z_, const T& w_) : x(x_), y(y_), z(z_), w(w_) {} @@ -503,6 +536,14 @@ public: return *this; } + [[nodiscard]] constexpr bool operator!=(const Vec4& other) const { + return std::memcmp(AsArray(), other.AsArray(), sizeof(Vec4)) != 0; + } + + [[nodiscard]] constexpr bool operator==(const Vec4& other) const { + return std::memcmp(AsArray(), other.AsArray(), sizeof(Vec4)) == 0; + } + [[nodiscard]] constexpr T Length2() const { return x * x + y * y + z * z + w * w; } @@ -623,6 +664,8 @@ template } using Vec4f = Vec4; +using Vec4i = Vec4; +using Vec4u = Vec4; template constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec2& a, const Vec2& b) { diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp index 7e385b61af..c140b7e5c1 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer.cpp +++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp @@ -13,6 +13,7 @@ #include "video_core/renderer_opengl/gl_rasterizer.h" #include "video_core/renderer_opengl/gl_shader_gen.h" #include "video_core/renderer_opengl/gl_vars.h" +#include "video_core/renderer_opengl/pica_to_gl.h" #include "video_core/renderer_opengl/renderer_opengl.h" #include "video_core/video_core.h" @@ -1638,7 +1639,7 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig( if (border_color != config.border_color.raw) { border_color = config.border_color.raw; auto gl_color = PicaToGL::ColorRGBA8(border_color); - glSamplerParameterfv(s, GL_TEXTURE_BORDER_COLOR, gl_color.data()); + glSamplerParameterfv(s, GL_TEXTURE_BORDER_COLOR, gl_color.AsArray()); } } @@ -1668,8 +1669,8 @@ void RasterizerOpenGL::SyncClipEnabled() { void RasterizerOpenGL::SyncClipCoef() { const auto raw_clip_coef = Pica::g_state.regs.rasterizer.GetClipCoef(); - const GLvec4 new_clip_coef = {raw_clip_coef.x.ToFloat32(), raw_clip_coef.y.ToFloat32(), - raw_clip_coef.z.ToFloat32(), raw_clip_coef.w.ToFloat32()}; + const Common::Vec4f new_clip_coef = {raw_clip_coef.x.ToFloat32(), raw_clip_coef.y.ToFloat32(), + raw_clip_coef.z.ToFloat32(), raw_clip_coef.w.ToFloat32()}; if (new_clip_coef != uniform_block_data.data.clip_coef) { uniform_block_data.data.clip_coef = new_clip_coef; uniform_block_data.dirty = true; @@ -1939,10 +1940,12 @@ void RasterizerOpenGL::SyncLightAmbient(int light_index) { } void RasterizerOpenGL::SyncLightPosition(int light_index) { - GLvec3 position = { - Pica::float16::FromRaw(Pica::g_state.regs.lighting.light[light_index].x).ToFloat32(), - Pica::float16::FromRaw(Pica::g_state.regs.lighting.light[light_index].y).ToFloat32(), - Pica::float16::FromRaw(Pica::g_state.regs.lighting.light[light_index].z).ToFloat32()}; + const auto& light = Pica::g_state.regs.lighting.light[light_index]; + const Common::Vec3f position = { + Pica::float16::FromRaw(light.x).ToFloat32(), + Pica::float16::FromRaw(light.y).ToFloat32(), + Pica::float16::FromRaw(light.z).ToFloat32() + }; if (position != uniform_block_data.data.light_src[light_index].position) { uniform_block_data.data.light_src[light_index].position = position; @@ -1952,8 +1955,8 @@ void RasterizerOpenGL::SyncLightPosition(int light_index) { void RasterizerOpenGL::SyncLightSpotDirection(int light_index) { const auto& light = Pica::g_state.regs.lighting.light[light_index]; - GLvec3 spot_direction = {light.spot_x / 2047.0f, light.spot_y / 2047.0f, - light.spot_z / 2047.0f}; + const auto spot_direction = Common::Vec3u{light.spot_x, light.spot_y, light.spot_z} + / 2047.0f; if (spot_direction != uniform_block_data.data.light_src[light_index].spot_direction) { uniform_block_data.data.light_src[light_index].spot_direction = spot_direction; @@ -1962,9 +1965,8 @@ void RasterizerOpenGL::SyncLightSpotDirection(int light_index) { } void RasterizerOpenGL::SyncLightDistanceAttenuationBias(int light_index) { - GLfloat dist_atten_bias = - Pica::float20::FromRaw(Pica::g_state.regs.lighting.light[light_index].dist_atten_bias) - .ToFloat32(); + const auto& light = Pica::g_state.regs.lighting.light[light_index]; + float dist_atten_bias = Pica::float20::FromRaw(light.dist_atten_bias).ToFloat32(); if (dist_atten_bias != uniform_block_data.data.light_src[light_index].dist_atten_bias) { uniform_block_data.data.light_src[light_index].dist_atten_bias = dist_atten_bias; @@ -1973,9 +1975,8 @@ void RasterizerOpenGL::SyncLightDistanceAttenuationBias(int light_index) { } void RasterizerOpenGL::SyncLightDistanceAttenuationScale(int light_index) { - GLfloat dist_atten_scale = - Pica::float20::FromRaw(Pica::g_state.regs.lighting.light[light_index].dist_atten_scale) - .ToFloat32(); + const auto& light = Pica::g_state.regs.lighting.light[light_index]; + float dist_atten_scale = Pica::float20::FromRaw(light.dist_atten_scale).ToFloat32(); if (dist_atten_scale != uniform_block_data.data.light_src[light_index].dist_atten_scale) { uniform_block_data.data.light_src[light_index].dist_atten_scale = dist_atten_scale; @@ -2006,7 +2007,8 @@ void RasterizerOpenGL::SyncShadowTextureBias() { void RasterizerOpenGL::SyncAndUploadLUTsLF() { constexpr std::size_t max_size = - sizeof(GLvec2) * 256 * Pica::LightingRegs::NumLightingSampler + sizeof(GLvec2) * 128; // fog + sizeof(Common::Vec2f) * 256 * Pica::LightingRegs::NumLightingSampler + + sizeof(Common::Vec2f) * 128; // fog if (!uniform_block_data.lighting_lut_dirty_any && !uniform_block_data.fog_lut_dirty) { return; @@ -2017,27 +2019,27 @@ void RasterizerOpenGL::SyncAndUploadLUTsLF() { bool invalidate; std::size_t bytes_used = 0; glBindBuffer(GL_TEXTURE_BUFFER, texture_lf_buffer.GetHandle()); - std::tie(buffer, offset, invalidate) = texture_lf_buffer.Map(max_size, sizeof(GLvec4)); + std::tie(buffer, offset, invalidate) = texture_lf_buffer.Map(max_size, sizeof(Common::Vec4f)); // Sync the lighting luts if (uniform_block_data.lighting_lut_dirty_any || invalidate) { for (unsigned index = 0; index < uniform_block_data.lighting_lut_dirty.size(); index++) { if (uniform_block_data.lighting_lut_dirty[index] || invalidate) { - std::array new_data; + std::array new_data; const auto& source_lut = Pica::g_state.lighting.luts[index]; std::transform(source_lut.begin(), source_lut.end(), new_data.begin(), [](const auto& entry) { - return GLvec2{entry.ToFloat(), entry.DiffToFloat()}; + return Common::Vec2f{entry.ToFloat(), entry.DiffToFloat()}; }); if (new_data != lighting_lut_data[index] || invalidate) { lighting_lut_data[index] = new_data; std::memcpy(buffer + bytes_used, new_data.data(), - new_data.size() * sizeof(GLvec2)); + new_data.size() * sizeof(Common::Vec2f)); uniform_block_data.data.lighting_lut_offset[index / 4][index % 4] = - static_cast((offset + bytes_used) / sizeof(GLvec2)); + static_cast((offset + bytes_used) / sizeof(Common::Vec2f)); uniform_block_data.dirty = true; - bytes_used += new_data.size() * sizeof(GLvec2); + bytes_used += new_data.size() * sizeof(Common::Vec2f); } uniform_block_data.lighting_lut_dirty[index] = false; } @@ -2047,20 +2049,20 @@ void RasterizerOpenGL::SyncAndUploadLUTsLF() { // Sync the fog lut if (uniform_block_data.fog_lut_dirty || invalidate) { - std::array new_data; + std::array new_data; std::transform(Pica::g_state.fog.lut.begin(), Pica::g_state.fog.lut.end(), new_data.begin(), [](const auto& entry) { - return GLvec2{entry.ToFloat(), entry.DiffToFloat()}; + return Common::Vec2f{entry.ToFloat(), entry.DiffToFloat()}; }); if (new_data != fog_lut_data || invalidate) { fog_lut_data = new_data; - std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(GLvec2)); + std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(Common::Vec2f)); uniform_block_data.data.fog_lut_offset = - static_cast((offset + bytes_used) / sizeof(GLvec2)); + static_cast((offset + bytes_used) / sizeof(Common::Vec2f)); uniform_block_data.dirty = true; - bytes_used += new_data.size() * sizeof(GLvec2); + bytes_used += new_data.size() * sizeof(Common::Vec2f); } uniform_block_data.fog_lut_dirty = false; } @@ -2069,9 +2071,9 @@ void RasterizerOpenGL::SyncAndUploadLUTsLF() { } void RasterizerOpenGL::SyncAndUploadLUTs() { - constexpr std::size_t max_size = sizeof(GLvec2) * 128 * 3 + // proctex: noise + color + alpha - sizeof(GLvec4) * 256 + // proctex - sizeof(GLvec4) * 256; // proctex diff + constexpr std::size_t max_size = sizeof(Common::Vec2f) * 128 * 3 + // proctex: noise + color + alpha + sizeof(Common::Vec4f) * 256 + // proctex + sizeof(Common::Vec4f) * 256; // proctex diff if (!uniform_block_data.proctex_noise_lut_dirty && !uniform_block_data.proctex_color_map_dirty && @@ -2085,23 +2087,23 @@ void RasterizerOpenGL::SyncAndUploadLUTs() { bool invalidate; std::size_t bytes_used = 0; glBindBuffer(GL_TEXTURE_BUFFER, texture_buffer.GetHandle()); - std::tie(buffer, offset, invalidate) = texture_buffer.Map(max_size, sizeof(GLvec4)); + std::tie(buffer, offset, invalidate) = texture_buffer.Map(max_size, sizeof(Common::Vec4f)); // helper function for SyncProcTexNoiseLUT/ColorMap/AlphaMap auto SyncProcTexValueLUT = [this, buffer, offset, invalidate, &bytes_used]( const std::array& lut, - std::array& lut_data, GLint& lut_offset) { - std::array new_data; + std::array& lut_data, GLint& lut_offset) { + std::array new_data; std::transform(lut.begin(), lut.end(), new_data.begin(), [](const auto& entry) { - return GLvec2{entry.ToFloat(), entry.DiffToFloat()}; + return Common::Vec2f{entry.ToFloat(), entry.DiffToFloat()}; }); if (new_data != lut_data || invalidate) { lut_data = new_data; - std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(GLvec2)); - lut_offset = static_cast((offset + bytes_used) / sizeof(GLvec2)); + std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(Common::Vec2f)); + lut_offset = static_cast((offset + bytes_used) / sizeof(Common::Vec2f)); uniform_block_data.dirty = true; - bytes_used += new_data.size() * sizeof(GLvec2); + bytes_used += new_data.size() * sizeof(Common::Vec2f); } }; @@ -2128,44 +2130,44 @@ void RasterizerOpenGL::SyncAndUploadLUTs() { // Sync the proctex lut if (uniform_block_data.proctex_lut_dirty || invalidate) { - std::array new_data; + std::array new_data; std::transform(Pica::g_state.proctex.color_table.begin(), Pica::g_state.proctex.color_table.end(), new_data.begin(), [](const auto& entry) { auto rgba = entry.ToVector() / 255.0f; - return GLvec4{rgba.r(), rgba.g(), rgba.b(), rgba.a()}; + return Common::Vec4f{rgba.r(), rgba.g(), rgba.b(), rgba.a()}; }); if (new_data != proctex_lut_data || invalidate) { proctex_lut_data = new_data; - std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(GLvec4)); + std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(Common::Vec4f)); uniform_block_data.data.proctex_lut_offset = - static_cast((offset + bytes_used) / sizeof(GLvec4)); + static_cast((offset + bytes_used) / sizeof(Common::Vec4f)); uniform_block_data.dirty = true; - bytes_used += new_data.size() * sizeof(GLvec4); + bytes_used += new_data.size() * sizeof(Common::Vec4f); } uniform_block_data.proctex_lut_dirty = false; } // Sync the proctex difference lut if (uniform_block_data.proctex_diff_lut_dirty || invalidate) { - std::array new_data; + std::array new_data; std::transform(Pica::g_state.proctex.color_diff_table.begin(), Pica::g_state.proctex.color_diff_table.end(), new_data.begin(), [](const auto& entry) { auto rgba = entry.ToVector() / 255.0f; - return GLvec4{rgba.r(), rgba.g(), rgba.b(), rgba.a()}; + return Common::Vec4f{rgba.r(), rgba.g(), rgba.b(), rgba.a()}; }); if (new_data != proctex_diff_lut_data || invalidate) { proctex_diff_lut_data = new_data; - std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(GLvec4)); + std::memcpy(buffer + bytes_used, new_data.data(), new_data.size() * sizeof(Common::Vec4f)); uniform_block_data.data.proctex_diff_lut_offset = - static_cast((offset + bytes_used) / sizeof(GLvec4)); + static_cast((offset + bytes_used) / sizeof(Common::Vec4f)); uniform_block_data.dirty = true; - bytes_used += new_data.size() * sizeof(GLvec4); + bytes_used += new_data.size() * sizeof(Common::Vec4f); } uniform_block_data.proctex_diff_lut_dirty = false; } diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h index 21068fc9ea..e623f3bdb1 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer.h +++ b/src/video_core/renderer_opengl/gl_rasterizer.h @@ -13,7 +13,6 @@ #include "video_core/renderer_opengl/gl_shader_manager.h" #include "video_core/renderer_opengl/gl_state.h" #include "video_core/renderer_opengl/gl_stream_buffer.h" -#include "video_core/renderer_opengl/pica_to_gl.h" #include "video_core/shader/shader.h" namespace Frontend { @@ -105,20 +104,18 @@ private: view[2] = v.view.z.ToFloat32(); if (flip_quaternion) { - for (float& x : normquat) { - x = -x; - } + normquat = -normquat; } } - GLvec4 position; - GLvec4 color; - GLvec2 tex_coord0; - GLvec2 tex_coord1; - GLvec2 tex_coord2; - GLfloat tex_coord0_w; - GLvec4 normquat; - GLvec3 view; + Common::Vec4f position; + Common::Vec4f color; + Common::Vec2f tex_coord0; + Common::Vec2f tex_coord1; + Common::Vec2f tex_coord2; + float tex_coord0_w; + Common::Vec4f normquat; + Common::Vec3f view; }; /// Syncs the clip enabled status to match the PICA register @@ -301,13 +298,13 @@ private: OGLTexture texture_buffer_lut_rg; OGLTexture texture_buffer_lut_rgba; - std::array, Pica::LightingRegs::NumLightingSampler> lighting_lut_data{}; - std::array fog_lut_data{}; - std::array proctex_noise_lut_data{}; - std::array proctex_color_map_data{}; - std::array proctex_alpha_map_data{}; - std::array proctex_lut_data{}; - std::array proctex_diff_lut_data{}; + std::array, Pica::LightingRegs::NumLightingSampler> lighting_lut_data{}; + std::array fog_lut_data{}; + std::array proctex_noise_lut_data{}; + std::array proctex_color_map_data{}; + std::array proctex_alpha_map_data{}; + std::array proctex_lut_data{}; + std::array proctex_diff_lut_data{}; }; } // namespace OpenGL diff --git a/src/video_core/renderer_opengl/gl_shader_manager.cpp b/src/video_core/renderer_opengl/gl_shader_manager.cpp index 5283fe59cf..badc1af34d 100644 --- a/src/video_core/renderer_opengl/gl_shader_manager.cpp +++ b/src/video_core/renderer_opengl/gl_shader_manager.cpp @@ -4,6 +4,7 @@ #include #include +#include #include #include #include @@ -150,11 +151,11 @@ void PicaUniformsData::SetFromRegs(const Pica::ShaderRegs& regs, std::transform(std::begin(setup.uniforms.b), std::end(setup.uniforms.b), std::begin(bools), [](bool value) -> BoolAligned { return {value ? GL_TRUE : GL_FALSE}; }); std::transform(std::begin(regs.int_uniforms), std::end(regs.int_uniforms), std::begin(i), - [](const auto& value) -> GLuvec4 { + [](const auto& value) -> Common::Vec4u { return {value.x.Value(), value.y.Value(), value.z.Value(), value.w.Value()}; }); std::transform(std::begin(setup.uniforms.f), std::end(setup.uniforms.f), std::begin(f), - [](const auto& value) -> GLvec4 { + [](const auto& value) -> Common::Vec4f { return {value.x.ToFloat32(), value.y.ToFloat32(), value.z.ToFloat32(), value.w.ToFloat32()}; }); diff --git a/src/video_core/renderer_opengl/gl_shader_manager.h b/src/video_core/renderer_opengl/gl_shader_manager.h index 5ad448e0fd..eef52383a4 100644 --- a/src/video_core/renderer_opengl/gl_shader_manager.h +++ b/src/video_core/renderer_opengl/gl_shader_manager.h @@ -5,34 +5,40 @@ #pragma once #include +#include "common/vector_math.h" #include "video_core/rasterizer_interface.h" -#include "video_core/renderer_opengl/pica_to_gl.h" +#include "video_core/regs_lighting.h" namespace Core { class System; } +namespace Frontend { +class EmuWindow; +} + namespace Pica { struct Regs; struct ShaderRegs; -namespace Shader { -struct ShaderSetup; } + +namespace Pica::Shader { +struct ShaderSetup; } namespace OpenGL { -enum class UniformBindings : GLuint { Common, VS, GS }; +enum class UniformBindings : u32 { Common, VS, GS }; struct LightSrc { - alignas(16) GLvec3 specular_0; - alignas(16) GLvec3 specular_1; - alignas(16) GLvec3 diffuse; - alignas(16) GLvec3 ambient; - alignas(16) GLvec3 position; - alignas(16) GLvec3 spot_direction; // negated - GLfloat dist_atten_bias; - GLfloat dist_atten_scale; + alignas(16) Common::Vec3f specular_0; + alignas(16) Common::Vec3f specular_1; + alignas(16) Common::Vec3f diffuse; + alignas(16) Common::Vec3f ambient; + alignas(16) Common::Vec3f position; + alignas(16) Common::Vec3f spot_direction; // negated + float dist_atten_bias; + float dist_atten_scale; }; /// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned @@ -40,39 +46,38 @@ struct LightSrc { // the end of a uniform block is included in UNIFORM_BLOCK_DATA_SIZE or not. // Not following that rule will cause problems on some AMD drivers. struct UniformData { - GLint framebuffer_scale; - GLint alphatest_ref; - GLfloat depth_scale; - GLfloat depth_offset; - GLfloat shadow_bias_constant; - GLfloat shadow_bias_linear; - GLint scissor_x1; - GLint scissor_y1; - GLint scissor_x2; - GLint scissor_y2; - GLint fog_lut_offset; - GLint proctex_noise_lut_offset; - GLint proctex_color_map_offset; - GLint proctex_alpha_map_offset; - GLint proctex_lut_offset; - GLint proctex_diff_lut_offset; - GLfloat proctex_bias; - GLint shadow_texture_bias; - alignas(16) GLivec4 lighting_lut_offset[Pica::LightingRegs::NumLightingSampler / 4]; - alignas(16) GLvec3 fog_color; - alignas(8) GLvec2 proctex_noise_f; - alignas(8) GLvec2 proctex_noise_a; - alignas(8) GLvec2 proctex_noise_p; - alignas(16) GLvec3 lighting_global_ambient; + int framebuffer_scale; + int alphatest_ref; + float depth_scale; + float depth_offset; + float shadow_bias_constant; + float shadow_bias_linear; + int scissor_x1; + int scissor_y1; + int scissor_x2; + int scissor_y2; + int fog_lut_offset; + int proctex_noise_lut_offset; + int proctex_color_map_offset; + int proctex_alpha_map_offset; + int proctex_lut_offset; + int proctex_diff_lut_offset; + float proctex_bias; + int shadow_texture_bias; + alignas(16) Common::Vec4i lighting_lut_offset[Pica::LightingRegs::NumLightingSampler / 4]; + alignas(16) Common::Vec3f fog_color; + alignas(8) Common::Vec2f proctex_noise_f; + alignas(8) Common::Vec2f proctex_noise_a; + alignas(8) Common::Vec2f proctex_noise_p; + alignas(16) Common::Vec3f lighting_global_ambient; LightSrc light_src[8]; - alignas(16) GLvec4 const_color[6]; // A vec4 color for each of the six tev stages - alignas(16) GLvec4 tev_combiner_buffer_color; - alignas(16) GLvec4 clip_coef; + alignas(16) Common::Vec4f const_color[6]; // A vec4 color for each of the six tev stages + alignas(16) Common::Vec4f tev_combiner_buffer_color; + alignas(16) Common::Vec4f clip_coef; }; -static_assert( - sizeof(UniformData) == 0x4F0, - "The size of the UniformData structure has changed, update the structure in the shader"); +static_assert(sizeof(UniformData) == 0x4F0, + "The size of the UniformData does not match the structure in the shader"); static_assert(sizeof(UniformData) < 16384, "UniformData structure must be less than 16kb as per the OpenGL spec"); @@ -82,20 +87,19 @@ struct PicaUniformsData { void SetFromRegs(const Pica::ShaderRegs& regs, const Pica::Shader::ShaderSetup& setup); struct BoolAligned { - alignas(16) GLint b; + alignas(16) int b; }; std::array bools; - alignas(16) std::array i; - alignas(16) std::array f; + alignas(16) std::array i; + alignas(16) std::array f; }; struct VSUniformData { PicaUniformsData uniforms; }; -static_assert( - sizeof(VSUniformData) == 1856, - "The size of the VSUniformData structure has changed, update the structure in the shader"); +static_assert(sizeof(VSUniformData) == 1856, + "The size of the VSUniformData does not match the structure in the shader"); static_assert(sizeof(VSUniformData) < 16384, "VSUniformData structure must be less than 16kb as per the OpenGL spec"); diff --git a/src/video_core/renderer_opengl/pica_to_gl.h b/src/video_core/renderer_opengl/pica_to_gl.h index 7f854fc48e..5a559d72e5 100644 --- a/src/video_core/renderer_opengl/pica_to_gl.h +++ b/src/video_core/renderer_opengl/pica_to_gl.h @@ -1,32 +1,18 @@ -// Copyright 2015 Citra Emulator Project +// Copyright 2022 Citra Emulator Project // Licensed under GPLv2 or any later version // Refer to the license.txt file included. #pragma once #include -#include #include #include "common/assert.h" -#include "common/common_types.h" #include "common/logging/log.h" #include "core/core.h" #include "video_core/regs_framebuffer.h" #include "video_core/regs_lighting.h" #include "video_core/regs_texturing.h" -using GLvec2 = std::array; -using GLvec3 = std::array; -using GLvec4 = std::array; - -using GLuvec2 = std::array; -using GLuvec3 = std::array; -using GLuvec4 = std::array; - -using GLivec2 = std::array; -using GLivec3 = std::array; -using GLivec4 = std::array; - namespace PicaToGL { using TextureFilter = Pica::TexturingRegs::TextureConfig::TextureFilter; @@ -245,21 +231,14 @@ inline GLenum StencilOp(Pica::FramebufferRegs::StencilAction action) { return stencil_op_table[index]; } -inline GLvec4 ColorRGBA8(const u32 color) { - return {{ - (color >> 0 & 0xFF) / 255.0f, - (color >> 8 & 0xFF) / 255.0f, - (color >> 16 & 0xFF) / 255.0f, - (color >> 24 & 0xFF) / 255.0f, - }}; +inline Common::Vec4f ColorRGBA8(const u32 color) { + const auto rgba = Common::Vec4u{color >> 0 & 0xFF, color >> 8 & 0xFF, + color >> 16 & 0xFF, color >> 24 & 0xFF}; + return rgba / 255.0f; } -inline std::array LightColor(const Pica::LightingRegs::LightColor& color) { - return {{ - color.r / 255.0f, - color.g / 255.0f, - color.b / 255.0f, - }}; +inline Common::Vec3f LightColor(const Pica::LightingRegs::LightColor& color) { + return Common::Vec3u{color.r, color.g, color.b} / 255.0f; } } // namespace PicaToGL