RenderStates: rework to split node and rendering part

The apply method was removed from GenericState and its subclasses.
This allows to keep the GenericStates in the aspect part and let the renderer
perform the right calls based on the state class it is provided with.

Change-Id: I9c3ac04b4eb489e7443e67615e35e850c0aba07f
Task-number: QTBUG-61151
Reviewed-by: Mike Krus <mike.krus@kdab.com>

6 files changed, 200 insertions, 242 deletions

diff --git a/src/render/renderstates/genericstate_p.h b/src/render/renderstates/genericstate_p.h
index 236d36690..69c3dee15 100644
--- a/src/render/renderstates/genericstate_p.h
+++ b/src/render/renderstates/genericstate_p.h
@@ -78,7 +78,6 @@ class RenderStateImpl
 public:
     virtual ~RenderStateImpl() {}
 
-    virtual void apply(GraphicsContext* gc) const = 0;
     virtual StateMask mask() const = 0;
     virtual bool equalTo(const RenderStateImpl &renderState) const = 0;
     virtual void updateProperty(const char *name, const QVariant &value);
@@ -110,6 +109,11 @@ public:
         return stateMask;
     }
 
+    std::tuple<T ...> values() const
+    {
+        return m_values;
+    }
+
 protected:
     std::tuple<T ...> m_values;
 };
diff --git a/src/render/renderstates/renderstatenode.cpp b/src/render/renderstates/renderstatenode.cpp
index d1698e4b6..52d5e20ce 100644
--- a/src/render/renderstates/renderstatenode.cpp
+++ b/src/render/renderstates/renderstatenode.cpp
@@ -38,13 +38,196 @@
 #include <Qt3DRender/qrenderstate.h>
 #include <Qt3DRender/private/qrenderstatecreatedchange_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DRender/private/renderstateset_p.h>
