qsgtexture.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsgtexture_p.h"
#include "qsgtexture_platform.h"
#include <private/qqmlglobal_p.h>
#include <private/qsgmaterialshader_p.h>
#include <private/qsgrenderer_p.h>
#include <private/qquickitem_p.h> // qquickwindow_p.h cannot be included on its own due to template nonsense
#include <private/qquickwindow_p.h>
#include <QtCore/private/qnativeinterface_p.h>
#include <rhi/qrhi.h>
 
#if defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID) && defined(__GLIBC__)
#define CAN_BACKTRACE_EXECINFO
#endif
 
#if defined(Q_OS_MAC)
#define CAN_BACKTRACE_EXECINFO
#endif
 
#if defined(QT_NO_DEBUG)
#undef CAN_BACKTRACE_EXECINFO
#endif
 
#if defined(CAN_BACKTRACE_EXECINFO)
#include <execinfo.h>
#include <QHash>
#endif
 
#ifndef QT_NO_DEBUG
Q_GLOBAL_STATIC(QSet<QSGTexture *>, qsg_valid_texture_set)
Q_GLOBAL_STATIC(QMutex, qsg_valid_texture_mutex)
#endif
 
QT_BEGIN_NAMESPACE
 
bool operator==(const QSGSamplerDescription &a, const QSGSamplerDescription &b) noexcept
{
    return a.filtering == b.filtering
            && a.mipmapFiltering == b.mipmapFiltering
            && a.horizontalWrap == b.horizontalWrap
            && a.verticalWrap == b.verticalWrap
            && a.anisotropylevel == b.anisotropylevel;
}
 
bool operator!=(const QSGSamplerDescription &a, const QSGSamplerDescription &b) noexcept
{
    return !(a == b);
}
 
size_t qHash(const QSGSamplerDescription &s, size_t seed) noexcept
{
    const int f = s.filtering;
    const int m = s.mipmapFiltering;
    const int w = s.horizontalWrap;
    const int a = s.anisotropylevel;
    return (((f & 7) << 24) | ((m & 7) << 16) | ((w & 7) << 8) | (a & 7)) ^ seed;
}
 
QSGSamplerDescription QSGSamplerDescription::fromTexture(QSGTexture *t)
{
    QSGSamplerDescription s;
    s.filtering = t->filtering();
    s.mipmapFiltering = t->mipmapFiltering();
    s.horizontalWrap = t->horizontalWrapMode();
    s.verticalWrap = t->verticalWrapMode();
    s.anisotropylevel = t->anisotropyLevel();
    return s;
}
 
QSGTexturePrivate::QSGTexturePrivate(QSGTexture *t)
    : wrapChanged(false)
    , filteringChanged(false)
    , anisotropyChanged(false)
    , horizontalWrap(QSGTexture::ClampToEdge)
    , verticalWrap(QSGTexture::ClampToEdge)
    , mipmapMode(QSGTexture::None)
    , filterMode(QSGTexture::Nearest)
    , anisotropyLevel(QSGTexture::AnisotropyNone)
#if QT_CONFIG(opengl)
    , m_openglTextureAccessor(t)
#endif
#ifdef Q_OS_WIN
    , m_d3d11TextureAccessor(t)
    , m_d3d12TextureAccessor(t)
#endif
#if defined(__OBJC__)
    , m_metalTextureAccessor(t)
#endif
#if QT_CONFIG(vulkan)
    , m_vulkanTextureAccessor(t)
#endif
{
#if !QT_CONFIG(opengl)
    Q_UNUSED(t);
#endif
}
 
#ifndef QT_NO_DEBUG
 
static int qt_debug_texture_count = 0;
 
#if (defined(Q_OS_LINUX) || defined (Q_OS_MAC)) && !defined(Q_OS_ANDROID)
DEFINE_BOOL_CONFIG_OPTION(qmlDebugLeakBacktrace, QML_DEBUG_LEAK_BACKTRACE)
 
#define BACKTRACE_SIZE 20
class SGTextureTraceItem
{
public:
    void *backTrace[BACKTRACE_SIZE];
    size_t backTraceSize;
};
 
static QHash<QSGTexture*, SGTextureTraceItem*> qt_debug_allocated_textures;
#endif
 
