fx

src/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.0.2'
+        classpath 'com.android.tools.build:gradle:8.1.1'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

src/video_core/renderer_opengl/gl_resource_manager.cpp

@@ -6,21 +6,16 @@
 #include <glad/glad.h>
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "common/microprofile.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
 #include "video_core/renderer_opengl/gl_state.h"
 
-MICROPROFILE_DEFINE(OpenGL_ResourceCreation, "OpenGL", "Resource Creation", MP_RGB(128, 128, 192));
-MICROPROFILE_DEFINE(OpenGL_ResourceDeletion, "OpenGL", "Resource Deletion", MP_RGB(128, 128, 192));
-
 namespace OpenGL {
 
 void OGLRenderbuffer::Create() {
     if (handle != 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     glGenRenderbuffers(1, &handle);
 }
 
@@ -29,70 +24,56 @@ void OGLRenderbuffer::Release() {
         return;
 
     glDeleteRenderbuffers(1, &handle);
-    OpenGLState::ResetRenderbuffer(handle);
     handle = 0;
 }
 
 void OGLTexture::Create() {
     if (handle != 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     glGenTextures(1, &handle);
 }
 
 void OGLTexture::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteTextures(1, &handle);
-    OpenGLState::ResetTexture(handle);
     handle = 0;
 }
 
 void OGLSampler::Create() {
     if (handle != 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     glGenSamplers(1, &handle);
 }
 
 void OGLSampler::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteSamplers(1, &handle);
-    OpenGLState::ResetSampler(handle);
     handle = 0;
 }
 
 void OGLShader::Create(const char* source, GLenum type) {
     if (handle != 0)
         return;
-    if (source == nullptr)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     handle = LoadShader(source, type);
 }
 
 void OGLShader::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteShader(handle);
     handle = 0;
 }
 
 void OGLProgram::Create(bool separable_program, const std::vector<GLuint>& shaders) {
     if (handle != 0)
         return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     handle = LoadProgram(separable_program, shaders);
 }
 
@@ -153,81 +134,67 @@ void OGLProgram::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteProgram(handle);
-    OpenGLState::ResetProgram(handle);
     handle = 0;
 }
 
 void OGLPipeline::Create() {
     if (handle != 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     glGenProgramPipelines(1, &handle);
 }
 
 void OGLPipeline::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteProgramPipelines(1, &handle);
-    OpenGLState::ResetPipeline(handle);
     handle = 0;
 }
 
 void OGLBuffer::Create() {
     if (handle != 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     glGenBuffers(1, &handle);
 }
 
 void OGLBuffer::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteBuffers(1, &handle);
-    OpenGLState::ResetBuffer(handle);
     handle = 0;
 }
 
 void OGLVertexArray::Create() {
     if (handle != 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     glGenVertexArrays(1, &handle);
 }
 
 void OGLVertexArray::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteVertexArrays(1, &handle);
-    OpenGLState::ResetVertexArray(handle);
     handle = 0;
 }
 
 void OGLFramebuffer::Create() {
     if (handle != 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
     glGenFramebuffers(1, &handle);
 }
 
 void OGLFramebuffer::Release() {
     if (handle == 0)
         return;
 
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteFramebuffers(1, &handle);
-    OpenGLState::ResetFramebuffer(handle);
     handle = 0;
 }
 

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -154,13 +154,17 @@ PicaFSConfig PicaFSConfig::BuildFromRegs(const Pica::Regs& regs) {
     // We don't sync const_color here because of the high variance, it is a
     // shader uniform instead.
     const auto& tev_stages = regs.texturing.GetTevStages();
-    DEBUG_ASSERT(state.tev_stages.size() == tev_stages.size());
     for (std::size_t i = 0; i < tev_stages.size(); i++) {
         const auto& tev_stage = tev_stages[i];
         state.tev_stages[i].sources_raw = tev_stage.sources_raw;
         state.tev_stages[i].modifiers_raw = tev_stage.modifiers_raw;
         state.tev_stages[i].ops_raw = tev_stage.ops_raw;
         state.tev_stages[i].scales_raw = tev_stage.scales_raw;
+        if (tev_stage.color_op == TevStageConfig::Operation::Dot3_RGBA) {
+            state.tev_stages[i].sources_raw &= 0xFFF;
+            state.tev_stages[i].modifiers_raw &= 0xFFF;
+            state.tev_stages[i].ops_raw &= 0xF;
+        }
     }
 
     state.fog_mode = regs.texturing.fog_mode;

src/video_core/renderer_opengl/gl_state.cpp

@@ -342,13 +342,6 @@ GLuint OpenGLState::BindVertexArray(GLuint array) {
     return previous;
 }
 
-GLuint OpenGLState::BindVertexBuffer(GLuint buffer) {
-    GLuint previous = cur_state.draw.vertex_buffer;
-    glBindBuffer(GL_ARRAY_BUFFER, buffer);
-    cur_state.draw.vertex_buffer = buffer;
-    return previous;
-}
-
 GLuint OpenGLState::BindUniformBuffer(GLuint buffer) {
     GLuint previous = cur_state.draw.uniform_buffer;
     glBindBuffer(GL_UNIFORM_BUFFER, buffer);
@@ -388,25 +381,20 @@ GLuint OpenGLState::BindReadFramebuffer(GLuint framebuffer) {
 
 GLuint OpenGLState::BindDrawFramebuffer(GLuint framebuffer) {
     GLuint previous = cur_state.draw.draw_framebuffer;
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer);
-    cur_state.draw.draw_framebuffer = framebuffer;
+    if (previous != framebuffer) {
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer);
+        cur_state.draw.draw_framebuffer = framebuffer;
+    }
     return previous;
 }
 
-GLuint OpenGLState::BindRenderbuffer(GLuint buffer) {
-    GLuint previous = cur_state.renderbuffer;
-    glBindRenderbuffer(GL_RENDERBUFFER, buffer);
-    cur_state.renderbuffer = buffer;
+GLuint OpenGLState::BindShaderProgram(GLuint program) {
+    GLuint previous = cur_state.draw.shader_program;
+    glUseProgram(program);
+    cur_state.draw.shader_program = program;
     return previous;
 }
 
-GLuint OpenGLState::BindShaderProgram(GLuint shader) {
-    GLuint previous_shader = cur_state.draw.shader_program;
-    glUseProgram(shader);
-    cur_state.draw.shader_program = shader;
-    return previous_shader;
-}
-
 void OpenGLState::ResetTexture(GLuint handle) {
     for (unsigned i = 0; i < ARRAY_SIZE(cur_state.texture_units); ++i) {
         if (cur_state.texture_units[i].texture_2d == handle) {
@@ -517,11 +505,4 @@ void OpenGLState::ResetFramebuffer(GLuint handle) {
     }
 }
 
-void OpenGLState::ResetRenderbuffer(GLuint handle) {
-    if (cur_state.renderbuffer == handle) {
-        cur_state.renderbuffer = 0;
-        glBindRenderbuffer(GL_RENDERBUFFER, 0);
-    }
-}
-
 } // namespace OpenGL