improve glsl pre-roll triangles

src/shaders/endoftrackshader.cpp

@@ -4,7 +4,7 @@ using namespace mixxx;
 
 void EndOfTrackShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
-attribute highp vec4 position;
+attribute highp vec4 position; // use vec4 here (will be padded) to assign directly to gl_Position
 attribute highp float gradient;
 varying highp float vgradient;
 void main()

src/shaders/patternshader.cpp

@@ -5,7 +5,7 @@ using namespace mixxx;
 void PatternShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
 uniform highp mat4 matrix;
-attribute highp vec4 position;
+attribute highp vec4 position; // use vec4 here (will be padded) for matrix multiplication
 attribute highp vec2 texcoor;
 varying highp vec2 vTexcoor;
 void main()

src/shaders/rgbashader.cpp

@@ -5,7 +5,7 @@ using namespace mixxx;
 void RGBAShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
 uniform mat4 matrix;
-attribute highp vec4 position;
+attribute highp vec4 position; // use vec4 here (will be padded) for matrix multiplication
 attribute highp vec4 color;
 varying highp vec4 vColor;
 void main()

src/shaders/rgbshader.cpp

@@ -5,7 +5,7 @@ using namespace mixxx;
 void RGBShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
 uniform mat4 matrix;
-attribute highp vec4 position;
+attribute highp vec4 position; // use vec4 here (will be padded) for matrix multiplication
 attribute highp vec3 color;
 varying highp vec3 vColor;
 void main()

src/shaders/textureshader.cpp

@@ -5,7 +5,7 @@ using namespace mixxx;
 void TextureShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
 uniform highp mat4 matrix;
-attribute highp vec4 position;
+attribute highp vec4 position; // use vec4 here (will be padded) for matrix multiplication
 attribute highp vec2 texcoord;
 varying highp vec2 vTexcoord;
 void main()

src/shaders/unicolorshader.cpp

@@ -5,7 +5,7 @@ using namespace mixxx;
 void UnicolorShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
 uniform mat4 matrix;