inline static void qt_debug_print_texture_count()
{
    qDebug("Number of leaked textures: %i", qt_debug_texture_count);
    qt_debug_texture_count = -1;
 
#if defined(CAN_BACKTRACE_EXECINFO)
    if (qmlDebugLeakBacktrace()) {
        while (!qt_debug_allocated_textures.isEmpty()) {
            QHash<QSGTexture*, SGTextureTraceItem*>::Iterator it = qt_debug_allocated_textures.begin();
            QSGTexture* texture = it.key();
            SGTextureTraceItem* item = it.value();
 
            qt_debug_allocated_textures.erase(it);
 
            qDebug() << "------";
            qDebug() << "Leaked" << texture << "backtrace:";
 
            char** symbols = backtrace_symbols(item->backTrace, item->backTraceSize);
 
            if (symbols) {
                for (int i=0; i<(int) item->backTraceSize; i++)
                    qDebug("Backtrace <%02d>: %s", i, symbols[i]);
                free(symbols);
            }
 
            qDebug() << "------";
 
            delete item;
        }
    }
#endif
}
 
inline static void qt_debug_add_texture(QSGTexture* texture)
{
#if defined(CAN_BACKTRACE_EXECINFO)
    if (qmlDebugLeakBacktrace()) {
        SGTextureTraceItem* item = new SGTextureTraceItem;
        item->backTraceSize = backtrace(item->backTrace, BACKTRACE_SIZE);
        qt_debug_allocated_textures.insert(texture, item);
    }
#else
    Q_UNUSED(texture);
#endif // Q_OS_LINUX
 
    ++qt_debug_texture_count;
 
    static bool atexit_registered = false;
    if (!atexit_registered) {
        atexit(qt_debug_print_texture_count);
        atexit_registered = true;
    }
}
 
static void qt_debug_remove_texture(QSGTexture* texture)
{
#if defined(CAN_BACKTRACE_EXECINFO)
    if (qmlDebugLeakBacktrace()) {
        SGTextureTraceItem* item = qt_debug_allocated_textures.value(texture, 0);
        if (item) {
            qt_debug_allocated_textures.remove(texture);
            delete item;
        }
    }
#else
    Q_UNUSED(texture);
#endif
 
    --qt_debug_texture_count;
 
    if (qt_debug_texture_count < 0)
        qDebug("Texture destroyed after qt_debug_print_texture_count() was called.");
}
 
#endif // QT_NO_DEBUG
 
QSGTexture::QSGTexture()
    : QObject(*(new QSGTexturePrivate(this)))
{
#ifndef QT_NO_DEBUG
    if (_q_sg_leak_check)
        qt_debug_add_texture(this);
 
    QMutexLocker locker(qsg_valid_texture_mutex());
    qsg_valid_texture_set()->insert(this);
#endif
}
 
QSGTexture::QSGTexture(QSGTexturePrivate &dd)
    : QObject(dd)
{
#ifndef QT_NO_DEBUG
    if (_q_sg_leak_check)
        qt_debug_add_texture(this);
 
    QMutexLocker locker(qsg_valid_texture_mutex());
    qsg_valid_texture_set()->insert(this);
#endif
}
 
QSGTexture::~QSGTexture()
{
#ifndef QT_NO_DEBUG
    if (_q_sg_leak_check)
        qt_debug_remove_texture(this);
 
    QMutexLocker locker(qsg_valid_texture_mutex());
    qsg_valid_texture_set()->remove(this);
#endif
}
 
QSGTexture *QSGTexture::removedFromAtlas(QRhiResourceUpdateBatch *resourceUpdates) const
{
    Q_UNUSED(resourceUpdates);
    Q_ASSERT_X(!isAtlasTexture(), "QSGTexture::removedFromAtlas()", "Called on a non-atlas texture");
    return nullptr;
}
 
bool QSGTexture::isAtlasTexture() const
{
    return false;
}
 
QRectF QSGTexture::normalizedTextureSubRect() const
{
    return QRectF(0, 0, 1, 1);
}
 
void QSGTexture::setMipmapFiltering(Filtering filter)
{
    Q_D(QSGTexture);
    if (d->mipmapMode != (uint) filter) {
        d->mipmapMode = filter;
        d->filteringChanged = true;
    }
}
 
