qquick3dtexture_p.h

// Copyright (C) 2019 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QSSGIMAGE_H

#define QSSGIMAGE_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <QtQuick3D/qquick3dobject.h>

#include <QtQuick3D/QQuick3DTextureData>

#include <QtQuick/private/qquickitemchangelistener_p.h>

#include <QtQuick/private/qsgadaptationlayer_p.h>

#include <QtQuick/QQuickItem>

#include <QtQuick/QSGNode>

#include <QtCore/QUrl>

#include <QtCore/QPointer>

QT_BEGIN_NAMESPACE

class QSGLayer;

struct QSSGRenderImage;

class QQuick3DRenderExtension;

class QQuickWindow;

class QQuick3DTextureInternalChange

public:

    enum class Type {

        BackendNode,

};

    Type type;

};

class Q_QUICK3D_EXPORT QQuick3DTexture : public QQuick3DObject, public QQuickItemChangeListener

    Q_OBJECT

    Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)

    Q_PROPERTY(QQuickItem *sourceItem READ sourceItem WRITE setSourceItem NOTIFY sourceItemChanged)

    Q_PROPERTY(QQuick3DTextureData *textureData READ textureData WRITE setTextureData NOTIFY textureDataChanged)

    Q_PROPERTY(QQuick3DRenderExtension *textureProvider READ textureProvider WRITE setTextureProvider NOTIFY textureProviderChanged FINAL REVISION(6, 7))

    Q_PROPERTY(float scaleU READ scaleU WRITE setScaleU NOTIFY scaleUChanged)

    Q_PROPERTY(float scaleV READ scaleV WRITE setScaleV NOTIFY scaleVChanged)

    Q_PROPERTY(MappingMode mappingMode READ mappingMode WRITE setMappingMode NOTIFY mappingModeChanged)

    Q_PROPERTY(TilingMode tilingModeHorizontal READ horizontalTiling WRITE setHorizontalTiling NOTIFY horizontalTilingChanged)

    Q_PROPERTY(TilingMode tilingModeVertical READ verticalTiling WRITE setVerticalTiling NOTIFY verticalTilingChanged)

    Q_PROPERTY(TilingMode tilingModeDepth READ depthTiling WRITE setDepthTiling NOTIFY depthTilingChanged REVISION(6, 7))

    Q_PROPERTY(float rotationUV READ rotationUV WRITE setRotationUV NOTIFY rotationUVChanged)

    Q_PROPERTY(float positionU READ positionU WRITE setPositionU NOTIFY positionUChanged)

    Q_PROPERTY(float positionV READ positionV WRITE setPositionV NOTIFY positionVChanged)

    Q_PROPERTY(float pivotU READ pivotU WRITE setPivotU NOTIFY pivotUChanged)

    Q_PROPERTY(float pivotV READ pivotV WRITE setPivotV NOTIFY pivotVChanged)

    Q_PROPERTY(bool flipU READ flipU WRITE setFlipU NOTIFY flipUChanged)

    Q_PROPERTY(bool flipV READ flipV WRITE setFlipV NOTIFY flipVChanged)

    Q_PROPERTY(int indexUV READ indexUV WRITE setIndexUV NOTIFY indexUVChanged)

    Q_PROPERTY(Filter magFilter READ magFilter WRITE setMagFilter NOTIFY magFilterChanged)

    Q_PROPERTY(Filter minFilter READ minFilter WRITE setMinFilter NOTIFY minFilterChanged)

    Q_PROPERTY(Filter mipFilter READ mipFilter WRITE setMipFilter NOTIFY mipFilterChanged)

    Q_PROPERTY(bool generateMipmaps READ generateMipmaps WRITE setGenerateMipmaps NOTIFY generateMipmapsChanged)

    Q_PROPERTY(bool autoOrientation READ autoOrientation WRITE setAutoOrientation NOTIFY autoOrientationChanged REVISION(6, 2))

    QML_NAMED_ELEMENT(Texture)

public:

    enum MappingMode

        UV = 0,

        Environment = 1,

        LightProbe = 2,

};

    Q_ENUM(MappingMode)

    enum TilingMode // must match QSSGRenderTextureCoordOp

        ClampToEdge = 1,

        MirroredRepeat,

        Repeat

};

    Q_ENUM(TilingMode)

    enum Filter { // must match QSSGRenderTextureFilterOp

        None = 0,

        Nearest,

        Linear

};

    Q_ENUM(Filter)

    explicit QQuick3DTexture(QQuick3DObject *parent = nullptr);

    ~QQuick3DTexture() override;

    QUrl source() const;

    QQuickItem *sourceItem() const;

    float scaleU() const;

    float scaleV() const;

    MappingMode mappingMode() const;

    TilingMode horizontalTiling() const;

    TilingMode verticalTiling() const;

    Q_REVISION(6, 7) TilingMode depthTiling() const;

    float rotationUV() const;

    float positionU() const;

    float positionV() const;

    float pivotU() const;

    float pivotV() const;

    bool flipU() const;

    bool flipV() const;

    int indexUV() const;

    Filter magFilter() const;

    Filter minFilter() const;

    Filter mipFilter() const;

    QQuick3DTextureData *textureData() const;

    bool generateMipmaps() const;

    bool autoOrientation() const;

    QSSGRenderImage *getRenderImage();

    Q_REVISION(6, 7) QQuick3DRenderExtension *textureProvider() const;

    Q_REVISION(6, 7) void setTextureProvider(QQuick3DRenderExtension *newRenderTexture);

    bool hasSourceData() const

        return !m_source.isEmpty() || m_sourceItem || m_textureData;