+
+#include <Qt3DRender/qalphacoverage.h>
+#include <Qt3DRender/qalphatest.h>
+#include <Qt3DRender/private/qalphatest_p.h>
+#include <Qt3DRender/qblendequation.h>
+#include <Qt3DRender/private/qblendequation_p.h>
+#include <Qt3DRender/qblendequationarguments.h>
+#include <Qt3DRender/private/qblendequationarguments_p.h>
+#include <Qt3DRender/qcolormask.h>
+#include <Qt3DRender/private/qcolormask_p.h>
+#include <Qt3DRender/qcullface.h>
+#include <Qt3DRender/private/qcullface_p.h>
+#include <Qt3DRender/qnodepthmask.h>
+#include <Qt3DRender/qdepthtest.h>
+#include <Qt3DRender/private/qdepthtest_p.h>
+#include <Qt3DRender/qdithering.h>
+#include <Qt3DRender/qfrontface.h>
+#include <Qt3DRender/private/qfrontface_p.h>
+#include <Qt3DRender/qpointsize.h>
+#include <Qt3DRender/private/qpointsize_p.h>
+#include <Qt3DRender/qpolygonoffset.h>
+#include <Qt3DRender/private/qpolygonoffset_p.h>
+#include <Qt3DRender/qscissortest.h>
+#include <Qt3DRender/private/qscissortest_p.h>
+#include <Qt3DRender/qstenciltest.h>
+#include <Qt3DRender/private/qstenciltest_p.h>
+#include <Qt3DRender/qstenciltestarguments.h>
+#include <Qt3DRender/private/qstenciltestarguments_p.h>
+#include <Qt3DRender/qclipplane.h>
+#include <Qt3DRender/private/qclipplane_p.h>
+#include <Qt3DRender/qmultisampleantialiasing.h>
+#include <Qt3DRender/qseamlesscubemap.h>
+#include <Qt3DRender/qstenciloperation.h>
+#include <Qt3DRender/private/qstenciloperation_p.h>
+#include <Qt3DRender/qstenciloperationarguments.h>
+#include <Qt3DRender/private/qstenciloperationarguments_p.h>
+#include <Qt3DRender/qstencilmask.h>
+#include <Qt3DRender/private/qstencilmask_p.h>
+#include <Qt3DRender/qlinewidth.h>
+#include <Qt3DRender/private/qlinewidth_p.h>
 
 QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 namespace Render {
 
+namespace {
+
+StateVariant createStateImplementation(const Qt3DRender::QRenderStateCreatedChangeBasePtr renderStateChange)
+{
+    switch (renderStateChange->renderStateType()) {
+
+    case AlphaCoverageStateMask: {
+        return StateVariant::createState<AlphaCoverage>();
+    }
+
+    case AlphaTestMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QAlphaTestData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<AlphaFunc>(data.alphaFunction, data.referenceValue);
+    }
+
+    case BlendStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QBlendEquationData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<BlendEquation>(data.blendFunction);
+    }
+
+    case BlendEquationArgumentsMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QBlendEquationArgumentsData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<BlendEquationArguments>(
+                    data.sourceRgb, data.destinationRgb,
+                    data.sourceAlpha, data.destinationAlpha,
+                    renderStateChange->isNodeEnabled(),
+                    data.bufferIndex);
+    }
+
+    case MSAAEnabledStateMask: {
+        return StateVariant::createState<MSAAEnabled>(renderStateChange->isNodeEnabled());
+    }
+
+    case CullFaceStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QCullFaceData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<CullFace>(data.mode);
+    }
+
+    case DepthWriteStateMask: {
+        return StateVariant::createState<NoDepthMask>(false);
+    }
+
+    case DepthTestStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QDepthTestData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<DepthTest>(data.depthFunction);
+    }
+
+    case FrontFaceStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QFrontFaceData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<FrontFace>(data.direction);
+    }
+
+    case ScissorStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QScissorTestData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<ScissorTest>(data.left, data.bottom,
+                                                      data.width, data.height);
+    }
+
+    case StencilTestStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QStencilTestData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<StencilTest>(data.front.stencilFunction,
+                                                      data.front.referenceValue,
+                                                      data.front.comparisonMask,
+                                                      data.back.stencilFunction,
+                                                      data.back.referenceValue,
+                                                      data.back.comparisonMask);
+    }
+
+    case PointSizeMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QPointSizeData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        const bool isProgrammable = (data.sizeMode == QPointSize::Programmable);
+        return StateVariant::createState<PointSize>(isProgrammable, data.value);
+    }
+
+    case PolygonOffsetStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QPolygonOffsetData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<PolygonOffset>(data.scaleFactor, data.depthSteps);
+    }
+
+    case ColorStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QColorMaskData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<ColorMask>(data.redMasked, data.greenMasked,
+                                                    data.blueMasked, data.alphaMasked);
+    }
+
+    case ClipPlaneMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QClipPlaneData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<ClipPlane>(data.planeIndex,
+                                                    data.normal,
+                                                    data.distance);
+    }
+
+    case SeamlessCubemapMask: {
+        return StateVariant::createState<SeamlessCubemap>();
+    }
+
+    case StencilOpMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QStencilOperationData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<StencilOp>(data.front.stencilTestFailureOperation,
+                                                    data.front.depthTestFailureOperation,
+                                                    data.front.allTestsPassOperation,
+                                                    data.back.stencilTestFailureOperation,
+                                                    data.back.depthTestFailureOperation,
+                                                    data.back.allTestsPassOperation);
+    }
+
+    case StencilWriteStateMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QStencilMaskData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<StencilMask>(data.frontOutputMask,
+                                                      data.backOutputMask);
+    }
+
+    case DitheringStateMask: {
+        return StateVariant::createState<Dithering>();
+    }
+
+    case LineWidthMask: {
+        const auto typedChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChange<QLineWidthData>>(renderStateChange);
+        const auto &data = typedChange->data;
+        return StateVariant::createState<LineWidth>(data.value, data.smooth);
+    }
+
+    default:
+        Q_UNREACHABLE();
+        return StateVariant();
+    }
+}
+
+} // anonymous
+
 RenderStateNode::RenderStateNode()
     : BackendNode()
 {
@@ -59,11 +242,11 @@ void RenderStateNode::cleanup()
 {
 }
 
-void RenderStateNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void RenderStateNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &chang3)
 {
     cleanup();
-    const auto renderStateChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChangeBase>(change);
-    m_impl = RenderStateSet::initializeStateFromPeer(renderStateChange);
+    const auto renderStateChange = qSharedPointerCast<Qt3DRender::QRenderStateCreatedChangeBase>(chang3);
+    m_impl = createStateImplementation(renderStateChange);
 }
 
 void RenderStateNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