QSGTexture::Filtering QSGTexture::mipmapFiltering() const
{
    return (QSGTexture::Filtering) d_func()->mipmapMode;
}
 
 
void QSGTexture::setFiltering(QSGTexture::Filtering filter)
{
    Q_D(QSGTexture);
    if (d->filterMode != (uint) filter) {
        d->filterMode = filter;
        d->filteringChanged = true;
    }
}
 
QSGTexture::Filtering QSGTexture::filtering() const
{
    return (QSGTexture::Filtering) d_func()->filterMode;
}
 
void QSGTexture::setAnisotropyLevel(AnisotropyLevel level)
{
    Q_D(QSGTexture);
    if (d->anisotropyLevel != (uint) level) {
        d->anisotropyLevel = level;
        d->anisotropyChanged = true;
    }
}
 
QSGTexture::AnisotropyLevel QSGTexture::anisotropyLevel() const
{
    return (QSGTexture::AnisotropyLevel) d_func()->anisotropyLevel;
}
 
 
 
void QSGTexture::setHorizontalWrapMode(WrapMode hwrap)
{
    Q_D(QSGTexture);
    if ((uint) hwrap != d->horizontalWrap) {
        d->horizontalWrap = hwrap;
        d->wrapChanged = true;
    }
}
 
QSGTexture::WrapMode QSGTexture::horizontalWrapMode() const
{
    return (QSGTexture::WrapMode) d_func()->horizontalWrap;
}
 
 
 
void QSGTexture::setVerticalWrapMode(WrapMode vwrap)
{
    Q_D(QSGTexture);
    if ((uint) vwrap != d->verticalWrap) {
        d->verticalWrap = vwrap;
        d->wrapChanged = true;
    }
}
 
QSGTexture::WrapMode QSGTexture::verticalWrapMode() const
{
    return (QSGTexture::WrapMode) d_func()->verticalWrap;
}
 
QRhiTexture *QSGTexture::rhiTexture() const
{
    return nullptr;
}
 
void QSGTexture::commitTextureOperations(QRhi *rhi, QRhiResourceUpdateBatch *resourceUpdates)
{
    Q_UNUSED(rhi);
    Q_UNUSED(resourceUpdates);
}
 
bool QSGTexturePrivate::hasDirtySamplerOptions() const
{
    return wrapChanged || filteringChanged || anisotropyChanged;
}
 
void QSGTexturePrivate::resetDirtySamplerOptions()
{
    wrapChanged = filteringChanged = anisotropyChanged = false;
}
 
QSGDynamicTexture::QSGDynamicTexture(QSGTexturePrivate &dd)
    : QSGTexture(dd)
{
}
 
QSGDynamicTexture::~QSGDynamicTexture()
    = default;
 
#if QT_CONFIG(opengl) || defined(Q_QDOC)
namespace QNativeInterface {
QT_DEFINE_NATIVE_INTERFACE(QSGOpenGLTexture);
 
QSGTexture *QSGOpenGLTexture::fromNative(GLuint textureId,
                                         QQuickWindow *window,
                                         const QSize &size,
                                         QQuickWindow::CreateTextureOptions options)
{
    return QQuickWindowPrivate::get(window)->createTextureFromNativeTexture(quint64(textureId), 0, size, options);
}
 
QSGTexture *QSGOpenGLTexture::fromNativeExternalOES(GLuint textureId,
                                                    QQuickWindow *window,
                                                    const QSize &size,
                                                    QQuickWindow::CreateTextureOptions options)
{
    return QQuickWindowPrivate::get(window)->createTextureFromNativeTexture(quint64(textureId),
                                                                            0,
                                                                            size,
                                                                            options,
                                                                            QQuickWindowPrivate::NativeTextureIsExternalOES);
}
} // QNativeInterface
 
GLuint QSGTexturePlatformOpenGL::nativeTexture() const
{
    if (auto *tex = m_texture->rhiTexture())
        return GLuint(tex->nativeTexture().object);
    return 0;
}
#endif // opengl
 
