qskinny/src/nodes/QskBasicLinesNode.cpp

/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/

#include "QskBasicLinesNode.h"

#include <qsgmaterial.h>
#include <qsggeometry.h>
#include <QTransform>

QSK_QT_PRIVATE_BEGIN
#include <private/qsgnode_p.h>
QSK_QT_PRIVATE_END

static inline QVector4D qskColorVector( const QColor& c, qreal opacity)
{
    const auto a = c.alphaF() * opacity;
    return QVector4D( c.redF() * a, c.greenF() * a, c.blueF() * a, a );
}

static inline QVector2D qskOrigin(
    const QRect& rect, Qt::Orientations orientations )
{
    return QVector2D(
        ( orientations & Qt::Horizontal ) ? 0.5 * rect.width() : 0.0,
        ( orientations & Qt::Vertical ) ? 0.5 * rect.height() : 0.0
    );
}

#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
    #include <QSGMaterialRhiShader>
    using RhiShader = QSGMaterialRhiShader;
#else
    using RhiShader = QSGMaterialShader;
#endif

namespace
{
    class Material final : public QSGMaterial
    {
      public:
        Material();

#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
        QSGMaterialShader* createShader() const override;
#else
        QSGMaterialShader* createShader( QSGRendererInterface::RenderMode ) const override;
#endif

        QSGMaterialType* type() const override;

        int compare( const QSGMaterial* other ) const override;

        QColor m_color = QColor( 255, 255, 255 );
        Qt::Orientations m_pixelAlignment;
    };

    class ShaderRhi final : public RhiShader
    {
      public:

        ShaderRhi()
        {
            const QString root( ":/qskinny/shaders/" );

            setShaderFileName( VertexStage, root + "crisplines.vert.qsb" );
            setShaderFileName( FragmentStage, root + "crisplines.frag.qsb" );
        }

        bool updateUniformData( RenderState& state,
            QSGMaterial* newMaterial, QSGMaterial* oldMaterial ) override
        {
            auto matOld = static_cast< Material* >( oldMaterial );
            auto matNew = static_cast< Material* >( newMaterial );

            Q_ASSERT( state.uniformData()->size() >= 88 );

            auto data = state.uniformData()->data();
            bool changed = false;

            const auto matrix = state.combinedMatrix();

            if ( state.isMatrixDirty() )
            {
                memcpy( data + 0, matrix.constData(), 64 );
                changed = true;
            }

            if ( ( matOld == nullptr ) || ( matNew->m_color != matOld->m_color )
                || state.isOpacityDirty() )
            {
                const auto v4 = qskColorVector( matNew->m_color, state.opacity() );
                memcpy( data + 64, &v4, 16 );
                changed = true;
            }

            if ( state.isMatrixDirty() || ( matOld == nullptr )
                || ( matNew->m_pixelAlignment != matOld->m_pixelAlignment ) )
            {
                /*
                    The shaders work with coordinates in the range[-1,1]. When knowing
                    the device coordinates corresponding to [0.0] we can scale a vertex
                    into device coordinates.

                    coordinates <= 0.0 indicate, that no rounding should be done.
                 */
                const auto origin = qskOrigin(
                    state.viewportRect(), matNew->m_pixelAlignment );

                memcpy( data + 80, &origin, 8 );
                changed = true;
            }

            return changed;
        }
    };
}

#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )

namespace
{
    // the old type of shader - spcific for OpenGL

    class ShaderGL final : public QSGMaterialShader
    {
      public:
        ShaderGL()
        {
            const QString root( ":/qskinny/shaders/" );

            setShaderSourceFile( QOpenGLShader::Vertex,
                ":/qskinny/shaders/crisplines.vert" );

            setShaderSourceFile( QOpenGLShader::Fragment,
                ":/qt-project.org/scenegraph/shaders/flatcolor.frag" );
        }

        char const* const* attributeNames() const override
        {
            static char const* const names[] = { "in_vertex", nullptr };
            return names;
        }

