riveqtquickitem.h

// SPDX-FileCopyrightText: 2023 Jeremias Bosch <jeremias.bosch@basyskom.com>
// SPDX-FileCopyrightText: 2023 basysKom GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <QElapsedTimer>
#include <QQuickItem>
#include <QQuickPaintedItem>
#include <QSGRenderNode>
#include <QSGTextureProvider>
#include <QImage>
#include <QPainter>
#include <QTimer>
#include <QtCore/QtGlobal>
 
#include <rive/artboard.hpp>
#include <rive/listener_type.hpp>
 
#include "rivestatemachineinput.h"
#include "datatypes.h"
#include "renderer/riveqtfactory.h"
 
#if defined(RIVEQTQUICKITEM_LIBRARY)
#    define RIVEQTQUICKITEM_EXPORT Q_DECL_EXPORT
#else
#    define RIVEQTQUICKITEM_EXPORT Q_DECL_IMPORT
#endif
 
class RiveQSGRenderNode;
class RiveQSGRHIRenderNode;
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
class RiveQSGSoftwareRenderNode;
#endif
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
class RiveQtQuickItem : public QQuickPaintedItem
#else
class RiveQtQuickItem : public QQuickItem
#endif
{
    Q_OBJECT
 
    Q_PROPERTY(QString fileSource READ fileSource WRITE setFileSource NOTIFY fileSourceChanged)
 
    
    Q_PROPERTY(LoadingStatus loadingStatus READ loadingStatus NOTIFY loadingStatusChanged)
 
    
    Q_PROPERTY(QVector<ArtBoardInfo> artboards READ artboards NOTIFY artboardsChanged)
 
    
    Q_PROPERTY(QVector<AnimationInfo> animations READ animations NOTIFY animationsChanged)
 
    
    Q_PROPERTY(QVector<StateMachineInfo> stateMachines READ stateMachines NOTIFY stateMachinesChanged)
 
    
    Q_PROPERTY(int currentArtboardIndex READ currentArtboardIndex WRITE setCurrentArtboardIndex NOTIFY currentArtboardIndexChanged)
 
    
    Q_PROPERTY(int currentAnimationIndex READ currentAnimationIndex WRITE triggerAnimation NOTIFY currentAnimationIndexChanged)
 
    
    Q_PROPERTY(
        int currentStateMachineIndex READ currentStateMachineIndex WRITE setCurrentStateMachineIndex NOTIFY currentStateMachineIndexChanged)
 
    
    Q_PROPERTY(bool interactive READ interactive WRITE setInteractive NOTIFY interactiveChanged)
 
    
    Q_PROPERTY(RiveStateMachineInput *stateMachineInterface READ stateMachineInterface WRITE setStateMachineInterface NOTIFY
                   stateMachineInterfaceChanged)
 
    
    Q_PROPERTY(RiveRenderSettings::RenderQuality renderQuality READ renderQuality WRITE setRenderQuality NOTIFY renderQualityChanged)
 
    
    Q_PROPERTY(RiveRenderSettings::PostprocessingMode postprocessingMode READ postprocessingMode WRITE setPostprocessingMode NOTIFY
                   postprocessingModeChanged)
 
    
    Q_PROPERTY(RiveRenderSettings::FillMode fillMode READ fillMode WRITE setFillMode NOTIFY fillModeChanged)
 
    
    Q_PROPERTY(int frameRate READ frameRate NOTIFY frameRateChanged)
 
    QML_ELEMENT
 
public:
    enum LoadingStatus
    {
        Idle,
        Loading,
        Loaded,
        Error,
        Unloading,
    };
    Q_ENUM(LoadingStatus)
 
    RiveQtQuickItem(QQuickItem *parent = nullptr);
    ~RiveQtQuickItem();
 
    void triggerAnimation(int id);
 
    bool isTextureProvider() const override;
 
    QSGTextureProvider *textureProvider() const override;
 
    QString fileSource() const;
    void setFileSource(const QString &source);
 
    LoadingStatus loadingStatus() const;
 
    int currentAnimationIndex() const;
    int currentArtboardIndex() const;
    void setCurrentArtboardIndex(const int newCurrentArtboardIndex);
 
    const QVector<ArtBoardInfo> &artboards() const;
    const QVector<StateMachineInfo> &stateMachines() const;
    const QVector<AnimationInfo> &animations() const;
 
    int currentStateMachineIndex() const;
    void setCurrentStateMachineIndex(const int newCurrentStateMachineIndex);
 
    RiveStateMachineInput *stateMachineInterface() const;
    void setStateMachineInterface(RiveStateMachineInput *stateMachineInterface);
 
    bool interactive() const;
    void setInteractive(bool newInteractive);
 
    RiveRenderSettings::PostprocessingMode postprocessingMode() const;
    void setPostprocessingMode(const RiveRenderSettings::PostprocessingMode mode);
 
    RiveRenderSettings::RenderQuality renderQuality() const;
    void setRenderQuality(const RiveRenderSettings::RenderQuality quality);
 
    RiveRenderSettings::FillMode fillMode() const;
    void setFillMode(const RiveRenderSettings::FillMode fillMode);
 
    int frameRate();
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    void paint(QPainter *painter) override;
#endif
 
signals:
    void animationsChanged();
    void artboardsChanged();
    void stateMachinesChanged();
 
    void fileSourceChanged();
    void loadingStatusChanged();
 
    void currentArtboardIndexChanged();
    void currentAnimationIndexChanged();
    void currentStateMachineIndexChanged();
 
    void interactiveChanged();
 
    void loadFileAfterUnloading(QString fileName);
    void internalArtboardChanged();
    void internalStateMachineChanged();
    void stateMachineInterfaceChanged();
    void stateMachineStringInterfaceChanged();
 
    void renderQualityChanged();
    void postprocessingModeChanged();
    void fillModeChanged();
 
    void frameRateChanged();
 
protected:
    QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data) override;
    void componentComplete() override;
 
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) override;
#else
    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override;
