/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtQuick module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qsgd3d12shadereffectnode_p.h"
#include "qsgd3d12rendercontext_p.h"
#include "qsgd3d12texture_p.h"
#include "qsgd3d12engine_p.h"
#include <QtCore/qthreadpool.h>
#include <QtCore/qfile.h>
#include <QtCore/qfileselector.h>
#include <QtQml/qqmlfile.h>
#include <qsgtextureprovider.h>

#include <d3d12shader.h>
#include <d3dcompiler.h>

#include "vs_shadereffectdefault.hlslh"
#include "ps_shadereffectdefault.hlslh"

QT_BEGIN_NAMESPACE

// NOTE: Avoid categorized logging. It is slow.

#define DECLARE_DEBUG_VAR(variable) \
    static bool debug_ ## variable() \
    { static bool value = qgetenv("QSG_RENDERER_DEBUG").contains(QT_STRINGIFY(variable)); return value; }

DECLARE_DEBUG_VAR(shader)

void QSGD3D12ShaderLinker::reset(const QByteArray &vertBlob, const QByteArray &fragBlob)
{
    Q_ASSERT(!vertBlob.isEmpty() && !fragBlob.isEmpty());
    vs = vertBlob;
    fs = fragBlob;

    error = false;

    constantBufferSize = 0;
    constants.clear();
    samplers.clear();
    textures.clear();
    textureNameMap.clear();
}

void QSGD3D12ShaderLinker::feedConstants(const QSGShaderEffectNode::ShaderData &shader, const QSet<int> *dirtyIndices)
{
    Q_ASSERT(shader.shaderInfo.variables.count() == shader.varData.count());
    if (!dirtyIndices) {
        constantBufferSize = qMax(constantBufferSize, shader.shaderInfo.constantDataSize);
        for (int i = 0; i < shader.shaderInfo.variables.count(); ++i) {
            const auto &var(shader.shaderInfo.variables.at(i));
            if (var.type == QSGGuiThreadShaderEffectManager::ShaderInfo::Constant) {
                const auto &vd(shader.varData.at(i));
                Constant c;
                c.size = var.size;
                c.specialType = vd.specialType;
                if (c.specialType != QSGShaderEffectNode::VariableData::SubRect) {
                    c.value = vd.value;
                } else {
                    Q_ASSERT(var.name.startsWith(QByteArrayLiteral("qt_SubRect_")));
                    c.value = var.name.mid(11);
                }
                constants[var.offset] = c;
            }
        }
    } else {
        for (int idx : *dirtyIndices)
            constants[shader.shaderInfo.variables.at(idx).offset].value = shader.varData.at(idx).value;
    }
}

void QSGD3D12ShaderLinker::feedSamplers(const QSGShaderEffectNode::ShaderData &shader)
{
    for (int i = 0; i < shader.shaderInfo.variables.count(); ++i) {
        const auto &var(shader.shaderInfo.variables.at(i));
        if (var.type == QSGGuiThreadShaderEffectManager::ShaderInfo::Sampler) {
            Q_ASSERT(shader.varData.at(i).specialType == QSGShaderEffectNode::VariableData::Unused);
            samplers.insert(var.bindPoint);
        }
    }
}

void QSGD3D12ShaderLinker::feedTextures(const QSGShaderEffectNode::ShaderData &shader, const QSet<int> *dirtyIndices)
{
    if (!dirtyIndices) {
        for (int i = 0; i < shader.shaderInfo.variables.count(); ++i) {
            const auto &var(shader.shaderInfo.variables.at(i));
            const auto &vd(shader.varData.at(i));
            if (var.type == QSGGuiThreadShaderEffectManager::ShaderInfo::Texture) {
                Q_ASSERT(vd.specialType == QSGShaderEffectNode::VariableData::Source);
                textures.insert(var.bindPoint, vd.value);
                textureNameMap.insert(var.name, var.bindPoint);
            }
        }
    } else {
        for (int idx : *dirtyIndices) {
            const auto &var(shader.shaderInfo.variables.at(idx));
            const auto &vd(shader.varData.at(idx));
            textures.insert(var.bindPoint, vd.value);
            textureNameMap.insert(var.name, var.bindPoint);
        }
    }
}

void QSGD3D12ShaderLinker::linkTextureSubRects()
{
    // feedConstants stores <name> in Constant::value for subrect entries. Now
    // that both constants and textures are known, replace the name with the
    // texture bind point.
    for (Constant &c : constants) {
        if (c.specialType == QSGShaderEffectNode::VariableData::SubRect) {
            if (c.value.type() == QVariant::ByteArray) {
                const QByteArray name = c.value.toByteArray();
                if (!textureNameMap.contains(name))
                    qWarning("ShaderEffect: qt_SubRect_%s refers to unknown source texture", qPrintable(name));
                c.value = textureNameMap[name];
            }
        }
    }
}