diff --git a/src/render/renderstates/renderstates.cpp b/src/render/renderstates/renderstates.cpp
index 4a2ec69b0..d6be80b1c 100644
--- a/src/render/renderstates/renderstates.cpp
+++ b/src/render/renderstates/renderstates.cpp
@@ -60,34 +60,6 @@ void RenderStateImpl::updateProperty(const char *name, const QVariant &value)
     Q_UNUSED(value);
 }
 
-void BlendEquationArguments::apply(GraphicsContext* gc) const
-{
-    // Un-indexed BlendEquationArguments -> Use normal GL1.0 functions
-    if (std::get<5>(m_values) < 0) {
-        if (std::get<4>(m_values)) {
-            gc->openGLContext()->functions()->glEnable(GL_BLEND);
-            gc->openGLContext()->functions()->glBlendFuncSeparate(std::get<0>(m_values), std::get<1>(m_values), std::get<2>(m_values), std::get<3>(m_values));
-        } else {
-            gc->openGLContext()->functions()->glDisable(GL_BLEND);
-        }
-    }
-    // BlendEquationArguments for a particular Draw Buffer. Different behaviours for
-    //  (1) 3.0-3.3: only enablei/disablei supported.
-    //  (2) 4.0+: all operations supported.
-    // We just ignore blend func parameter for (1), so no warnings get
-    // printed.
-    else {
-        if (std::get<4>(m_values)) {
-            gc->enablei(GL_BLEND, std::get<5>(m_values));
-            if (gc->supportsDrawBuffersBlend()) {
-                gc->blendFuncSeparatei(std::get<5>(m_values), std::get<0>(m_values), std::get<1>(m_values), std::get<2>(m_values), std::get<3>(m_values));
-            }
-        } else {
-            gc->disablei(GL_BLEND, std::get<5>(m_values));
-        }
-    }
-}
-
 void BlendEquationArguments::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("sourceRgb")) std::get<0>(m_values) = value.toInt();
@@ -98,21 +70,11 @@ void BlendEquationArguments::updateProperty(const char *name, const QVariant &va
     else if (name == QByteArrayLiteral("bufferIndex")) std::get<5>(m_values) = value.toInt();
 }
 
-void BlendEquation::apply(GraphicsContext *gc) const
-{
-    gc->blendEquation(std::get<0>(m_values));
-}
-
 void BlendEquation::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("blendFunction")) std::get<0>(m_values) = value.toInt();
 }
 
-void AlphaFunc::apply(GraphicsContext* gc) const
-{
-    gc->alphaTest(std::get<0>(m_values), std::get<1>(m_values));
-}
-
 void AlphaFunc::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("alphaFunction"))
@@ -121,73 +83,32 @@ void AlphaFunc::updateProperty(const char *name, const QVariant &value)
         std::get<1>(m_values) = value.toFloat();
 }
 
-void MSAAEnabled::apply(GraphicsContext *gc) const
-{
-    gc->setMSAAEnabled(std::get<0>(m_values));
-}
-
 void MSAAEnabled::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("enabled"))
         std::get<0>(m_values) = value.toBool();
 }
 
-void DepthTest::apply(GraphicsContext *gc) const
-{
-    gc->depthTest(std::get<0>(m_values));
-}
-
 void DepthTest::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("depthFunction")) std::get<0>(m_values) = value.toInt();
 }
 
-void CullFace::apply(GraphicsContext *gc) const
-{
-    if (std::get<0>(m_values) == QCullFace::NoCulling) {
-        gc->openGLContext()->functions()->glDisable(GL_CULL_FACE);
-    } else {
-        gc->openGLContext()->functions()->glEnable(GL_CULL_FACE);
-        gc->openGLContext()->functions()->glCullFace(std::get<0>(m_values));
-    }
-}
-
 void CullFace::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("mode")) std::get<0>(m_values) = value.toInt();
 }
 
