Revision control
Copy as Markdown
// 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 "qrenderaspect.h"
#include "qrenderaspect_p.h"
#include <Qt3DRender/private/nodemanagers_p.h>
#include <Qt3DRender/private/abstractrenderer_p.h>
#include <Qt3DRender/private/scenemanager_p.h>
#include <Qt3DRender/private/geometryrenderermanager_p.h>
#include <Qt3DRender/qsceneloader.h>
#include <Qt3DRender/qcamera.h>
#include <Qt3DRender/qcameraselector.h>
#include <Qt3DRender/qlayer.h>
#include <Qt3DRender/qlayerfilter.h>
#include <Qt3DRender/qlevelofdetail.h>
#include <Qt3DRender/qlevelofdetailswitch.h>
#include <Qt3DRender/qmaterial.h>
#include <Qt3DRender/qmesh.h>
#include <Qt3DRender/qparameter.h>
#include <Qt3DRender/qrenderpassfilter.h>
#include <Qt3DRender/qrenderpass.h>
#include <Qt3DRender/qrendertargetselector.h>
#include <Qt3DRender/qtechniquefilter.h>
#include <Qt3DRender/qtechnique.h>
#include <Qt3DRender/qviewport.h>
#include <Qt3DRender/qrendertarget.h>
#include <Qt3DRender/qclearbuffers.h>
#include <Qt3DRender/qtexture.h>
#include <Qt3DRender/qeffect.h>
#include <Qt3DRender/qshaderdata.h>
#include <Qt3DRender/qrenderstateset.h>
#include <Qt3DRender/qnodraw.h>
#include <Qt3DRender/qnopicking.h>
#include <Qt3DRender/qcameralens.h>
#include <Qt3DRender/qgeometryrenderer.h>
#include <Qt3DRender/qobjectpicker.h>
#include <Qt3DRender/qraycaster.h>
#include <Qt3DRender/qscreenraycaster.h>
#include <Qt3DRender/qfrustumculling.h>
#include <Qt3DRender/qabstractlight.h>
#include <Qt3DRender/qenvironmentlight.h>
#include <Qt3DRender/qdispatchcompute.h>
#include <Qt3DRender/qcomputecommand.h>
#include <Qt3DRender/qrendersurfaceselector.h>
#include <Qt3DRender/qrendersettings.h>
#include <Qt3DRender/qrendercapture.h>
#include <Qt3DRender/qbuffercapture.h>
#include <Qt3DRender/qmemorybarrier.h>
#include <Qt3DRender/qproximityfilter.h>
#include <Qt3DRender/qshaderprogrambuilder.h>
#include <Qt3DRender/qblitframebuffer.h>
#include <Qt3DRender/qsetfence.h>
#include <Qt3DRender/qwaitfence.h>
#include <Qt3DRender/qshaderimage.h>
#include <Qt3DRender/qsubtreeenabler.h>
#include <Qt3DRender/qdebugoverlay.h>
#include <Qt3DRender/qpickingproxy.h>
#include <Qt3DCore/qarmature.h>
#include <Qt3DCore/qjoint.h>
#include <Qt3DCore/qskeletonloader.h>
#include <Qt3DCore/qcoreaspect.h>
#include <Qt3DRender/private/backendnode_p.h>
#include <Qt3DRender/private/cameraselectornode_p.h>
#include <Qt3DRender/private/layerfilternode_p.h>
#include <Qt3DRender/private/cameralens_p.h>
#include <Qt3DRender/private/filterkey_p.h>
#include <Qt3DRender/private/entity_p.h>
#include <Qt3DRender/private/abstractrenderer_p.h>
#include <Qt3DRender/private/shaderdata_p.h>
#include <Qt3DRender/private/renderpassfilternode_p.h>
#include <Qt3DRender/private/rendertargetselectornode_p.h>
#include <Qt3DRender/private/techniquefilternode_p.h>
#include <Qt3DRender/private/viewportnode_p.h>
#include <Qt3DRender/private/rendertarget_p.h>
#include <Qt3DRender/private/scenemanager_p.h>
#include <Qt3DRender/private/clearbuffers_p.h>
#include <Qt3DRender/private/sortpolicy_p.h>
#include <Qt3DRender/private/renderlogging_p.h>
#include <Qt3DRender/private/nodefunctor_p.h>
#include <Qt3DRender/private/framegraphnode_p.h>
#include <Qt3DRender/private/textureimage_p.h>
#include <Qt3DRender/private/statesetnode_p.h>
#include <Qt3DRender/private/nodraw_p.h>
#include <Qt3DRender/private/nopicking_p.h>
#include <Qt3DRender/private/vsyncframeadvanceservice_p.h>
#include <Qt3DRender/private/attribute_p.h>
#include <Qt3DRender/private/buffer_p.h>
#include <Qt3DRender/private/geometry_p.h>
#include <Qt3DRender/private/geometryrenderer_p.h>
#include <Qt3DRender/private/objectpicker_p.h>
#include <Qt3DRender/private/raycaster_p.h>
#include <Qt3DRender/private/boundingvolumedebug_p.h>
#include <Qt3DRender/private/nodemanagers_p.h>
#include <Qt3DRender/private/handle_types_p.h>
#include <Qt3DRender/private/buffermanager_p.h>
#include <Qt3DRender/private/geometryrenderermanager_p.h>
#include <Qt3DRender/private/loadgeometryjob_p.h>
#include <Qt3DRender/private/qsceneimportfactory_p.h>
#include <Qt3DRender/private/qsceneimporter_p.h>
#include <Qt3DRender/private/frustumculling_p.h>
#include <Qt3DRender/private/light_p.h>
#include <Qt3DRender/private/environmentlight_p.h>
#include <Qt3DRender/private/dispatchcompute_p.h>
#include <Qt3DRender/private/computecommand_p.h>
#include <Qt3DRender/private/rendersurfaceselector_p.h>
#include <Qt3DRender/private/rendersettings_p.h>
#include <Qt3DRender/private/backendnode_p.h>
#include <Qt3DRender/private/rendercapture_p.h>
#include <Qt3DRender/private/buffercapture_p.h>
#include <Qt3DRender/private/technique_p.h>
#include <Qt3DRender/private/offscreensurfacehelper_p.h>
#include <Qt3DRender/private/memorybarrier_p.h>
#include <Qt3DRender/private/shaderbuilder_p.h>
#include <Qt3DRender/private/blitframebuffer_p.h>
#include <Qt3DRender/private/subtreeenabler_p.h>
#include <Qt3DRender/private/armature_p.h>
#include <Qt3DRender/private/skeleton_p.h>
#include <Qt3DRender/private/joint_p.h>
#include <Qt3DRender/private/loadskeletonjob_p.h>
#include <Qt3DRender/private/proximityfilter_p.h>
#include <Qt3DRender/private/setfence_p.h>
#include <Qt3DRender/private/waitfence_p.h>
#include <Qt3DRender/private/shaderimage_p.h>
#include <Qt3DRender/private/debugoverlay_p.h>
#include <Qt3DRender/private/qrendererpluginfactory_p.h>
#include <Qt3DRender/private/updatelevelofdetailjob_p.h>
#include <Qt3DRender/private/job_common_p.h>
#include <Qt3DRender/private/pickeventfilter_p.h>
#include <Qt3DRender/private/techniquemanager_p.h>
#include <Qt3DRender/private/qgraphicsapifilter_p.h>
#include <private/qrenderpluginfactory_p.h>
#include <private/qrenderplugin_p.h>
#include <Qt3DCore/qentity.h>
#include <Qt3DCore/qtransform.h>
#include <Qt3DCore/qattribute.h>
#include <Qt3DCore/qbuffer.h>
#include <Qt3DCore/qgeometry.h>
#include <Qt3DCore/qnode.h>
#include <Qt3DCore/QAspectEngine>
#include <Qt3DCore/private/qservicelocator_p.h>
#include <Qt3DCore/private/qscene_p.h>
#include <Qt3DCore/private/qentity_p.h>
#include <Qt3DCore/private/qaspectmanager_p.h>
#include <Qt3DCore/private/qeventfilterservice_p.h>
#include <Qt3DCore/private/calcboundingvolumejob_p.h>
#include <Qt3DCore/private/vector_helper_p.h>
#include <QThread>
#include <QOpenGLContext>
QT_BEGIN_NAMESPACE
namespace {
QString dumpNode(const Qt3DCore::QEntity *n) {
auto formatNode = [](const Qt3DCore::QNode *n) {
QString res = QString(QLatin1String("%1{%2}"))
.arg(QLatin1String(n->metaObject()->className()))
.arg(n->id().id());
if (!n->objectName().isEmpty())
res += QString(QLatin1String(" (%1)")).arg(n->objectName());
if (!n->isEnabled())
res += QLatin1String(" [D]");
return res;
};
return formatNode(n);
}
QString dumpNodeFilters(const QString &filterType, const QList<Qt3DRender::QFilterKey *> &filters) {
QString res;
QStringList kv;
for (auto filter: filters)
kv.push_back(QString(QLatin1String("%1: %2")).arg(filter->name(), filter->value().toString()));
if (kv.size())
res += QString(QLatin1String("%1 <%2>")).arg(filterType, kv.join(QLatin1String(", ")));
return res;
}
QStringList dumpSGFilterState(Qt3DRender::Render::TechniqueManager *manager,
const Qt3DRender::GraphicsApiFilterData *contextData,
const Qt3DCore::QNode *n, int level = 0)
{
using namespace Qt3DRender;
QStringList reply;
const auto *entity = qobject_cast<const Qt3DCore::QEntity *>(n);
if (entity != nullptr) {
QString res = dumpNode(entity);
auto materials = entity->componentsOfType<QMaterial>();
if (!materials.empty() && materials.front()->effect()) {
auto m = materials.front();
const auto techniques = m->effect()->techniques();
for (auto t: m->effect()->techniques()) {
auto apiFilter = t->graphicsApiFilter();
if (apiFilter) {
auto backendTechnique = manager->lookupResource(t->id());
if (backendTechnique &&
!(*contextData == *backendTechnique->graphicsApiFilter()))
continue; // skip technique that doesn't match current renderer
}
QStringList filters;
filters += dumpNodeFilters(QLatin1String("T"), t->filterKeys());
const auto &renderPasses = t->renderPasses();
for (auto r: renderPasses)
filters += dumpNodeFilters(QLatin1String("RP"), r->filterKeys());
if (!filters.empty())
res += QLatin1String(" [ %1 ]").arg(filters.join(QLatin1String(" ")));
}
}
reply += res.rightJustified(res.size() + level * 2, QLatin1Char(' '));
level++;
}
const auto children = n->childNodes();
for (auto *child: children)
reply += dumpSGFilterState(manager, contextData, child, level);
return reply;
}
}
namespace Qt3DRender {
using namespace Qt3DCore;
#define CreateSynchronizerJobPtr(lambda, type) \
Render::SynchronizerJobPtr::create(lambda, type, #type)
/*!
* \class Qt3DRender::QRenderAspect
* \inheaderfile Qt3DRender/QRenderAspect
* \brief The QRenderAspect class.
* \since 5.7
* \inmodule Qt3DRender
*/
/*!
\namespace Qt3DRender::Render
\inmodule Qt3DRender
\brief Namespace used for accessing the classes
Renderer and QRenderPlugin.
*/
/*! \internal */
QRenderAspectPrivate::QRenderAspectPrivate(QRenderAspect::SubmissionType submissionType)
: QAbstractAspectPrivate()
, m_nodeManagers(nullptr)
, m_renderer(nullptr)
, m_initialized(false)
, m_renderAfterJobs(submissionType == QRenderAspect::Automatic
|| qEnvironmentVariableIsSet("QT3D_FORCE_SYNCHRONOUS_RENDER"))
, m_sceneImportersLoaded(false)
, m_offscreenHelper(nullptr)
, m_updateTreeEnabledJob(Render::UpdateTreeEnabledJobPtr::create())
, m_worldTransformJob(Render::UpdateWorldTransformJobPtr::create())
, m_expandBoundingVolumeJob(Render::ExpandBoundingVolumeJobPtr::create())
, m_calculateBoundingVolumeJob(Render::CalculateBoundingVolumeJobPtr::create())
, m_updateWorldBoundingVolumeJob(Render::UpdateWorldBoundingVolumeJobPtr::create())
, m_updateSkinningPaletteJob(Render::UpdateSkinningPaletteJobPtr::create())
, m_updateLevelOfDetailJob(Render::UpdateLevelOfDetailJobPtr::create())
, m_updateEntityLayersJob(Render::UpdateEntityLayersJobPtr::create())
, m_syncLoadingJobs(CreateSynchronizerJobPtr([] {}, Render::JobTypes::SyncLoadingJobs))
, m_pickBoundingVolumeJob(Render::PickBoundingVolumeJobPtr::create())
, m_rayCastingJob(Render::RayCastingJobPtr::create())
, m_pickEventFilter(new Render::PickEventFilter(this))
, m_submissionType(submissionType)
{
m_instances.append(this);
m_updateWorldBoundingVolumeJob->addDependency(m_worldTransformJob);
m_updateWorldBoundingVolumeJob->addDependency(m_calculateBoundingVolumeJob);
m_calculateBoundingVolumeJob->addDependency(m_updateTreeEnabledJob);
m_expandBoundingVolumeJob->addDependency(m_updateWorldBoundingVolumeJob);
m_updateLevelOfDetailJob->addDependency(m_expandBoundingVolumeJob);
m_pickBoundingVolumeJob->addDependency(m_expandBoundingVolumeJob);
m_pickBoundingVolumeJob->addDependency(m_updateEntityLayersJob);
m_rayCastingJob->addDependency(m_expandBoundingVolumeJob);
m_rayCastingJob->addDependency(m_updateEntityLayersJob);
}
/*! \internal */
QRenderAspectPrivate::~QRenderAspectPrivate()
{
// The renderer should have been shutdown as part of onUnregistered().
// If it still exists then this aspect is being deleted before the aspect
// engine is finished with it.
if (m_renderer != nullptr)
qWarning() << Q_FUNC_INFO << "The renderer should have been deleted when reaching this point (this warning may be normal when running tests)";
delete m_nodeManagers;
m_instances.removeAll(this);
qDeleteAll(m_sceneImporters);
}
QRenderAspectPrivate *QRenderAspectPrivate::findPrivate(Qt3DCore::QAspectEngine *engine)
{
const QList<QAbstractAspect *> aspects = engine->aspects();
for (QAbstractAspect* aspect : aspects) {
QRenderAspect *renderAspect = qobject_cast<QRenderAspect *>(aspect);
if (renderAspect)
return static_cast<QRenderAspectPrivate *>(renderAspect->d_ptr.get());
}
return nullptr;
}
QRenderAspectPrivate *QRenderAspectPrivate::get(QRenderAspect *q)
{
return q->d_func();
}
void QRenderAspectPrivate::jobsDone()
{
m_renderer->jobsDone(m_aspectManager);
}
void QRenderAspectPrivate::frameDone()
{
m_renderer->setJobsInLastFrame(m_aspectManager->jobsInLastFrame());
if (m_renderAfterJobs)
m_renderer->render(true);
}
void QRenderAspectPrivate::createNodeManagers()
{
m_nodeManagers = new Render::NodeManagers();
m_updateTreeEnabledJob->setManagers(m_nodeManagers);
m_worldTransformJob->setManagers(m_nodeManagers);
m_expandBoundingVolumeJob->setManagers(m_nodeManagers);
m_calculateBoundingVolumeJob->setManagers(m_nodeManagers);
m_updateWorldBoundingVolumeJob->setManager(m_nodeManagers->renderNodesManager());
m_updateSkinningPaletteJob->setManagers(m_nodeManagers);
m_updateLevelOfDetailJob->setManagers(m_nodeManagers);
m_updateEntityLayersJob->setManager(m_nodeManagers);
m_pickBoundingVolumeJob->setManagers(m_nodeManagers);
m_rayCastingJob->setManagers(m_nodeManagers);
m_calculateBoundingVolumeJob->setFrontEndNodeManager(m_aspectManager);
}
void QRenderAspectPrivate::onEngineStartup()
{
Render::Entity *rootEntity = m_nodeManagers->lookupResource<Render::Entity, Render::EntityManager>(m_rootId);
Q_ASSERT(rootEntity);
m_renderer->setSceneRoot(rootEntity);
m_worldTransformJob->setRoot(rootEntity);
m_expandBoundingVolumeJob->setRoot(rootEntity);
m_calculateBoundingVolumeJob->setRoot(rootEntity);
m_updateLevelOfDetailJob->setRoot(rootEntity);
m_updateSkinningPaletteJob->setRoot(rootEntity);
m_updateTreeEnabledJob->setRoot(rootEntity);
m_pickBoundingVolumeJob->setRoot(rootEntity);
m_rayCastingJob->setRoot(rootEntity);
// Ensures all skeletons are loaded before we try to update them
m_updateSkinningPaletteJob->addDependency(m_syncLoadingJobs);
// make sure bv job in core aspect runs before the one in render aspect
if (m_aspectManager) {
auto *coreAspect = qobject_cast<Qt3DCore::QCoreAspect *>(m_aspectManager->aspect(&Qt3DCore::QCoreAspect::staticMetaObject));
Q_ASSERT(coreAspect);
m_calculateBoundingVolumeJob->addDependency(coreAspect->calculateBoundingVolumeJob());
auto bvJob = qSharedPointerCast<Qt3DCore::CalculateBoundingVolumeJob>(coreAspect->calculateBoundingVolumeJob());
bvJob->addWatcher(m_calculateBoundingVolumeJob);
}
}
void QRenderAspectPrivate::onEngineAboutToShutdown()
{
if (m_aspectManager) {
auto *coreAspect = qobject_cast<Qt3DCore::QCoreAspect *>(m_aspectManager->aspect(&Qt3DCore::QCoreAspect::staticMetaObject));
Q_ASSERT(coreAspect);
auto bvJob = qSharedPointerCast<Qt3DCore::CalculateBoundingVolumeJob>(coreAspect->calculateBoundingVolumeJob());
bvJob->removeWatcher(m_calculateBoundingVolumeJob);
}
}
/*! \internal */
void QRenderAspectPrivate::registerBackendTypes()
{
Q_Q(QRenderAspect);
qRegisterMetaType<Qt3DCore::QBuffer*>();
qRegisterMetaType<Qt3DCore::QJoint*>();
qRegisterMetaType<Qt3DRender::QEffect*>();
qRegisterMetaType<Qt3DRender::QFrameGraphNode *>();
qRegisterMetaType<Qt3DRender::QCamera*>();
qRegisterMetaType<Qt3DRender::QShaderProgram*>();
qRegisterMetaType<Qt3DRender::QViewport*>();
q->registerBackendType<Qt3DCore::QEntity>(QSharedPointer<Render::RenderEntityFunctor>::create(m_renderer, m_nodeManagers));
q->registerBackendType<Qt3DCore::QTransform>(QSharedPointer<Render::NodeFunctor<Render::Transform, Render::TransformManager> >::create(m_renderer));
q->registerBackendType<Qt3DRender::QCameraLens>(QSharedPointer<Render::CameraLensFunctor>::create(m_renderer, q));
q->registerBackendType<QLayer>(QSharedPointer<Render::NodeFunctor<Render::Layer, Render::LayerManager> >::create(m_renderer));
q->registerBackendType<QLevelOfDetail>(QSharedPointer<Render::NodeFunctor<Render::LevelOfDetail, Render::LevelOfDetailManager> >::create(m_renderer));
q->registerBackendType<QLevelOfDetailSwitch>(QSharedPointer<Render::NodeFunctor<Render::LevelOfDetail, Render::LevelOfDetailManager> >::create(m_renderer));
q->registerBackendType<QSceneLoader>(QSharedPointer<Render::RenderSceneFunctor>::create(m_renderer, m_nodeManagers->sceneManager()));
q->registerBackendType<QRenderTarget>(QSharedPointer<Render::RenderTargetFunctor>::create(m_renderer, m_nodeManagers->renderTargetManager()));
q->registerBackendType<QRenderTargetOutput>(QSharedPointer<Render::NodeFunctor<Render::RenderTargetOutput, Render::AttachmentManager> >::create(m_renderer));
q->registerBackendType<QRenderSettings>(QSharedPointer<Render::RenderSettingsFunctor>::create(m_renderer));
q->registerBackendType<QRenderState>(QSharedPointer<Render::NodeFunctor<Render::RenderStateNode, Render::RenderStateManager> >::create(m_renderer));
// Geometry + Compute
q->registerBackendType<Qt3DCore::QAttribute>(QSharedPointer<Render::NodeFunctor<Render::Attribute, Render::AttributeManager> >::create(m_renderer));
q->registerBackendType<Qt3DCore::QBuffer>(QSharedPointer<Render::BufferFunctor>::create(m_renderer, m_nodeManagers->bufferManager()));
q->registerBackendType<QComputeCommand>(QSharedPointer<Render::NodeFunctor<Render::ComputeCommand, Render::ComputeCommandManager> >::create(m_renderer));
q->registerBackendType<QGeometry>(QSharedPointer<Render::NodeFunctor<Render::Geometry, Render::GeometryManager> >::create(m_renderer));
q->registerBackendType<QGeometryRenderer>(QSharedPointer<Render::GeometryRendererFunctor>::create(m_renderer, m_nodeManagers->geometryRendererManager()));
q->registerBackendType<QPickingProxy>(QSharedPointer<Render::PickingProxyFunctor>::create(m_renderer, m_nodeManagers->pickingProxyManager()));
q->registerBackendType<Qt3DCore::QArmature>(QSharedPointer<Render::NodeFunctor<Render::Armature, Render::ArmatureManager>>::create(m_renderer));
q->registerBackendType<Qt3DCore::QAbstractSkeleton>(QSharedPointer<Render::SkeletonFunctor>::create(m_renderer, m_nodeManagers->skeletonManager(), m_nodeManagers->jointManager()));
q->registerBackendType<Qt3DCore::QJoint>(QSharedPointer<Render::JointFunctor>::create(m_renderer, m_nodeManagers->jointManager(), m_nodeManagers->skeletonManager()));
// Textures
q->registerBackendType<QAbstractTexture>(QSharedPointer<Render::TextureFunctor>::create(m_renderer, m_nodeManagers->textureManager()));
q->registerBackendType<QAbstractTextureImage>(QSharedPointer<Render::TextureImageFunctor>::create(m_renderer,
m_nodeManagers->textureImageManager()));
// Material system
q->registerBackendType<QEffect>(QSharedPointer<Render::NodeFunctor<Render::Effect, Render::EffectManager> >::create(m_renderer));
q->registerBackendType<QFilterKey>(QSharedPointer<Render::NodeFunctor<Render::FilterKey, Render::FilterKeyManager> >::create(m_renderer));
q->registerBackendType<QAbstractLight>(QSharedPointer<Render::RenderLightFunctor>::create(m_renderer, m_nodeManagers));
q->registerBackendType<QEnvironmentLight>(QSharedPointer<Render::NodeFunctor<Render::EnvironmentLight, Render::EnvironmentLightManager> >::create(m_renderer));
q->registerBackendType<QMaterial>(QSharedPointer<Render::NodeFunctor<Render::Material, Render::MaterialManager> >::create(m_renderer));
q->registerBackendType<QParameter>(QSharedPointer<Render::NodeFunctor<Render::Parameter, Render::ParameterManager> >::create(m_renderer));
q->registerBackendType<QRenderPass>(QSharedPointer<Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager> >::create(m_renderer));
q->registerBackendType<QShaderData>(QSharedPointer<Render::RenderShaderDataFunctor>::create(m_renderer, m_nodeManagers));
q->registerBackendType<QShaderProgram>(QSharedPointer<Render::ShaderFunctor>::create(m_renderer, m_nodeManagers->shaderManager()));
q->registerBackendType<QShaderProgramBuilder>(QSharedPointer<Render::NodeFunctor<Render::ShaderBuilder, Render::ShaderBuilderManager> >::create(m_renderer));
q->registerBackendType<QTechnique>(QSharedPointer<Render::TechniqueFunctor>::create(m_renderer, m_nodeManagers));
q->registerBackendType<QShaderImage>(QSharedPointer<Render::NodeFunctor<Render::ShaderImage, Render::ShaderImageManager>>::create(m_renderer));
// Framegraph
q->registerBackendType<QFrameGraphNode>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::FrameGraphNode, QFrameGraphNode> >::create(m_renderer));
q->registerBackendType<QCameraSelector>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector> >::create(m_renderer));
q->registerBackendType<QClearBuffers>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ClearBuffers, QClearBuffers> >::create(m_renderer));
q->registerBackendType<QDispatchCompute>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::DispatchCompute, QDispatchCompute> >::create(m_renderer));
q->registerBackendType<QFrustumCulling>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::FrustumCulling, QFrustumCulling> >::create(m_renderer));
q->registerBackendType<QLayerFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter> >::create(m_renderer));
q->registerBackendType<QNoDraw>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw> >::create(m_renderer));
q->registerBackendType<QRenderPassFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter> >::create(m_renderer));
q->registerBackendType<QRenderStateSet>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::StateSetNode, QRenderStateSet> >::create(m_renderer));
q->registerBackendType<QRenderSurfaceSelector>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderSurfaceSelector, QRenderSurfaceSelector> >::create(m_renderer));
q->registerBackendType<QRenderTargetSelector>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector> >::create(m_renderer));
q->registerBackendType<QSortPolicy>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SortPolicy, QSortPolicy> >::create(m_renderer));
q->registerBackendType<QTechniqueFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter> >::create(m_renderer));
q->registerBackendType<QViewport>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport> >::create(m_renderer));
q->registerBackendType<QRenderCapture>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderCapture, QRenderCapture> >::create(m_renderer));
q->registerBackendType<QBufferCapture>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::BufferCapture, QBufferCapture> >::create(m_renderer));
q->registerBackendType<QMemoryBarrier>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::MemoryBarrier, QMemoryBarrier> >::create(m_renderer));
q->registerBackendType<QProximityFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ProximityFilter, QProximityFilter> >::create(m_renderer));
q->registerBackendType<QBlitFramebuffer>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::BlitFramebuffer, QBlitFramebuffer> >::create(m_renderer));
q->registerBackendType<QSetFence>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SetFence, QSetFence> >::create(m_renderer));
q->registerBackendType<QWaitFence>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::WaitFence, QWaitFence> >::create(m_renderer));
q->registerBackendType<QNoPicking>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::NoPicking, QNoPicking> >::create(m_renderer));
q->registerBackendType<QSubtreeEnabler>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SubtreeEnabler, QSubtreeEnabler> >::create(m_renderer));
q->registerBackendType<QDebugOverlay>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::DebugOverlay, QDebugOverlay> >::create(m_renderer));
// Picking
q->registerBackendType<QObjectPicker>(QSharedPointer<Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager> >::create(m_renderer));
q->registerBackendType<QRayCaster>(QSharedPointer<Render::NodeFunctor<Render::RayCaster, Render::RayCasterManager> >::create(m_renderer));
q->registerBackendType<QScreenRayCaster>(QSharedPointer<Render::NodeFunctor<Render::RayCaster, Render::RayCasterManager> >::create(m_renderer));
// Plugins
for (const QString &plugin : std::as_const(m_pluginConfig))
loadRenderPlugin(plugin);
}
/*! \internal */
void QRenderAspectPrivate::unregisterBackendTypes()
{
Q_Q(QRenderAspect);
unregisterBackendType<Qt3DCore::QEntity>();
unregisterBackendType<Qt3DCore::QTransform>();
unregisterBackendType<Qt3DRender::QCameraLens>();
unregisterBackendType<QLayer>();
unregisterBackendType<QSceneLoader>();
unregisterBackendType<QRenderTarget>();
unregisterBackendType<QRenderTargetOutput>();
unregisterBackendType<QRenderSettings>();
unregisterBackendType<QRenderState>();
// Geometry + Compute
unregisterBackendType<Qt3DCore::QAttribute>();
unregisterBackendType<Qt3DCore::QBuffer>();
unregisterBackendType<QComputeCommand>();
unregisterBackendType<QGeometry>();
unregisterBackendType<QGeometryRenderer>();
unregisterBackendType<QPickingProxy>();
unregisterBackendType<Qt3DCore::QArmature>();
unregisterBackendType<Qt3DCore::QAbstractSkeleton>();
unregisterBackendType<Qt3DCore::QJoint>();
// Textures
unregisterBackendType<QAbstractTexture>();
unregisterBackendType<QAbstractTextureImage>();
// Material system
unregisterBackendType<QEffect>();
unregisterBackendType<QFilterKey>();
unregisterBackendType<QAbstractLight>();
unregisterBackendType<QEnvironmentLight>();
unregisterBackendType<QMaterial>();
unregisterBackendType<QParameter>();
unregisterBackendType<QRenderPass>();
unregisterBackendType<QShaderData>();
unregisterBackendType<QShaderProgram>();
unregisterBackendType<QShaderProgramBuilder>();
unregisterBackendType<QTechnique>();
unregisterBackendType<QShaderImage>();
// Framegraph
unregisterBackendType<QCameraSelector>();
unregisterBackendType<QClearBuffers>();
unregisterBackendType<QDispatchCompute>();
unregisterBackendType<QFrustumCulling>();
unregisterBackendType<QLayerFilter>();
unregisterBackendType<QNoDraw>();
unregisterBackendType<QRenderPassFilter>();
unregisterBackendType<QRenderStateSet>();
unregisterBackendType<QRenderSurfaceSelector>();
unregisterBackendType<QRenderTargetSelector>();
unregisterBackendType<QSortPolicy>();
unregisterBackendType<QTechniqueFilter>();
unregisterBackendType<QViewport>();
unregisterBackendType<QRenderCapture>();
unregisterBackendType<QBufferCapture>();
unregisterBackendType<QMemoryBarrier>();
unregisterBackendType<QSetFence>();
unregisterBackendType<QWaitFence>();
unregisterBackendType<QSubtreeEnabler>();
unregisterBackendType<QDebugOverlay>();
// Picking
unregisterBackendType<QObjectPicker>();
unregisterBackendType<QRayCaster>();
unregisterBackendType<QScreenRayCaster>();
// Plugins
for (auto &plugin : m_renderPlugins)
plugin->unregisterBackendTypes(q);
}
void QRenderAspectPrivate::registerBackendType(const QMetaObject &obj,
const QBackendNodeMapperPtr &functor)
{
Q_Q(QRenderAspect);
q->registerBackendType(obj, functor);
}
/*!
* \enum Qt3DRender::QRenderAspect::SubmissionType
*
* \value Automatic
* The QRenderAspect takes care of submitting rendering commands to the
* GPU.
* \value Manual
* The user will take care of telling the QRenderAspect when is the
* appropriate time to submit the rendering commands to the GPU.
*/
/*!
* The constructor creates a new QRenderAspect::QRenderAspect instance with the
* specified \a parent. This constructor will set the submission type to
* Automatic.
* \param parent
*/
QRenderAspect::QRenderAspect(QObject *parent)
: QRenderAspect(QRenderAspect::Automatic, parent)
{
}
/*!
* The constructor creates a new QRenderAspect::QRenderAspect instance with the
* specified \a parent. The \a submissionType specifies whether the
* RenderAspect is in charge of performing the rendering submission or if the
* user will take care of it.
* \param parent
*/
QRenderAspect::QRenderAspect(QRenderAspect::SubmissionType submissionType,
QObject *parent)
: Qt3DCore::QAbstractAspect(*new QRenderAspectPrivate(submissionType),
parent)
{
}
/*! \internal */
QRenderAspect::QRenderAspect(QRenderAspectPrivate &dd, QObject *parent)
: QAbstractAspect(dd, parent)
{
setObjectName(QStringLiteral("Render Aspect"));
}
/*! \internal */
QRenderAspect::~QRenderAspect()
{
}
std::vector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
{
using namespace Render;
Q_D(QRenderAspect);
d->m_renderer->setTime(time);
#if defined(QT3D_RENDER_DUMP_BACKEND_NODES)
d->m_renderer->dumpInfo();
#endif
// Create jobs that will get executed by the threadpool
std::vector<QAspectJobPtr> jobs;
// 1 GeometryJobs, SceneLoaderJobs, LoadTextureJobs
// 2 CalculateBoundingVolumeJob (depends on LoadBuffer)
// 3 WorldTransformJob
// 4 UpdateBoundingVolume, FramePreparationJob (depend on WorlTransformJob)
// 5 RenderViewJobs
// 6 PickBoundingVolumeJob
// 7 Cleanup Job (depends on RV)
// Ensure we have a settings object. It may get deleted by the call to
// QChangeArbiter::syncChanges() that happens just before the render aspect is
// asked for jobs to execute (this function). If that is the case, the RenderSettings will
// be null and we should not generate any jobs.
if (d->m_renderer->isRunning() && d->m_renderer->settings()) {
NodeManagers *manager = d->m_nodeManagers;
d->m_syncLoadingJobs->removeDependency(QWeakPointer<QAspectJob>());
d->m_calculateBoundingVolumeJob->removeDependency(QWeakPointer<QAspectJob>());
d->m_updateLevelOfDetailJob->setFrameGraphRoot(d->m_renderer->frameGraphRoot());
// Launch skeleton loader jobs once all loading jobs have completed.
const QList<Render::HSkeleton> skeletonsToLoad =
manager->skeletonManager()->takeDirtySkeletons(Render::SkeletonManager::SkeletonDataDirty);
for (const auto &skeletonHandle : skeletonsToLoad) {
auto loadSkeletonJob = Render::LoadSkeletonJobPtr::create(skeletonHandle);
loadSkeletonJob->setNodeManagers(manager);
d->m_syncLoadingJobs->addDependency(loadSkeletonJob);
jobs.push_back(loadSkeletonJob);
}
// TO DO: Have 2 jobs queue
// One for urgent jobs that are mandatory for the rendering of a frame
// Another for jobs that can span across multiple frames (Scene/Mesh loading)
const std::vector<Render::LoadSceneJobPtr> sceneJobs = manager->sceneManager()->takePendingSceneLoaderJobs();
if (!sceneJobs.empty() && !d->m_sceneImportersLoaded) {
d->loadSceneImporters();
}
for (const Render::LoadSceneJobPtr &job : sceneJobs) {
job->setNodeManagers(d->m_nodeManagers);
job->setSceneImporters(d->m_sceneImporters);
jobs.push_back(job);
}
Qt3DCore::moveAtEnd(jobs, d->createGeometryRendererJobs());
Qt3DCore::moveAtEnd(jobs, d->createPreRendererJobs());
// Don't spawn any rendering jobs, if the renderer decides to skip this frame
// Note: this only affects rendering jobs (jobs that load buffers,
// perform picking,... must still be run)
if (!d->m_renderer->shouldRender()) {
d->m_renderer->skipNextFrame();
QThread::msleep(1);
return jobs;
}
// Traverse the current framegraph and create jobs to populate
// RenderBins with RenderCommands
// All jobs needed to create the frame and their dependencies are set by
// renderBinJobs()
const AbstractRenderer::BackendNodeDirtySet dirtyBitsForFrame = d->m_renderer->dirtyBits();
// Create the jobs to build the frame
const bool entitiesEnabledDirty = dirtyBitsForFrame & AbstractRenderer::EntityEnabledDirty;
if (entitiesEnabledDirty)
jobs.push_back(d->m_updateTreeEnabledJob);
if (entitiesEnabledDirty ||
dirtyBitsForFrame & AbstractRenderer::TransformDirty) {
jobs.push_back(d->m_worldTransformJob);
jobs.push_back(d->m_updateWorldBoundingVolumeJob);
}
if (entitiesEnabledDirty ||
dirtyBitsForFrame & AbstractRenderer::GeometryDirty ||
dirtyBitsForFrame & AbstractRenderer::BuffersDirty) {
jobs.push_back(d->m_calculateBoundingVolumeJob);
}
if (entitiesEnabledDirty ||
dirtyBitsForFrame & AbstractRenderer::GeometryDirty ||
dirtyBitsForFrame & AbstractRenderer::TransformDirty) {
jobs.push_back(d->m_expandBoundingVolumeJob);
}
// TO DO: Conditionally add if skeletons dirty
jobs.push_back(d->m_syncLoadingJobs);
d->m_updateSkinningPaletteJob->setDirtyJoints(manager->jointManager()->dirtyJoints());
jobs.push_back(d->m_updateSkinningPaletteJob);
jobs.push_back(d->m_updateLevelOfDetailJob);
// Rebuild Entity Layers list if layers are dirty
const bool layersDirty = dirtyBitsForFrame & AbstractRenderer::LayersDirty;
if (layersDirty)
jobs.push_back(d->m_updateEntityLayersJob);
Qt3DCore::moveAtEnd(jobs, d->m_renderer->renderBinJobs());
}
return jobs;
}
QVariant QRenderAspect::executeCommand(const QStringList &args)
{
Q_D(QRenderAspect);
if (args.size() == 1) {
Render::RenderSettings *settings = d->m_renderer->settings();
auto *droot = static_cast<Qt3DCore::QEntityPrivate *>(Qt3DCore::QNodePrivate::get(d->m_root));
auto *fg = qobject_cast<Qt3DRender::QFrameGraphNode *>(droot->m_scene->lookupNode(settings->activeFrameGraphID()));
if (fg) {
if (args.front() == QLatin1String("framegraph"))
return Qt3DRender::QFrameGraphNodePrivate::get(fg)->dumpFrameGraph();
if (args.front() == QLatin1String("framepaths"))
return Qt3DRender::QFrameGraphNodePrivate::get(fg)->dumpFrameGraphPaths().join(QLatin1String("\n"));
if (args.front() == QLatin1String("filterstates")) {
const auto activeContextInfo = d->m_renderer->contextInfo();
QString res = QLatin1String("Active Graphics API: ") + activeContextInfo->toString() + QLatin1String("\n");
res += QLatin1String("Render Views:\n ") + Qt3DRender::QFrameGraphNodePrivate::get(fg)->dumpFrameGraphFilterState().join(QLatin1String("\n ")) + QLatin1String("\n");
res += QLatin1String("Scene Graph:\n ") + dumpSGFilterState(d->m_nodeManagers->techniqueManager(), activeContextInfo, d->m_root).join(QLatin1String("\n "));
return res;
}
}
if (args.front() == QLatin1String("scenegraph"))
return droot->dumpSceneGraph();
}
return d->m_renderer->executeCommand(args);
}
void QRenderAspect::onEngineStartup()
{
Q_D(QRenderAspect);
if (d->m_renderAfterJobs) // synchronous rendering but using QWindow
d->m_renderer->initialize();
d->onEngineStartup();
}
QStringList QRenderAspect::dependencies() const
{
return { QLatin1String("core") };
}
void QRenderAspect::onRegistered()
{
// Create a renderer each time as this is destroyed in onUnregistered below. If
// using a threaded renderer, this blocks until the render thread has been created
// and started.
Q_D(QRenderAspect);
d->createNodeManagers();
// Load proper Renderer class based on Qt configuration preferences
d->m_renderer = d->loadRendererPlugin();
Q_ASSERT(d->m_renderer);
d->m_renderer->setScreen(d->m_screen);
d->m_renderer->setAspect(this);
d->m_renderer->setNodeManagers(d->m_nodeManagers);
// Create a helper for deferring creation of an offscreen surface used during cleanup
// to the main thread, after we know what the surface format in use is.
d->m_offscreenHelper = new Render::OffscreenSurfaceHelper(d->m_renderer);
d->m_offscreenHelper->moveToThread(QCoreApplication::instance()->thread());
d->m_renderer->setOffscreenSurfaceHelper(d->m_offscreenHelper);
// Register backend types now that we have a renderer
d->registerBackendTypes();
if (!d->m_initialized) {
// Register the VSyncFrameAdvanceService to drive the aspect manager loop
// depending on the vsync
if (d->m_aspectManager) {
QAbstractFrameAdvanceService *advanceService = d->m_renderer->frameAdvanceService();
if (advanceService)
d->services()->registerServiceProvider(Qt3DCore::QServiceLocator::FrameAdvanceService,
advanceService);
}
if (d->services())
d->m_renderer->setServices(d->services());
d->m_initialized = true;
}
if (d->m_aspectManager)
d->services()->eventFilterService()->registerEventFilter(d->m_pickEventFilter.data(), 1024);
}
void QRenderAspect::onUnregistered()
{
Q_D(QRenderAspect);
if (d->m_renderer) {
// Request the renderer shuts down. In the threaded renderer case, the
// Renderer destructor is the synchronization point where we wait for the
// thread to join (see below).
d->m_renderer->shutdown();
}
d->unregisterBackendTypes();
d->m_renderer->releaseGraphicsResources();
if (d->m_aspectManager)
d->services()->eventFilterService()->unregisterEventFilter(d->m_pickEventFilter.data());
delete d->m_nodeManagers;
d->m_nodeManagers = nullptr;
// Waits for the render thread to join (if using threaded renderer)
delete d->m_renderer;
d->m_renderer = nullptr;
// Queue the offscreen surface helper for deletion on the main thread.
// That will take care of deleting the offscreen surface itself.
d->m_offscreenHelper->deleteLater();
d->m_offscreenHelper = nullptr;
}
std::vector<Qt3DCore::QAspectJobPtr> QRenderAspectPrivate::createGeometryRendererJobs() const
{
Render::GeometryRendererManager *geomRendererManager = m_nodeManagers->geometryRendererManager();
const QList<QNodeId> dirtyGeometryRenderers = geomRendererManager->dirtyGeometryRenderers();
std::vector<QAspectJobPtr> dirtyGeometryRendererJobs;
dirtyGeometryRendererJobs.reserve(dirtyGeometryRenderers.size());
for (const QNodeId &geoRendererId : dirtyGeometryRenderers) {
Render::HGeometryRenderer geometryRendererHandle = geomRendererManager->lookupHandle(geoRendererId);
if (!geometryRendererHandle.isNull()) {
auto job = Render::LoadGeometryJobPtr::create(geometryRendererHandle);
job->setNodeManagers(m_nodeManagers);
dirtyGeometryRendererJobs.push_back(job);
}
}
return dirtyGeometryRendererJobs;
}
std::vector<QAspectJobPtr> QRenderAspectPrivate::createPreRendererJobs() const
{
if (!m_renderer)
return {};
auto jobs = m_renderer->preRenderingJobs();
// Set values on picking jobs
Render::RenderSettings *renderSetting = m_renderer->settings();
if (renderSetting != nullptr) {
m_pickBoundingVolumeJob->setRenderSettings(renderSetting);
m_pickBoundingVolumeJob->setFrameGraphRoot(m_renderer->frameGraphRoot());
m_rayCastingJob->setRenderSettings(renderSetting);
m_rayCastingJob->setFrameGraphRoot(m_renderer->frameGraphRoot());
}
jobs.push_back(m_pickBoundingVolumeJob);
jobs.push_back(m_rayCastingJob);
return jobs;
}
void QRenderAspectPrivate::loadSceneImporters()
{
const QStringList keys = QSceneImportFactory::keys();
for (const QString &key : keys) {
QSceneImporter *sceneIOHandler = QSceneImportFactory::create(key, QStringList());
if (sceneIOHandler != nullptr)
m_sceneImporters.append(sceneIOHandler);
}
m_sceneImportersLoaded = true;
}
Render::AbstractRenderer *QRenderAspectPrivate::loadRendererPlugin()
{
// Note: for now we load the first renderer plugin that is successfully loaded
// In the future we might want to offer the user a way to hint at which renderer
// plugin would best be loaded
const QByteArray envTarget = qgetenv("QT3D_RENDERER");
const QString targetKey = !envTarget.isEmpty() ? QString::fromLatin1(envTarget) : QStringLiteral("opengl");
const QStringList keys = Render::QRendererPluginFactory::keys();
for (const QString &key : keys) {
if (key != targetKey)
continue;
Render::AbstractRenderer *renderer = Render::QRendererPluginFactory::create(key);
if (renderer)
return renderer;
}
const QByteArray targetKeyName = targetKey.toLatin1();
qFatal("Unable to find renderer plugin for %s", targetKeyName.constData());
return nullptr;
}
bool QRenderAspectPrivate::processMouseEvent(QObject *obj, QMouseEvent *event)
{
Render::RenderSettings *renderSetting = m_renderer->settings();
if (!renderSetting)
return false;
if (m_renderer->processMouseEvent(obj, event))
return true;
m_pickBoundingVolumeJob->processMouseEvent(obj, event);
return false;
}
bool QRenderAspectPrivate::processKeyEvent(QObject *obj, QKeyEvent *event)
{
Q_UNUSED(obj);
if (m_renderer->processKeyEvent(obj, event))
return true;
return false;
}
void QRenderAspectPrivate::loadRenderPlugin(const QString &pluginName)
{
Q_Q(QRenderAspect);
const QStringList keys = Render::QRenderPluginFactory::keys();
if (!keys.contains(pluginName))
return;
if (m_pluginConfig.contains(pluginName) && !m_loadedPlugins.contains(pluginName)) {
auto plugin = std::unique_ptr<Render::QRenderPlugin>(Render::QRenderPluginFactory::create(pluginName, QStringList()));
if (plugin) {
m_loadedPlugins.append(pluginName);
plugin->registerBackendTypes(q, m_renderer);
m_renderPlugins.push_back(std::move(plugin));
}
}
}
QList<QString> QRenderAspectPrivate::m_pluginConfig;
QMutex QRenderAspectPrivate::m_pluginLock;
QList<QRenderAspectPrivate *> QRenderAspectPrivate::m_instances;
void QRenderAspectPrivate::configurePlugin(const QString &plugin)
{
QMutexLocker lock(&m_pluginLock);
if (!m_pluginConfig.contains(plugin)) {
m_pluginConfig.append(plugin);
for (QRenderAspectPrivate *instance : std::as_const(m_instances))
instance->loadRenderPlugin(plugin);
}
}
} // namespace Qt3DRender
QT_END_NAMESPACE
QT3D_REGISTER_NAMESPACED_ASPECT("render", QT_PREPEND_NAMESPACE(Qt3DRender), QRenderAspect)
#include "moc_qrenderaspect.cpp"