-attribute highp vec4 position;
+attribute highp vec4 position; // use vec4 here (will be padded) for matrix multiplication
 void main()
 {
     gl_Position = matrix * position;

src/shaders/vinylqualityshader.cpp

@@ -5,7 +5,7 @@ using namespace mixxx;
 void VinylQualityShader::init() {
     QString vertexShaderCode = QStringLiteral(R"--(
 uniform mat4 matrix;
-attribute highp vec4 position;
+attribute highp vec4 position; // use vec4 here (will be padded) for matrix multiplication
 attribute highp vec2 texcoord;
 varying highp vec2 vTexcoord;
 void main()

src/util/texture.cpp

@@ -1,31 +1,31 @@
 #include "util/texture.h"
 
-QOpenGLTexture* createTexture(const QImage& image) {
+std::unique_ptr<QOpenGLTexture> createTexture(const QImage& image) {
     if (image.isNull()) {
-        return nullptr;
+        return std::unique_ptr<QOpenGLTexture>{};
     }
-    QOpenGLTexture* pTexture = new QOpenGLTexture(image);
+    std::unique_ptr<QOpenGLTexture> pTexture{new QOpenGLTexture(image)};
     pTexture->setMinificationFilter(QOpenGLTexture::Linear);
     pTexture->setMagnificationFilter(QOpenGLTexture::Linear);
     pTexture->setWrapMode(QOpenGLTexture::ClampToEdge);
 
     return pTexture;
 }
 
-QOpenGLTexture* createTexture(const QPixmap& pixmap) {
+std::unique_ptr<QOpenGLTexture> createTexture(const QPixmap& pixmap) {
     return createTexture(pixmap.toImage());
 }
 
-QOpenGLTexture* createTexture(const QSharedPointer<Paintable>& pPaintable) {
+std::unique_ptr<QOpenGLTexture> createTexture(const QSharedPointer<Paintable>& pPaintable) {
     if (pPaintable.isNull()) {
-        return nullptr;
+        return std::unique_ptr<QOpenGLTexture>{};
     }
     return createTexture(pPaintable->toImage());
 }
 
-QOpenGLTexture* createTexture(const std::shared_ptr<QImage>& pImage) {
+std::unique_ptr<QOpenGLTexture> createTexture(const std::shared_ptr<QImage>& pImage) {
     if (!pImage) {
-        return nullptr;
+        return std::unique_ptr<QOpenGLTexture>{};
     }
     return createTexture(*pImage);
 }

src/util/texture.h

@@ -6,7 +6,7 @@
 
 #include "widget/paintable.h"
 
-QOpenGLTexture* createTexture(const QImage& image);
-QOpenGLTexture* createTexture(const QPixmap& pixmap);
-QOpenGLTexture* createTexture(const QSharedPointer<Paintable>& pPaintable);
-QOpenGLTexture* createTexture(const std::shared_ptr<QImage>& pImage);
+std::unique_ptr<QOpenGLTexture> createTexture(const QImage& image);
+std::unique_ptr<QOpenGLTexture> createTexture(const QPixmap& pixmap);
+std::unique_ptr<QOpenGLTexture> createTexture(const QSharedPointer<Paintable>& pPaintable);
+std::unique_ptr<QOpenGLTexture> createTexture(const std::shared_ptr<QImage>& pImage);

src/waveform/renderers/allshader/waveformrendererpreroll.cpp

@@ -13,7 +13,7 @@
 #include "widget/wwidget.h"
 
 namespace {
-QOpenGLTexture* generateTexture(float markerLength,
+std::unique_ptr<QOpenGLTexture> generateTexture(float markerLength,
         float markerBreadth,
         float devicePixelRatio,
         QColor color) {
@@ -121,10 +121,10 @@ void WaveformRendererPreroll::paintGL() {
         // has changed size last time.
         m_markerLength = markerLength;
         m_markerBreadth = markerBreadth;
-        m_pTexture.reset(generateTexture(m_markerLength,
+        m_pTexture = generateTexture(m_markerLength,
                 m_markerBreadth,
                 m_waveformRenderer->getDevicePixelRatio(),
-                m_color));
+                m_color);
     }
 
     if (!m_pTexture) {

src/waveform/renderers/allshader/waveformrendermark.cpp

@@ -298,7 +298,7 @@ void allshader::WaveformRenderMark::generatePlayPosMarkTexture(float breadth) {
     }
     painter.end();
 
-    m_pPlayPosMarkTexture.reset(createTexture(image));
+    m_pPlayPosMarkTexture = createTexture(image);
 }
 
 void allshader::WaveformRenderMark::drawTriangle(QPainter* painter,
@@ -405,7 +405,7 @@ void allshader::WaveformRenderMark::generateMarkImage(WaveformMarkPointer pMark,
             //  Also, without this some Qt-internal issue results in an offset
             //  image when calculating the center line of pixmaps in draw().
             pMark->m_image.setDevicePixelRatio(devicePixelRatio);
-            pMark->m_pTexture.reset(createTexture(pMark->m_image));
+            pMark->m_pTexture = createTexture(pMark->m_image);
             return;
         }
     }
@@ -547,5 +547,5 @@ void allshader::WaveformRenderMark::generateMarkImage(WaveformMarkPointer pMark,
         painter.drawText(labelRect, Qt::AlignCenter, label);
     }
 
-    pMark->m_pTexture.reset(createTexture(pMark->m_image));
+    pMark->m_pTexture = createTexture(pMark->m_image);
 }

src/widget/wspinnyglsl.cpp

@@ -31,7 +31,7 @@ void WSpinnyGLSL::cleanupGL() {
 void WSpinnyGLSL::coverChanged() {
     if (isContextValid()) {
         makeCurrentIfNeeded();
-        m_pLoadedCoverTextureScaled.reset(createTexture(m_loadedCoverScaled));
+        m_pLoadedCoverTextureScaled = createTexture(m_loadedCoverScaled);
         doneCurrent();
     }
     // otherwise this will happen in initializeGL
@@ -53,11 +53,11 @@ void WSpinnyGLSL::resizeGL(int w, int h) {
 }
 
 void WSpinnyGLSL::updateTextures() {
-    m_pBgTexture.reset(createTexture(m_pBgImage));
-    m_pMaskTexture.reset(createTexture(m_pMaskImage));
-    m_pFgTextureScaled.reset(createTexture(m_fgImageScaled));
-    m_pGhostTextureScaled.reset(createTexture(m_ghostImageScaled));
-    m_pLoadedCoverTextureScaled.reset(createTexture(m_loadedCoverScaled));
+    m_pBgTexture = createTexture(m_pBgImage);
+    m_pMaskTexture = createTexture(m_pMaskImage);
+    m_pFgTextureScaled = createTexture(m_fgImageScaled);
+    m_pGhostTextureScaled = createTexture(m_ghostImageScaled);
+    m_pLoadedCoverTextureScaled = createTexture(m_loadedCoverScaled);
 }
 
 void WSpinnyGLSL::setupVinylSignalQuality() {
@@ -101,7 +101,7 @@ void WSpinnyGLSL::paintGL() {
     int positionLocation = m_textureShader.positionLocation();
     int texcoordLocation = m_textureShader.texcoordLocation();
 
-    QMatrix matrix;
+    QMatrix4x4 matrix;
     m_textureShader.setUniformValue(matrixLocation, matrix);
 
     m_textureShader.enableAttributeArray(positionLocation);
@@ -137,16 +137,16 @@ void WSpinnyGLSL::paintGL() {
     bool paintGhost = m_bGhostPlayback && m_pGhostTextureScaled;
 
     if (paintGhost) {
-        QMatrix rotate;
-        rotate.rotate(-m_fGhostAngle);
+        QMatrix4x4 rotate;
+        rotate.rotate(-m_fGhostAngle, 0, 0);
         m_textureShader.setUniformValue(matrixLocation, rotate);
 
         drawTexture(m_pGhostTextureScaled.get());
     }
 
     if (m_pFgTextureScaled) {
-        QMatrix rotate;
-        rotate.rotate(-m_fAngle);
+        QMatrix4x4 rotate;
+        rotate.rotate(-m_fAngle, 0, 0);
         m_textureShader.setUniformValue(matrixLocation, rotate);
 
         drawTexture(m_pFgTextureScaled.get());
@@ -224,7 +224,7 @@ void WSpinnyGLSL::drawVinylQuality() {
     int positionLocation = m_vinylQualityShader.positionLocation();
     int texcoordLocation = m_vinylQualityShader.texcoordLocation();
 
-    QMatrix matrix;
+    QMatrix4x4 matrix;
     m_vinylQualityShader.setUniformValue(matrixLocation, matrix);
     m_vinylQualityShader.setUniformValue(colorLocation, m_vinylQualityColor);
 

src/widget/wvumeterglsl.cpp

@@ -24,8 +24,8 @@ void WVuMeterGLSL::draw() {
 void WVuMeterGLSL::initializeGL() {
     initializeOpenGLFunctions();
 
-    m_pTextureBack.reset(createTexture(m_pPixmapBack));
-    m_pTextureVu.reset(createTexture(m_pPixmapVu));
+    m_pTextureBack = createTexture(m_pPixmapBack);
+    m_pTextureVu = createTexture(m_pPixmapVu);
     m_textureShader.init();
 }