public Q_SLOTS:

    void setSource(const QUrl &source);

    void setSourceItem(QQuickItem *sourceItem);

    void setScaleU(float scaleU);

    void setScaleV(float scaleV);

    void setMappingMode(QQuick3DTexture::MappingMode mappingMode);

    void setHorizontalTiling(QQuick3DTexture::TilingMode tilingModeHorizontal);

    void setVerticalTiling(QQuick3DTexture::TilingMode tilingModeVertical);

    Q_REVISION(6, 7) void setDepthTiling(QQuick3DTexture::TilingMode tilingModeDepth);

    void setRotationUV(float rotationUV);

    void setPositionU(float positionU);

    void setPositionV(float positionV);

    void setPivotU(float pivotU);

    void setPivotV(float pivotV);

    void setFlipU(bool flipU);

    void setFlipV(bool flipV);

    void setIndexUV(int indexUV);

    void setMagFilter(QQuick3DTexture::Filter magFilter);

    void setMinFilter(QQuick3DTexture::Filter minFilter);

    void setMipFilter(QQuick3DTexture::Filter mipFilter);

    void setTextureData(QQuick3DTextureData * textureData);

    void setGenerateMipmaps(bool generateMipmaps);

    void setAutoOrientation(bool autoOrientation);

Q_SIGNALS:

    void sourceChanged();

    void sourceItemChanged();

    void scaleUChanged();

    void scaleVChanged();

    void mappingModeChanged();

    void horizontalTilingChanged();

    void verticalTilingChanged();

    Q_REVISION(6, 7) void depthTilingChanged();

    void rotationUVChanged();

    void positionUChanged();

    void positionVChanged();

    void pivotUChanged();

    void pivotVChanged();

    void flipUChanged();

    void flipVChanged();

    void indexUVChanged();

    void magFilterChanged();

    void minFilterChanged();

    void mipFilterChanged();

    void textureDataChanged();

    void generateMipmapsChanged();

    void autoOrientationChanged();

    Q_REVISION(6, 7) void textureProviderChanged();

    Q_REVISION(6, 12) void textureInternalChange(QQuick3DTextureInternalChange, QPrivateSignal);

protected:

    QSSGRenderGraphObject *updateSpatialNode(QSSGRenderGraphObject *node) override;

    void markAllDirty() override;

    void itemChange(ItemChange change, const ItemChangeData &value) override;

    void itemGeometryChanged(QQuickItem *item, QQuickGeometryChange change, const QRectF &geometry) override;

    explicit QQuick3DTexture(QQuick3DObjectPrivate &dd, QQuick3DObject *parent = nullptr);

private Q_SLOTS:

    void sourceItemDestroyed(QObject *item);

    void sourceItemWindowChanged(QQuickWindow *window);

private:

    enum class DirtyFlag {

        TransformDirty = (1 << 0),

        SourceDirty = (1 << 1),

        IndexUVDirty = (1 << 2),

        TextureDataDirty = (1 << 3),

        SamplerDirty = (1 << 4),

        SourceItemDirty = (1 << 5),

        FlipVDirty = (1 << 6),

        ExtensionDirty = (1 << 7)

};

    Q_DECLARE_FLAGS(DirtyFlags, DirtyFlag)

    void markDirty(DirtyFlag type, bool requestSecondaryUpdate = false);

    void trySetSourceParent();

    bool effectiveFlipV(const QSSGRenderImage &imageNode) const;

    QUrl m_source;

    QQuickItem *m_sourceItem = nullptr;

    bool m_sourceItemReparented = false;

    bool m_sourceItemRefed = false;

    QSGLayer *m_layer = nullptr;

    float m_scaleU = 1.0f;

    float m_scaleV = 1.0f;

    MappingMode m_mappingMode = UV;

    TilingMode m_tilingModeHorizontal = Repeat;

    TilingMode m_tilingModeVertical = Repeat;

    TilingMode m_tilingModeDepth = Repeat;

    float m_rotationUV = 0;

    float m_positionU = 0;

    float m_positionV = 0;

    float m_pivotU = 0;

    float m_pivotV = 0;

    bool m_flipU = false;

    bool m_flipV = false;

    int m_indexUV = 0;

    Filter m_magFilter = Linear;

    Filter m_minFilter = Linear;

    Filter m_mipFilter = None;

    DirtyFlags m_dirtyFlags = DirtyFlags(DirtyFlag::TransformDirty)

                              | DirtyFlags(DirtyFlag::SourceDirty)

                              | DirtyFlags(DirtyFlag::IndexUVDirty)

                              | DirtyFlags(DirtyFlag::TextureDataDirty);

    QMetaObject::Connection m_textureProviderConnection;

    QMetaObject::Connection m_textureUpdateConnection;

    QQuick3DSceneManager *m_sceneManagerForLayer = nullptr;

    QMetaObject::Connection m_sceneManagerWindowChangeConnection;

    QQuickItem *m_initializedSourceItem = nullptr;

    QSizeF m_initializedSourceItemSize;

    QHash<QByteArray, QMetaObject::Connection> m_connections;

    QMetaObject::Connection m_textureDataConnection;

    QQuick3DTextureData *m_textureData = nullptr;

    bool m_generateMipmaps = false;

    bool m_autoOrientation = true;

    QQuick3DRenderExtension *m_renderExtension = nullptr;

};

QT_END_NAMESPACE

#endif // QSSGIMAGE_H

Revision control

Copy as Markdown