Source code
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 "qsgcurvestrokenode_p_p.h"
#include "qsgcurvestrokenode_p.h"
#include <private/qsgtexture_p.h>
QT_BEGIN_NAMESPACE
void QSGCurveStrokeMaterialShader::updateSampledImage(RenderState &state, int binding, QSGTexture **texture,
QSGMaterial *newMaterial, QSGMaterial *oldMaterial)
{
Q_UNUSED(oldMaterial);
QSGCurveStrokeMaterial *m = static_cast<QSGCurveStrokeMaterial *>(newMaterial);
const QSGCurveStrokeNode *node = m->node();
if (binding != 1 || node->gradientType() == QGradient::NoGradient)
return;
if (node->gradientType() != QGradient::NoGradient) {
const QSGGradientCacheKey cacheKey(node->strokeGradient()->stops,
node->strokeGradient()->spread);
QSGTexture *t = QSGGradientCache::cacheForRhi(state.rhi())->get(cacheKey);
t->commitTextureOperations(state.rhi(), state.resourceUpdateBatch());
*texture = t;
}
}
bool QSGCurveStrokeMaterialShader::updateUniformData(RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
{
bool changed = false;
QByteArray *buf = state.uniformData();
Q_ASSERT(buf->size() >= 64);
const int matrixCount = qMin(state.projectionMatrixCount(), newEffect->viewCount());
auto *newMaterial = static_cast<QSGCurveStrokeMaterial *>(newEffect);
auto *oldMaterial = static_cast<QSGCurveStrokeMaterial *>(oldEffect);
auto *newNode = newMaterial != nullptr ? newMaterial->node() : nullptr;
auto *oldNode = oldMaterial != nullptr ? oldMaterial->node() : nullptr;
if (state.isMatrixDirty()) {
float localScale = newNode != nullptr ? newNode->localScale() : 1.0f;
for (int viewIndex = 0; viewIndex < matrixCount; ++viewIndex) {
QMatrix4x4 m = state.combinedMatrix(viewIndex);
m.scale(localScale);
memcpy(buf->data() + viewIndex * 64, m.constData(), 64);
}
// determinant is xscale * yscale, as long as Item.transform does not include shearing or rotation
float matrixScale = qSqrt(qAbs(state.determinant())) * state.devicePixelRatio() * localScale;
memcpy(buf->data() + matrixCount * 64, &matrixScale, 4);
float dpr = state.devicePixelRatio();
memcpy(buf->data() + matrixCount * 64 + 8, &dpr, 4);
changed = true;
}
if (state.isOpacityDirty()) {
const float opacity = state.opacity();
memcpy(buf->data() + matrixCount * 64 + 4, &opacity, 4);
changed = true;
}
if (oldNode == nullptr || newNode->strokeWidth() != oldNode->strokeWidth()) {
float w = newNode->strokeWidth();
memcpy(buf->data() + matrixCount * 64 + 12, &w, 4);
changed = true;
}
int offset = matrixCount * 64 + 16;
if (newNode == nullptr)
return changed;
if (newNode->gradientType() == QGradient::NoGradient) {
QVector4D newStrokeColor(newNode->color().redF(),
newNode->color().greenF(),
newNode->color().blueF(),
newNode->color().alphaF());
QVector4D oldStrokeColor = oldNode != nullptr
? QVector4D(oldNode->color().redF(),
oldNode->color().greenF(),
oldNode->color().blueF(),
oldNode->color().alphaF())
: QVector4D{};
if (oldNode == nullptr || oldStrokeColor != newStrokeColor) {
memcpy(buf->data() + offset, &newStrokeColor, 16);
changed = true;
}
offset += 16;
} else if (newNode->gradientType() == QGradient::LinearGradient) {
Q_ASSERT(buf->size() >= offset + 8 + 8);
QVector2D newGradientStart = QVector2D(newNode->strokeGradient()->a);
QVector2D oldGradientStart = oldNode != nullptr
? QVector2D(oldNode->strokeGradient()->a)
: QVector2D{};
if (newGradientStart != oldGradientStart || oldEffect == nullptr) {
memcpy(buf->data() + offset, &newGradientStart, 8);
changed = true;
}
offset += 8;
QVector2D newGradientEnd = QVector2D(newNode->strokeGradient()->b);
QVector2D oldGradientEnd = oldNode!= nullptr
? QVector2D(oldNode->strokeGradient()->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 + 4);
QVector2D newFocalPoint = QVector2D(newNode->strokeGradient()->b);
QVector2D oldFocalPoint = oldNode != nullptr
? QVector2D(oldNode->strokeGradient()->b)
: QVector2D{};
if (oldNode == nullptr || newFocalPoint != oldFocalPoint) {
memcpy(buf->data() + offset, &newFocalPoint, 8);
changed = true;
}
offset += 8;
QVector2D newCenterPoint = QVector2D(newNode->strokeGradient()->a);
QVector2D oldCenterPoint = oldNode != nullptr
? QVector2D(oldNode->strokeGradient()->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->strokeGradient()->v0;
float oldCenterRadius = oldNode != nullptr
? oldNode->strokeGradient()->v0
: 0.0f;
if (oldNode == nullptr || !qFuzzyCompare(newCenterRadius, oldCenterRadius)) {
memcpy(buf->data() + offset, &newCenterRadius, 4);
changed = true;
}
offset += 4;
float newFocalRadius = newNode->strokeGradient()->v1;
float oldFocalRadius = oldNode != nullptr
? oldNode->strokeGradient()->v1
: 0.0f;
if (oldNode == nullptr || !qFuzzyCompare(newFocalRadius, oldFocalRadius)) {
memcpy(buf->data() + offset, &newFocalRadius, 4);
changed = true;
}
offset += 4;
// reserved
offset += 8;
} else if (newNode->gradientType() == QGradient::ConicalGradient) {
Q_ASSERT(buf->size() >= offset + 8 + 4 + 4);
QVector2D newFocalPoint = QVector2D(newNode->strokeGradient()->a);
QVector2D oldFocalPoint = oldNode != nullptr
? QVector2D(oldNode->strokeGradient()->a)
: QVector2D{};
if (oldNode == nullptr || newFocalPoint != oldFocalPoint) {
memcpy(buf->data() + offset, &newFocalPoint, 8);
changed = true;
}
offset += 8;
float newAngle = newNode->strokeGradient()->v0;
float oldAngle = oldNode != nullptr
? oldNode->strokeGradient()->v0
: 0.0f;
if (oldNode == nullptr || !qFuzzyCompare(newAngle, oldAngle)) {
newAngle = -qDegreesToRadians(newAngle);
memcpy(buf->data() + offset, &newAngle, 4);
changed = true;
}
offset += 4;
// Reserved
offset += 4;
}
if (oldNode == nullptr || newNode->debug() != oldNode->debug()) {
float w = newNode->debug();
memcpy(buf->data() + offset, &w, 4);
changed = true;
}
return changed;
}
QSGMaterialType *QSGCurveStrokeMaterial::type() const
{
static QSGMaterialType types[8];
uint type = node()->gradientType();
Q_ASSERT((type & ~3) == 0); // Only two first bits for gradient type
uchar expanding = m_strokeExpanding ? 1 : 0;
uint index = (type << 1) | expanding;
Q_ASSERT(index < 8);
return &types[index];
}
int QSGCurveStrokeMaterial::compare(const QSGMaterial *other) const
{
const QSGCurveStrokeMaterial *otherMaterial = static_cast<const QSGCurveStrokeMaterial *>(other);
QSGCurveStrokeNode *a = node();
QSGCurveStrokeNode *b = otherMaterial->node();
if (a == b)
return 0;
int typeDif = type() - other->type();
if (!typeDif) {
if (a->gradientType() == QGradient::NoGradient && a->color() != b->color())
return a->color().rgb() < b->color().rgb() ? -1 : 1;
if (a->gradientType() != QGradient::NoGradient) {
const QSGGradientCache::GradientDesc &ga = *a->strokeGradient();
const QSGGradientCache::GradientDesc &gb = *b->strokeGradient();
if (int d = ga.compare(gb))
return d;
}
if (a->strokeWidth() != b->strokeWidth())
return a->strokeWidth() < b->strokeWidth() ? -1 : 1;
}
return typeDif;
}
QSGMaterialShader *QSGCurveStrokeMaterial::createShader(QSGRendererInterface::RenderMode renderMode) const
{
Q_UNUSED(renderMode);
int variant = int(QSGCurveStrokeMaterialShader::Variant::Default);
if (m_strokeExpanding)
variant |= int(QSGCurveStrokeMaterialShader::Variant::Expanding);
if (node()->useStandardDerivatives())
variant |= int(QSGCurveStrokeMaterialShader::Variant::Derivatives);
switch (node()->gradientType()) {
case QGradient::LinearGradient:
variant |= int(QSGCurveStrokeMaterialShader::Variant::LinearGradient);
break;
case QGradient::RadialGradient:
variant |= int(QSGCurveStrokeMaterialShader::Variant::RadialGradient);
break;
case QGradient::ConicalGradient:
variant |= int(QSGCurveStrokeMaterialShader::Variant::ConicalGradient);
break;
default:
break;
}
return new QSGCurveStrokeMaterialShader(variant, viewCount());
}
QT_END_NAMESPACE