void QSGD3D12ShaderLinker::dump()
{
    if (error) {
        qDebug() << "Failed to generate program data";
        return;
    }
    qDebug() << "Combined shader data" << vs.size() << fs.size() << "cbuffer size" << constantBufferSize;
    qDebug() << " - constants" << constants;
    qDebug() << " - samplers" << samplers;
    qDebug() << " - textures" << textures;
}

QDebug operator<<(QDebug debug, const QSGD3D12ShaderLinker::Constant &c)
{
    QDebugStateSaver saver(debug);
    debug.space();
    debug << "size" << c.size;
    if (c.specialType != QSGShaderEffectNode::VariableData::None)
        debug << "special" << c.specialType;
    else
        debug << "value" << c.value;
    return debug;
}

QSGD3D12ShaderEffectMaterial::QSGD3D12ShaderEffectMaterial(QSGD3D12ShaderEffectNode *node)
    : node(node)
{
    setFlag(Blending | RequiresFullMatrix, true); // may be changed in sync()
}

QSGD3D12ShaderEffectMaterial::~QSGD3D12ShaderEffectMaterial()
{
    delete dummy;
}

struct QSGD3D12ShaderMaterialTypeCache
{
    QSGMaterialType *get(const QByteArray &vs, const QByteArray &fs);
    void reset() { qDeleteAll(m_types); m_types.clear(); }

    struct Key {
        QByteArray blob[2];
        Key() { }
        Key(const QByteArray &vs, const QByteArray &fs) { blob[0] = vs; blob[1] = fs; }
        bool operator==(const Key &other) const {
            return blob[0] == other.blob[0] && blob[1] == other.blob[1];
        }
    };
    QHash<Key, QSGMaterialType *> m_types;
};

uint qHash(const QSGD3D12ShaderMaterialTypeCache::Key &key, uint seed = 0)
{
    uint hash = seed;
    for (int i = 0; i < 2; ++i)
        hash = hash * 31337 + qHash(key.blob[i]);
    return hash;
}

QSGMaterialType *QSGD3D12ShaderMaterialTypeCache::get(const QByteArray &vs, const QByteArray &fs)
{
    const Key k(vs, fs);
    if (m_types.contains(k))
        return m_types.value(k);

    QSGMaterialType *t = new QSGMaterialType;
    m_types.insert(k, t);
    return t;
}

Q_GLOBAL_STATIC(QSGD3D12ShaderMaterialTypeCache, shaderMaterialTypeCache)

void QSGD3D12ShaderEffectNode::cleanupMaterialTypeCache()
{
    shaderMaterialTypeCache()->reset();
}

QSGMaterialType *QSGD3D12ShaderEffectMaterial::type() const
{
    return mtype;
}

static bool hasAtlasTexture(const QVector<QSGTextureProvider *> &textureProviders)
{
    for (int i = 0; i < textureProviders.count(); ++i) {
        QSGTextureProvider *t = textureProviders.at(i);
        if (t && t->texture() && t->texture()->isAtlasTexture())
            return true;
    }
    return false;
}

int QSGD3D12ShaderEffectMaterial::compare(const QSGMaterial *other) const
{
    Q_ASSERT(other && type() == other->type());
    const QSGD3D12ShaderEffectMaterial *o = static_cast<const QSGD3D12ShaderEffectMaterial *>(other);

    if (int diff = cullMode - o->cullMode)
        return diff;

    if (int diff = textureProviders.count() - o->textureProviders.count())
        return diff;

    if (linker.constants != o->linker.constants)
        return 1;

    if ((hasAtlasTexture(textureProviders) && !geometryUsesTextureSubRect)
            || (hasAtlasTexture(o->textureProviders) && !o->geometryUsesTextureSubRect))
        return 1;

    for (int i = 0; i < textureProviders.count(); ++i) {
        QSGTextureProvider *tp1 = textureProviders.at(i);
        QSGTextureProvider *tp2 = o->textureProviders.at(i);
        if (!tp1 || !tp2)
            return tp1 == tp2 ? 0 : 1;
        QSGTexture *t1 = tp1->texture();
        QSGTexture *t2 = tp2->texture();
        if (!t1 || !t2)
            return t1 == t2 ? 0 : 1;
        if (int diff = t1->textureId() - t2->textureId())
            return diff;
    }

    return 0;
}

int QSGD3D12ShaderEffectMaterial::constantBufferSize() const
{
    return QSGD3D12Engine::alignedConstantBufferSize(linker.constantBufferSize);
}

void QSGD3D12ShaderEffectMaterial::preparePipeline(QSGD3D12PipelineState *pipelineState)
{
    pipelineState->shaders.vs = reinterpret_cast<const quint8 *>(linker.vs.constData());
    pipelineState->shaders.vsSize = linker.vs.size();
    pipelineState->shaders.ps = reinterpret_cast<const quint8 *>(linker.fs.constData());
    pipelineState->shaders.psSize = linker.fs.size();

    pipelineState->shaders.rootSig.textureViewCount = textureProviders.count();
}