#if defined(Q_OS_WIN) || defined(Q_QDOC)
namespace QNativeInterface {
QT_DEFINE_NATIVE_INTERFACE(QSGD3D11Texture);
 
QSGTexture *QSGD3D11Texture::fromNative(void *texture,
                                        QQuickWindow *window,
                                        const QSize &size,
                                        QQuickWindow::CreateTextureOptions options)
{
    return QQuickWindowPrivate::get(window)->createTextureFromNativeTexture(quint64(texture), 0, size, options);
}
} // QNativeInterface
 
void *QSGTexturePlatformD3D11::nativeTexture() const
{
    if (auto *tex = m_texture->rhiTexture())
        return reinterpret_cast<void *>(quintptr(tex->nativeTexture().object));
    return 0;
}
 
namespace QNativeInterface {
QT_DEFINE_NATIVE_INTERFACE(QSGD3D12Texture);
 
QSGTexture *QSGD3D12Texture::fromNative(void *texture,
                                        int resourceState,
                                        QQuickWindow *window,
                                        const QSize &size,
                                        QQuickWindow::CreateTextureOptions options)
{
    return QQuickWindowPrivate::get(window)->createTextureFromNativeTexture(quint64(texture), resourceState, size, options);
}
} // QNativeInterface
 
int QSGTexturePlatformD3D12::nativeResourceState() const
{
    if (auto *tex = m_texture->rhiTexture())
        return tex->nativeTexture().layout;
    return 0;
}
 
void *QSGTexturePlatformD3D12::nativeTexture() const
{
    if (auto *tex = m_texture->rhiTexture())
        return reinterpret_cast<void *>(quintptr(tex->nativeTexture().object));
    return 0;
}
 
#endif // win
 
#if defined(__OBJC__) || defined(Q_QDOC)
namespace QNativeInterface {
} // QNativeInterface
#endif // OBJC
 
#if QT_CONFIG(vulkan) || defined(Q_QDOC)
namespace QNativeInterface {
QT_DEFINE_NATIVE_INTERFACE(QSGVulkanTexture);
 
QSGTexture *QSGVulkanTexture::fromNative(VkImage image,
                                         VkImageLayout layout,
                                         QQuickWindow *window,
                                         const QSize &size,
                                         QQuickWindow::CreateTextureOptions options)
{
    return QQuickWindowPrivate::get(window)->createTextureFromNativeTexture(quint64(image), layout, size, options);
}
} // QNativeInterface
 
VkImage QSGTexturePlatformVulkan::nativeImage() const
{
    if (auto *tex = m_texture->rhiTexture())
        return VkImage(tex->nativeTexture().object);
    return VK_NULL_HANDLE;
}
 
VkImageLayout QSGTexturePlatformVulkan::nativeImageLayout() const
{
    if (auto *tex = m_texture->rhiTexture())
        return VkImageLayout(tex->nativeTexture().layout);
    return VK_IMAGE_LAYOUT_UNDEFINED;
}
#endif // vulkan
 
void *QSGTexture::resolveInterface(const char *name, int revision) const
{
    using namespace QNativeInterface;
    Q_UNUSED(name);
    Q_UNUSED(revision);
 
    Q_D(const QSGTexture);
    auto *dd = const_cast<QSGTexturePrivate *>(d);
    Q_UNUSED(dd);
 
#if QT_CONFIG(vulkan)
    QT_NATIVE_INTERFACE_RETURN_IF(QSGVulkanTexture, &dd->m_vulkanTextureAccessor);
#endif
#if defined(__OBJC__)
    QT_NATIVE_INTERFACE_RETURN_IF(QSGMetalTexture, &dd->m_metalTextureAccessor);
#endif
#if defined(Q_OS_WIN)
    QT_NATIVE_INTERFACE_RETURN_IF(QSGD3D11Texture, &dd->m_d3d11TextureAccessor);
    QT_NATIVE_INTERFACE_RETURN_IF(QSGD3D12Texture, &dd->m_d3d12TextureAccessor);
#endif
#if QT_CONFIG(opengl)
    QT_NATIVE_INTERFACE_RETURN_IF(QSGOpenGLTexture, &dd->m_openglTextureAccessor);
#endif
 
    return nullptr;
}
 
QT_END_NAMESPACE
 
#include "moc_qsgtexture.cpp"