-void FrontFace::apply(GraphicsContext *gc) const
-{
-    gc->frontFace(std::get<0>(m_values));
-}
-
 void FrontFace::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("direction")) std::get<0>(m_values) = value.toInt();
 }
 
-void NoDepthMask::apply(GraphicsContext *gc) const
-{
-    gc->depthMask(std::get<0>(m_values));
-}
-
 void NoDepthMask::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("mask")) std::get<0>(m_values) = value.toBool();
 }
 
-void Dithering::apply(GraphicsContext *gc) const
-{
-    gc->openGLContext()->functions()->glEnable(GL_DITHER);
-}
-
-void ScissorTest::apply(GraphicsContext *gc) const
-{
-    gc->openGLContext()->functions()->glEnable(GL_SCISSOR_TEST);
-    gc->openGLContext()->functions()->glScissor(std::get<0>(m_values), std::get<1>(m_values), std::get<2>(m_values), std::get<3>(m_values));
-}
-
 void ScissorTest::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("left")) std::get<0>(m_values) = value.toInt();
@@ -196,13 +117,6 @@ void ScissorTest::updateProperty(const char *name, const QVariant &value)
     else if (name == QByteArrayLiteral("height")) std::get<3>(m_values) = value.toInt();
 }
 
-void StencilTest::apply(GraphicsContext *gc) const
-{
-    gc->openGLContext()->functions()->glEnable(GL_STENCIL_TEST);
-    gc->openGLContext()->functions()->glStencilFuncSeparate(GL_FRONT, std::get<0>(m_values), std::get<1>(m_values), std::get<2>(m_values));
-    gc->openGLContext()->functions()->glStencilFuncSeparate(GL_BACK, std::get<3>(m_values), std::get<4>(m_values), std::get<5>(m_values));
-}
-
 void StencilTest::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("arguments")) {
@@ -216,39 +130,18 @@ void StencilTest::updateProperty(const char *name, const QVariant &value)
     }
 }
 
-void AlphaCoverage::apply(GraphicsContext *gc) const
-{
-    gc->setAlphaCoverageEnabled(true);
-}
-
-void PointSize::apply(GraphicsContext *gc) const
-{
-    gc->pointSize(std::get<0>(m_values), std::get<1>(m_values));
-}
-
 void PointSize::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("sizeMode")) std::get<0>(m_values) = (value.toInt() == QPointSize::Programmable);
     else if (name == QByteArrayLiteral("value")) std::get<1>(m_values) = value.toFloat();
 }
 
-void PolygonOffset::apply(GraphicsContext *gc) const
-{
-    gc->openGLContext()->functions()->glEnable(GL_POLYGON_OFFSET_FILL);
-    gc->openGLContext()->functions()->glPolygonOffset(std::get<0>(m_values), std::get<1>(m_values));
-}
-
 void PolygonOffset::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("scaleFactor")) std::get<0>(m_values) = value.toFloat();
     else if (name == QByteArrayLiteral("depthSteps")) std::get<1>(m_values) = value.toFloat();
 }
 
-void ColorMask::apply(GraphicsContext *gc) const
-{
-    gc->openGLContext()->functions()->glColorMask(std::get<0>(m_values), std::get<1>(m_values), std::get<2>(m_values), std::get<3>(m_values));
-}
-
 void ColorMask::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("redMasked")) std::get<0>(m_values) = value.toBool();
@@ -257,12 +150,6 @@ void ColorMask::updateProperty(const char *name, const QVariant &value)
     else if (name == QByteArrayLiteral("alphaMasked")) std::get<3>(m_values) = value.toBool();
 }
 
-void ClipPlane::apply(GraphicsContext *gc) const
-{
-    gc->enableClipPlane(std::get<0>(m_values));
-    gc->setClipPlane(std::get<0>(m_values), std::get<1>(m_values), std::get<2>(m_values));
-}
-
 void ClipPlane::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("planeIndex")) std::get<0>(m_values) = value.toInt();
@@ -270,17 +157,6 @@ void ClipPlane::updateProperty(const char *name, const QVariant &value)
     else if (name == QByteArrayLiteral("distance")) std::get<2>(m_values) = value.toFloat();
 }
 
