QColorMask properties renamed

red -> redMasked
green -> greenMasked
blue -> blueMasked
alpha -> alphaMasked

Change-Id: I5df99a6cf79b77ee344c9b9e45c940b084b65ad7
Task-number: QTBUG-51437
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

6 files changed, 65 insertions, 65 deletions

diff --git a/examples/qt3d/anaglyph-rendering/StereoFrameGraph.qml b/examples/qt3d/anaglyph-rendering/StereoFrameGraph.qml
index d2256c7ac..c39afc9d6 100644
--- a/examples/qt3d/anaglyph-rendering/StereoFrameGraph.qml
+++ b/examples/qt3d/anaglyph-rendering/StereoFrameGraph.qml
@@ -72,7 +72,7 @@ Viewport {
             id: leftCameraSelector
             RenderStateSet {
                 renderStates: [
-                    ColorMask { red: true; green: false; blue: false; alpha: false },
+                    ColorMask { redMasked: true; greenMasked: false; blueMasked: false; alphaMasked: false },
                     DepthTest { depthFunction: DepthTest.Less }
                 ]
             }
@@ -85,7 +85,7 @@ Viewport {
                 id: rightCameraSelector
                 RenderStateSet {
                     renderStates: [
-                        ColorMask { red: false; green: true; blue: true; alpha: false },
+                        ColorMask { redMasked: false; greenMasked: true; blueMasked: true; alphaMasked: false },
                         DepthTest { depthFunction: DepthTest.Less }
                     ]
                 }
diff --git a/examples/qt3d/clip-planes-qml/ClipCappingFrameGraph.qml b/examples/qt3d/clip-planes-qml/ClipCappingFrameGraph.qml
index ab7f33d1a..61c721fe1 100644
--- a/examples/qt3d/clip-planes-qml/ClipCappingFrameGraph.qml
+++ b/examples/qt3d/clip-planes-qml/ClipCappingFrameGraph.qml
@@ -107,7 +107,7 @@ Viewport {
                                 front.stencilDepthPass: StencilOpSeparate.Decr
                                 back.stencilDepthPass: StencilOpSeparate.Incr
                             },
-                            ColorMask { red: false; green: false; blue: false; alpha: false }
+                            ColorMask { redMasked: false; greenMasked: false; blueMasked: false; alphaMasked: false }
                         ]
 
                         LayerFilter {
diff --git a/src/plugins/sceneparsers/gltf/gltfparser.cpp b/src/plugins/sceneparsers/gltf/gltfparser.cpp
index 532ea242d..8202f87c9 100644
--- a/src/plugins/sceneparsers/gltf/gltfparser.cpp
+++ b/src/plugins/sceneparsers/gltf/gltfparser.cpp
@@ -1490,10 +1490,10 @@ QRenderState* GLTFParser::buildState(const QString& functionName, const QJsonVal
 
     if (functionName == QStringLiteral("colorMask")) {
         QColorMask *colorMask = new QColorMask;
-        colorMask->setRed(values.at(0).toBool(true));
-        colorMask->setGreen(values.at(1).toBool(true));
-        colorMask->setBlue(values.at(2).toBool(true));
-        colorMask->setAlpha(values.at(3).toBool(true));
+        colorMask->setRedMasked(values.at(0).toBool(true));
+        colorMask->setGreenMasked(values.at(1).toBool(true));
+        colorMask->setBlueMasked(values.at(2).toBool(true));
+        colorMask->setAlphaMasked(values.at(3).toBool(true));
         return colorMask;
     }
 
diff --git a/src/render/renderstates/qcolormask.cpp b/src/render/renderstates/qcolormask.cpp
index f1a7cb6a7..c5b1f75c2 100644
--- a/src/render/renderstates/qcolormask.cpp
+++ b/src/render/renderstates/qcolormask.cpp
@@ -49,16 +49,16 @@ class QColorMaskPrivate : public QRenderStatePrivate
 public:
     QColorMaskPrivate()
         : QRenderStatePrivate(QRenderState::ColorMask)
-        , m_red(true)
-        , m_green(true)
-        , m_blue(true)
-        , m_alpha(true)
+        , m_redMasked(true)
+        , m_greenMasked(true)
+        , m_blueMasked(true)
+        , m_alphaMasked(true)
     {}
 
-    bool m_red;
-    bool m_green;
-    bool m_blue;
-    bool m_alpha;
+    bool m_redMasked;
+    bool m_greenMasked;
+    bool m_blueMasked;
+    bool m_alphaMasked;
 
     Q_DECLARE_PUBLIC(QColorMask)
 };
@@ -90,40 +90,40 @@ QColorMask::~QColorMask()
     QNode::cleanup();
 }
 
-bool QColorMask::isRed() const
+bool QColorMask::isRedMasked() const
 {
     Q_D(const QColorMask);
-    return d->m_red;
+    return d->m_redMasked;
 }
 
-bool QColorMask::isGreen() const
+bool QColorMask::isGreenMasked() const
 {
     Q_D(const QColorMask);
-    return d->m_green;
+    return d->m_greenMasked;
 }
 
-bool QColorMask::isBlue() const
+bool QColorMask::isBlueMasked() const
 {
     Q_D(const QColorMask);
-    return d->m_blue;
+    return d->m_blueMasked;
 }
 
-bool QColorMask::isAlpha() const
+bool QColorMask::isAlphaMasked() const
 {
     Q_D(const QColorMask);
-    return d->m_alpha;
+    return d->m_alphaMasked;
 }
 
 /*!
     \property Qt3DRender::QColorMask::red
     Holds whether the red color component should be written to the frame buffer.
  */
-void QColorMask::setRed(bool red)
+void QColorMask::setRedMasked(bool redMasked)
 {
     Q_D(QColorMask);
-    if (red != d->m_red) {
-        d->m_red = red;
-        emit redChanged(red);
+    if (redMasked != d->m_redMasked) {
+        d->m_redMasked = redMasked;
+        emit redMaskedChanged(redMasked);
     }
 }
 
@@ -131,12 +131,12 @@ void QColorMask::setRed(bool red)
     \property Qt3DRender::QColorMask::green
     Holds whether the green color component should be written to the frame buffer.
  */
-void QColorMask::setGreen(bool green)
+void QColorMask::setGreenMasked(bool greenMasked)
 {
     Q_D(QColorMask);
-    if (green != d->m_green) {
-        d->m_green = green;
-        emit greenChanged(green);
+    if (greenMasked != d->m_greenMasked) {
+        d->m_greenMasked = greenMasked;
+        emit greenMaskedChanged(greenMasked);
     }
 }
 
@@ -144,25 +144,25 @@ void QColorMask::setGreen(bool green)
     \property Qt3DRender::QColorMask::blue
     Holds whether the blue color component should be written to the frame buffer.
  */
-void QColorMask::setBlue(bool blue)
+void QColorMask::setBlueMasked(bool blueMasked)
 {
     Q_D(QColorMask);
-    if (blue != d->m_blue) {
-        d->m_blue = blue;
-        emit blueChanged(blue);
+    if (blueMasked != d->m_blueMasked) {
+        d->m_blueMasked = blueMasked;
+        emit blueMaskedChanged(blueMasked);
     }
 }
 
 /*!
-    \property Qt3DRender::QColorMask::alpha
-    Holds whether the alpha component should be written to the frame buffer.
+    \property Qt3DRender::QColorMask::alphaMasked
+    Holds whether the alphaMasked component should be written to the frame buffer.
  */
-void QColorMask::setAlpha(bool alpha)
+void QColorMask::setAlphaMasked(bool alphaMasked)
 {
     Q_D(QColorMask);
-    if (alpha != d->m_alpha) {
-        d->m_alpha = alpha;
-        emit alphaChanged(alpha);
+    if (alphaMasked != d->m_alphaMasked) {
+        d->m_alphaMasked = alphaMasked;
+        emit alphaMaskedChanged(alphaMasked);
     }
 }
 
@@ -170,10 +170,10 @@ void QColorMask::copy(const QNode *ref)
 {
     QRenderState::copy(ref);
     const QColorMask *refState = static_cast<const QColorMask *>(ref);
-    d_func()->m_red = refState->d_func()->m_red;
-    d_func()->m_green = refState->d_func()->m_green;
-    d_func()->m_blue = refState->d_func()->m_blue;
-    d_func()->m_alpha = refState->d_func()->m_alpha;
+    d_func()->m_redMasked = refState->d_func()->m_redMasked;
+    d_func()->m_greenMasked = refState->d_func()->m_greenMasked;
+    d_func()->m_blueMasked = refState->d_func()->m_blueMasked;
+    d_func()->m_alphaMasked = refState->d_func()->m_alphaMasked;
 }
 
 } // namespace Qt3DRender
diff --git a/src/render/renderstates/qcolormask.h b/src/render/renderstates/qcolormask.h
index 4ac572437..e0a66b033 100644
--- a/src/render/renderstates/qcolormask.h
+++ b/src/render/renderstates/qcolormask.h
@@ -51,31 +51,31 @@ class QColorMaskPrivate;
 class QT3DRENDERSHARED_EXPORT QColorMask : public QRenderState
 {
     Q_OBJECT
-    Q_PROPERTY(bool red READ isRed WRITE setRed NOTIFY redChanged)
-    Q_PROPERTY(bool green READ isGreen WRITE setGreen NOTIFY greenChanged)
-    Q_PROPERTY(bool blue READ isBlue WRITE setBlue NOTIFY blueChanged)
-    Q_PROPERTY(bool alpha READ isAlpha WRITE setAlpha NOTIFY alphaChanged)
+    Q_PROPERTY(bool redMasked READ isRedMasked WRITE setRedMasked NOTIFY redMaskedChanged)
+    Q_PROPERTY(bool greenMasked READ isGreenMasked WRITE setGreenMasked NOTIFY greenMaskedChanged)
+    Q_PROPERTY(bool blueMasked READ isBlueMasked WRITE setBlueMasked NOTIFY blueMaskedChanged)
+    Q_PROPERTY(bool alphaMasked READ isAlphaMasked WRITE setAlphaMasked NOTIFY alphaMaskedChanged)
 
 public:
     explicit QColorMask(Qt3DCore::QNode *parent = Q_NULLPTR);
     ~QColorMask();
 
-    bool isRed() const;
-    bool isGreen() const;
-    bool isBlue() const;
-    bool isAlpha() const;
+    bool isRedMasked() const;
+    bool isGreenMasked() const;
+    bool isBlueMasked() const;
+    bool isAlphaMasked() const;
 
 public Q_SLOTS:
-    void setRed(bool red);
-    void setGreen(bool green);
-    void setBlue(bool blue);
-    void setAlpha(bool alpha);
+    void setRedMasked(bool redMasked);
+    void setGreenMasked(bool greenMasked);
+    void setBlueMasked(bool blueMasked);
+    void setAlphaMasked(bool alphaMasked);
 
 Q_SIGNALS:
-    void redChanged(bool red);
-    void greenChanged(bool green);
-    void blueChanged(bool blue);
-    void alphaChanged(bool alpha);
+    void redMaskedChanged(bool redMasked);
+    void greenMaskedChanged(bool greenMasked);
+    void blueMaskedChanged(bool blueMasked);
+    void alphaMaskedChanged(bool alphaMasked);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_FINAL;
diff --git a/src/render/renderstates/renderstateset.cpp b/src/render/renderstates/renderstateset.cpp
index 554512035..8575596e8 100644
--- a/src/render/renderstates/renderstateset.cpp
+++ b/src/render/renderstates/renderstateset.cpp
@@ -328,10 +328,10 @@ RenderStateImpl* RenderStateImpl::getOrCreateState(QRenderState *renderState)
     }
     case QRenderState::ColorMask: {
         QColorMask *colorMask = static_cast<QColorMask *>(renderState);
-        return getOrCreateRenderStateImpl<ColorMask>(colorMask->isRed(),
-                                      colorMask->isGreen(),
-                                      colorMask->isBlue(),
-                                      colorMask->isAlpha());
+        return getOrCreateRenderStateImpl<ColorMask>(colorMask->isRedMasked(),
+                                      colorMask->isGreenMasked(),
+                                      colorMask->isBlueMasked(),
+                                      colorMask->isAlphaMasked());
     }
     case QRenderState::ClipPlane: {
         QClipPlane *clipPlane = static_cast<QClipPlane *>(renderState);