improve glsl pre-roll triangles

CMakeLists.txt

@@ -1428,6 +1428,7 @@ else()
   if(QOPENGL)
     target_sources(mixxx-lib PRIVATE
       src/shaders/endoftrackshader.cpp
+      src/shaders/patternshader.cpp
       src/shaders/rgbashader.cpp
       src/shaders/rgbshader.cpp
       src/shaders/shader.cpp

src/shaders/endoftrackshader.cpp

@@ -21,9 +21,13 @@ void main()
 {
     highp float minAlpha = 0.5 * color.w;
     highp float maxAlpha = 0.83 * color.w;
-    gl_FragColor = vec4(color.xyz, mix(minAlpha, maxAlpha, max(0.,vgradient)));
+    gl_FragColor = vec4(color.xyz, mix(minAlpha, maxAlpha, max(0.0, vgradient)));
 }
 )--");
 
     load(vertexShaderCode, fragmentShaderCode);
+
+    m_positionLocation = attributeLocation("position");
+    m_gradientLocation = attributeLocation("gradient");
+    m_colorLocation = uniformLocation("color");
 }

src/shaders/endoftrackshader.h

@@ -12,6 +12,20 @@ class mixxx::EndOfTrackShader : public mixxx::Shader {
     ~EndOfTrackShader() = default;
     void init();
 
+    int positionLocation() const {
+        return m_positionLocation;
+    }
+    int gradientLocation() const {
+        return m_gradientLocation;
+    }
+    int colorLocation() const {
+        return m_colorLocation;
+    }
+
   private:
+    int m_positionLocation;
+    int m_gradientLocation;
+    int m_colorLocation;
+
     DISALLOW_COPY_AND_ASSIGN(EndOfTrackShader)
 };

src/shaders/patternshader.cpp

@@ -0,0 +1,35 @@
+#include "shaders/patternshader.h"
+
+using namespace mixxx;
+
+void PatternShader::init() {
+    QString vertexShaderCode = QStringLiteral(R"--(
+uniform highp mat4 matrix;
+attribute highp vec4 position;
+attribute highp vec2 texcoor;
+varying highp vec2 vTexcoor;
+void main()
+{
+    vTexcoor = texcoor;
+    gl_Position = matrix * position;
+}
+)--");
+
+    QString fragmentShaderCode = QStringLiteral(R"--(
+uniform sampler2D texture;
+uniform vec2 repetitions;
+varying highp vec2 vTexcoor;
+void main()
+{
+    gl_FragColor = texture2D(texture, fract(vTexcoor * repetitions));
+}
+)--");
+
+    load(vertexShaderCode, fragmentShaderCode);
+
+    m_matrixLocation = uniformLocation("matrix");
+    m_positionLocation = attributeLocation("position");
+    m_texcoordLocation = attributeLocation("texcoor");
+    m_textureLocation = uniformLocation("texture");
+    m_repetitionsLocation = uniformLocation("repetitions");
+}

src/shaders/patternshader.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "shaders/shader.h"
+
+namespace mixxx {
+class PatternShader;
+}
+
+class mixxx::PatternShader final : public mixxx::Shader {
+  public:
+    PatternShader() = default;
+    ~PatternShader() = default;
+    void init();
+
+    int matrixLocation() const {
+        return m_matrixLocation;
+    }
+    int positionLocation() const {
+        return m_positionLocation;
+    }
+    int texcoordLocation() const {
+        return m_texcoordLocation;
+    }
+    int textureLocation() const {
+        return m_textureLocation;
+    }
+    int repetitionsLocation() const {
+        return m_repetitionsLocation;
+    }
+
+  private:
+    int m_matrixLocation;
+    int m_positionLocation;
+    int m_texcoordLocation;
+    int m_textureLocation;
+    int m_repetitionsLocation;
+
+    DISALLOW_COPY_AND_ASSIGN(PatternShader)
+};

src/shaders/rgbashader.cpp