static inline QColor qsg_premultiply_color(const QColor &c)
{
    return QColor::fromRgbF(c.redF() * c.alphaF(), c.greenF() * c.alphaF(), c.blueF() * c.alphaF(), c.alphaF());
}

QSGD3D12Material::UpdateResults QSGD3D12ShaderEffectMaterial::updatePipeline(const QSGD3D12MaterialRenderState &state,
                                                                             QSGD3D12PipelineState *pipelineState,
                                                                             ExtraState *,
                                                                             quint8 *constantBuffer)
{
    QSGD3D12Material::UpdateResults r = 0;
    quint8 *p = constantBuffer;

    for (auto it = linker.constants.constBegin(), itEnd = linker.constants.constEnd(); it != itEnd; ++it) {
        quint8 *dst = p + it.key();
        const QSGD3D12ShaderLinker::Constant &c(it.value());
        if (c.specialType == QSGShaderEffectNode::VariableData::Opacity) {
            if (state.isOpacityDirty()) {
                const float f = state.opacity();
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, &f, sizeof(f));
                r |= UpdatedConstantBuffer;
            }
        } else if (c.specialType == QSGShaderEffectNode::VariableData::Matrix) {
            if (state.isMatrixDirty()) {
                const int sz = 16 * sizeof(float);
                Q_ASSERT(sz == c.size);
                memcpy(dst, state.combinedMatrix().constData(), sz);
                r |= UpdatedConstantBuffer;
            }
        } else if (c.specialType == QSGShaderEffectNode::VariableData::SubRect) {
            // float4
            QRectF subRect(0, 0, 1, 1);
            int srcBindPoint = c.value.toInt(); // filled in by linkTextureSubRects
            if (QSGTexture *t = textureProviders.at(srcBindPoint)->texture())
                subRect = t->normalizedTextureSubRect();
            const float f[4] = { float(subRect.x()), float(subRect.y()),
                                 float(subRect.width()), float(subRect.height()) };
            Q_ASSERT(sizeof(f) == c.size);
            memcpy(dst, f, sizeof(f));
        } else if (c.specialType == QSGShaderEffectNode::VariableData::None) {
            r |= UpdatedConstantBuffer;
            switch (c.value.type()) {
            case QMetaType::QColor: {
                const QColor v = qsg_premultiply_color(qvariant_cast<QColor>(c.value));
                const float f[4] = { float(v.redF()), float(v.greenF()), float(v.blueF()), float(v.alphaF()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::Float: {
                const float f = qvariant_cast<float>(c.value);
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, &f, sizeof(f));
                break;
            }
            case QMetaType::Double: {
                const float f = float(qvariant_cast<double>(c.value));
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, &f, sizeof(f));
                break;
            }
            case QMetaType::Int: {
                const int i = c.value.toInt();
                Q_ASSERT(sizeof(i) == c.size);
                memcpy(dst, &i, sizeof(i));
                break;
            }
            case QMetaType::Bool: {
                const bool b = c.value.toBool();
                Q_ASSERT(sizeof(b) == c.size);
                memcpy(dst, &b, sizeof(b));
                break;
            }
            case QMetaType::QTransform: { // float3x3
                const QTransform v = qvariant_cast<QTransform>(c.value);
                const float m[3][3] = {
                    { float(v.m11()), float(v.m12()), float(v.m13()) },
                    { float(v.m21()), float(v.m22()), float(v.m23()) },
                    { float(v.m31()), float(v.m32()), float(v.m33()) }
                };
                Q_ASSERT(sizeof(m) == c.size);
                memcpy(dst, m[0], sizeof(m));
                break;
            }
            case QMetaType::QSize:
            case QMetaType::QSizeF: { // float2
                const QSizeF v = c.value.toSizeF();
                const float f[2] = { float(v.width()), float(v.height()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::QPoint:
            case QMetaType::QPointF: { // float2
                const QPointF v = c.value.toPointF();
                const float f[2] = { float(v.x()), float(v.y()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::QRect:
            case QMetaType::QRectF: { // float4
                const QRectF v = c.value.toRectF();
                const float f[4] = { float(v.x()), float(v.y()), float(v.width()), float(v.height()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::QVector2D: { // float2
                const QVector2D v = qvariant_cast<QVector2D>(c.value);
                const float f[2] = { float(v.x()), float(v.y()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::QVector3D: { // float3
                const QVector3D v = qvariant_cast<QVector3D>(c.value);
                const float f[3] = { float(v.x()), float(v.y()), float(v.z()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::QVector4D: { // float4
                const QVector4D v = qvariant_cast<QVector4D>(c.value);
                const float f[4] = { float(v.x()), float(v.y()), float(v.z()), float(v.w()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::QQuaternion: { // float4
                const QQuaternion v = qvariant_cast<QQuaternion>(c.value);
                const float f[4] = { float(v.x()), float(v.y()), float(v.z()), float(v.scalar()) };
                Q_ASSERT(sizeof(f) == c.size);
                memcpy(dst, f, sizeof(f));
                break;
            }
            case QMetaType::QMatrix4x4: { // float4x4
                const QMatrix4x4 v = qvariant_cast<QMatrix4x4>(c.value);
                const int sz = 16 * sizeof(float);
                Q_ASSERT(sz == c.size);
                memcpy(dst, v.constData(), sz);
                break;
            }
            default:
                break;
            }
        }
    }

    for (int i = 0; i < textureProviders.count(); ++i) {
        QSGTextureProvider *tp = textureProviders[i];
        QSGD3D12TextureView &tv(pipelineState->shaders.rootSig.textureViews[i]);
        if (tp) {
            if (QSGTexture *t = tp->texture()) {
                if (t->isAtlasTexture() && !geometryUsesTextureSubRect) {
                    QSGTexture *newTexture = t->removedFromAtlas();
                    if (newTexture)
                        t = newTexture;
                }
                tv.filter = t->filtering() == QSGTexture::Linear
                        ? QSGD3D12TextureView::FilterLinear : QSGD3D12TextureView::FilterNearest;
                tv.addressModeHoriz = t->horizontalWrapMode() == QSGTexture::ClampToEdge
                        ? QSGD3D12TextureView::AddressClamp : QSGD3D12TextureView::AddressWrap;
                tv.addressModeVert = t->verticalWrapMode() == QSGTexture::ClampToEdge
                        ? QSGD3D12TextureView::AddressClamp : QSGD3D12TextureView::AddressWrap;
                t->bind();
                continue;
            }
        }
        if (!dummy) {
            dummy = new QSGD3D12Texture(node->renderContext()->engine());
            QImage img(128, 128, QImage::Format_ARGB32_Premultiplied);
            img.fill(0);
            dummy->create(img, QSGRenderContext::CreateTexture_Alpha);
        }
        tv.filter = QSGD3D12TextureView::FilterNearest;
        tv.addressModeHoriz = QSGD3D12TextureView::AddressWrap;
        tv.addressModeVert = QSGD3D12TextureView::AddressWrap;
        dummy->bind();
    }

    switch (cullMode) {
    case QSGShaderEffectNode::FrontFaceCulling:
        pipelineState->cullMode = QSGD3D12PipelineState::CullFront;
        break;
    case QSGShaderEffectNode::BackFaceCulling:
        pipelineState->cullMode = QSGD3D12PipelineState::CullBack;
        break;
    default:
        pipelineState->cullMode = QSGD3D12PipelineState::CullNone;
        break;
    }

    return r;
}

void QSGD3D12ShaderEffectMaterial::updateTextureProviders(bool layoutChange)
{
    if (layoutChange) {
        for (QSGTextureProvider *tp : textureProviders) {
            if (tp) {
                QObject::disconnect(tp, SIGNAL(textureChanged()), node,
                                    SLOT(handleTextureChange()));
                QObject::disconnect(tp, SIGNAL(destroyed(QObject*)), node,
                                    SLOT(handleTextureProviderDestroyed(QObject*)));
            }
        }

        textureProviders.fill(nullptr, linker.textures.count());
    }

    for (auto it = linker.textures.constBegin(), itEnd = linker.textures.constEnd(); it != itEnd; ++it) {
        const int bindPoint = it.key();
        // Now that the linker has merged the textures, we can switch over to a
        // simple vector indexed by the binding point for textureProviders.
        Q_ASSERT(bindPoint >= 0 && bindPoint < textureProviders.count());
        QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(it.value()));
        QSGTextureProvider *newProvider = source && source->isTextureProvider() ? source->textureProvider() : nullptr;
        QSGTextureProvider *&activeProvider(textureProviders[bindPoint]);
        if (newProvider != activeProvider) {
            if (activeProvider) {
                QObject::disconnect(activeProvider, SIGNAL(textureChanged()), node,
                                    SLOT(handleTextureChange()));
                QObject::disconnect(activeProvider, SIGNAL(destroyed(QObject*)), node,
                                    SLOT(handleTextureProviderDestroyed(QObject*)));
            }
            if (newProvider) {
                Q_ASSERT_X(newProvider->thread() == QThread::currentThread(),
                           "QSGD3D12ShaderEffectMaterial::updateTextureProviders",
                           "Texture provider must belong to the rendering thread");
                QObject::connect(newProvider, SIGNAL(textureChanged()), node, SLOT(handleTextureChange()));
                QObject::connect(newProvider, SIGNAL(destroyed(QObject*)), node,
                                 SLOT(handleTextureProviderDestroyed(QObject*)));
            } else {
                const char *typeName = source ? source->metaObject()->className() : it.value().typeName();
                qWarning("ShaderEffect: Texture t%d is not assigned a valid texture provider (%s).",
                         bindPoint, typeName);
            }
            activeProvider = newProvider;
        }
    }
}

QSGD3D12ShaderEffectNode::QSGD3D12ShaderEffectNode(QSGD3D12RenderContext *rc, QSGD3D12GuiThreadShaderEffectManager *mgr)
    : QSGShaderEffectNode(mgr),
      m_rc(rc),
      m_mgr(mgr),
      m_material(this)
{
    setFlag(UsePreprocess, true);
    setMaterial(&m_material);
}

QRectF QSGD3D12ShaderEffectNode::updateNormalizedTextureSubRect(bool supportsAtlasTextures)
{
    QRectF srcRect(0, 0, 1, 1);
    bool geometryUsesTextureSubRect = false;
    if (supportsAtlasTextures && m_material.textureProviders.count() == 1) {
        QSGTextureProvider *provider = m_material.textureProviders.at(0);
        if (provider->texture()) {
            srcRect = provider->texture()->normalizedTextureSubRect();
            geometryUsesTextureSubRect = true;
        }
    }

    if (m_material.geometryUsesTextureSubRect != geometryUsesTextureSubRect) {
        m_material.geometryUsesTextureSubRect = geometryUsesTextureSubRect;
        markDirty(QSGNode::DirtyMaterial);
    }

    return srcRect;
}

void QSGD3D12ShaderEffectNode::syncMaterial(SyncData *syncData)
{
    if (Q_UNLIKELY(debug_shader()))
        qDebug() << "shadereffect node sync" << syncData->dirty;

    if (bool(m_material.flags() & QSGMaterial::Blending) != syncData->blending) {
        m_material.setFlag(QSGMaterial::Blending, syncData->blending);
        markDirty(QSGNode::DirtyMaterial);
    }

    if (m_material.cullMode != syncData->cullMode) {
        m_material.cullMode = syncData->cullMode;
        markDirty(QSGNode::DirtyMaterial);
    }

    if (syncData->dirty & QSGShaderEffectNode::DirtyShaders) {
        QByteArray vertBlob, fragBlob;

        m_material.hasCustomVertexShader = syncData->vertex.shader->hasShaderCode;
        if (m_material.hasCustomVertexShader) {
            vertBlob = syncData->vertex.shader->shaderInfo.blob;
        } else {
            vertBlob = QByteArray::fromRawData(reinterpret_cast<const char *>(g_VS_DefaultShaderEffect),
                                               sizeof(g_VS_DefaultShaderEffect));
        }

        m_material.hasCustomFragmentShader = syncData->fragment.shader->hasShaderCode;
        if (m_material.hasCustomFragmentShader) {
            fragBlob = syncData->fragment.shader->shaderInfo.blob;
        } else {
            fragBlob = QByteArray::fromRawData(reinterpret_cast<const char *>(g_PS_DefaultShaderEffect),
                                               sizeof(g_PS_DefaultShaderEffect));
        }

        m_material.mtype = shaderMaterialTypeCache()->get(vertBlob, fragBlob);
        m_material.linker.reset(vertBlob, fragBlob);

        if (m_material.hasCustomVertexShader) {
            m_material.linker.feedConstants(*syncData->vertex.shader);
        } else {
            QSGShaderEffectNode::ShaderData defaultSD;
            defaultSD.shaderInfo.blob = vertBlob;
            defaultSD.shaderInfo.type = QSGGuiThreadShaderEffectManager::ShaderInfo::TypeVertex;

            // { float4x4 qt_Matrix; float qt_Opacity; } where only the matrix is used
            QSGGuiThreadShaderEffectManager::ShaderInfo::Variable v;
            v.name = QByteArrayLiteral("qt_Matrix");
            v.offset = 0;
            v.size = 16 * sizeof(float);
            defaultSD.shaderInfo.variables.append(v);
            QSGShaderEffectNode::VariableData vd;
            vd.specialType = QSGShaderEffectNode::VariableData::Matrix;
            defaultSD.varData.append(vd);
            defaultSD.shaderInfo.constantDataSize = (16 + 1) * sizeof(float);
            m_material.linker.feedConstants(defaultSD);
        }

        m_material.linker.feedSamplers(*syncData->vertex.shader);
        m_material.linker.feedTextures(*syncData->vertex.shader);

        if (m_material.hasCustomFragmentShader) {
            m_material.linker.feedConstants(*syncData->fragment.shader);
        } else {
            QSGShaderEffectNode::ShaderData defaultSD;
            defaultSD.shaderInfo.blob = fragBlob;
            defaultSD.shaderInfo.type = QSGGuiThreadShaderEffectManager::ShaderInfo::TypeFragment;

            // { float4x4 qt_Matrix; float qt_Opacity; } where only the opacity is used
            QSGGuiThreadShaderEffectManager::ShaderInfo::Variable v;
            v.name = QByteArrayLiteral("qt_Opacity");
            v.offset = 16 * sizeof(float);
            v.size = sizeof(float);
            defaultSD.shaderInfo.variables.append(v);
            QSGShaderEffectNode::VariableData vd;
            vd.specialType = QSGShaderEffectNode::VariableData::Opacity;
            defaultSD.varData.append(vd);

            v.name = QByteArrayLiteral("source");
            v.bindPoint = 0;
            v.type = QSGGuiThreadShaderEffectManager::ShaderInfo::Texture;
            defaultSD.shaderInfo.variables.append(v);
            vd.specialType = QSGShaderEffectNode::VariableData::Source;
            defaultSD.varData.append(vd);

            v.name = QByteArrayLiteral("sourceSampler");
            v.bindPoint = 0;
            v.type = QSGGuiThreadShaderEffectManager::ShaderInfo::Sampler;
            defaultSD.shaderInfo.variables.append(v);
            vd.specialType = QSGShaderEffectNode::VariableData::Unused;
            defaultSD.varData.append(vd);

            defaultSD.shaderInfo.constantDataSize = (16 + 1) * sizeof(float);

            m_material.linker.feedConstants(defaultSD);
            m_material.linker.feedSamplers(defaultSD);
            m_material.linker.feedTextures(defaultSD);
        }

        // While this may seem unnecessary for the built-in shaders, the value
        // of 'source' is still in there and we have to process it.
        m_material.linker.feedSamplers(*syncData->fragment.shader);
        m_material.linker.feedTextures(*syncData->fragment.shader);

        m_material.linker.linkTextureSubRects();

        m_material.updateTextureProviders(true);

        markDirty(QSGNode::DirtyMaterial);

        if (Q_UNLIKELY(debug_shader()))
            m_material.linker.dump();
    } else  {
        if (syncData->dirty & QSGShaderEffectNode::DirtyShaderConstant) {
            if (!syncData->vertex.dirtyConstants->isEmpty())
                m_material.linker.feedConstants(*syncData->vertex.shader, syncData->vertex.dirtyConstants);
            if (!syncData->fragment.dirtyConstants->isEmpty())
                m_material.linker.feedConstants(*syncData->fragment.shader, syncData->fragment.dirtyConstants);
            markDirty(QSGNode::DirtyMaterial);
            if (Q_UNLIKELY(debug_shader()))
                m_material.linker.dump();
        }

        if (syncData->dirty & QSGShaderEffectNode::DirtyShaderTexture) {
            if (!syncData->vertex.dirtyTextures->isEmpty())
                m_material.linker.feedTextures(*syncData->vertex.shader, syncData->vertex.dirtyTextures);
            if (!syncData->fragment.dirtyTextures->isEmpty())
                m_material.linker.feedTextures(*syncData->fragment.shader, syncData->fragment.dirtyTextures);
            m_material.linker.linkTextureSubRects();
            m_material.updateTextureProviders(false);
            markDirty(QSGNode::DirtyMaterial);
            if (Q_UNLIKELY(debug_shader()))
                m_material.linker.dump();
        }
    }

    if (bool(m_material.flags() & QSGMaterial::RequiresFullMatrix) != m_material.hasCustomVertexShader) {
        m_material.setFlag(QSGMaterial::RequiresFullMatrix, m_material.hasCustomVertexShader);
        markDirty(QSGNode::DirtyMaterial);
    }
}

void QSGD3D12ShaderEffectNode::handleTextureChange()
{
    markDirty(QSGNode::DirtyMaterial);
    emit m_mgr->textureChanged();
}

void QSGD3D12ShaderEffectNode::handleTextureProviderDestroyed(QObject *object)
{
    for (QSGTextureProvider *&tp : m_material.textureProviders) {
        if (tp == object)
            tp = nullptr;
    }
}

void QSGD3D12ShaderEffectNode::preprocess()
{
    for (QSGTextureProvider *tp : m_material.textureProviders) {
        if (tp) {
            if (QSGDynamicTexture *texture = qobject_cast<QSGDynamicTexture *>(tp->texture()))
                texture->updateTexture();
        }
    }
}

bool QSGD3D12GuiThreadShaderEffectManager::hasSeparateSamplerAndTextureObjects() const
{
    return true;
}

QString QSGD3D12GuiThreadShaderEffectManager::log() const
{
    return m_log;
}

QSGGuiThreadShaderEffectManager::Status QSGD3D12GuiThreadShaderEffectManager::status() const
{
    return m_status;
}

struct RefGuard {
    RefGuard(IUnknown *p) : p(p) { }
    ~RefGuard() { p->Release(); }
    IUnknown *p;
};

class QSGD3D12ShaderCompileTask : public QRunnable
{
public:
    QSGD3D12ShaderCompileTask(QSGD3D12GuiThreadShaderEffectManager *mgr,
                              QSGD3D12GuiThreadShaderEffectManager::ShaderInfo::Type typeHint,
                              const QByteArray &src,
                              QSGD3D12GuiThreadShaderEffectManager::ShaderInfo *result)
        : mgr(mgr), typeHint(typeHint), src(src), result(result) { }

    void run() override;

private:
    QSGD3D12GuiThreadShaderEffectManager *mgr;
    QSGD3D12GuiThreadShaderEffectManager::ShaderInfo::Type typeHint;
    QByteArray src;
    QSGD3D12GuiThreadShaderEffectManager::ShaderInfo *result;
};

void QSGD3D12ShaderCompileTask::run()
{
    const char *target = typeHint == QSGD3D12GuiThreadShaderEffectManager::ShaderInfo::TypeVertex ? "vs_5_0" : "ps_5_0";
    ID3DBlob *bytecode = nullptr;
    ID3DBlob *errors = nullptr;
    HRESULT hr = D3DCompile(src.constData(), src.size(), nullptr, nullptr, nullptr,
                            "main", target, 0, 0, &bytecode, &errors);
    if (FAILED(hr) || !bytecode) {
        qWarning("HLSL shader compilation failed: 0x%x", hr);
        if (errors) {
            mgr->m_log += QString::fromUtf8(static_cast<const char *>(errors->GetBufferPointer()), errors->GetBufferSize());
            errors->Release();
        }
        mgr->m_status = QSGGuiThreadShaderEffectManager::Error;
        emit mgr->shaderCodePrepared(false, typeHint, src, result);
        emit mgr->logAndStatusChanged();
        return;
    }

    result->blob.resize(bytecode->GetBufferSize());
    memcpy(result->blob.data(), bytecode->GetBufferPointer(), result->blob.size());
    bytecode->Release();

    const bool ok = mgr->reflect(result);
    mgr->m_status = ok ? QSGGuiThreadShaderEffectManager::Compiled : QSGGuiThreadShaderEffectManager::Error;
    emit mgr->shaderCodePrepared(ok, typeHint, src, result);
    emit mgr->logAndStatusChanged();
}

static const int BYTECODE_MAGIC = 0x43425844; // 'DXBC'

void QSGD3D12GuiThreadShaderEffectManager::prepareShaderCode(ShaderInfo::Type typeHint, const QByteArray &src, ShaderInfo *result)
{
    // The D3D12 backend's ShaderEffect implementation supports both HLSL
    // source strings and bytecode or source in files as input. Bytecode is
    // strongly recommended, but in order to make ShaderEffect users' (and
    // anything that stiches shader strings together dynamically, e.g.
    // qtgraphicaleffects) life easier, and since we link to d3dcompiler
    // anyways, compiling from source is also supported.

    QByteArray shaderSourceCode = src;
    QUrl srcUrl(QString::fromUtf8(src));
    if (!srcUrl.scheme().compare(QLatin1String("qrc"), Qt::CaseInsensitive) || srcUrl.isLocalFile()) {
        if (!m_fileSelector) {
            m_fileSelector = new QFileSelector(this);
            m_fileSelector->setExtraSelectors(QStringList() << QStringLiteral("hlsl"));
        }
        const QString fn = m_fileSelector->select(QQmlFile::urlToLocalFileOrQrc(srcUrl));
        QFile f(fn);
        if (!f.open(QIODevice::ReadOnly)) {
            qWarning("ShaderEffect: Failed to read %s", qPrintable(fn));
            emit shaderCodePrepared(false, typeHint, src, result);
            return;
        }
        QByteArray blob = f.readAll();
        f.close();
        if (blob.size() > 4) {
            const quint32 *p = reinterpret_cast<const quint32 *>(blob.constData());
            if (*p == BYTECODE_MAGIC) {
                // already compiled D3D bytecode, skip straight to reflection
                result->blob = blob;
                const bool ok = reflect(result);
                m_status = ok ? Compiled : Error;
                emit shaderCodePrepared(ok, typeHint, src, result);
                emit logAndStatusChanged();
                return;
            }
            // assume the file contained HLSL source code
            shaderSourceCode = blob;
        }
    }

    QThreadPool::globalInstance()->start(new QSGD3D12ShaderCompileTask(this, typeHint, shaderSourceCode, result));
}

bool QSGD3D12GuiThreadShaderEffectManager::reflect(ShaderInfo *result)
{
    ID3D12ShaderReflection *reflector;
    HRESULT hr = D3DReflect(result->blob.constData(), result->blob.size(), IID_PPV_ARGS(&reflector));
    if (FAILED(hr)) {
        qWarning("D3D shader reflection failed: 0x%x", hr);
        return false;
    }
    RefGuard rg(reflector);

    D3D12_SHADER_DESC shaderDesc;
    reflector->GetDesc(&shaderDesc);

    const uint progType = (shaderDesc.Version & 0xFFFF0000) >> 16;
    const uint major = (shaderDesc.Version & 0x000000F0) >> 4;
    const uint minor = (shaderDesc.Version & 0x0000000F);

    switch (progType) {
    case D3D12_SHVER_VERTEX_SHADER:
        result->type = ShaderInfo::TypeVertex;
        break;
    case D3D12_SHVER_PIXEL_SHADER:
        result->type = ShaderInfo::TypeFragment;
        break;
    default:
        result->type = ShaderInfo::TypeOther;
        qWarning("D3D shader is of unknown type 0x%x", shaderDesc.Version);
        return false;
    }

    if (major < 5) {
        qWarning("D3D shader model version %u.%u is too low", major, minor);
        return false;
    }

    const int ieCount = shaderDesc.InputParameters;
    const int cbufferCount = shaderDesc.ConstantBuffers;
    const int boundResCount = shaderDesc.BoundResources;

    result->constantDataSize = 0;

    if (ieCount < 1) {
        qWarning("Invalid shader: Not enough input parameters (%d)", ieCount);
        return false;
    }
    if (cbufferCount < 1) {
        qWarning("Invalid shader: Shader has no constant buffers");
        return false;
    }
    if (boundResCount < 1) {
        qWarning("Invalid shader: No resources bound. Expected to have at least a constant buffer bound.");
        return false;
    }

    if (Q_UNLIKELY(debug_shader()))
        qDebug("Shader reflection size %d type %d v%u.%u input elems %d cbuffers %d boundres %d",
               result->blob.size(), result->type, major, minor, ieCount, cbufferCount, boundResCount);

    for (int i = 0; i < boundResCount; ++i) {
        D3D12_SHADER_INPUT_BIND_DESC desc;
        if (FAILED(reflector->GetResourceBindingDesc(i, &desc))) {
            qWarning("D3D reflection: Failed to query resource binding %d", i);
            continue;
        }
        bool gotCBuffer = false;
        if (desc.Type == D3D_SIT_CBUFFER) {
            ID3D12ShaderReflectionConstantBuffer *cbuf = reflector->GetConstantBufferByName(desc.Name);
            D3D12_SHADER_BUFFER_DESC bufDesc;
            if (FAILED(cbuf->GetDesc(&bufDesc))) {
                qWarning("D3D reflection: Failed to query constant buffer description");
                continue;
            }
            if (gotCBuffer) {
                qWarning("D3D reflection: Found more than one constant buffers. Only the first one is used.");
                continue;
            }
            gotCBuffer = true;
            result->constantDataSize = bufDesc.Size;
            for (uint cbIdx = 0; cbIdx < bufDesc.Variables; ++cbIdx) {
                ID3D12ShaderReflectionVariable *cvar = cbuf->GetVariableByIndex(cbIdx);
                D3D12_SHADER_VARIABLE_DESC varDesc;
                if (FAILED(cvar->GetDesc(&varDesc))) {
                    qWarning("D3D reflection: Failed to query constant buffer variable %d", cbIdx);
                    return false;
                }
                // we report the full size of the buffer but only return variables that are actually used by this shader
                if (!(varDesc.uFlags & D3D_SVF_USED))
                    continue;
                ShaderInfo::Variable v;
                v.type = ShaderInfo::Constant;
                v.name = QByteArray(varDesc.Name);
                v.offset = varDesc.StartOffset;
                v.size = varDesc.Size;
                result->variables.append(v);
            }
        } else if (desc.Type == D3D_SIT_TEXTURE) {
            if (desc.Dimension != D3D_SRV_DIMENSION_TEXTURE2D) {
                qWarning("D3D reflection: Texture %s is not a 2D texture, ignoring.", qPrintable(desc.Name));
                continue;
            }
            if (desc.NumSamples != (UINT) -1) {
                qWarning("D3D reflection: Texture %s is multisample (%u), ignoring.", qPrintable(desc.Name), desc.NumSamples);
                continue;
            }
            if (desc.BindCount != 1) {
                qWarning("D3D reflection: Texture %s is an array, ignoring.", qPrintable(desc.Name));
                continue;
            }
            if (desc.Space != 0) {
                qWarning("D3D reflection: Texture %s is not using register space 0, ignoring.", qPrintable(desc.Name));
                continue;
            }
            ShaderInfo::Variable v;
            v.type = ShaderInfo::Texture;
            v.name = QByteArray(desc.Name);
            v.bindPoint = desc.BindPoint;
            result->variables.append(v);
        } else if (desc.Type == D3D_SIT_SAMPLER) {
            if (desc.BindCount != 1) {
                qWarning("D3D reflection: Sampler %s is an array, ignoring.", qPrintable(desc.Name));
                continue;
            }
            if (desc.Space != 0) {
                qWarning("D3D reflection: Sampler %s is not using register space 0, ignoring.", qPrintable(desc.Name));
                continue;
            }
            ShaderInfo::Variable v;
            v.type = ShaderInfo::Sampler;
            v.name = QByteArray(desc.Name);
            v.bindPoint = desc.BindPoint;
            result->variables.append(v);
        } else {
            qWarning("D3D reflection: Resource binding %d has an unknown type of %d and will be ignored.", i, desc.Type);
            continue;
        }
    }

    if (Q_UNLIKELY(debug_shader()))
        qDebug() << "Variables:" << result->variables << "cbuffer size" << result->constantDataSize;

    return true;
}

QT_END_NAMESPACE