Shader flags are now sent as bit masks instead of via discreet values.

Also changed the shader flags to enums.

es-app/src/MediaViewer.cpp

@@ -90,9 +90,9 @@ void MediaViewer::render(const glm::mat4& /*parentTrans*/)
         Renderer::postProcessingParams videoParameters;
         unsigned int shaders {0};
         if (Settings::getInstance()->getBool("MediaViewerVideoScanlines"))
-            shaders = Renderer::SHADER_SCANLINES;
+            shaders = Renderer::Shader::SCANLINES;
         if (Settings::getInstance()->getBool("MediaViewerVideoBlur")) {
-            shaders |= Renderer::SHADER_BLUR_HORIZONTAL;
+            shaders |= Renderer::Shader::BLUR_HORIZONTAL;
             float heightModifier {Renderer::getScreenHeightModifier()};
             // clang-format off
             if (heightModifier < 1)
@@ -120,10 +120,10 @@ void MediaViewer::render(const glm::mat4& /*parentTrans*/)
 
         if (mCurrentImageIndex == mScreenshotIndex &&
             Settings::getInstance()->getBool("MediaViewerScreenshotScanlines"))
-            mRenderer->shaderPostprocessing(Renderer::SHADER_SCANLINES);
+            mRenderer->shaderPostprocessing(Renderer::Shader::SCANLINES);
         else if (mCurrentImageIndex == mTitleScreenIndex &&
                  Settings::getInstance()->getBool("MediaViewerScreenshotScanlines"))
-            mRenderer->shaderPostprocessing(Renderer::SHADER_SCANLINES);
+            mRenderer->shaderPostprocessing(Renderer::Shader::SCANLINES);
 
         // This is necessary so that the video loops if viewing an image when
         // the video ends.

es-app/src/Screensaver.cpp

@@ -269,7 +269,7 @@ void Screensaver::renderScreensaver()
         if (Settings::getInstance()->getString("ScreensaverType") == "slideshow") {
             if (mHasMediaFiles) {
                 if (Settings::getInstance()->getBool("ScreensaverSlideshowScanlines"))
-                    mRenderer->shaderPostprocessing(Renderer::SHADER_SCANLINES);
+                    mRenderer->shaderPostprocessing(Renderer::Shader::SCANLINES);
                 if (Settings::getInstance()->getBool("ScreensaverSlideshowGameInfo") &&
                     mGameOverlay) {
                     if (mGameOverlayRectangleCoords.size() == 4) {
@@ -297,9 +297,9 @@ void Screensaver::renderScreensaver()
                 Renderer::postProcessingParams videoParameters;
                 unsigned int shaders {0};
                 if (Settings::getInstance()->getBool("ScreensaverVideoScanlines"))
-                    shaders = Renderer::SHADER_SCANLINES;
+                    shaders = Renderer::Shader::SCANLINES;
                 if (Settings::getInstance()->getBool("ScreensaverVideoBlur")) {
-                    shaders |= Renderer::SHADER_BLUR_HORIZONTAL;
+                    shaders |= Renderer::Shader::BLUR_HORIZONTAL;
                     float heightModifier = Renderer::getScreenHeightModifier();
                     // clang-format off
                     if (heightModifier < 1)
@@ -348,7 +348,7 @@ void Screensaver::renderScreensaver()
             Renderer::postProcessingParams dimParameters;
             dimParameters.dimming = mDimValue;
             dimParameters.saturation = mSaturationAmount;
-            mRenderer->shaderPostprocessing(Renderer::SHADER_CORE, dimParameters);
+            mRenderer->shaderPostprocessing(Renderer::Shader::CORE, dimParameters);
             if (mDimValue > 0.63)
                 mDimValue = glm::clamp(mDimValue - 0.015f, 0.68f, 1.0f);
             if (mSaturationAmount > 0.0)
@@ -357,7 +357,7 @@ void Screensaver::renderScreensaver()
         else if (Settings::getInstance()->getString("ScreensaverType") == "black") {
             Renderer::postProcessingParams blackParameters;
             blackParameters.dimming = mDimValue;
-            mRenderer->shaderPostprocessing(Renderer::SHADER_CORE, blackParameters);
+            mRenderer->shaderPostprocessing(Renderer::Shader::CORE, blackParameters);
             if (mDimValue > 0.0)
                 mDimValue = glm::clamp(mDimValue - 0.045f, 0.0f, 1.0f);
         }

es-core/src/Window.cpp

@@ -477,15 +477,15 @@ void Window::render()
                     // Also dim the background slightly.
                     backgroundParameters.dimming = 0.60f;
 
-                    mRenderer->shaderPostprocessing(Renderer::SHADER_CORE |
+                    mRenderer->shaderPostprocessing(Renderer::Shader::CORE |
-                                                        Renderer::SHADER_BLUR_HORIZONTAL |
+                                                        Renderer::Shader::BLUR_HORIZONTAL |
-                                                        Renderer::SHADER_BLUR_VERTICAL,
+                                                        Renderer::Shader::BLUR_VERTICAL,
                                                     backgroundParameters, &processedTexture[0]);
                 }
                 else {
                     // Dim the background slightly.
                     backgroundParameters.dimming = 0.60f;
-                    mRenderer->shaderPostprocessing(Renderer::SHADER_CORE, backgroundParameters,
+                    mRenderer->shaderPostprocessing(Renderer::Shader::CORE, backgroundParameters,
                                                     &processedTexture[0]);
                 }
 

es-core/src/components/GIFAnimComponent.cpp

@@ -491,7 +491,7 @@ void GIFAnimComponent::render(const glm::mat4& parentTrans)
         vertices->saturation = mSaturation;
         vertices->opacity = mOpacity * mThemeOpacity;
         vertices->dimming = mDimming;
-        vertices->convertBGRAToRGBA = true;
+        vertices->shaderFlags = Renderer::ShaderFlags::BGRA_TO_RGBA;
 
         // Render it.
         mRenderer->drawTriangleStrips(&vertices[0], 4);

es-core/src/components/LottieAnimComponent.cpp

@@ -480,7 +480,7 @@ void LottieAnimComponent::render(const glm::mat4& parentTrans)
         vertices->saturation = mSaturation;
         vertices->opacity = mOpacity * mThemeOpacity;
         vertices->dimming = mDimming;
-        vertices->convertBGRAToRGBA = true;
+        vertices->shaderFlags = Renderer::ShaderFlags::BGRA_TO_RGBA;
 
         // Render it.
         mRenderer->drawTriangleStrips(&vertices[0], 4);

es-core/src/components/VideoFFmpegComponent.cpp

@@ -217,7 +217,7 @@ void VideoFFmpegComponent::render(const glm::mat4& parentTrans)
             vertices[0].opacity = mFadeIn * mThemeOpacity;
             if ((mLegacyTheme && Settings::getInstance()->getBool("GamelistVideoScanlines")) ||
                 (!mLegacyTheme && mRenderScanlines)) {
-                vertices[0].shaders = Renderer::SHADER_SCANLINES;
+                vertices[0].shaders = Renderer::Shader::SCANLINES;
             }
         }
 

es-core/src/renderers/Renderer.h

@@ -17,47 +17,14 @@
 #include <vector>
 
 struct SDL_Window;
-class Shader;
 
 class Renderer
 {
 public:
-    struct Vertex {
+    enum class TextureType {
-        glm::vec2 position;
+        RGBA, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
-        glm::vec2 texture;
+        BGRA,
-        unsigned int color;
+        RED
-        float opacity;
-        float saturation;
-        float dimming;
-        bool convertBGRAToRGBA;
-        bool font;
-        bool postProcessing;
-        unsigned int shaders;
-
-        Vertex()
-            : opacity {1.0f}
-            , saturation {1.0f}
-            , dimming {1.0f}
-            , convertBGRAToRGBA {false}
-            , font {false}
-            , postProcessing {false}
-            , shaders {0}
-        {
-        }
-
-        Vertex(const glm::vec2& position, const glm::vec2& textureCoord, const unsigned int color)
-            : position(position)
-            , texture(textureCoord)
-            , color(color)
-            , opacity {1.0f}
-            , saturation {1.0f}
-            , dimming {1.0f}
-            , convertBGRAToRGBA {false}
-            , font {false}
-            , postProcessing {false}
-            , shaders {0}
-        {
-        }
     };
 
     enum class BlendFactor {
@@ -73,17 +40,57 @@ public:
         ONE_MINUS_DST_ALPHA
     };
 
-    enum class TextureType {
+    // clang-format off
-        RGBA, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
+    enum Shader {
-        BGRA,
+        CORE =            0x00000001,
-        RED
+        BLUR_HORIZONTAL = 0x00000002,
+        BLUR_VERTICAL =   0x00000004,
+        SCANLINES =       0x00000008
+    };
+
+    enum ShaderFlags {
+        BGRA_TO_RGBA =    0x00000001,
+        FONT_TEXTURE =    0x00000002,
+        POST_PROCESSING = 0x00000004
+    };
+    // clang-format on
+
+    struct Vertex {
+        glm::vec2 position;
+        glm::vec2 texture;
+        unsigned int color;
+        float opacity;
+        float saturation;
+        float dimming;
+        unsigned int shaders;
+        unsigned int shaderFlags;
+
+        Vertex()
+            : opacity {1.0f}
+            , saturation {1.0f}
+            , dimming {1.0f}
+            , shaders {0}
+            , shaderFlags {0}
+        {
+        }
+
+        Vertex(const glm::vec2& position, const glm::vec2& textureCoord, const unsigned int color)
+            : position(position)
+            , texture(textureCoord)
+            , color(color)
+            , opacity {1.0f}
+            , saturation {1.0f}
+            , dimming {1.0f}
+            , shaders {0}
+            , shaderFlags {0}
+        {
+        }
     };
 
     struct postProcessingParams {
         float opacity;
         float saturation;
         float dimming;
-        bool convertBGRAToRGBA;
         unsigned int blurPasses;
         unsigned int shaders;
 
@@ -91,7 +98,6 @@ public:
             : opacity {1.0f}
             , saturation {1.0f}
             , dimming {1.0f}
-            , convertBGRAToRGBA {false}
             , blurPasses {1}
             , shaders {0}
         {
@@ -192,13 +198,7 @@ public:
     virtual void setSwapInterval() = 0;
     virtual void swapBuffers() = 0;
 
-    // clang-format off
+private:
-    static constexpr unsigned int SHADER_CORE            {0x00000001};
-    static constexpr unsigned int SHADER_BLUR_HORIZONTAL {0x00000002};
-    static constexpr unsigned int SHADER_BLUR_VERTICAL   {0x00000004};
-    static constexpr unsigned int SHADER_SCANLINES       {0x00000008};
-    // clang-format on
-
     std::stack<Rect> mClipStack;
     SDL_Window* mSDLWindow {nullptr};
     glm::mat4 mProjectionMatrix {};

es-core/src/renderers/RendererOpenGL.cpp

@@ -365,9 +365,9 @@ void RendererOpenGL::drawTriangleStrips(const Vertex* vertices,
     GL_CHECK_ERROR(glBlendFunc(convertBlendFactor(srcBlendFactorFactor),
                                convertBlendFactor(dstBlendFactorFactor)));
 
-    if (vertices->shaders == 0 || vertices->shaders & SHADER_CORE) {
+    if (vertices->shaders == 0 || vertices->shaders & Shader::CORE) {
         if (mCoreShader == nullptr)
-            mCoreShader = getShaderProgram(SHADER_CORE);
+            mCoreShader = getShaderProgram(Shader::CORE);
         if (mCoreShader) {
             if (mLastShader != mCoreShader)
                 mCoreShader->activateShaders();
@@ -379,16 +379,14 @@ void RendererOpenGL::drawTriangleStrips(const Vertex* vertices,
             mCoreShader->setOpacity(vertices->opacity);
             mCoreShader->setSaturation(vertices->saturation);
             mCoreShader->setDimming(vertices->dimming);
-            mCoreShader->setBGRAToRGBA(vertices->convertBGRAToRGBA);
+            mCoreShader->setFlags(vertices->shaderFlags);
-            mCoreShader->setFont(vertices->font);
-            mCoreShader->setPostProcessing(vertices->postProcessing);
             GL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, numVertices));
             mLastShader = mCoreShader;
         }
     }
-    else if (vertices->shaders & SHADER_BLUR_HORIZONTAL) {
+    else if (vertices->shaders & Shader::BLUR_HORIZONTAL) {
         if (mBlurHorizontalShader == nullptr)
-            mBlurHorizontalShader = getShaderProgram(SHADER_BLUR_HORIZONTAL);
+            mBlurHorizontalShader = getShaderProgram(Shader::BLUR_HORIZONTAL);
         if (mBlurHorizontalShader) {
             if (mLastShader != mBlurHorizontalShader)
                 mBlurHorizontalShader->activateShaders();
@@ -403,9 +401,9 @@ void RendererOpenGL::drawTriangleStrips(const Vertex* vertices,
         }
         return;
     }
-    else if (vertices->shaders & SHADER_BLUR_VERTICAL) {
+    else if (vertices->shaders & Shader::BLUR_VERTICAL) {
         if (mBlurVerticalShader == nullptr)
-            mBlurVerticalShader = getShaderProgram(SHADER_BLUR_VERTICAL);
+            mBlurVerticalShader = getShaderProgram(Shader::BLUR_VERTICAL);
         if (mBlurVerticalShader) {
             if (mLastShader != mBlurVerticalShader)
                 mBlurVerticalShader->activateShaders();
@@ -420,9 +418,9 @@ void RendererOpenGL::drawTriangleStrips(const Vertex* vertices,
         }
         return;
     }
-    else if (vertices->shaders & SHADER_SCANLINES) {
+    else if (vertices->shaders & Shader::SCANLINES) {
         if (mScanlinelShader == nullptr)
-            mScanlinelShader = getShaderProgram(SHADER_SCANLINES);
+            mScanlinelShader = getShaderProgram(Shader::SCANLINES);
         float shaderWidth {width * 1.2f};
         // Scale the scanlines relative to screen resolution.
         float screenHeightModifier {getScreenHeightModifier()};
@@ -481,16 +479,16 @@ void RendererOpenGL::shaderPostprocessing(unsigned int shaders,
     vertices->opacity = parameters.opacity;
     vertices->saturation = parameters.saturation;
     vertices->dimming = parameters.dimming;
-    vertices->postProcessing = true;
+    vertices->shaderFlags = ShaderFlags::POST_PROCESSING;
 
-    if (shaders & SHADER_CORE)
+    if (shaders & Shader::CORE)
-        shaderList.push_back(SHADER_CORE);
+        shaderList.push_back(Shader::CORE);
-    if (shaders & SHADER_BLUR_HORIZONTAL)
+    if (shaders & Shader::BLUR_HORIZONTAL)
-        shaderList.push_back(SHADER_BLUR_HORIZONTAL);
+        shaderList.push_back(Shader::BLUR_HORIZONTAL);
-    if (shaders & SHADER_BLUR_VERTICAL)
+    if (shaders & Shader::BLUR_VERTICAL)
-        shaderList.push_back(SHADER_BLUR_VERTICAL);
+        shaderList.push_back(Shader::BLUR_VERTICAL);
-    if (shaders & SHADER_SCANLINES)
+    if (shaders & Shader::SCANLINES)
-        shaderList.push_back(SHADER_SCANLINES);
+        shaderList.push_back(Shader::SCANLINES);
 
     setMatrix(getIdentity());
     bindTexture(mPostProcTexture1);
@@ -511,8 +509,8 @@ void RendererOpenGL::shaderPostprocessing(unsigned int shaders,
         int shaderPasses = 1;
         // For the blur shaders there is an optional variable to set the number of passes
         // to execute, which proportionally affects the blur amount.
-        if (shaderList[i] == Renderer::SHADER_BLUR_HORIZONTAL ||
+        if (shaderList[i] == Renderer::Shader::BLUR_HORIZONTAL ||
-            shaderList[i] == Renderer::SHADER_BLUR_VERTICAL) {
+            shaderList[i] == Renderer::Shader::BLUR_VERTICAL) {
             shaderPasses = parameters.blurPasses;
         }
 

es-core/src/renderers/ShaderOpenGL.cpp

@@ -22,9 +22,7 @@ ShaderOpenGL::ShaderOpenGL()
     , mShaderOpacity {0}
     , mShaderSaturation {0}
     , mShaderDimming {0}
-    , mShaderBGRAToRGBA {0}
+    , mShaderFlags {0}
-    , mShaderFont {0}
-    , mShaderPostProcessing {0}
 {
 }
 
@@ -125,9 +123,7 @@ void ShaderOpenGL::getVariableLocations(GLuint programID)
     mShaderOpacity = glGetUniformLocation(mProgramID, "opacity");
     mShaderSaturation = glGetUniformLocation(mProgramID, "saturation");
     mShaderDimming = glGetUniformLocation(mProgramID, "dimming");
-    mShaderBGRAToRGBA = glGetUniformLocation(mProgramID, "BGRAToRGBA");
+    mShaderFlags = glGetUniformLocation(mProgramID, "shaderFlags");
-    mShaderFont = glGetUniformLocation(mProgramID, "font");
-    mShaderPostProcessing = glGetUniformLocation(mProgramID, "postProcessing");
 }
 
 void ShaderOpenGL::setModelViewProjectionMatrix(glm::mat4 mvpMatrix)
@@ -178,22 +174,10 @@ void ShaderOpenGL::setDimming(GLfloat dimming)
         GL_CHECK_ERROR(glUniform1f(mShaderDimming, dimming));
 }
 
-void ShaderOpenGL::setBGRAToRGBA(GLboolean BGRAToRGBA)
+void ShaderOpenGL::setFlags(GLuint flags)
 {
-    if (mShaderBGRAToRGBA != -1)
+    if (mShaderFlags != -1)
-        GL_CHECK_ERROR(glUniform1i(mShaderBGRAToRGBA, BGRAToRGBA ? 1 : 0));
+        GL_CHECK_ERROR(glUniform1ui(mShaderFlags, flags));
-}
-
-void ShaderOpenGL::setFont(GLboolean font)
-{
-    if (mShaderFont != -1)
-        GL_CHECK_ERROR(glUniform1i(mShaderFont, font ? 1 : 0));
-}
-
-void ShaderOpenGL::setPostProcessing(GLboolean postProcessing)
-{
-    if (mShaderPostProcessing != -1)
-        GL_CHECK_ERROR(glUniform1i(mShaderPostProcessing, postProcessing ? 1 : 0));
 }
 
 void ShaderOpenGL::activateShaders()

es-core/src/renderers/ShaderOpenGL.h

@@ -71,9 +71,7 @@ public:
     void setOpacity(GLfloat opacity);
     void setSaturation(GLfloat saturation);
     void setDimming(GLfloat dimming);
-    void setBGRAToRGBA(GLboolean BGRAToRGBA);
+    void setFlags(GLuint flags);
-    void setFont(GLboolean font);
-    void setPostProcessing(GLboolean postProcessing);
     // Sets the shader program to use the loaded shaders.
     void activateShaders();
     // Sets the shader program to 0 which reverts to the fixed function pipeline.
@@ -97,9 +95,7 @@ private:
     GLint mShaderOpacity;
     GLint mShaderSaturation;
     GLint mShaderDimming;
-    GLint mShaderBGRAToRGBA;
+    GLint mShaderFlags;
-    GLint mShaderFont;
-    GLint mShaderPostProcessing;
 };
 
 #endif // ES_CORE_RENDERER_SHADER_OPENGL_H

es-core/src/resources/Font.cpp

@@ -397,7 +397,7 @@ void Font::renderTextCache(TextCache* cache)
         assert(*it->textureIdPtr != 0);
 
         auto vertexList = *it;
-        it->verts[0].font = true;
+        it->verts[0].shaderFlags = Renderer::ShaderFlags::FONT_TEXTURE;
 
         mRenderer->bindTexture(*it->textureIdPtr);
         mRenderer->drawTriangleStrips(&it->verts[0],

resources/shaders/glsl/core.glsl

@@ -63,24 +63,27 @@ COMPAT_VARYING COMPAT_PRECISION vec2 texCoord;
 uniform COMPAT_PRECISION float opacity;
 uniform COMPAT_PRECISION float saturation;
 uniform COMPAT_PRECISION float dimming;
-uniform int BGRAToRGBA;
+uniform unsigned int shaderFlags;
-uniform int font;
+uniform sampler2D textureSampler;
-uniform int postProcessing;
+
-uniform sampler2D myTexture;
+// shaderFlags:
+// 0x00000001 - BGRA to RGBA conversion
+// 0x00000002 - Font texture
+// 0x00000004 - Post processing
 
 void main()
 {
-    COMPAT_PRECISION vec4 sampledColor = COMPAT_TEXTURE(myTexture, texCoord);
+    COMPAT_PRECISION vec4 sampledColor = COMPAT_TEXTURE(textureSampler, texCoord);
 
     // For fonts the alpha information is stored in the red channel.
-    if (font == 1)
+    if (0u != (shaderFlags & 2u))
         sampledColor = vec4(1.0f, 1.0f, 1.0f, sampledColor.r);
 
     sampledColor *= color;
 
     // When post-processing we drop the alpha channel to avoid strange issues
     // with some graphics drivers.
-    if (postProcessing == 1)
+    if (0u != (shaderFlags & 4u))
         sampledColor.a = 1.0f;
 
     // Opacity.
@@ -101,7 +104,7 @@ void main()
     }
 
     // BGRA to RGBA conversion.
-    if (BGRAToRGBA == 1)
+    if (0u != (shaderFlags & 1u))
         sampledColor = vec4(sampledColor.bgr, sampledColor.a);
 
     FragColor = sampledColor;