BlurringNode -> TextureFilterNode

playground/parrots/CMakeLists.txt

@@ -5,7 +5,7 @@
 
 set(SOURCES
     Overlay.h Overlay.cpp
-    BlurringNode.h BlurringNode.cpp
+    TextureFilterNode.h TextureFilterNode.cpp
     main.cpp)
 
 qt_add_resources(SOURCES images.qrc shaders.qrc)

playground/parrots/Overlay.cpp

@@ -4,7 +4,7 @@
  *****************************************************************************/
 
 #include "Overlay.h"
-#include "BlurringNode.h"
+#include "TextureFilterNode.h"
 
 #include <QskSkinlet.h>
 #include <QskSceneTexture.h>
@@ -23,11 +23,11 @@ namespace
         using Inherited = QskSkinlet;
 
       public:
-        enum NodeRole { EffectRole, BorderRole };
+        enum NodeRole { FillRole, BorderRole };
 
         Skinlet()
         {
-            setNodeRoles( { EffectRole, BorderRole } );
+            setNodeRoles( { FillRole, BorderRole } );
         }
 
         QRectF subControlRect( const QskSkinnable*,
@@ -43,8 +43,8 @@ namespace
 
             switch ( nodeRole )
             {
-                case EffectRole:
+                case FillRole:
-                    return updateClippedEffectNode( overlay, node );
+                    return updateFillNode( overlay, node );
 
                 case BorderRole:
                     return updateBoxNode( skinnable, node, Overlay::Panel );
@@ -55,31 +55,31 @@ namespace
         }
 
       private:
-        QSGNode* updateClippedEffectNode( const Overlay* overlay, QSGNode* node ) const
+        QSGNode* updateFillNode( const Overlay* overlay, QSGNode* node ) const
         {
             /*
                 There should be a way to avoid the clip node by passing the
-                vertex list directly to the effect node. TODO ...
+                vertex list directly to the texture node. TODO ...
              */
             using Q = Overlay;
 
             QSGNode* clipNode = nullptr;
-            QSGNode* effectNode = nullptr;
+            QSGNode* textureNode = nullptr;
 
             if ( node )
             {
                 if ( node->firstChild() )
                 {
                     clipNode = node;
-                    effectNode = node->firstChild();
+                    textureNode = node->firstChild();
                 }
                 else
                 {
-                    effectNode = node;
+                    textureNode = node;
                 }
             }
 
-            effectNode = updateEffectNode( overlay, effectNode );
+            textureNode = updateTextureNode( overlay, textureNode );
 
             if ( overlay->boxShapeHint( Q::Panel ).isRectangle() )
             {
@@ -91,12 +91,12 @@ namespace
                 clipNode = updateBoxClipNode( overlay, clipNode, Q::Panel );
             }
 
-            QskSGNode::setParentNode( effectNode, clipNode );
+            QskSGNode::setParentNode( textureNode, clipNode );
 
-            return clipNode ? clipNode : effectNode;
+            return clipNode ? clipNode : textureNode;
         }
 
-        QSGNode* updateEffectNode( const Overlay* overlay, QSGNode* node ) const
+        QSGNode* updateTextureNode( const Overlay* overlay, QSGNode* node ) const
         {
             const auto window = overlay->window();
 
@@ -107,20 +107,20 @@ namespace
             if ( rootNode == nullptr )
                 return nullptr;
 
-            auto effectNode = static_cast< BlurringNode* >( node );
+            auto textureNode = static_cast< TextureFilterNode* >( node );
 
-            if ( effectNode == nullptr )
+            if ( textureNode == nullptr )
             {
                 auto texture = new QskSceneTexture( window );
                 QObject::connect( texture, &QskSceneTexture::updateRequested,
                     overlay, &QQuickItem::update );
 
-                effectNode = new BlurringNode();
+                textureNode = new TextureFilterNode();
-                effectNode->setTexture( texture );
+                textureNode->setTexture( texture );
             }
 
             {
-                auto texture = qobject_cast< QskSceneTexture* >( effectNode->texture() );
+                auto texture = qobject_cast< QskSceneTexture* >( textureNode->texture() );
                 Q_ASSERT( texture );
 
                 texture->setFiltering(
@@ -132,10 +132,10 @@ namespace
 
             {
                 const auto rect = overlay->subControlRect( Overlay::Panel );
-                effectNode->setRect( rect );
+                textureNode->setRect( rect );
             }
 
-            return effectNode;
+            return textureNode;
         }
     };
 }

playground/parrots/TextureFilterNode.cpp

@@ -3,7 +3,7 @@
  *           SPDX-License-Identifier: BSD-3-Clause
  *****************************************************************************/
 
-#include "BlurringNode.h"
+#include "TextureFilterNode.h"
 
 #include <qsgmaterialshader.h>
 #include <qsgmaterial.h>
@@ -122,10 +122,10 @@ QSGMaterialShader* Material::createShader(
     return new MaterialShader();
 }
 
-class BlurringNodePrivate final : public QSGGeometryNodePrivate
+class TextureFilterNodePrivate final : public QSGGeometryNodePrivate
 {
   public:
-    BlurringNodePrivate()
+    TextureFilterNodePrivate()
         : geometry( QSGGeometry::defaultAttributes_TexturedPoint2D(), 4 )
     {
     }
@@ -136,32 +136,32 @@ class BlurringNodePrivate final : public QSGGeometryNodePrivate
     QRectF rect;
 };
 
-BlurringNode::BlurringNode()
+TextureFilterNode::TextureFilterNode()
-    : QSGGeometryNode( *new BlurringNodePrivate )
+    : QSGGeometryNode( *new TextureFilterNodePrivate )
 {
-    Q_D( BlurringNode );
+    Q_D( TextureFilterNode );
 
     setMaterial( &d->material );
     setGeometry( &d->geometry );
 }
 
-BlurringNode::~BlurringNode()
+TextureFilterNode::~TextureFilterNode()
 {
 }
 
-void BlurringNode::setTexture( QSGTexture* texture )
+void TextureFilterNode::setTexture( QSGTexture* texture )
 {
     d_func()->material.texture = texture;
 }
 
-QSGTexture* BlurringNode::texture()
+QSGTexture* TextureFilterNode::texture()
 {
     return d_func()->material.texture;
 }
 
-void BlurringNode::setRect( const QRectF& rect )
+void TextureFilterNode::setRect( const QRectF& rect )
 {
-    Q_D( BlurringNode );
+    Q_D( TextureFilterNode );
 
     if ( rect != d->rect )
     {

playground/parrots/TextureFilterNode.h

@@ -10,15 +10,15 @@
 class QRect;
 class QSGTexture;
 
-class BlurringNodePrivate;
+class TextureFilterNodePrivate;
 
-class BlurringNode : public QSGGeometryNode
+class TextureFilterNode : public QSGGeometryNode
 {
     using Inherited = QSGGeometryNode;
 
   public:
-    BlurringNode();
+    TextureFilterNode();
-    ~BlurringNode();
+    ~TextureFilterNode();
 
     void setTexture( QSGTexture* );
     QSGTexture* texture();
@@ -26,5 +26,5 @@ class BlurringNode : public QSGGeometryNode
     void setRect( const QRectF& );
 
   private:
-    Q_DECLARE_PRIVATE( BlurringNode )
+    Q_DECLARE_PRIVATE( TextureFilterNode )
 };