-void SeamlessCubemap::apply(GraphicsContext *gc) const
-{
-    gc->setSeamlessCubemap(true);
-}
-
-void StencilOp::apply(GraphicsContext *gc) const
-{
-    gc->openGLContext()->functions()->glStencilOpSeparate(GL_FRONT, std::get<0>(m_values), std::get<1>(m_values), std::get<2>(m_values));
-    gc->openGLContext()->functions()->glStencilOpSeparate(GL_BACK, std::get<3>(m_values), std::get<4>(m_values), std::get<5>(m_values));
-}
-
 void StencilOp::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("arguments")) {
@@ -294,32 +170,12 @@ void StencilOp::updateProperty(const char *name, const QVariant &value)
     }
 }
 
-void StencilMask::apply(GraphicsContext *gc) const
-{
-    gc->openGLContext()->functions()->glStencilMaskSeparate(GL_FRONT, std::get<0>(m_values));
-    gc->openGLContext()->functions()->glStencilMaskSeparate(GL_BACK, std::get<1>(m_values));
-}
-
 void StencilMask::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("frontOutputMask")) std::get<0>(m_values) = value.toInt();
     else if (name == QByteArrayLiteral("backOutputMask")) std::get<1>(m_values) = value.toInt();
 }
 
-#ifndef GL_LINE_SMOOTH
-#define GL_LINE_SMOOTH 0x0B20
-#endif
-
-void LineWidth::apply(GraphicsContext *gc) const
-{
-    if (std::get<1>(m_values))
-        gc->openGLContext()->functions()->glEnable(GL_LINE_SMOOTH);
-    else
-        gc->openGLContext()->functions()->glDisable(GL_LINE_SMOOTH);
-
-    gc->openGLContext()->functions()->glLineWidth(std::get<0>(m_values));
-}
-
 void LineWidth::updateProperty(const char *name, const QVariant &value)
 {
     if (name == QByteArrayLiteral("value"))
diff --git a/src/render/renderstates/renderstates_p.h b/src/render/renderstates/renderstates_p.h
index c85606f87..eafaeb25f 100644
--- a/src/render/renderstates/renderstates_p.h
+++ b/src/render/renderstates/renderstates_p.h
@@ -62,138 +62,115 @@ namespace Render {
 class Q_AUTOTEST_EXPORT BlendEquationArguments : public GenericState<BlendEquationArguments, BlendEquationArgumentsMask, GLenum, GLenum, GLenum, GLenum, bool, int>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT BlendEquation : public GenericState<BlendEquation, BlendStateMask, GLenum>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
-
 class Q_AUTOTEST_EXPORT AlphaFunc : public GenericState<AlphaFunc, AlphaTestMask, GLenum, GLclampf>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT MSAAEnabled : public GenericState<MSAAEnabled, MSAAEnabledStateMask, GLboolean>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT DepthTest : public GenericState<DepthTest, DepthTestStateMask, GLenum>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT NoDepthMask : public GenericState<NoDepthMask, DepthWriteStateMask, GLboolean>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT CullFace : public GenericState<CullFace, CullFaceStateMask, GLenum>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT FrontFace : public GenericState<FrontFace, FrontFaceStateMask, GLenum>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT Dithering : public GenericState<Dithering, DitheringStateMask>
 {
-public:
-    void apply(GraphicsContext *gc) const override;
 };
 
 class Q_AUTOTEST_EXPORT ScissorTest : public GenericState<ScissorTest, ScissorStateMask, int, int, int, int>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT StencilTest : public GenericState<StencilTest, StencilTestStateMask, GLenum, int, uint, GLenum, int, uint>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT AlphaCoverage : public GenericState<AlphaCoverage, AlphaCoverageStateMask>
 {
-public:
-    void apply(GraphicsContext *gc) const override;
 };
 
 class Q_AUTOTEST_EXPORT PointSize : public GenericState<PointSize, PointSizeMask, bool, GLfloat>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT PolygonOffset : public GenericState<PolygonOffset, PolygonOffsetStateMask, GLfloat, GLfloat>
 {
 public:
-    void apply(GraphicsContext *gc) const override;
+
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT ColorMask : public GenericState<ColorMask, ColorStateMask, GLboolean, GLboolean, GLboolean, GLboolean>
 {
 public:
-    void apply(GraphicsContext *gc) const final;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT ClipPlane : public GenericState<ClipPlane, ClipPlaneMask, int, QVector3D, float>
 {
 public:
-    void apply(GraphicsContext *gc) const final;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT SeamlessCubemap : public GenericState<SeamlessCubemap, SeamlessCubemapMask>
 {
-public:
-    void apply(GraphicsContext *gc) const override;
 };
 
 class Q_AUTOTEST_EXPORT StencilOp : public GenericState<StencilOp, StencilOpMask, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum>
 {
 public:
-    void apply(GraphicsContext *gc) const final;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT StencilMask : public GenericState<StencilMask, StencilWriteStateMask, uint, uint>
 {
 public:
-    void apply(GraphicsContext *gc) const final;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
 class Q_AUTOTEST_EXPORT LineWidth : public GenericState<LineWidth, LineWidthMask, GLfloat, bool>
 {
 public:
-    void apply(GraphicsContext *gc) const final;
     void updateProperty(const char *name, const QVariant &value) override;
 };
 
diff --git a/src/render/renderstates/statevariant.cpp b/src/render/renderstates/statevariant.cpp
index e72262825..8161cba0b 100644
--- a/src/render/renderstates/statevariant.cpp
+++ b/src/render/renderstates/statevariant.cpp
@@ -44,74 +44,6 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 namespace Render {
 
-void StateVariant::apply(GraphicsContext *gc) const
-{
-    switch (type) {
-    case BlendEquationArgumentsMask:
-        data.blendEquationArguments.apply(gc);
-        return;
-    case BlendStateMask:
-        data.blendEquation.apply(gc);
-        return;
-    case AlphaTestMask:
-        data.alphaFunc.apply(gc);
-        return;
-    case MSAAEnabledStateMask:
-        data.msaaEnabled.apply(gc);
-        return;
-    case DepthTestStateMask:
-        data.depthTest.apply(gc);
-        return;
-    case DepthWriteStateMask:
-        data.noDepthMask.apply(gc);
-        return;
-    case CullFaceStateMask:
-        data.cullFace.apply(gc);
-        return;
-    case FrontFaceStateMask:
-        data.frontFace.apply(gc);
-        return;
-    case DitheringStateMask:
-        data.dithering.apply(gc);
-        return;
-    case ScissorStateMask:
-        data.scissorTest.apply(gc);
-        return;
-    case StencilTestStateMask:
-        data.stencilTest.apply(gc);
-        return;
-    case AlphaCoverageStateMask:
-        data.alphaCoverage.apply(gc);
-        return;
-    case PointSizeMask:
-        data.pointSize.apply(gc);
-        return;
-    case PolygonOffsetStateMask:
-        data.polygonOffset.apply(gc);
-        return;
-    case ColorStateMask:
-        data.colorMask.apply(gc);
-        return;
-    case ClipPlaneMask:
-        data.clipPlane.apply(gc);
-        return;
-    case SeamlessCubemapMask:
-        data.seamlessCubemap.apply(gc);
-        return;
-    case StencilOpMask:
-        data.stencilOp.apply(gc);
-        return;
-    case StencilWriteStateMask:
-        data.stencilMask.apply(gc);
-        return;
-    case LineWidthMask:
-        data.lineWidth.apply(gc);
-        return;
-    default:
-        Q_UNREACHABLE();
-    }
-}
-
 RenderStateImpl *StateVariant::state()
 {
     switch (type) {
diff --git a/src/render/renderstates/statevariant_p.h b/src/render/renderstates/statevariant_p.h
index 3fc93e7bd..ac3c12682 100644
--- a/src/render/renderstates/statevariant_p.h
+++ b/src/render/renderstates/statevariant_p.h
@@ -107,7 +107,13 @@ struct Q_AUTOTEST_EXPORT StateVariant
         }
     } data;
 
-    void apply(GraphicsContext *gc) const;
+    template<class State, typename ... Args>
+    static StateVariant createState(Args... values)
+    {
+        State state;
+        state.set(values...);
+        return StateVariant::fromValue(state);
+    }
 
     template<typename GenericState>
     static StateVariant fromValue(const GenericState &state)