Reduce redundant rendering work per frame

Author: drhelius

platforms/shared/desktop/emu.cpp

@@ -552,6 +552,8 @@ void emu_load_state_file(const char* file_path)
 
 void update_savestates_data(void)
 {
+    emu_savestates_generation++;
+
     if (emu_is_empty())
         return;
 

platforms/shared/desktop/emu.h

@@ -46,6 +46,7 @@ enum Directory_Location
 EXTERN u8* emu_frame_buffer;
 EXTERN GS_SaveState_Header emu_savestates[5];
 EXTERN GS_SaveState_Screenshot emu_savestates_screenshots[5];
+EXTERN u32 emu_savestates_generation;
 EXTERN u8* emu_debug_sprite_buffers[64];
 EXTERN u8* emu_debug_background_buffer;
 EXTERN u8* emu_debug_tile_buffer;

platforms/shared/desktop/ogl_renderer.cpp

@@ -41,6 +41,8 @@ static uint32_t system_texture;
 static uint32_t frame_buffer_object;
 static GS_RuntimeInfo current_runtime;
 static OglRendererScreenGeometry screen_geometry;
+static int savestates_texture_slot = -1;
+static u32 savestates_texture_generation = 0;
 
 static uint32_t quad_shader_program = 0;
 static uint32_t quad_vao = 0;
@@ -60,7 +62,6 @@ static void render_internal_shader_chain(void);
 static void render_external_shader_chain(void);
 static void render_internal_shader_chain_feedback(void);
 static void render_emu_normal(void);
-static void update_emu_texture(void);
 static void render_quad(uint32_t program, uint32_t texture, int viewport_width, int viewport_height, float tex_h, float tex_v, float red, float green, float blue, float alpha);
 static void render_quad_preset(int pass_index, uint32_t program, uint32_t texture, int input_width, int input_height, int viewport_width, int viewport_height);
 static void update_system_texture(void);
@@ -162,8 +163,6 @@ void ogl_renderer_render(void)
     else
         render_emu_normal();
 
-    update_emu_texture();
-
     ImVec4 clear_color = ImVec4(config_video.background_color[0], config_video.background_color[1], config_video.background_color[2], 1.00f);
 
     ImGuiIO& io = ImGui::GetIO();
@@ -321,6 +320,8 @@ static void init_ogl_debug(void)
 static void init_ogl_savestates(void)
 {
     create_texture_2d(&ogl_renderer_emu_savestates, SYSTEM_TEXTURE_WIDTH, SYSTEM_TEXTURE_HEIGHT, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, NULL, false);
+    savestates_texture_slot = -1;
+    savestates_texture_generation = 0;
 }
 
 static void render_gui(void)
@@ -340,8 +341,7 @@ static bool should_use_internal_shader_chain(void)
 
 static void render_internal_shader_chain(void)
 {
-    bool has_preset = ogl_shader_chain_has_preset();
-    bool filter_linear = has_preset ? ogl_shader_chain_get_preset_filter_linear() : false;
+    bool filter_linear = ogl_shader_chain_get_preset_filter_linear();
 
     OglShaderChainSourceTexture source_texture;
     source_texture.width = current_runtime.screen_width;
@@ -355,33 +355,7 @@ static void render_internal_shader_chain(void)
         return;
     }
 
-    if (has_preset)
-    {
-        render_external_shader_chain();
-        return;
-    }
-
-    OglShaderChainFramebufferTexture pass_texture;
-    pass_texture.width = screen_geometry.physical_width;
-    pass_texture.height = screen_geometry.physical_height;
-    pass_texture.filter_linear = false;
-    pass_texture.float_framebuffer = false;
-
-    if (!ogl_shader_chain_resize_pass_texture(&pass_texture))
-    {
-        render_emu_normal();
-        return;
-    }
-
-    glBindFramebuffer(GL_FRAMEBUFFER, ogl_shader_chain_get_pass_framebuffer());
-    glDisable(GL_BLEND);
-
-    render_quad(quad_shader_program, ogl_shader_chain_get_source_texture(),
-            ogl_shader_chain_get_pass_width(), ogl_shader_chain_get_pass_height(),
-            1.0f, 1.0f,
-            1.0f, 1.0f, 1.0f, 1.0f);
-
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    render_external_shader_chain();
 }
 
 static void render_external_shader_chain(void)