@@ -7,21 +7,25 @@ void RGBAShader::init() {
 uniform mat4 matrix;
 attribute highp vec4 position;
 attribute highp vec4 color;
-varying highp vec4 vcolor;
+varying highp vec4 vColor;
 void main()
 {
-    vcolor = color;
+    vColor = color;
     gl_Position = matrix * position;
 }
 )--");
 
     QString fragmentShaderCode = QStringLiteral(R"--(
-varying highp vec4 vcolor;
+varying highp vec4 vColor;
 void main()
 {
-    gl_FragColor = vcolor;
+    gl_FragColor = vColor;
 }
 )--");
 
     load(vertexShaderCode, fragmentShaderCode);
+
+    m_matrixLocation = uniformLocation("matrix");
+    m_positionLocation = attributeLocation("position");
+    m_colorLocation = attributeLocation("color");
 }

src/shaders/rgbashader.h

@@ -12,6 +12,20 @@ class mixxx::RGBAShader final : public mixxx::Shader {
     ~RGBAShader() = default;
     void init();
 
+    int matrixLocation() const {
+        return m_matrixLocation;
+    }
+    int positionLocation() const {
+        return m_positionLocation;
+    }
+    int colorLocation() const {
+        return m_colorLocation;
+    }
+
   private:
+    int m_matrixLocation;
+    int m_positionLocation;
+    int m_colorLocation;
+
     DISALLOW_COPY_AND_ASSIGN(RGBAShader)
 };

src/shaders/rgbshader.cpp

@@ -7,21 +7,25 @@ void RGBShader::init() {
 uniform mat4 matrix;
 attribute highp vec4 position;
 attribute highp vec3 color;
-varying highp vec3 vcolor;
+varying highp vec3 vColor;
 void main()
 {
-    vcolor = color;
+    vColor = color;
     gl_Position = matrix * position;
 }
 )--");
 
     QString fragmentShaderCode = QStringLiteral(R"--(
-varying highp vec3 vcolor;
+varying highp vec3 vColor;
 void main()
 {
-    gl_FragColor = vec4(vcolor,1.0);
+    gl_FragColor = vec4(vColor, 1.0);
 }
 )--");
 
     load(vertexShaderCode, fragmentShaderCode);
+
+    m_matrixLocation = uniformLocation("matrix");
+    m_positionLocation = attributeLocation("position");
+    m_colorLocation = attributeLocation("color");
 }

src/shaders/rgbshader.h

@@ -12,6 +12,20 @@ class mixxx::RGBShader final : public mixxx::Shader {
     ~RGBShader() = default;
     void init();
 
+    int matrixLocation() const {
+        return m_matrixLocation;
+    }
+    int positionLocation() const {
+        return m_positionLocation;
+    }
+    int colorLocation() const {
+        return m_colorLocation;
+    }
+
   private:
+    int m_matrixLocation;
+    int m_positionLocation;
+    int m_colorLocation;
+
     DISALLOW_COPY_AND_ASSIGN(RGBShader)
 };

src/shaders/textureshader.cpp

@@ -4,30 +4,30 @@ using namespace mixxx;
 
 void TextureShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
-uniform mat4 matrix;
+uniform highp mat4 matrix;
 attribute highp vec4 position;
-attribute highp vec3 texcoor;
-varying highp vec3 vTexcoor;
+attribute highp vec2 texcoord;
+varying highp vec2 vTexcoord;
 void main()
 {
-    vTexcoor = texcoor;
+    vTexcoord = texcoord;
     gl_Position = matrix * position;
 }
 )--");
 
     QString fragmentShaderCode = QStringLiteral(R"--(
-uniform sampler2D sampler;
-varying highp vec3 vTexcoor;
+uniform sampler2D texture;
+varying highp vec2 vTexcoord;
 void main()
 {
-    gl_FragColor = texture2D(sampler, vTexcoor.xy);
+    gl_FragColor = texture2D(texture, vTexcoord);
 }
 )--");
 
     load(vertexShaderCode, fragmentShaderCode);
 
     m_matrixLocation = uniformLocation("matrix");
-    m_samplerLocation = uniformLocation("sampler");
     m_positionLocation = attributeLocation("position");
-    m_texcoordLocation = attributeLocation("texcoor");
+    m_texcoordLocation = attributeLocation("texcoord");
+    m_textureLocation = uniformLocation("texture");
 }

src/shaders/textureshader.h

