Revision control
++ // Copyright (C) 2014 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 "technique_p.h"
++
++ #include <Qt3DRender/qrenderpass.h>
++ #include <Qt3DRender/qparameter.h>
++ #include <Qt3DRender/qtechnique.h>
++ #include <Qt3DRender/qgraphicsapifilter.h>
++ #include <Qt3DRender/private/filterkey_p.h>
++ #include <Qt3DRender/private/qtechnique_p.h>
++ #include <Qt3DRender/private/shader_p.h>
++ #include <Qt3DCore/private/qchangearbiter_p.h>
++ #include <Qt3DRender/private/managers_p.h>
++ #include <Qt3DRender/private/techniquemanager_p.h>
++ #include <Qt3DRender/private/nodemanagers_p.h>
++
++ #include <QDebug>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace Qt3DRender {
++ namespace Render {
++
++ using namespace Qt3DCore;
++
++ Technique::Technique()
++ : BackendNode()
++ , m_isCompatibleWithRenderer(false)
++ , m_nodeManager(nullptr)
++ {
++ }
++
++ Technique::~Technique()
++ {
++ cleanup();
++ }
++
++ void Technique::cleanup()
++ {
++ QBackendNode::setEnabled(false);
++ m_parameterPack.clear();
++ m_renderPasses.clear();
++ m_filterKeyList.clear();
++ m_isCompatibleWithRenderer = false;
++ }
++
++ void Technique::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
++ {
++ const QTechnique *node = qobject_cast<const QTechnique *>(frontEnd);
++
++ if (!node)
++ return;
++
++ bool dirty = isEnabled() != frontEnd->isEnabled();
++ BackendNode::syncFromFrontEnd(frontEnd, firstTime);
++
++ auto renderPasses = qIdsForNodes(node->renderPasses());
++ std::sort(std::begin(renderPasses), std::end(renderPasses));
++ if (m_renderPasses != renderPasses) {
++ m_renderPasses = renderPasses;
++ dirty = true;
++ }
++
++ auto parameters = qIdsForNodes(node->parameters());
++ std::sort(std::begin(parameters), std::end(parameters));
++ if (m_parameterPack.parameters() != parameters) {
++ m_parameterPack.setParameters(parameters);
++ dirty = true;
++ }
++
++ auto filterKeys = qIdsForNodes(node->filterKeys());
++ std::sort(std::begin(filterKeys), std::end(filterKeys));
++ if (m_filterKeyList != filterKeys) {
++ m_filterKeyList = filterKeys;
++ dirty = true;
++ }
++
++ auto graphicsApiFilterData = QGraphicsApiFilterPrivate::get(node->graphicsApiFilter())->m_data;
++ if (m_graphicsApiFilterData != graphicsApiFilterData) {
++ m_graphicsApiFilterData = graphicsApiFilterData;
++ m_isCompatibleWithRenderer = false;
++ dirty = true;
++ }
++
++ if (dirty) {
++ m_nodeManager->techniqueManager()->addDirtyTechnique(peerId());
++ markDirty(AbstractRenderer::TechniquesDirty);
++ }
++ }
++
++ QList<Qt3DCore::QNodeId> Technique::parameters() const
++ {
++ return m_parameterPack.parameters();
++ }
++
++ void Technique::appendRenderPass(Qt3DCore::QNodeId renderPassId)
++ {
++ if (!m_renderPasses.contains(renderPassId))
++ m_renderPasses.append(renderPassId);
++ }
++
++ void Technique::removeRenderPass(Qt3DCore::QNodeId renderPassId)
++ {
++ m_renderPasses.removeOne(renderPassId);
++ }
++
++ QList<Qt3DCore::QNodeId> Technique::filterKeys() const
++ {
++ return m_filterKeyList;
++ }
++
++ QList<Qt3DCore::QNodeId> Technique::renderPasses() const
++ {
++ return m_renderPasses;
++ }
++
++ const GraphicsApiFilterData *Technique::graphicsApiFilter() const
++ {
++ return &m_graphicsApiFilterData;
++ }
++
++ bool Technique::isCompatibleWithRenderer() const
++ {
++ return m_isCompatibleWithRenderer;
++ }
++
++ void Technique::setCompatibleWithRenderer(bool compatible)
++ {
++ m_isCompatibleWithRenderer = compatible;
++ }
++
++ bool Technique::isCompatibleWithFilters(const QNodeIdVector &filterKeyIds)
++ {
++ // There is a technique filter so we need to check for a technique with suitable criteria.
++ // Check for early bail out if the technique doesn't have sufficient number of criteria and
++ // can therefore never satisfy the filter
++ if (m_filterKeyList.size() < filterKeyIds.size())
++ return false;
++
++ // Iterate through the filter criteria and for each one search for a criteria on the
++ // technique that satisfies it
++ for (const QNodeId &filterKeyId : filterKeyIds) {
++ FilterKey *filterKey = m_nodeManager->filterKeyManager()->lookupResource(filterKeyId);
++
++ bool foundMatch = false;
++
++ for (const QNodeId &techniqueFilterKeyId : std::as_const(m_filterKeyList)) {
++ FilterKey *techniqueFilterKey = m_nodeManager->filterKeyManager()->lookupResource(techniqueFilterKeyId);
++ if ((foundMatch = (*techniqueFilterKey == *filterKey)))
++ break;
++ }
++
++ // No match for TechniqueFilter criterion in any of the technique's criteria.
++ // So no way this can match. Don't bother checking the rest of the criteria.
++ if (!foundMatch)
++ return false;
++ }
++ return true;
++ }
++
++ void Technique::setNodeManager(NodeManagers *nodeManager)
++ {
++ m_nodeManager = nodeManager;
++ }
++
++ NodeManagers *Technique::nodeManager() const
++ {
++ return m_nodeManager;
++ }
++
++ void Technique::appendFilterKey(Qt3DCore::QNodeId criterionId)
++ {
++ if (!m_filterKeyList.contains(criterionId))
++ m_filterKeyList.append(criterionId);
++ }
++
++ void Technique::removeFilterKey(Qt3DCore::QNodeId criterionId)
++ {
++ m_filterKeyList.removeOne(criterionId);
++ }
++
++ TechniqueFunctor::TechniqueFunctor(AbstractRenderer *renderer, NodeManagers *manager)
++ : m_manager(manager)
++ , m_renderer(renderer)
++ {
++ }
++
++ QBackendNode *TechniqueFunctor::create(Qt3DCore::QNodeId id) const
++ {
++ Technique *technique = m_manager->techniqueManager()->getOrCreateResource(id);
++ technique->setNodeManager(m_manager);
++ technique->setRenderer(m_renderer);
++ return technique;
++ }
++
++ QBackendNode *TechniqueFunctor::get(QNodeId id) const
++ {
++ return m_manager->techniqueManager()->lookupResource(id);
++ }
++
++ void TechniqueFunctor::destroy(QNodeId id) const
++ {
++ m_manager->techniqueManager()->releaseResource(id);
++
++ }
++
++ } // namespace Render
++ } // namespace Qt3DRender
++
++ QT_END_NAMESPACE