Revision control
Copy as Markdown
// Copyright (C) 2023 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
// Qt-Security score:significant reason:default
#include "qsgcurvefillnode_p_p.h"
#include "qsgcurvefillnode_p.h"
#include "util/qsggradientcache_p.h"
#include <private/qsgtexture_p.h>
#include <private/qsgplaintexture_p.h>
QT_BEGIN_NAMESPACE
namespace {
class QSGCurveFillMaterialShader : public QSGMaterialShader
{
public:
QSGCurveFillMaterialShader(QGradient::Type gradientType,
bool useTextureFill,
bool useDerivatives,
int viewCount);
bool updateUniformData(RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect) override;
void updateSampledImage(RenderState &state, int binding, QSGTexture **texture,
QSGMaterial *newMaterial, QSGMaterial *oldMaterial) override;
};
QSGCurveFillMaterialShader::QSGCurveFillMaterialShader(QGradient::Type gradientType,
bool useTextureFill,
bool useDerivatives,
int viewCount)
{
QString baseName = QStringLiteral(":/qt-project.org/scenegraph/shaders_ng/shapecurve");
if (gradientType == QGradient::LinearGradient) {
baseName += QStringLiteral("_lg");
} else if (gradientType == QGradient::RadialGradient) {
baseName += QStringLiteral("_rg");
} else if (gradientType == QGradient::ConicalGradient) {
baseName += QStringLiteral("_cg");
} else if (useTextureFill) {
baseName += QStringLiteral("_tf");
}
if (useDerivatives)
baseName += QStringLiteral("_derivatives");
setShaderFileName(VertexStage, baseName + QStringLiteral(".vert.qsb"), viewCount);
setShaderFileName(FragmentStage, baseName + QStringLiteral(".frag.qsb"), viewCount);
}
void QSGCurveFillMaterialShader::updateSampledImage(RenderState &state, int binding, QSGTexture **texture,
QSGMaterial *newMaterial, QSGMaterial *oldMaterial)
{
Q_UNUSED(oldMaterial);
QSGCurveFillMaterial *m = static_cast<QSGCurveFillMaterial *>(newMaterial);
const QSGCurveFillNode *node = m->node();
if (binding != 1
|| (node->gradientType() == QGradient::NoGradient && node->fillTextureProvider() == nullptr)) {
return;
}
QSGTexture *t = nullptr;
if (node->gradientType() != QGradient::NoGradient) {
const QSGGradientCacheKey cacheKey(node->fillGradient()->stops,
node->fillGradient()->spread);
t = QSGGradientCache::cacheForRhi(state.rhi())->get(cacheKey);
} else if (node->fillTextureProvider() != nullptr) {
t = node->fillTextureProvider()->texture();
if (t != nullptr && t->isAtlasTexture()) {
// Create a non-atlas copy to make texture coordinate wrapping work. This
// texture copy is owned by the QSGTexture so memory is managed with the original
// texture provider.
QSGTexture *newTexture = t->removedFromAtlas(state.resourceUpdateBatch());
if (newTexture != nullptr)
t = newTexture;
}
}
if (t != nullptr) {
t->commitTextureOperations(state.rhi(), state.resourceUpdateBatch());
} else {
if (m->dummyTexture() == nullptr) {
QSGPlainTexture *dummyTexture = new QSGPlainTexture;
dummyTexture->setFiltering(QSGTexture::Nearest);
dummyTexture->setHorizontalWrapMode(QSGTexture::Repeat);
dummyTexture->setVerticalWrapMode(QSGTexture::Repeat);
QImage img(128, 128, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
dummyTexture->setImage(img);
dummyTexture->commitTextureOperations(state.rhi(), state.resourceUpdateBatch());
m->setDummyTexture(dummyTexture);
}
t = m->dummyTexture();
}
*texture = t;
}
bool QSGCurveFillMaterialShader::updateUniformData(RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
{
bool changed = false;
QByteArray *buf = state.uniformData();
Q_ASSERT(buf->size() >= 80);
const int matrixCount = qMin(state.projectionMatrixCount(), newEffect->viewCount());
int offset = 0;
float matrixScale = 0.0f;
if (state.isMatrixDirty()) {
for (int viewIndex = 0; viewIndex < matrixCount; ++viewIndex) {
const QMatrix4x4 m = state.combinedMatrix(viewIndex);
memcpy(buf->data() + offset + viewIndex * 64, m.constData(), 64);
}
matrixScale = qSqrt(qAbs(state.determinant())) * state.devicePixelRatio();
memcpy(buf->data() + offset + newEffect->viewCount() * 64, &matrixScale, 4);
changed = true;
}
offset += newEffect->viewCount() * 64 + 4;
if (state.isOpacityDirty()) {
const float opacity = state.opacity();
memcpy(buf->data() + offset, &opacity, 4);
changed = true;
}
offset += 4;
QSGCurveFillMaterial *newMaterial = static_cast<QSGCurveFillMaterial *>(newEffect);
QSGCurveFillMaterial *oldMaterial = static_cast<QSGCurveFillMaterial *>(oldEffect);
QSGCurveFillNode *newNode = newMaterial != nullptr ? newMaterial->node() : nullptr;
QSGCurveFillNode *oldNode = oldMaterial != nullptr ? oldMaterial->node() : nullptr;
if (newNode == nullptr)
return changed;
if (oldNode == nullptr || oldNode->debug() != newNode->debug()) {
float debug = newNode->debug();
memcpy(buf->data() + offset, &debug, 4);
changed = true;
}
offset += 8;
if (newNode->gradientType() == QGradient::NoGradient
&& newNode->fillTextureProvider() == nullptr) {
Q_ASSERT(buf->size() >= offset + 16);
QVector4D newColor = QVector4D(newNode->color().redF(),
newNode->color().greenF(),
newNode->color().blueF(),
newNode->color().alphaF());
QVector4D oldColor = oldNode != nullptr
? QVector4D(oldNode->color().redF(),
oldNode->color().greenF(),
oldNode->color().blueF(),
oldNode->color().alphaF())
: QVector4D{};
if (oldNode == nullptr || oldColor != newColor) {
memcpy(buf->data() + offset, &newColor, 16);
changed = true;
}
offset += 16;
} else {
Q_ASSERT(buf->size() >= offset + 64);
if (!oldNode || *oldNode->fillTransform() != *newNode->fillTransform()) {
memcpy(buf->data() + offset, newNode->fillTransform()->invertedData(), 64);
changed = true;
}
offset += 64;
}
if (newNode->gradientType() == QGradient::NoGradient
&& newNode->fillTextureProvider() != nullptr) {
Q_ASSERT(buf->size() >= offset + 8);
const QSizeF newTextureSize = newNode->fillTextureProvider()->texture() != nullptr
? newNode->fillTextureProvider()->texture()->textureSize()
: QSizeF(0, 0);
const QVector2D newBoundsSize(newTextureSize.width() / state.devicePixelRatio(),
newTextureSize.height() / state.devicePixelRatio());
const QVector2D oldBoundsSize = oldNode != nullptr
? oldNode->boundsSize()
: QVector2D{};
if (oldEffect == nullptr || newBoundsSize != oldBoundsSize) {
newNode->setBoundsSize(newBoundsSize);
memcpy(buf->data() + offset, &newBoundsSize, 8);
changed = true;
}
offset += 8;
} else if (newNode->gradientType() == QGradient::LinearGradient) {
Q_ASSERT(buf->size() >= offset + 8 + 8);
QVector2D newGradientStart = QVector2D(newNode->fillGradient()->a);
QVector2D oldGradientStart = oldNode != nullptr
? QVector2D(oldNode->fillGradient()->a)
: QVector2D{};
if (newGradientStart != oldGradientStart || oldEffect == nullptr) {
memcpy(buf->data() + offset, &newGradientStart, 8);
changed = true;
}
offset += 8;
QVector2D newGradientEnd = QVector2D(newNode->fillGradient()->b);
QVector2D oldGradientEnd = oldNode!= nullptr
? QVector2D(oldNode->fillGradient()->b)
: QVector2D{};
if (newGradientEnd != oldGradientEnd || oldEffect == nullptr) {
memcpy(buf->data() + offset, &newGradientEnd, 8);
changed = true;
}
offset += 8;
} else if (newNode->gradientType() == QGradient::RadialGradient) {
Q_ASSERT(buf->size() >= offset + 8 + 8 + 4 + 4);
QVector2D newFocalPoint = QVector2D(newNode->fillGradient()->b);
QVector2D oldFocalPoint = oldNode != nullptr
? QVector2D(oldNode->fillGradient()->b)
: QVector2D{};
if (oldNode == nullptr || newFocalPoint != oldFocalPoint) {
memcpy(buf->data() + offset, &newFocalPoint, 8);
changed = true;
}
offset += 8;
QVector2D newCenterPoint = QVector2D(newNode->fillGradient()->a);
QVector2D oldCenterPoint = oldNode != nullptr
? QVector2D(oldNode->fillGradient()->a)
: QVector2D{};
QVector2D newCenterToFocal = newCenterPoint - newFocalPoint;
QVector2D oldCenterToFocal = oldCenterPoint - oldFocalPoint;
if (oldNode == nullptr || newCenterToFocal != oldCenterToFocal) {
memcpy(buf->data() + offset, &newCenterToFocal, 8);
changed = true;
}
offset += 8;
float newCenterRadius = newNode->fillGradient()->v0;
float oldCenterRadius = oldNode != nullptr
? oldNode->fillGradient()->v0
: 0.0f;
if (oldNode == nullptr || !qFuzzyCompare(newCenterRadius, oldCenterRadius)) {
memcpy(buf->data() + offset, &newCenterRadius, 4);
changed = true;
}
offset += 4;
float newFocalRadius = newNode->fillGradient()->v1;
float oldFocalRadius = oldNode != nullptr
? oldNode->fillGradient()->v1
: 0.0f;
if (oldNode == nullptr || !qFuzzyCompare(newFocalRadius, oldFocalRadius)) {
memcpy(buf->data() + offset, &newFocalRadius, 4);
changed = true;
}
offset += 4;
} else if (newNode->gradientType() == QGradient::ConicalGradient) {
Q_ASSERT(buf->size() >= offset + 8 + 4);
QVector2D newFocalPoint = QVector2D(newNode->fillGradient()->a);
QVector2D oldFocalPoint = oldNode != nullptr
? QVector2D(oldNode->fillGradient()->a)
: QVector2D{};
if (oldNode == nullptr || newFocalPoint != oldFocalPoint) {
memcpy(buf->data() + offset, &newFocalPoint, 8);
changed = true;
}
offset += 8;
float newAngle = newNode->fillGradient()->v0;
float oldAngle = oldNode != nullptr
? oldNode->fillGradient()->v0
: 0.0f;
if (oldNode == nullptr || !qFuzzyCompare(newAngle, oldAngle)) {
newAngle = -qDegreesToRadians(newAngle);
memcpy(buf->data() + offset, &newAngle, 4);
changed = true;
}
offset += 4;
}
return changed;
}
}
QSGCurveFillMaterial::QSGCurveFillMaterial(QSGCurveFillNode *node)
: m_node(node)
{
setFlag(Blending, true);
setFlag(RequiresDeterminant, true);
}
QSGCurveFillMaterial::~QSGCurveFillMaterial()
{
delete m_dummyTexture;
}
int QSGCurveFillMaterial::compare(const QSGMaterial *other) const
{
if (other->type() != type())
return (type() - other->type());
const QSGCurveFillMaterial *otherMaterial =
static_cast<const QSGCurveFillMaterial *>(other);
QSGCurveFillNode *a = node();
QSGCurveFillNode *b = otherMaterial->node();
if (a == b)
return 0;
if (a->gradientType() == QGradient::NoGradient && a->fillTextureProvider() == nullptr) {
if (int d = a->color().red() - b->color().red())
return d;
if (int d = a->color().green() - b->color().green())
return d;
if (int d = a->color().blue() - b->color().blue())
return d;
if (int d = a->color().alpha() - b->color().alpha())
return d;
} else {
if (a->gradientType() != QGradient::NoGradient) {
const QSGGradientCache::GradientDesc &ga = *a->fillGradient();
const QSGGradientCache::GradientDesc &gb = *b->fillGradient();
if (int d = ga.compare(gb))
return d;
}
if (int d = a->fillTransform()->compareTo(*b->fillTransform()))
return d;
}
const qintptr diff = qintptr(a->fillTextureProvider()) - qintptr(b->fillTextureProvider());
return diff < 0 ? -1 : (diff > 0 ? 1 : 0);
}
QSGMaterialType *QSGCurveFillMaterial::type() const
{
static QSGMaterialType type[5];
uint index = node()->gradientType();
Q_ASSERT((index & ~3) == 0); // Only two first bits for gradient type
if (node()->gradientType() == QGradient::NoGradient && node()->fillTextureProvider() != nullptr)
index = 4;
return &type[index];
}
QSGMaterialShader *QSGCurveFillMaterial::createShader(QSGRendererInterface::RenderMode renderMode) const
{
Q_UNUSED(renderMode);
return new QSGCurveFillMaterialShader(node()->gradientType(),
node()->gradientType() == QGradient::NoGradient
&& node()->fillTextureProvider() != nullptr,
node()->useStandardDerivatives(),
viewCount());
}
QT_END_NAMESPACE