#endif
 
    void mousePressEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
 
    void hoverMoveEvent(QHoverEvent *event) override;
    void hoverEnterEvent(QHoverEvent *event) override;
    void hoverLeaveEvent(QHoverEvent *event) override;
 
private:
    void loadRiveFile(const QString &source);
 
    void updateInternalArtboard();
    void updateAnimations();
    void updateStateMachines();
    void updateCurrentArtboardIndex();
    void updateCurrentStateMachineIndex();
 
    QRectF artboardRect();
 
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    void renderOffscreen();
#endif
 
    bool hitTest(const QPointF &pos, const rive::ListenerType &type);
 
    QVector<ArtBoardInfo> m_artboardInfoList;
    QVector<AnimationInfo> m_animationList;
    QVector<StateMachineInfo> m_stateMachineList;
 
    std::unique_ptr<rive::File> m_riveFile;
 
    mutable QScopedPointer<QSGTextureProvider> m_textureProvider;
 
    QString m_fileSource;
    LoadingStatus m_loadingStatus { Idle };
 
    std::shared_ptr<rive::ArtboardInstance> m_currentArtboardInstance { nullptr };
    std::unique_ptr<rive::LinearAnimationInstance> m_animationInstance { nullptr };
    std::shared_ptr<rive::StateMachineInstance> m_currentStateMachineInstance { nullptr };
 
    bool m_scheduleArtboardChange { false };
    bool m_scheduleStateMachineChange { false };
 
    int m_currentArtboardIndex { -1 };
    int m_currentAnimationIndex { -1 };
    int m_initialArtboardIndex { -1 };
    int m_currentStateMachineIndex { -1 };
    int m_initialStateMachineIndex { -1 };
 
    RiveStateMachineInput *m_stateMachineInterface { nullptr };
 
    RiveRenderSettings m_renderSettings;
 
    RiveQtFactory m_riveQtFactory { m_renderSettings };
 
    QElapsedTimer m_elapsedTimer;
    qint64 m_lastUpdateTime;
    bool m_geometryChanged { true };
 
    bool m_hasValidRenderNode { false };
    float m_lastMouseX { 0.f };
    float m_lastMouseY { 0.f };
 
    int m_frameRate { 0 };
 
    RiveQSGRenderNode *m_renderNode { nullptr };
    void updateStateMachineValues();
 
    bool m_loadingGuard { false };
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    RiveQSGSoftwareRenderNode *softwareRenderNode;
#endif
};