@@ -15,21 +15,21 @@ class mixxx::TextureShader final : public mixxx::Shader {
     int matrixLocation() const {
         return m_matrixLocation;
     }
-    int samplerLocation() const {
-        return m_samplerLocation;
-    }
     int positionLocation() const {
         return m_positionLocation;
     }
     int texcoordLocation() const {
         return m_texcoordLocation;
     }
+    int textureLocation() const {
+        return m_textureLocation;
+    }
 
   private:
     int m_matrixLocation;
-    int m_samplerLocation;
     int m_positionLocation;
     int m_texcoordLocation;
+    int m_textureLocation;
 
     DISALLOW_COPY_AND_ASSIGN(TextureShader)
 };

src/shaders/unicolorshader.cpp

@@ -21,4 +21,8 @@ void main()
 )--");
 
     load(vertexShaderCode, fragmentShaderCode);
+
+    m_matrixLocation = uniformLocation("matrix");
+    m_positionLocation = attributeLocation("position");
+    m_colorLocation = uniformLocation("color");
 }

src/shaders/unicolorshader.h

@@ -12,6 +12,20 @@ class mixxx::UnicolorShader final : public mixxx::Shader {
     ~UnicolorShader() = default;
     void init();
 
+    int matrixLocation() const {
+        return m_matrixLocation;
+    }
+    int positionLocation() const {
+        return m_positionLocation;
+    }
+    int colorLocation() const {
+        return m_colorLocation;
+    }
+
   private:
+    int m_matrixLocation;
+    int m_positionLocation;
+    int m_colorLocation;
+
     DISALLOW_COPY_AND_ASSIGN(UnicolorShader)
 };

src/shaders/vinylqualityshader.cpp

@@ -6,30 +6,30 @@ void VinylQualityShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
 uniform mat4 matrix;
 attribute highp vec4 position;
-attribute highp vec3 texcoor;
-varying highp vec3 vTexcoor;
+attribute highp vec2 texcoord;
+varying highp vec2 vTexcoord;
 void main()
 {
-    vTexcoor = texcoor;
+    vTexcoord = texcoord;
     gl_Position = matrix * position;
 }
 )--");
 
     QString fragmentShaderCode = QStringLiteral(R"--(
-uniform sampler2D sampler;
-uniform highp vec4 color;
-varying highp vec3 vTexcoor;
+uniform sampler2D texture;
+uniform highp vec3 color;
+varying highp vec2 vTexcoord;
 void main()
 {
-    gl_FragColor = vec4(color.xyz, texture2D(sampler, vTexcoor.xy) * 0.75);
+    gl_FragColor = vec4(color, texture2D(texture, vTexcoord) * 0.75);
 }
 )--");
 
     load(vertexShaderCode, fragmentShaderCode);
 
     m_matrixLocation = uniformLocation("matrix");
-    m_samplerLocation = uniformLocation("sampler");
-    m_colorLocation = uniformLocation("color");
     m_positionLocation = attributeLocation("position");
-    m_texcoordLocation = attributeLocation("texcoor");
+    m_texcoordLocation = attributeLocation("texcoord");
+    m_textureLocation = uniformLocation("texture");
+    m_colorLocation = uniformLocation("color");
 }

src/shaders/vinylqualityshader.h

@@ -15,25 +15,26 @@ class mixxx::VinylQualityShader final : public mixxx::Shader {
     int matrixLocation() const {
         return m_matrixLocation;
     }
-    int samplerLocation() const {
-        return m_samplerLocation;
-    }
-    int colorLocation() const {
-        return m_colorLocation;
-    }
     int positionLocation() const {
         return m_positionLocation;
     }
     int texcoordLocation() const {
         return m_texcoordLocation;
     }
 
+    int textureLocation() const {
+        return m_textureLocation;
+    }
+    int colorLocation() const {
+        return m_colorLocation;
+    }
+
   private:
     int m_matrixLocation;
-    int m_samplerLocation;
-    int m_colorLocation;
     int m_positionLocation;
     int m_texcoordLocation;
+    int m_textureLocation;
+    int m_colorLocation;
 
     DISALLOW_COPY_AND_ASSIGN(VinylQualityShader)
 };