        void initialize() override
        {
            QSGMaterialShader::initialize();

            auto p = program();

            m_matrixId = p->uniformLocation( "matrix" );
            m_colorId = p->uniformLocation( "color" );
            m_originId = p->uniformLocation( "origin" );
        }

        void updateState( const QSGMaterialShader::RenderState& state,
            QSGMaterial* newMaterial, QSGMaterial* oldMaterial) override
        {
            auto p = program();

            const auto matrix = state.combinedMatrix();

            if ( state.isMatrixDirty() )
                p->setUniformValue( m_matrixId, matrix );

            bool updateMaterial = ( oldMaterial == nullptr )
                || newMaterial->compare( oldMaterial ) != 0;

            updateMaterial |= state.isCachedMaterialDataDirty();

            if ( updateMaterial )
            {
                auto material = static_cast< const Material* >( newMaterial );

                p->setUniformValue( m_colorId,
                    qskColorVector( material->m_color, state.opacity() ) );

                const auto origin = qskOrigin(
                    state.viewportRect(), material->m_pixelAlignment );;
                p->setUniformValue( m_originId, origin );
            }
        }

      private:
        int m_matrixId = -1;
        int m_colorId = -1;
        int m_originId = -1;
    };
}

#endif

Material::Material()
{
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
    setFlag( QSGMaterial::SupportsRhiShader, true );
#endif
}

#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )

QSGMaterialShader* Material::createShader() const
{
    if ( !( flags() & QSGMaterial::RhiShaderWanted ) )
        return new ShaderGL();

    return new ShaderRhi();
}

#else

QSGMaterialShader* Material::createShader( QSGRendererInterface::RenderMode ) const
{
    return new ShaderRhi();
}

#endif

QSGMaterialType* Material::type() const
{
    static QSGMaterialType staticType;
    return &staticType;
}

int Material::compare( const QSGMaterial* other ) const
{
    auto material = static_cast< const Material* >( other );

    if ( ( material->m_color == m_color )
        && ( material->m_pixelAlignment == m_pixelAlignment ) )
    {
        return 0;
    }

    return QSGMaterial::compare( other );
}

class QskBasicLinesNodePrivate final : public QSGGeometryNodePrivate
{
  public:
    QskBasicLinesNodePrivate()
        : geometry( QSGGeometry::defaultAttributes_Point2D(), 0 )
    {
        geometry.setDrawingMode( QSGGeometry::DrawLines );
    }

    QSGGeometry geometry;
    Material material;
};

QskBasicLinesNode::QskBasicLinesNode()
    : QSGGeometryNode( *new QskBasicLinesNodePrivate )
{
    Q_D( QskBasicLinesNode );

    setGeometry( &d->geometry );
    setMaterial( &d->material );
}

QskBasicLinesNode::~QskBasicLinesNode()
{
}

void QskBasicLinesNode::setPixelAlignment( Qt::Orientations orientations )
{
    Q_D( QskBasicLinesNode );

    if ( orientations != d->material.m_pixelAlignment )
    {
        d->material.m_pixelAlignment = orientations;
        markDirty( QSGNode::DirtyMaterial );
    }
}

Qt::Orientations QskBasicLinesNode::pixelAlignment() const
{
    return d_func()->material.m_pixelAlignment;
}

void QskBasicLinesNode::setColor( const QColor& color )
{
    Q_D( QskBasicLinesNode );

    const auto c = color.toRgb();
    if ( c != d->material.m_color )
    {
        d->material.m_color = c;
        markDirty( QSGNode::DirtyMaterial );
    }
}

QColor QskBasicLinesNode::color() const
{
    return d_func()->material.m_color;
}

void QskBasicLinesNode::setLineWidth( float lineWidth )
{
    Q_D( QskBasicLinesNode );

    lineWidth = std::max( lineWidth, 0.0f );
    if( lineWidth != d->geometry.lineWidth() )
        d->geometry.setLineWidth( lineWidth );
}

float QskBasicLinesNode::lineWidth() const
{
    return d_func()->geometry.lineWidth();
}