QSkinny 0.8.0
C++/Qt UI toolkit
Loading...
Searching...
No Matches
QskBoxShadowNode.cpp
1/******************************************************************************
2 * QSkinny - Copyright (C) The authors
3 * SPDX-License-Identifier: BSD-3-Clause
4 *****************************************************************************/
5
6#include "QskBoxShadowNode.h"
7#include "QskBoxShapeMetrics.h"
8#include "QskInternalMacros.h"
9
10#include <qcolor.h>
11#include <qsgmaterialshader.h>
12#include <qsgmaterial.h>
13
14QSK_QT_PRIVATE_BEGIN
15#include <private/qsgnode_p.h>
16QSK_QT_PRIVATE_END
17
18// QSGMaterialRhiShader became QSGMaterialShader in Qt6
19
20#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
21 #include <QSGMaterialRhiShader>
22 using RhiShader = QSGMaterialRhiShader;
23#else
24 using RhiShader = QSGMaterialShader;
25#endif
26
27namespace
28{
29 class Material final : public QSGMaterial
30 {
31 public:
32 Material();
33
34#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
35 QSGMaterialShader* createShader() const override;
36#else
37 QSGMaterialShader* createShader( QSGRendererInterface::RenderMode ) const override;
38#endif
39
40 QSGMaterialType* type() const override;
41
42 int compare( const QSGMaterial* other ) const override;
43
44 QVector2D m_aspectRatio = QVector2D{ 1, 1 };
45 QVector4D m_radius = QVector4D{ 0, 0, 0, 0 };
46 QVector4D m_color = QVector4D{ 0, 0, 0, 1 };
47 float m_blurExtent = 0.0;
48 };
49}
50
51namespace
52{
53 class ShaderRhi final : public RhiShader
54 {
55 public:
56 ShaderRhi()
57 {
58 const QString root( ":/qskinny/shaders/" );
59
60 setShaderFileName( VertexStage, root + "boxshadow.vert.qsb" );
61 setShaderFileName( FragmentStage, root + "boxshadow.frag.qsb" );
62 }
63
64 bool updateUniformData( RenderState& state,
65 QSGMaterial* newMaterial, QSGMaterial* oldMaterial ) override
66 {
67 const auto matOld = static_cast< Material* >( oldMaterial );
68 const auto matNew = static_cast< Material* >( newMaterial );
69
70 Q_ASSERT( state.uniformData()->size() >= 112 );
71
72 auto data = state.uniformData()->data();
73 bool changed = false;
74
75 if ( state.isMatrixDirty() )
76 {
77 const auto matrix = state.combinedMatrix();
78 memcpy( data + 0, matrix.constData(), 64 );
79
80 changed = true;
81 }
82
83 if ( matOld == nullptr || matNew->m_color != matOld->m_color )
84 {
85 memcpy( data + 64, &matNew->m_color, 16 );
86 changed = true;
87 }
88
89 if ( matOld == nullptr || matNew->m_radius != matOld->m_radius )
90 {
91 memcpy( data + 80, &matNew->m_radius, 16 );
92 changed = true;
93 }
94
95 if ( matOld == nullptr || matNew->m_aspectRatio != matOld->m_aspectRatio )
96 {
97 memcpy( data + 96, &matNew->m_aspectRatio, 8 );
98 changed = true;
99 }
100
101 if ( matOld == nullptr || matNew->m_blurExtent != matOld->m_blurExtent )
102 {
103 memcpy( data + 104, &matNew->m_blurExtent, 4 );
104 changed = true;
105 }
106
107 if ( state.isOpacityDirty() )
108 {
109 const float opacity = state.opacity();
110 memcpy( data + 108, &opacity, 4 );
111
112 changed = true;
113 }
114
115 return changed;
116 }
117 };
118}
119
120#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
121
122namespace
123{
124 // the old type of shader - spcific for OpenGL
125
126 class ShaderGL final : public QSGMaterialShader
127 {
128 public:
129 ShaderGL()
130 {
131 const QString root( ":/qskinny/shaders/" );
132
133 setShaderSourceFile( QOpenGLShader::Vertex, root + "boxshadow.vert" );
134 setShaderSourceFile( QOpenGLShader::Fragment, root + "boxshadow.frag" );
135 }
136
137 char const* const* attributeNames() const override
138 {
139 static char const* const names[] = { "in_vertex", "in_coord", nullptr };
140 return names;
141 }
142
143 void initialize() override
144 {
145 QSGMaterialShader::initialize();
146
147 auto p = program();
148
149 m_matrixId = p->uniformLocation( "matrix" );
150 m_aspectRatioId = p->uniformLocation( "aspectRatio" );
151 m_opacityId = p->uniformLocation( "opacity" );
152 m_blurExtentId = p->uniformLocation( "blurExtent" );
153 m_radiusId = p->uniformLocation( "radius" );
154 m_colorId = p->uniformLocation( "color" );
155 }
156
157 void updateState( const QSGMaterialShader::RenderState& state,
158 QSGMaterial* newMaterial, QSGMaterial* oldMaterial) override
159 {
160 auto p = program();
161
162 if ( state.isMatrixDirty() )
163 p->setUniformValue( m_matrixId, state.combinedMatrix() );
164
165 if ( state.isOpacityDirty() )
166 p->setUniformValue( m_opacityId, state.opacity() );
167
168 bool updateMaterial = ( oldMaterial == nullptr )
169 || newMaterial->compare( oldMaterial ) != 0;
170
171 updateMaterial |= state.isCachedMaterialDataDirty();
172
173 if ( updateMaterial )
174 {
175 auto material = static_cast< const Material* >( newMaterial );
176
177 p->setUniformValue( m_aspectRatioId, material->m_aspectRatio );
178 p->setUniformValue( m_blurExtentId, material->m_blurExtent);
179 p->setUniformValue( m_radiusId, material->m_radius );
180 p->setUniformValue( m_colorId, material->m_color );
181 }
182 }
183
184 private:
185 int m_matrixId = -1;
186 int m_opacityId = -1;
187 int m_aspectRatioId = -1;
188 int m_blurExtentId = -1;
189 int m_radiusId = -1;
190 int m_colorId = -1;
191 };
192}
193
194#endif
195
196Material::Material()
197{
198 setFlag( QSGMaterial::Blending, true );
199
200#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
201 setFlag( QSGMaterial::SupportsRhiShader, true );
202#endif
203}
204
205#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
206
207QSGMaterialShader* Material::createShader() const
208{
209 if ( !( flags() & QSGMaterial::RhiShaderWanted ) )
210 return new ShaderGL();
211
212 return new ShaderRhi();
213}
214
215#else
216
217QSGMaterialShader* Material::createShader( QSGRendererInterface::RenderMode ) const
218{
219 return new ShaderRhi();
220}
221
222#endif
223
224QSGMaterialType* Material::type() const
225{
226 static QSGMaterialType staticType;
227 return &staticType;
228}
229
230int Material::compare( const QSGMaterial* other ) const
231{
232 auto material = static_cast< const Material* >( other );
233
234 if ( ( material->m_color == m_color )
235 && ( material->m_aspectRatio == m_aspectRatio )
236 && qFuzzyCompare(material->m_blurExtent, m_blurExtent)
237 && qFuzzyCompare(material->m_radius, m_radius) )
238 {
239 return 0;
240 }
241
242 return QSGMaterial::compare( other );
243}
244
245class QskBoxShadowNodePrivate final : public QSGGeometryNodePrivate
246{
247 public:
248 QskBoxShadowNodePrivate()
249 : geometry( QSGGeometry::defaultAttributes_TexturedPoint2D(), 4 )
250 {
251 }
252
253 QSGGeometry geometry;
254 Material material;
255
256 QRectF rect;
257};
258
259QskBoxShadowNode::QskBoxShadowNode()
260 : QSGGeometryNode( *new QskBoxShadowNodePrivate )
261{
262 Q_D( QskBoxShadowNode );
263
264 setGeometry( &d->geometry );
265 setMaterial( &d->material );
266}
267
268QskBoxShadowNode::~QskBoxShadowNode()
269{
270}
271
272void QskBoxShadowNode::setShadowData(
273 const QRectF& rect, const QskBoxShapeMetrics& shapeMetrics,
274 qreal blurRadius, const QColor& color )
275{
276 Q_D( QskBoxShadowNode );
277
278 if ( rect != d->rect )
279 {
280 d->rect = rect;
281
282 QSGGeometry::updateTexturedRectGeometry(
283 &d->geometry, d->rect, QRectF( -0.5, -0.5, 1.0, 1.0 ) );
284
285 d->geometry.markVertexDataDirty();
286 markDirty( QSGNode::DirtyGeometry );
287
288 QVector2D aspectRatio( 1.0, 1.0 );
289
290 if ( rect.width() >= rect.height() )
291 aspectRatio.setX( rect.width() / rect.height() );
292 else
293 aspectRatio.setY( rect.height() / rect.width() );
294
295 if ( d->material.m_aspectRatio != aspectRatio )
296 {
297 d->material.m_aspectRatio = aspectRatio;
298 markDirty( QSGNode::DirtyMaterial );
299 }
300 }
301
302 {
303 const auto shape = shapeMetrics.toAbsolute( rect.size() );
304
305 const float t = std::min( d->rect.width(), d->rect.height() );
306
307 const float r1 = shape.radius( Qt::BottomRightCorner ).width();
308 const float r2 = shape.radius( Qt::TopRightCorner ).width();
309 const float r3 = shape.radius( Qt::BottomLeftCorner ).width();
310 const float r4 = shape.radius( Qt::TopLeftCorner ).width();
311
312 const auto uniformRadius = QVector4D(
313 std::min( r1 / t, 1.0f ), std::min( r2 / t, 1.0f ),
314 std::min( r3 / t, 1.0f ), std::min( r4 / t, 1.0f ) );
315
316 if ( d->material.m_radius != uniformRadius )
317 {
318 d->material.m_radius = uniformRadius;
319 markDirty( QSGNode::DirtyMaterial );
320 }
321 }
322
323 {
324 if ( blurRadius <= 0.0 )
325 blurRadius = 0.0;
326
327 const float t = 0.5 * std::min( d->rect.width(), d->rect.height() );
328 const float uniformExtent = blurRadius / t;
329
330 if ( !qFuzzyCompare( d->material.m_blurExtent, uniformExtent ) )
331 {
332 d->material.m_blurExtent = uniformExtent;
333 markDirty( QSGNode::DirtyMaterial );
334 }
335 }
336
337 {
338 const auto a = color.alphaF();
339
340 const QVector4D c( color.redF() * a, color.greenF() * a, color.blueF() * a, a );
341
342 if ( d->material.m_color != c )
343 {
344 d->material.m_color = c;
345 markDirty( QSGNode::DirtyMaterial );
346 }
347 }
348}