@@ -497,8 +471,6 @@ static void update_system_texture(void)
     glBindTexture(GL_TEXTURE_2D, system_texture);
     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, current_runtime.screen_width, current_runtime.screen_height,
             GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*) emu_frame_buffer);
-
-    configure_texture_2d(false);
 }
 
 static void update_debug_textures(void)
@@ -531,6 +503,14 @@ static void update_debug_textures(void)
 static void update_savestates_texture(void)
 {
     int i = config_emulator.save_slot;
+    if (i < 0 || i >= 5)
+        return;
+
+    if ((savestates_texture_slot == i) && (savestates_texture_generation == emu_savestates_generation))
+        return;
+
+    savestates_texture_slot = i;
+    savestates_texture_generation = emu_savestates_generation;
 
     if (IsValidPointer(emu_savestates_screenshots[i].data))
     {
@@ -541,13 +521,6 @@ static void update_savestates_texture(void)
     }
 }
 
-static void update_emu_texture(void)
-{
-    glBindTexture(GL_TEXTURE_2D, ogl_renderer_emu_texture);
-
-    configure_texture_2d(false);
-}
-
 static void render_quad(uint32_t program, uint32_t texture, int viewport_width, int viewport_height, float tex_h, float tex_v, float red, float green, float blue, float alpha)
 {
     glActiveTexture(GL_TEXTURE0);

platforms/shared/desktop/ogl_shader_chain.cpp

@@ -26,17 +26,22 @@ static uint32_t intermediate_textures[SHADER_PRESET_MAX_PASSES - 1];
 static uint32_t intermediate_fbos[SHADER_PRESET_MAX_PASSES - 1];
 static int intermediate_widths[SHADER_PRESET_MAX_PASSES - 1];
 static int intermediate_heights[SHADER_PRESET_MAX_PASSES - 1];
+static bool intermediate_filter_linears[SHADER_PRESET_MAX_PASSES - 1];
 static bool intermediate_float_framebuffers[SHADER_PRESET_MAX_PASSES - 1];
 static uint32_t pass_history_textures[SHADER_PRESET_MAX_PASSES][SHADER_PRESET_MAX_HISTORY_TEXTURES];
 static int pass_history_widths[SHADER_PRESET_MAX_PASSES];
 static int pass_history_heights[SHADER_PRESET_MAX_PASSES];
+static bool pass_history_filter_linears[SHADER_PRESET_MAX_PASSES];
 static int pass_history_counts[SHADER_PRESET_MAX_PASSES];
 static int pass_history_write_indices[SHADER_PRESET_MAX_PASSES];
 static bool pass_history_float_framebuffers[SHADER_PRESET_MAX_PASSES];
 static int source_width = 1;
 static int source_height = 1;
+static bool source_filter_linear = false;
 static int pass_width = 1;
 static int pass_height = 1;
+static bool pass_filter_linear = false;
+static bool feedback_filter_linear = false;
 static bool pass_float_framebuffer = false;
 static bool initialized = false;
 static const char* framebuffer_name = "shader-chain framebuffer";
@@ -98,8 +103,11 @@ bool ogl_shader_chain_init(const char* name)
     framebuffer_name = name ? name : "shader-chain framebuffer";
     source_width = 1;
     source_height = 1;
+    source_filter_linear = false;
     pass_width = 1;
     pass_height = 1;
+    pass_filter_linear = false;
+    feedback_filter_linear = false;
     pass_float_framebuffer = false;
 
     glGenTextures(1, &source_texture);
@@ -127,13 +135,15 @@ bool ogl_shader_chain_init(const char* name)
         intermediate_fbos[i] = 0;
         intermediate_widths[i] = 1;
         intermediate_heights[i] = 1;
+        intermediate_filter_linears[i] = false;
         intermediate_float_framebuffers[i] = false;
     }
 
     for (int i = 0; i < SHADER_PRESET_MAX_PASSES; i++)
     {
         pass_history_widths[i] = 1;
         pass_history_heights[i] = 1;
+        pass_history_filter_linears[i] = false;
         pass_history_counts[i] = 0;
         pass_history_write_indices[i] = 0;
         pass_history_float_framebuffers[i] = false;
@@ -175,6 +185,7 @@ void ogl_shader_chain_destroy(void)
 
         pass_history_widths[i] = 1;
         pass_history_heights[i] = 1;
+        pass_history_filter_linears[i] = false;
         pass_history_counts[i] = 0;
         pass_history_write_indices[i] = 0;
         pass_history_float_framebuffers[i] = false;
@@ -197,8 +208,12 @@ void ogl_shader_chain_destroy(void)
     source_texture = 0;
     source_width = 1;
     source_height = 1;
+    source_filter_linear = false;
     pass_width = 1;
     pass_height = 1;
+    pass_filter_linear = false;
+    feedback_filter_linear = false;
+    pass_float_framebuffer = false;
     initialized = false;
 }
 
