Revision control
++ // Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB).
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "renderstatenode_p.h"
++ #include <Qt3DRender/qrenderstate.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/qdepthrange.h>
++ #include <Qt3DRender/private/qdepthrange_p.h>
++ #include <Qt3DRender/qdepthtest.h>
++ #include <Qt3DRender/private/qdepthtest_p.h>
++ #include <Qt3DRender/qrastermode.h>
++ #include <Qt3DRender/private/qrastermode_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 QRenderState *node)
++ {
++ const QRenderStatePrivate *d = static_cast<const QRenderStatePrivate *>(Qt3DCore::QNodePrivate::get(node));
++ switch (d->m_type) {
++
++ case AlphaCoverageStateMask: {
++ return StateVariant::createState<AlphaCoverage>();
++ }
++
++ case AlphaTestMask: {
++ const QAlphaTest *alphaTest = static_cast<const QAlphaTest *>(node);
++ return StateVariant::createState<AlphaFunc>(alphaTest->alphaFunction(), alphaTest->referenceValue());
++ }
++
++ case BlendStateMask: {
++ const QBlendEquation *blendEquation = static_cast<const QBlendEquation *>(node);
++ return StateVariant::createState<BlendEquation>(blendEquation->blendFunction());
++ }
++
++ case BlendEquationArgumentsMask: {
++ const QBlendEquationArguments *blendArgs = static_cast<const QBlendEquationArguments *>(node);
++ return StateVariant::createState<BlendEquationArguments>(
++ blendArgs->sourceRgb(), blendArgs->destinationRgb(),
++ blendArgs->sourceAlpha(), blendArgs->destinationAlpha(),
++ blendArgs->isEnabled(),
++ blendArgs->bufferIndex());
++ }
++
++ case MSAAEnabledStateMask: {
++ return StateVariant::createState<MSAAEnabled>(node->isEnabled());
++ }
++
++ case CullFaceStateMask: {
++ const QCullFace *cullFace = static_cast<const QCullFace *>(node);
++ return StateVariant::createState<CullFace>(cullFace->mode());
++ }
++
++ case DepthRangeMask: {
++ const QDepthRange *depthRange = static_cast<const QDepthRange *>(node);
++ return StateVariant::createState<DepthRange>(depthRange->nearValue(), depthRange->farValue());
++ }
++
++ case DepthWriteStateMask: {
++ return StateVariant::createState<NoDepthMask>(!node->isEnabled());
++ }
++
++ case DepthTestStateMask: {
++ const QDepthTest *depthTest = static_cast<const QDepthTest *>(node);
++ return StateVariant::createState<DepthTest>(depthTest->depthFunction());
++ }
++
++ case RasterModeMask: {
++ const QRasterMode *rasterMode = static_cast<const QRasterMode *>(node);
++ return StateVariant::createState<RasterMode>(rasterMode->faceMode(), rasterMode->rasterMode());
++ }
++
++ case FrontFaceStateMask: {
++ const QFrontFace *frontFace = static_cast<const QFrontFace *>(node);
++ return StateVariant::createState<FrontFace>(frontFace->direction());
++ }
++
++ case ScissorStateMask: {
++ const QScissorTest *scissorTest = static_cast<const QScissorTest *>(node);
++ return StateVariant::createState<ScissorTest>(scissorTest->left(), scissorTest->bottom(),
++ scissorTest->width(), scissorTest->height());
++ }
++
++ case StencilTestStateMask: {
++ const QStencilTest *stencilTest = static_cast<const QStencilTest *>(node);
++ return StateVariant::createState<StencilTest>(stencilTest->front()->stencilFunction(),
++ stencilTest->front()->referenceValue(),
++ stencilTest->front()->comparisonMask(),
++ stencilTest->back()->stencilFunction(),
++ stencilTest->back()->referenceValue(),
++ stencilTest->back()->comparisonMask());
++ }
++
++ case PointSizeMask: {
++ const QPointSize *pointSize = static_cast<const QPointSize *>(node);
++ const bool isProgrammable = (pointSize->sizeMode() == QPointSize::Programmable);
++ return StateVariant::createState<PointSize>(isProgrammable, pointSize->value());
++ }
++
++ case PolygonOffsetStateMask: {
++ const QPolygonOffset *offset = static_cast<const QPolygonOffset *>(node);
++ return StateVariant::createState<PolygonOffset>(offset->scaleFactor(), offset->depthSteps());
++ }
++
++ case ColorStateMask: {
++ const QColorMask *colorMask = static_cast<const QColorMask *>(node);
++ return StateVariant::createState<ColorMask>(colorMask->isRedMasked(), colorMask->isGreenMasked(),
++ colorMask->isBlueMasked(), colorMask->isAlphaMasked());
++ }
++
++ case ClipPlaneMask: {
++ const QClipPlane *clipPlane = static_cast<const QClipPlane *>(node);
++ return StateVariant::createState<ClipPlane>(clipPlane->planeIndex(),
++ clipPlane->normal(),
++ clipPlane->distance());
++ }
++
++ case SeamlessCubemapMask: {
++ return StateVariant::createState<SeamlessCubemap>();
++ }
++
++ case StencilOpMask: {
++ const QStencilOperation *stencilOp = static_cast<const QStencilOperation *>(node);
++ return StateVariant::createState<StencilOp>(stencilOp->front()->stencilTestFailureOperation(),
++ stencilOp->front()->depthTestFailureOperation(),
++ stencilOp->front()->allTestsPassOperation(),
++ stencilOp->back()->stencilTestFailureOperation(),
++ stencilOp->back()->depthTestFailureOperation(),
++ stencilOp->back()->allTestsPassOperation());
++ }
++
++ case StencilWriteStateMask: {
++ const QStencilMask *stencilMask = static_cast<const QStencilMask *>(node);
++ return StateVariant::createState<StencilMask>(stencilMask->frontOutputMask(),
++ stencilMask->backOutputMask());
++ }
++
++ case DitheringStateMask: {
++ return StateVariant::createState<Dithering>();
++ }
++
++ case LineWidthMask: {
++ const QLineWidth *lineWidth = static_cast<const QLineWidth *>(node);
++ return StateVariant::createState<LineWidth>(lineWidth->value(), lineWidth->smooth());
++ }
++
++ default:
++ Q_UNREACHABLE_RETURN(StateVariant());
++ }
++ }
++
++ } // anonymous
++
++ RenderStateNode::RenderStateNode()
++ : BackendNode()
++ {
++ }
++
++ RenderStateNode::~RenderStateNode()
++ {
++ cleanup();
++ }
++
++ void RenderStateNode::cleanup()
++ {
++ }
++
++ void RenderStateNode::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
++ {
++ const QRenderState *node = qobject_cast<const QRenderState *>(frontEnd);
++ if (!node)
++ return;
++
++ BackendNode::syncFromFrontEnd(frontEnd, firstTime);
++
++ if (firstTime)
++ m_impl = createStateImplementation(node);
++
++ m_impl.state()->updateProperties(node);
++ markDirty(AbstractRenderer::AllDirty);
++ }
++
++ } // namespace Render
++ } // namespace Qt3DRender
++
++ QT_END_NAMESPACE