@@ -225,11 +240,16 @@ bool ogl_shader_chain_update_source_texture(const OglShaderChainSourceTexture* t
         resize_texture_2d(source_texture, width, height, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, NULL, texture->filter_linear);
         source_width = width;
         source_height = height;
+        source_filter_linear = texture->filter_linear;
     }
 
     glBindTexture(GL_TEXTURE_2D, source_texture);
     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, texture->pixels);
-    configure_texture_2d(texture->filter_linear);
+    if (source_filter_linear != texture->filter_linear)
+    {
+        configure_texture_2d(texture->filter_linear);
+        source_filter_linear = texture->filter_linear;
+    }
 
     return true;
 }
@@ -249,10 +269,20 @@ bool ogl_shader_chain_resize_pass_texture(const OglShaderChainFramebufferTexture
 
     if (pass_width == width && pass_height == height && pass_float_framebuffer == texture->float_framebuffer)
     {
-        glBindTexture(GL_TEXTURE_2D, pass_texture);
-        configure_texture_2d(texture->filter_linear);
-        glBindTexture(GL_TEXTURE_2D, feedback_texture);
-        configure_texture_2d(texture->filter_linear);
+        if (pass_filter_linear != texture->filter_linear)
+        {
+            glBindTexture(GL_TEXTURE_2D, pass_texture);
+            configure_texture_2d(texture->filter_linear);
+            pass_filter_linear = texture->filter_linear;
+        }
+
+        if (feedback_filter_linear != texture->filter_linear)
+        {
+            glBindTexture(GL_TEXTURE_2D, feedback_texture);
+            configure_texture_2d(texture->filter_linear);
+            feedback_filter_linear = texture->filter_linear;
+        }
+
         return true;
     }
 
@@ -267,6 +297,8 @@ bool ogl_shader_chain_resize_pass_texture(const OglShaderChainFramebufferTexture
     {
         pass_width = width;
         pass_height = height;
+        pass_filter_linear = texture->filter_linear;
+        feedback_filter_linear = texture->filter_linear;
         pass_float_framebuffer = texture->float_framebuffer;
         clear_feedback_texture();
     }
@@ -292,8 +324,13 @@ bool ogl_shader_chain_resize_intermediate_texture(int index, const OglShaderChai
 
     if (intermediate_widths[index] == width && intermediate_heights[index] == height && intermediate_float_framebuffers[index] == texture->float_framebuffer)
     {
-        glBindTexture(GL_TEXTURE_2D, intermediate_textures[index]);
-        configure_texture_2d(texture->filter_linear);
+        if (intermediate_filter_linears[index] != texture->filter_linear)
+        {
+            glBindTexture(GL_TEXTURE_2D, intermediate_textures[index]);
+            configure_texture_2d(texture->filter_linear);
+            intermediate_filter_linears[index] = texture->filter_linear;
+        }
+
         return true;
     }
 
@@ -302,6 +339,7 @@ bool ogl_shader_chain_resize_intermediate_texture(int index, const OglShaderChai
 
     intermediate_widths[index] = width;
     intermediate_heights[index] = height;
+    intermediate_filter_linears[index] = texture->filter_linear;
     intermediate_float_framebuffers[index] = texture->float_framebuffer;
     return true;
 }
@@ -534,27 +572,6 @@ void ogl_shader_chain_apply_preset_uniforms(int index, const OglShaderChainUnifo
     if (!state->program)
         return;
 
-    if (state->uniform_source >= 0)
-        glUniform1i(state->uniform_source, 0);
-
-    if (state->uniform_original >= 0)
-        glUniform1i(state->uniform_original, 1);
-
-    if (state->uniform_feedback >= 0)
-        glUniform1i(state->uniform_feedback, 2);
-
-    for (int i = 0; i < SHADER_PRESET_MAX_HISTORY_TEXTURES; i++)
-    {
-        if (state->uniform_source_history[i] >= 0)
-            glUniform1i(state->uniform_source_history[i], 3 + i);
-    }
-
-    for (int i = 0; i < SHADER_PRESET_MAX_PASS_OUTPUT_TEXTURES; i++)
-    {
-        if (state->uniform_pass_output[i] >= 0)
-            glUniform1i(state->uniform_pass_output[i], 3 + SHADER_PRESET_MAX_HISTORY_TEXTURES + i);
-    }
-
     if (state->uniform_source_size >= 0)
         glUniform4f(state->uniform_source_size, (float)uniforms->input_width, (float)uniforms->input_height, safe_inverse(uniforms->input_width), safe_inverse(uniforms->input_height));
 
@@ -671,7 +688,6 @@ bool ogl_shader_chain_store_pass_history(int index, uint32_t texture, int width,
 
     glBindTexture(GL_TEXTURE_2D, target_texture);
     glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, pass_history_widths[index], pass_history_heights[index]);
-    configure_texture_2d(filter_linear);
 
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -896,6 +912,7 @@ static void release_intermediate_textures(int keep_count)
         intermediate_textures[i] = 0;
         intermediate_widths[i] = 1;
         intermediate_heights[i] = 1;
+        intermediate_filter_linears[i] = false;
         intermediate_float_framebuffers[i] = false;
     }
 }
@@ -957,39 +974,50 @@ static bool resize_pass_history_textures(int index, int width, int height, bool
         height = 1;
 
     bool same_size = pass_history_widths[index] == width && pass_history_heights[index] == height && pass_history_float_framebuffers[index] == float_framebuffer;
+    bool same_filter = pass_history_filter_linears[index] == filter_linear;
     int internal_format = float_framebuffer ? GL_RGBA16F : GL_RGBA8;
     uint32_t type = float_framebuffer ? GL_FLOAT : GL_UNSIGNED_BYTE;
-    bool created = false;
+    bool needs_create = false;
+
+    for (int i = 0; i < SHADER_PRESET_MAX_HISTORY_TEXTURES; i++)
+    {
+        if (!pass_history_textures[index][i])
+            needs_create = true;
+    }
+
+    bool resize = !same_size || needs_create;
 
     for (int i = 0; i < SHADER_PRESET_MAX_HISTORY_TEXTURES; i++)
     {
         if (!pass_history_textures[index][i])
-        {
             glGenTextures(1, &pass_history_textures[index][i]);
-            created = true;
-        }
 
         if (!pass_history_textures[index][i])
             return false;
 
-        if (same_size && !created)
+        if (resize)
         {
-            glBindTexture(GL_TEXTURE_2D, pass_history_textures[index][i]);
-            configure_texture_2d(filter_linear);
+            resize_texture_2d(pass_history_textures[index][i], width, height, internal_format, GL_RGBA, type, NULL, filter_linear);
         }
-        else
+        else if (!same_filter)
         {
-            resize_texture_2d(pass_history_textures[index][i], width, height, internal_format, GL_RGBA, type, NULL, filter_linear);
+            glBindTexture(GL_TEXTURE_2D, pass_history_textures[index][i]);
+            configure_texture_2d(filter_linear);
         }
     }
 
-    if (!same_size || created)
+    if (resize)
     {
         pass_history_widths[index] = width;
         pass_history_heights[index] = height;
+        pass_history_filter_linears[index] = filter_linear;
         pass_history_float_framebuffers[index] = float_framebuffer;
         clear_pass_history_textures(index);
     }
+    else if (!same_filter)
+    {
+        pass_history_filter_linears[index] = filter_linear;
+    }
 
     return true;
 }