diff options
author | Paul Lemire <paul.lemire@kdab.com> | 2015-11-10 09:37:18 +0100 |
---|---|---|
committer | Andy Nichols <andy.nichols@theqtcompany.com> | 2015-11-16 12:26:12 +0000 |
commit | b15dbe34c7f9cccb943636b0fc95a9f52d3f79e9 (patch) | |
tree | 9e44b20b48bbf543754b3a328ddc6d93b5b32ecd /src | |
parent | eb43b63a8457f451507f47b4fb6b16bdafc677f9 (diff) |
Renderer: use NodeManagers
Change-Id: I8d505034b24c3ec00b93ace02e5a4fe450939478
Reviewed-by: Andy Nichols <andy.nichols@theqtcompany.com>
Diffstat (limited to 'src')
22 files changed, 293 insertions, 379 deletions
diff --git a/src/render/backend/entity.cpp b/src/render/backend/entity.cpp index 7d31a7645..cba6ef65c 100644 --- a/src/render/backend/entity.cpp +++ b/src/render/backend/entity.cpp @@ -36,7 +36,7 @@ #include "entity_p.h" #include <Qt3DRender/private/managers_p.h> -#include <Qt3DRender/private/renderer_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/qabstractlight.h> #include <Qt3DRender/qlayer.h> #include <Qt3DRender/qmaterial.h> @@ -66,7 +66,7 @@ namespace Render { Entity::Entity() : QBackendNode() - , m_renderer(Q_NULLPTR) + , m_nodeManagers(Q_NULLPTR) , m_enabled(true) { } @@ -78,15 +78,15 @@ Entity::~Entity() void Entity::cleanup() { - if (m_renderer != Q_NULLPTR) { + if (m_nodeManagers != Q_NULLPTR) { Entity *parentEntity = parent(); if (parentEntity != Q_NULLPTR) parentEntity->removeChildHandle(m_handle); for (int i = 0; i < m_childrenHandles.size(); i++) - m_renderer->renderNodesManager()->release(m_childrenHandles[i]); + m_nodeManagers->renderNodesManager()->release(m_childrenHandles[i]); // We need to release using peerUuid otherwise the handle will be cleared // but would still remain in the Id to Handle table - m_renderer->worldMatrixManager()->releaseResource(peerUuid()); + m_nodeManagers->worldMatrixManager()->releaseResource(peerUuid()); qCDebug(Render::RenderNodes) << Q_FUNC_INFO; @@ -111,20 +111,20 @@ void Entity::cleanup() void Entity::setParentHandle(HEntity parentHandle) { - Q_ASSERT(m_renderer); + Q_ASSERT(m_nodeManagers); // Remove ourselves from previous parent children list - Entity *parent = m_renderer->renderNodesManager()->data(parentHandle); + Entity *parent = m_nodeManagers->renderNodesManager()->data(parentHandle); if (parent != Q_NULLPTR && parent->m_childrenHandles.contains(m_handle)) parent->m_childrenHandles.remove(m_handle); m_parentHandle = parentHandle; - parent = m_renderer->renderNodesManager()->data(parentHandle); + parent = m_nodeManagers->renderNodesManager()->data(parentHandle); if (parent != Q_NULLPTR && !parent->m_childrenHandles.contains(m_handle)) parent->m_childrenHandles.append(m_handle); } -void Entity::setRenderer(Renderer *renderer) +void Entity::setNodeManagers(NodeManagers *manager) { - m_renderer = renderer; + m_nodeManagers = manager; } void Entity::setHandle(HEntity handle) @@ -138,7 +138,7 @@ void Entity::updateFromPeer(Qt3DCore::QNode *peer) const QNodeId parentEntityId = entity->parentEntityId(); m_objectName = peer->objectName(); - m_worldTransform = m_renderer->worldMatrixManager()->getOrAcquireHandle(peerUuid()); + m_worldTransform = m_nodeManagers->worldMatrixManager()->getOrAcquireHandle(peerUuid()); // TO DO: Suboptimal -> Maybe have a Hash<QComponent, QEntityList> instead m_transformComponent = QNodeId(); @@ -157,7 +157,7 @@ void Entity::updateFromPeer(Qt3DCore::QNode *peer) addComponent(comp); if (!parentEntityId.isNull()) { - setParentHandle(m_renderer->renderNodesManager()->lookupHandle(parentEntityId)); + setParentHandle(m_nodeManagers->renderNodesManager()->lookupHandle(parentEntityId)); } else { qCDebug(Render::RenderNodes) << Q_FUNC_INFO << "No parent entity found for Entity" << peerUuid(); } @@ -208,14 +208,14 @@ void Entity::dump() const Entity *Entity::parent() const { - return m_renderer->renderNodesManager()->data(m_parentHandle); + return m_nodeManagers->renderNodesManager()->data(m_parentHandle); } void Entity::appendChildHandle(HEntity childHandle) { if (!m_childrenHandles.contains(childHandle)) { m_childrenHandles.append(childHandle); - Entity *child = m_renderer->renderNodesManager()->data(childHandle); + Entity *child = m_nodeManagers->renderNodesManager()->data(childHandle); if (child != Q_NULLPTR) child->m_parentHandle = m_handle; } @@ -234,7 +234,7 @@ QVector<Entity *> Entity::children() const QVector<Entity *> childrenVector; childrenVector.reserve(m_childrenHandles.size()); foreach (HEntity handle, m_childrenHandles) { - Entity *child = m_renderer->renderNodesManager()->data(handle); + Entity *child = m_nodeManagers->renderNodesManager()->data(handle); if (child != Q_NULLPTR) childrenVector.append(child); } @@ -243,12 +243,12 @@ QVector<Entity *> Entity::children() const QMatrix4x4 *Entity::worldTransform() { - return m_renderer->worldMatrixManager()->data(m_worldTransform); + return m_nodeManagers->worldMatrixManager()->data(m_worldTransform); } const QMatrix4x4 *Entity::worldTransform() const { - return m_renderer->worldMatrixManager()->data(m_worldTransform); + return m_nodeManagers->worldMatrixManager()->data(m_worldTransform); } void Entity::addComponent(Qt3DCore::QComponent *component) @@ -309,31 +309,31 @@ void Entity::setEnabled(bool isEnabled) template<> HMaterial Entity::componentHandle<Material>() const { - return m_renderer->materialManager()->lookupHandle(m_materialComponent); + return m_nodeManagers->materialManager()->lookupHandle(m_materialComponent); } template<> HCamera Entity::componentHandle<CameraLens>() const { - return m_renderer->cameraManager()->lookupHandle(m_cameraComponent); + return m_nodeManagers->cameraManager()->lookupHandle(m_cameraComponent); } template<> HTransform Entity::componentHandle<Transform>() const { - return m_renderer->transformManager()->lookupHandle(m_transformComponent); + return m_nodeManagers->transformManager()->lookupHandle(m_transformComponent); } template<> HGeometryRenderer Entity::componentHandle<GeometryRenderer>() const { - return m_renderer->geometryRendererManager()->lookupHandle(m_geometryRendererComponent); + return m_nodeManagers->geometryRendererManager()->lookupHandle(m_geometryRendererComponent); } template<> HObjectPicker Entity::componentHandle<ObjectPicker>() const { - return m_renderer->objectPickerManager()->lookupHandle(m_objectPickerComponent); + return m_nodeManagers->objectPickerManager()->lookupHandle(m_objectPickerComponent); } template<> @@ -341,7 +341,7 @@ QList<HLayer> Entity::componentsHandle<Layer>() const { QList<HLayer> layerHandles; Q_FOREACH (const QNodeId &id, m_layerComponents) - layerHandles.append(m_renderer->layerManager()->lookupHandle(id)); + layerHandles.append(m_nodeManagers->layerManager()->lookupHandle(id)); return layerHandles; } @@ -350,14 +350,14 @@ QList<HShaderData> Entity::componentsHandle<ShaderData>() const { QList<HShaderData> shaderDataHandles; Q_FOREACH (const QNodeId &id, m_shaderDataComponents) - shaderDataHandles.append(m_renderer->shaderDataManager()->lookupHandle(id)); + shaderDataHandles.append(m_nodeManagers->shaderDataManager()->lookupHandle(id)); return shaderDataHandles; } template<> HBoundingVolumeDebug Entity::componentHandle<BoundingVolumeDebug>() const { - return m_renderer->boundingVolumeDebugManager()->lookupHandle(m_boundingVolumeDebugComponent); + return m_nodeManagers->boundingVolumeDebugManager()->lookupHandle(m_boundingVolumeDebugComponent); } // Render components @@ -365,31 +365,31 @@ HBoundingVolumeDebug Entity::componentHandle<BoundingVolumeDebug>() const template<> Material *Entity::renderComponent<Material>() const { - return m_renderer->materialManager()->lookupResource(m_materialComponent); + return m_nodeManagers->materialManager()->lookupResource(m_materialComponent); } template<> CameraLens *Entity::renderComponent<CameraLens>() const { - return m_renderer->cameraManager()->lookupResource(m_cameraComponent); + return m_nodeManagers->cameraManager()->lookupResource(m_cameraComponent); } template<> Transform *Entity::renderComponent<Transform>() const { - return m_renderer->transformManager()->lookupResource(m_transformComponent); + return m_nodeManagers->transformManager()->lookupResource(m_transformComponent); } template<> GeometryRenderer *Entity::renderComponent<GeometryRenderer>() const { - return m_renderer->geometryRendererManager()->lookupResource(m_geometryRendererComponent); + return m_nodeManagers->geometryRendererManager()->lookupResource(m_geometryRendererComponent); } template<> ObjectPicker *Entity::renderComponent<ObjectPicker>() const { - return m_renderer->objectPickerManager()->lookupResource(m_objectPickerComponent); + return m_nodeManagers->objectPickerManager()->lookupResource(m_objectPickerComponent); } template<> @@ -397,7 +397,7 @@ QList<Layer *> Entity::renderComponents<Layer>() const { QList<Layer *> layers; Q_FOREACH (const QNodeId &id, m_layerComponents) - layers.append(m_renderer->layerManager()->lookupResource(id)); + layers.append(m_nodeManagers->layerManager()->lookupResource(id)); return layers; } @@ -406,14 +406,14 @@ QList<ShaderData *> Entity::renderComponents<ShaderData>() const { QList<ShaderData *> shaderDatas; Q_FOREACH (const QNodeId &id, m_shaderDataComponents) - shaderDatas.append(m_renderer->shaderDataManager()->lookupResource(id)); + shaderDatas.append(m_nodeManagers->shaderDataManager()->lookupResource(id)); return shaderDatas; } template<> BoundingVolumeDebug *Entity::renderComponent<BoundingVolumeDebug>() const { - return m_renderer->boundingVolumeDebugManager()->lookupResource(m_boundingVolumeDebugComponent); + return m_nodeManagers->boundingVolumeDebugManager()->lookupResource(m_boundingVolumeDebugComponent); } // Uuid @@ -442,17 +442,17 @@ QNodeId Entity::componentUuid<ObjectPicker>() const { return m_objectPickerCompo template<> QNodeId Entity::componentUuid<BoundingVolumeDebug>() const { return m_boundingVolumeDebugComponent; } -RenderEntityFunctor::RenderEntityFunctor(Renderer *renderer) - : m_renderer(renderer) +RenderEntityFunctor::RenderEntityFunctor(NodeManagers *manager) + : m_nodeManagers(manager) { } Qt3DCore::QBackendNode *RenderEntityFunctor::create(Qt3DCore::QNode *frontend, const Qt3DCore::QBackendNodeFactory *factory) const { - HEntity renderNodeHandle = m_renderer->renderNodesManager()->getOrAcquireHandle(frontend->id()); - Entity *entity = m_renderer->renderNodesManager()->data(renderNodeHandle); + HEntity renderNodeHandle = m_nodeManagers->renderNodesManager()->getOrAcquireHandle(frontend->id()); + Entity *entity = m_nodeManagers->renderNodesManager()->data(renderNodeHandle); entity->setFactory(factory); - entity->setRenderer(m_renderer); + entity->setNodeManagers(m_nodeManagers); entity->setHandle(renderNodeHandle); entity->setPeer(frontend); return entity; @@ -460,12 +460,12 @@ Qt3DCore::QBackendNode *RenderEntityFunctor::create(Qt3DCore::QNode *frontend, c Qt3DCore::QBackendNode *RenderEntityFunctor::get(const Qt3DCore::QNodeId &id) const { - return m_renderer->renderNodesManager()->lookupResource(id); + return m_nodeManagers->renderNodesManager()->lookupResource(id); } void RenderEntityFunctor::destroy(const Qt3DCore::QNodeId &id) const { - m_renderer->renderNodesManager()->releaseResource(id); + m_nodeManagers->renderNodesManager()->releaseResource(id); } } // namespace Render diff --git a/src/render/backend/entity_p.h b/src/render/backend/entity_p.h index ea8d167ec..4566f749a 100644 --- a/src/render/backend/entity_p.h +++ b/src/render/backend/entity_p.h @@ -74,6 +74,7 @@ namespace Render { class Sphere; class Renderer; +class NodeManagers; class Q_AUTOTEST_EXPORT Entity : public Qt3DCore::QBackendNode { @@ -83,7 +84,7 @@ public: void cleanup(); void setParentHandle(HEntity parentHandle); - void setRenderer(Renderer *renderer); + void setNodeManagers(NodeManagers *manager); void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE; void updateFromPeer(Qt3DCore::QNode *peer) Q_DECL_OVERRIDE; @@ -148,19 +149,7 @@ public: } private: - - template<class Frontend, class Backend, class Manager> - void createRenderComponentHelper(Frontend *frontend, Manager *manager) - { - // We index using the Frontend id - if (!manager->contains(frontend->id())) { - Backend *backend = manager->getOrCreateResource(frontend->id()); - backend->setRenderer(m_renderer); - backend->setPeer(frontend); - } - } - - Renderer *m_renderer; + NodeManagers *m_nodeManagers; HEntity m_handle; HEntity m_parentHandle; QVector<HEntity > m_childrenHandles; @@ -262,13 +251,13 @@ Q_AUTOTEST_EXPORT Qt3DCore::QNodeId Entity::componentUuid<BoundingVolumeDebug>() class RenderEntityFunctor : public Qt3DCore::QBackendNodeFunctor { public: - explicit RenderEntityFunctor(Renderer *renderer); + explicit RenderEntityFunctor(NodeManagers *manager); Qt3DCore::QBackendNode *create(Qt3DCore::QNode *frontend, const Qt3DCore::QBackendNodeFactory *factory) const Q_DECL_OVERRIDE; Qt3DCore::QBackendNode *get(const Qt3DCore::QNodeId &id) const Q_DECL_OVERRIDE; void destroy(const Qt3DCore::QNodeId &id) const Q_DECL_OVERRIDE; private: - Renderer *m_renderer; + NodeManagers *m_nodeManagers; }; } // namespace Render diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp index 308aa120b..e4bceb724 100644 --- a/src/render/backend/renderer.cpp +++ b/src/render/backend/renderer.cpp @@ -62,21 +62,22 @@ #include <Qt3DRender/private/renderpassfilternode_p.h> #include <Qt3DRender/private/renderqueue_p.h> #include <Qt3DRender/private/shader_p.h> +#include <Qt3DRender/private/buffer_p.h> #include <Qt3DRender/private/renderstateset_p.h> #include <Qt3DRender/private/technique_p.h> #include <Qt3DRender/private/renderthread_p.h> #include <Qt3DRender/private/renderview_p.h> #include <Qt3DRender/private/techniquefilternode_p.h> -#include <Qt3DRender/private/texturedatamanager_p.h> -#include <Qt3DRender/private/scenemanager_p.h> #include <Qt3DRender/private/viewportnode_p.h> #include <Qt3DRender/private/vsyncframeadvanceservice_p.h> -#include <Qt3DRender/private/buffermanager_p.h> #include <Qt3DRender/private/loadbufferjob_p.h> #include <Qt3DRender/private/loadgeometryjob_p.h> -#include <Qt3DRender/private/geometryrenderermanager_p.h> #include <Qt3DRender/private/pickeventfilter_p.h> #include <Qt3DRender/private/qsceneparserfactory_p.h> +#include <Qt3DRender/private/managers_p.h> +#include <Qt3DRender/private/buffermanager_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> +#include <Qt3DRender/private/geometryrenderermanager_p.h> #include <Qt3DCore/qcameralens.h> #include <Qt3DCore/qeventfilterservice.h> @@ -133,38 +134,10 @@ const QString SCENE_PARSERS_PATH = QStringLiteral("/sceneparsers"); Renderer::Renderer(QRenderAspect::RenderType type) : m_rendererAspect(Q_NULLPTR) + , m_nodesManager(new NodeManagers()) , m_graphicsContext(Q_NULLPTR) , m_surface(Q_NULLPTR) , m_eventSource(Q_NULLPTR) - , m_cameraManager(new CameraManager()) - , m_renderNodesManager(new EntityManager()) - , m_materialManager(new MaterialManager()) - , m_worldMatrixManager(new MatrixManager()) - , m_vaoManager(new VAOManager()) - , m_shaderManager(new ShaderManager()) - , m_techniqueManager(new TechniqueManager()) - , m_effectManager(new EffectManager()) - , m_renderPassManager(new RenderPassManager()) - , m_textureManager(new TextureManager()) - , m_textureDataManager(new TextureDataManager()) - , m_layerManager(new LayerManager()) - , m_criterionManager(new CriterionManager()) - , m_frameGraphManager(new FrameGraphManager()) - , m_transformManager(new TransformManager()) - , m_renderTargetManager(new RenderTargetManager()) - , m_sceneManager(new SceneManager()) - , m_attachmentManager(new AttachmentManager()) - , m_sortCriterionManager(new SortCriterionManager()) - , m_parameterManager(new ParameterManager()) - , m_shaderDataManager(new ShaderDataManager()) - , m_uboManager(new UBOManager()) - , m_textureImageManager(new TextureImageManager()) - , m_bufferManager(new BufferManager()) - , m_attributeManager(new AttributeManager()) - , m_geometryManager(new GeometryManager()) - , m_geometryRendererManager(new GeometryRendererManager) - , m_objectPickerManager(new ObjectPickerManager()) - , m_boundingVolumeDebugManager(new BoundingVolumeDebugManager()) , m_renderQueue(new RenderQueue()) , m_renderThread(type == QRenderAspect::Threaded ? new RenderThread(this) : Q_NULLPTR) , m_vsyncFrameAdvanceService(new VSyncFrameAdvanceService()) @@ -183,7 +156,12 @@ Renderer::Renderer(QRenderAspect::RenderType type) Renderer::~Renderer() { // Clean up the TLS allocators - destroyAllocators(); + destroyAllocators(rendererAspect()->jobManager()); +} + +NodeManagers *Renderer::nodeManagers() const +{ + return m_nodesManager; } void Renderer::buildDefaultTechnique() @@ -268,20 +246,16 @@ void Renderer::buildDefaultMaterial() } -void Renderer::createAllocators() +void Renderer::createAllocators(QAbstractAspectJobManager *jobManager) { // Issue a set of jobs to create an allocator in TLS for each worker thread - Q_ASSERT(m_rendererAspect); - QAbstractAspectJobManager *jobManager = rendererAspect()->jobManager(); Q_ASSERT(jobManager); jobManager->waitForPerThreadFunction(Renderer::createThreadLocalAllocator, this); } -void Renderer::destroyAllocators() +void Renderer::destroyAllocators(Qt3DCore::QAbstractAspectJobManager *jobManager) { // Issue a set of jobs to destroy the allocator in TLS for each worker thread - Q_ASSERT(m_rendererAspect); - QAbstractAspectJobManager *jobManager = rendererAspect()->jobManager(); Q_ASSERT(jobManager); jobManager->waitForPerThreadFunction(Renderer::destroyThreadLocalAllocator, this); } @@ -429,7 +403,7 @@ void Renderer::setFrameGraphRoot(const Qt3DCore::QNodeId &frameGraphRootUuid) Render::FrameGraphNode *Renderer::frameGraphRoot() const { - FrameGraphNode **fgRoot = m_frameGraphManager->lookupResource(m_frameGraphRootUuid); + FrameGraphNode **fgRoot = m_nodesManager->lookupResource<FrameGraphNode*, FrameGraphManager>(m_frameGraphRootUuid); if (fgRoot != Q_NULLPTR) return *fgRoot; return Q_NULLPTR; @@ -448,7 +422,6 @@ void Renderer::setSceneGraphRoot(Entity *sgRoot) QMutexLocker lock(&m_mutex); // This waits until initialize and setSurface have been called if (m_graphicsContext == Q_NULLPTR) // If initialization hasn't been completed we must wait m_waitForInitializationToBeCompleted.wait(&m_mutex); - m_renderSceneRoot = sgRoot; if (!m_renderSceneRoot) qCWarning(Backend) << "Failed to build render scene"; @@ -475,11 +448,11 @@ void Renderer::setSceneGraphRoot(Entity *sgRoot) m_rendererAspect->createBackendNode(p); - m_defaultMaterialHandle = m_materialManager->lookupHandle(m_defaultMaterial->id()); - m_defaultEffectHandle = m_effectManager->lookupHandle(m_defaultMaterial->effect()->id()); - m_defaultTechniqueHandle = m_techniqueManager->lookupHandle(m_defaultTechnique->id()); - m_defaultRenderPassHandle = m_renderPassManager->lookupHandle(m_defaultTechnique->renderPasses().first()->id()); - m_defaultRenderShader = m_shaderManager->lookupResource(m_defaultTechnique->renderPasses().first()->shaderProgram()->id()); + m_defaultMaterialHandle = nodeManagers()->lookupHandle<Material, MaterialManager, HMaterial>(m_defaultMaterial->id()); + m_defaultEffectHandle = nodeManagers()->lookupHandle<Effect, EffectManager, HEffect>(m_defaultMaterial->effect()->id()); + m_defaultTechniqueHandle = nodeManagers()->lookupHandle<Technique, TechniqueManager, HTechnique>(m_defaultTechnique->id()); + m_defaultRenderPassHandle = nodeManagers()->lookupHandle<RenderPass, RenderPassManager, HRenderPass>(m_defaultTechnique->renderPasses().first()->id()); + m_defaultRenderShader = nodeManagers()->lookupResource<Shader, ShaderManager>(m_defaultTechnique->renderPasses().first()->shaderProgram()->id()); } // Called in RenderAspect Thread context @@ -710,7 +683,7 @@ bool Renderer::submitRenderViews() // Set RenderTarget ... // Activate RenderTarget - m_graphicsContext->activateRenderTarget(m_renderTargetManager->data(renderView->renderTargetHandle()), + m_graphicsContext->activateRenderTarget(nodeManagers()->data<RenderTarget, RenderTargetManager>(renderView->renderTargetHandle()), renderView->attachmentPack(), boundFboId); // Set clear color if different @@ -763,17 +736,13 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBinJobs() // populate the RenderView with a set of RenderCommands that get // their details from the RenderNodes that are visible to the // Camera selected by the framegraph configuration - QVector<QAspectJobPtr> renderBinJobs; - // Do not create any more jobs when the platform surface is gone. - if (m_surface) { - FrameGraphVisitor visitor; - visitor.traverse(frameGraphRoot(), this, &renderBinJobs); + FrameGraphVisitor visitor; + visitor.traverse(frameGraphRoot(), this, &renderBinJobs); - // Set target number of RenderViews - m_renderQueue->setTargetRenderViewCount(renderBinJobs.size()); - } + // Set target number of RenderViews + m_renderQueue->setTargetRenderViewCount(renderBinJobs.size()); return renderBinJobs; } @@ -781,15 +750,15 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBinJobs() // 1 dirty buffer == 1 job, all job can be performed in parallel QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBufferJobs() { - const QVector<QNodeId> dirtyBuffers = m_bufferManager->dirtyBuffers(); + const QVector<QNodeId> dirtyBuffers = nodeManagers()->bufferManager()->dirtyBuffers(); QVector<QAspectJobPtr> dirtyBuffersJobs; Q_FOREACH (const QNodeId &bufId, dirtyBuffers) { - HBuffer bufferHandle = m_bufferManager->lookupHandle(bufId); + HBuffer bufferHandle = m_nodesManager->lookupHandle<Buffer, BufferManager, HBuffer>(bufId); if (!bufferHandle.isNull()) { // Create new buffer job LoadBufferJobPtr job(new LoadBufferJob(bufferHandle)); - job->setRenderer(this); + job->setNodeManager(m_nodesManager); dirtyBuffersJobs.push_back(job); } } @@ -799,14 +768,15 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBufferJobs() QVector<Qt3DCore::QAspectJobPtr> Renderer::createGeometryRendererJobs() { - const QVector<QNodeId> dirtyGeometryRenderers = m_geometryRendererManager->dirtyGeometryRenderers(); + GeometryRendererManager *geomRendererManager = m_nodesManager->geometryRendererManager(); + const QVector<QNodeId> dirtyGeometryRenderers = geomRendererManager->dirtyGeometryRenderers(); QVector<QAspectJobPtr> dirtyGeometryRendererJobs; Q_FOREACH (const QNodeId &geoRendererId, dirtyGeometryRenderers) { - HGeometryRenderer geometryRendererHandle = m_geometryRendererManager->lookupHandle(geoRendererId); + HGeometryRenderer geometryRendererHandle = geomRendererManager->lookupHandle(geoRendererId); if (!geometryRendererHandle.isNull()) { LoadGeometryJobPtr job(new LoadGeometryJob(geometryRendererHandle)); - job->setRenderer(this); + job->setNodeManagers(m_nodesManager); dirtyGeometryRendererJobs.push_back(job); } } @@ -819,7 +789,8 @@ Qt3DCore::QAspectJobPtr Renderer::createRenderViewJob(FrameGraphNode *node, int { RenderViewJobPtr job(new RenderViewJob); job->setRenderer(this); - job->setSurfaceSize(m_surface->size()); + if (m_surface) + job->setSurfaceSize(m_surface->size()); job->setFrameGraphLeafNode(node); job->setSubmitOrderIndex(submitOrderIndex); return job; @@ -841,8 +812,8 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands) Q_FOREACH (RenderCommand *command, commands) { // Check if we have a valid GeometryRenderer + Geometry - Geometry *rGeometry = m_geometryManager->data(command->m_geometry); - GeometryRenderer *rGeometryRenderer = m_geometryRendererManager->data(command->m_geometryRenderer); + Geometry *rGeometry = m_nodesManager->data<Geometry, GeometryManager>(command->m_geometry); + GeometryRenderer *rGeometryRenderer = m_nodesManager->data<GeometryRenderer, GeometryRendererManager>(command->m_geometryRenderer); const bool hasGeometryRenderer = rGeometry != Q_NULLPTR && rGeometryRenderer != Q_NULLPTR && !rGeometry->attributes().isEmpty(); if (!hasGeometryRenderer) { @@ -850,7 +821,7 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands) continue; } - Shader *shader = m_shaderManager->data(command->m_shader); + Shader *shader = m_nodesManager->data<Shader, ShaderManager>(command->m_shader); if (shader == Q_NULLPTR) { shader = m_defaultRenderShader; command->m_parameterAttributeToShaderNames = m_defaultParameterToGLSLAttributeNames; @@ -861,17 +832,18 @@ void Renderer::executeCommands(const QVector<RenderCommand *> &commands) // Manager should have a VAO Manager that are indexed by QMeshData and Shader // RenderCommand should have a handle to the corresponding VAO for the Mesh and Shader bool needsToBindVAO = false; + VAOManager *vaoManager = m_nodesManager->vaoManager(); if (m_graphicsContext->supportsVAO()) { - command->m_vao = m_vaoManager->lookupHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader)); + command->m_vao = vaoManager->lookupHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader)); if (command->m_vao.isNull()) { qCDebug(Rendering) << Q_FUNC_INFO << "Allocating new VAO"; - command->m_vao = m_vaoManager->getOrAcquireHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader)); - *(m_vaoManager->data(command->m_vao)) = new QOpenGLVertexArrayObject(); + command->m_vao = vaoManager->getOrAcquireHandle(QPair<HGeometry, HShader>(command->m_geometry, command->m_shader)); + *(vaoManager->data(command->m_vao)) = new QOpenGLVertexArrayObject(); } if (previousVaoHandle != command->m_vao) { needsToBindVAO = true; previousVaoHandle = command->m_vao; - vao = *(m_vaoManager->data(command->m_vao)); + vao = *(vaoManager->data(command->m_vao)); } Q_ASSERT(vao); // If the VAO hasn't been created, we create it @@ -1008,12 +980,12 @@ Attribute *Renderer::updateBuffersAndAttributes(Geometry *geometry, RenderComman Q_FOREACH (const QNodeId &attributeId, geometry->attributes()) { // TO DO: Improvement we could store handles and use the non locking policy on the attributeManager - Attribute *attribute = attributeManager()->lookupResource(attributeId); + Attribute *attribute = m_nodesManager->attributeManager()->lookupResource(attributeId); if (attribute == Q_NULLPTR) continue; - Buffer *buffer = bufferManager()->lookupResource(attribute->bufferId()); + Buffer *buffer = m_nodesManager->bufferManager()->lookupResource(attribute->bufferId()); if (buffer == Q_NULLPTR) continue; diff --git a/src/render/backend/renderer_p.h b/src/render/backend/renderer_p.h index ee8e79596..7118f9ff1 100644 --- a/src/render/backend/renderer_p.h +++ b/src/render/backend/renderer_p.h @@ -102,46 +102,17 @@ class Technique; class Shader; class Entity; class RenderCommand; -class CameraManager; -class EntityManager; class RenderQueue; class RenderView; -class MaterialManager; -class MatrixManager; -class VAOManager; -class ShaderManager; -class TechniqueManager; -class EffectManager; -class RenderPassManager; class Effect; class RenderPass; -class TextureManager; -class TextureDataManager; -class LayerManager; -class LightManager; class RenderThread; -class CriterionManager; -class FrameGraphManager; -class TransformManager; class RenderStateSet; -class RenderTargetManager; -class SceneManager; -class AttachmentManager; -class SortCriterionManager; -class ParameterManager; -class ShaderDataManager; -class UBOManager; -class TextureImageManager; class VSyncFrameAdvanceService; -class BufferManager; -class AttributeManager; -class GeometryManager; -class GeometryRendererManager; -class ObjectPickerManager; class PickEventFilter; -class BoundingVolumeDebugManager; +class NodeManagers; -class Renderer +class Q_AUTOTEST_EXPORT Renderer { public: explicit Renderer(QRenderAspect::RenderType type); @@ -150,8 +121,10 @@ public: void setQRenderAspect(QRenderAspect *aspect) { m_rendererAspect = aspect; } QRenderAspect *rendererAspect() const { return m_rendererAspect; } - void createAllocators(); - void destroyAllocators(); + NodeManagers *nodeManagers() const; + + void createAllocators(Qt3DCore::QAbstractAspectJobManager *jobManager); + void destroyAllocators(Qt3DCore::QAbstractAspectJobManager *jobManager); Qt3DCore::QFrameAllocator *currentFrameAllocator(); @@ -174,35 +147,6 @@ public: Attribute *updateBuffersAndAttributes(Geometry *geometry, RenderCommand *command, GLsizei &count, bool forceUpdate); void addAllocator(Qt3DCore::QFrameAllocator *allocator); - inline CameraManager *cameraManager() const { return m_cameraManager; } - inline EntityManager *renderNodesManager() const { return m_renderNodesManager; } - inline MaterialManager *materialManager() const { return m_materialManager; } - inline MatrixManager *worldMatrixManager() const { return m_worldMatrixManager; } - inline VAOManager *vaoManager() const { return m_vaoManager; } - inline ShaderManager *shaderManager() const { return m_shaderManager; } - inline TechniqueManager *techniqueManager() const { return m_techniqueManager; } - inline EffectManager *effectManager() const { return m_effectManager; } - inline RenderPassManager *renderPassManager() const { return m_renderPassManager; } - inline TextureManager *textureManager() const { return m_textureManager; } - inline TextureDataManager *textureDataManager() const { return m_textureDataManager; } - inline LayerManager *layerManager() const { return m_layerManager; } - inline CriterionManager *criterionManager() const { return m_criterionManager; } - inline FrameGraphManager *frameGraphManager() const { return m_frameGraphManager; } - inline TransformManager *transformManager() const { return m_transformManager; } - inline RenderTargetManager *renderTargetManager() const { return m_renderTargetManager; } - inline SceneManager *sceneManager() const { return m_sceneManager; } - inline AttachmentManager *attachmentManager() const { return m_attachmentManager; } - inline SortCriterionManager *sortCriterionManager() const { return m_sortCriterionManager; } - inline ParameterManager *parameterManager() const { return m_parameterManager; } - inline ShaderDataManager *shaderDataManager() const { return m_shaderDataManager; } - inline UBOManager *uboManager() const { return m_uboManager; } - inline TextureImageManager *textureImageManager() const { return m_textureImageManager; } - inline BufferManager *bufferManager() const { return m_bufferManager; } - inline AttributeManager *attributeManager() const { return m_attributeManager; } - inline GeometryManager *geometryManager() const { return m_geometryManager; } - inline GeometryRendererManager *geometryRendererManager() const { return m_geometryRendererManager; } - inline ObjectPickerManager *objectPickerManager() const { return m_objectPickerManager; } - inline BoundingVolumeDebugManager *boundingVolumeDebugManager() const { return m_boundingVolumeDebugManager; } inline HMaterial defaultMaterialHandle() const { return m_defaultMaterialHandle; } inline HEffect defaultEffectHandle() const { return m_defaultEffectHandle; } @@ -230,10 +174,15 @@ public: QMutex* mutex() { return &m_mutex; } bool isRunning() const { return m_running.load(); } +#ifdef QT3D_RENDER_UNIT_TESTS +public: +#else private: +#endif bool canRender() const; QRenderAspect *m_rendererAspect; + NodeManagers *m_nodesManager; // Frame graph root Qt3DCore::QNodeId m_frameGraphRootUuid; @@ -262,35 +211,7 @@ private: QScopedPointer<GraphicsContext> m_graphicsContext; QSurface *m_surface; QObject *m_eventSource; - CameraManager *m_cameraManager; - EntityManager *m_renderNodesManager; - MaterialManager *m_materialManager; - MatrixManager *m_worldMatrixManager; - VAOManager *m_vaoManager; - ShaderManager *m_shaderManager; - TechniqueManager *m_techniqueManager; - EffectManager *m_effectManager; - RenderPassManager *m_renderPassManager; - TextureManager *m_textureManager; - TextureDataManager *m_textureDataManager; - LayerManager *m_layerManager; - CriterionManager *m_criterionManager; - FrameGraphManager *m_frameGraphManager; - TransformManager *m_transformManager; - RenderTargetManager *m_renderTargetManager; - SceneManager *m_sceneManager; - AttachmentManager *m_attachmentManager; - SortCriterionManager *m_sortCriterionManager; - ParameterManager *m_parameterManager; - ShaderDataManager *m_shaderDataManager; - UBOManager *m_uboManager; - TextureImageManager *m_textureImageManager; - BufferManager *m_bufferManager; - AttributeManager *m_attributeManager; - GeometryManager *m_geometryManager; - GeometryRendererManager *m_geometryRendererManager; - ObjectPickerManager *m_objectPickerManager; - BoundingVolumeDebugManager *m_boundingVolumeDebugManager; + RenderQueue *m_renderQueue; QScopedPointer<RenderThread> m_renderThread; diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp index c9b76182a..22000713a 100644 --- a/src/render/backend/renderview.cpp +++ b/src/render/backend/renderview.cpp @@ -50,6 +50,7 @@ #include <Qt3DRender/private/effect_p.h> #include <Qt3DRender/private/entity_p.h> #include <Qt3DRender/private/renderer_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/layer_p.h> #include <Qt3DRender/private/renderlogging_p.h> #include <Qt3DRender/private/renderpassfilternode_p.h> @@ -368,7 +369,8 @@ void RenderView::sort() void RenderView::setRenderer(Renderer *renderer) { m_renderer = renderer; - m_data->m_uniformBlockBuilder.shaderDataManager = m_renderer->shaderDataManager(); + m_manager = renderer->nodeManagers(); + m_data->m_uniformBlockBuilder.shaderDataManager = m_manager->shaderDataManager(); } // Tries to order renderCommand by shader so as to minimize shader changes @@ -395,7 +397,7 @@ void RenderView::buildRenderCommands(Entity *node) Material *material = Q_NULLPTR; Effect *effect = Q_NULLPTR; if ((material = node->renderComponent<Material>()) != Q_NULLPTR && material->isEnabled()) - effect = m_renderer->effectManager()->lookupResource(material->effect()); + effect = m_renderer->nodeManagers()->effectManager()->lookupResource(material->effect()); Technique *technique = findTechniqueForEffect(m_renderer, this, effect); ParameterInfoList parameters; @@ -410,36 +412,36 @@ void RenderView::buildRenderCommands(Entity *node) // Add Parameters define in techniqueFilter and passFilter // passFilter have priority over techniqueFilter if (m_data->m_passFilter) - parametersFromParametersProvider(¶meters, m_renderer->parameterManager(), + parametersFromParametersProvider(¶meters, m_renderer->nodeManagers()->parameterManager(), m_data->m_passFilter); if (m_data->m_techniqueFilter) - parametersFromParametersProvider(¶meters, m_renderer->parameterManager(), + parametersFromParametersProvider(¶meters, m_renderer->nodeManagers()->parameterManager(), m_data->m_techniqueFilter); RenderRenderPassList passes; if (technique) { - passes = findRenderPassesForTechnique(m_renderer, this, technique); + passes = findRenderPassesForTechnique(m_manager, this, technique); } else { - material = m_renderer->materialManager()->data(m_renderer->defaultMaterialHandle()); - effect = m_renderer->effectManager()->data(m_renderer->defaultEffectHandle()); - technique = m_renderer->techniqueManager()->data(m_renderer->defaultTechniqueHandle()); - passes << m_renderer->renderPassManager()->data(m_renderer->defaultRenderPassHandle()); + material = m_manager->data<Material, MaterialManager>(m_renderer->defaultMaterialHandle()); + effect = m_manager->data<Effect, EffectManager>(m_renderer->defaultEffectHandle()); + technique = m_manager->data<Technique, TechniqueManager>(m_renderer->defaultTechniqueHandle()); + passes << m_manager->data<RenderPass, RenderPassManager>(m_renderer->defaultRenderPassHandle()); } // Get the parameters for our selected rendering setup (override what was defined in the technique/pass filter) - parametersFromMaterialEffectTechnique(¶meters, m_renderer->parameterManager(), material, effect, technique); + parametersFromMaterialEffectTechnique(¶meters, m_manager->parameterManager(), material, effect, technique); // 1 RenderCommand per RenderPass pass on an Entity with a Mesh Q_FOREACH (RenderPass *pass, passes) { // Add the RenderPass Parameters ParameterInfoList globalParameters = parameters; - parametersFromParametersProvider(&globalParameters, m_renderer->parameterManager(), pass); + parametersFromParametersProvider(&globalParameters, m_manager->parameterManager(), pass); RenderCommand *command = m_allocator->allocate<RenderCommand>(); command->m_depth = m_data->m_eyePos.distanceToPoint(node->worldBoundingVolume()->center()); - command->m_geometry = m_renderer->geometryManager()->lookupHandle(geometryRenderer->geometryId()); + command->m_geometry = m_manager->lookupHandle<Geometry, GeometryManager, HGeometry>(geometryRenderer->geometryId()); command->m_geometryRenderer = node->componentHandle<GeometryRenderer, 16>(); command->m_instancesCount = 0; command->m_stateSet = Q_NULLPTR; @@ -522,8 +524,8 @@ void RenderView::setUniformBlockValue(QUniformPack &uniformPack, Shader *shader, bool uboNeedsUpdate = false; // build UBO at uboId if not created before - if (!m_renderer->uboManager()->contains(uboKey)) { - m_renderer->uboManager()->getOrCreateResource(uboKey); + if (!m_manager->uboManager()->contains(uboKey)) { + m_manager->uboManager()->getOrCreateResource(uboKey); uboNeedsUpdate = true; } @@ -582,7 +584,7 @@ void RenderView::buildSortingKey(RenderCommand *command) // Handle at most 4 filters at once for (int i = 0; i < sortCount && i < 4; i++) { - SortCriterion *sC = m_renderer->sortCriterionManager()->lookupResource(m_data->m_sortingCriteria[i]); + SortCriterion *sC = m_manager->lookupResource<SortCriterion, SortCriterionManager>(m_data->m_sortingCriteria[i]); switch (sC->sortType()) { case QSortCriterion::StateChangeCost: @@ -614,10 +616,9 @@ void RenderView::setShaderAndUniforms(RenderCommand *command, RenderPass *rPass, if (rPass != Q_NULLPTR) { // Index Shader by Shader UUID - command->m_shader = m_renderer->shaderManager()->lookupHandle(rPass->shaderProgram()); + command->m_shader = m_manager->lookupHandle<Shader, ShaderManager, HShader>(rPass->shaderProgram()); Shader *shader = Q_NULLPTR; - if ((shader = m_renderer->shaderManager()->data(command->m_shader)) != Q_NULLPTR) { - + if ((shader = m_manager->data<Shader, ShaderManager>(command->m_shader)) != Q_NULLPTR) { command->m_shaderDna = shader->dna(); // Builds the QUniformPack, sets shader standard uniforms and store attributes name / glname bindings diff --git a/src/render/backend/renderview_p.h b/src/render/backend/renderview_p.h index 67bed52a3..e585cb7ff 100644 --- a/src/render/backend/renderview_p.h +++ b/src/render/backend/renderview_p.h @@ -75,6 +75,7 @@ class QRenderPass; namespace Render { class Renderer; +class NodeManagers; class RenderCommand; class RenderPassFilter; class TechniqueFilter; @@ -103,6 +104,7 @@ public: void setRenderer(Renderer *renderer); inline void setSurfaceSize(const QSize &size) { m_surfaceSize = size; } inline Renderer *renderer() const { return m_renderer; } + inline NodeManagers *nodeManagers() const { return m_manager; } inline void setAllocator(Qt3DCore::QFrameAllocator *allocator) { @@ -223,6 +225,7 @@ private: void setShaderAndUniforms(RenderCommand *command, RenderPass *pass, ParameterInfoList ¶meters, const QMatrix4x4 &worldTransform); Renderer *m_renderer; + NodeManagers *m_manager; QSize m_surfaceSize; Qt3DCore::QFrameAllocator *m_allocator; diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp index 23de69f30..b3148b1e1 100644 --- a/src/render/frontend/qrenderaspect.cpp +++ b/src/render/frontend/qrenderaspect.cpp @@ -37,6 +37,7 @@ #include "qrenderaspect.h" #include "qrenderaspect_p.h" +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/texturedatamanager_p.h> #include <Qt3DRender/private/renderer_p.h> #include <Qt3DRender/private/scenemanager_p.h> @@ -100,6 +101,7 @@ #include <Qt3DRender/private/geometryrenderer_p.h> #include <Qt3DRender/private/objectpicker_p.h> #include <Qt3DRender/private/boundingvolumedebug_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DCore/qentity.h> #include <Qt3DCore/qtransform.h> @@ -141,7 +143,7 @@ QRenderAspectPrivate::QRenderAspectPrivate(QRenderAspect::RenderType type) , m_cleanupJob(new Render::FrameCleanupJob(m_renderer)) , m_worldTransformJob(new Render::UpdateWorldTransformJob()) , m_updateBoundingVolumeJob(new Render::UpdateBoundingVolumeJob()) - , m_calculateBoundingVolumeJob(new Render::CalculateBoundingVolumeJob(m_renderer)) + , m_calculateBoundingVolumeJob(new Render::CalculateBoundingVolumeJob(m_renderer->nodeManagers())) , m_pickBoundingVolumeJob(new Render::PickBoundingVolumeJob(m_renderer)) { initResources(); @@ -217,42 +219,44 @@ QRenderAspect::QRenderAspect(QRenderAspectPrivate &dd, QObject *parent) void QRenderAspect::registerBackendTypes() { Q_D(QRenderAspect); - registerBackendType<Qt3DCore::QEntity>(QBackendNodeFunctorPtr(new Render::RenderEntityFunctor(d->m_renderer))); - registerBackendType<Qt3DCore::QTransform>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Transform, Render::TransformManager>(d->m_renderer->transformManager()))); - registerBackendType<QMaterial>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Material, Render::MaterialManager>(d->m_renderer->materialManager()))); - registerBackendType<QTechnique>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Technique, Render::TechniqueManager>(d->m_renderer->techniqueManager()))); - registerBackendType<QAbstractTextureProvider>(QBackendNodeFunctorPtr(new Render::TextureFunctor(d->m_renderer->textureManager(), d->m_renderer->textureImageManager(), d->m_renderer->textureDataManager()))); - registerBackendType<QShaderProgram>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Shader, Render::ShaderManager>(d->m_renderer->shaderManager()))); - registerBackendType<QEffect>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Effect, Render::EffectManager>(d->m_renderer->effectManager()))); - registerBackendType<QAnnotation>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Annotation, Render::CriterionManager>(d->m_renderer->criterionManager()))); - registerBackendType<Qt3DCore::QCameraLens>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::CameraLens, Render::CameraManager>(d->m_renderer->cameraManager()))); - registerBackendType<QLayer>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Layer, Render::LayerManager>(d->m_renderer->layerManager()))); - registerBackendType<QRenderPass>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager>(d->m_renderer->renderPassManager()))); - registerBackendType<QAbstractSceneLoader>(QBackendNodeFunctorPtr(new Render::RenderSceneFunctor(d->m_renderer->sceneManager()))); - registerBackendType<QRenderTarget>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager>(d->m_renderer->renderTargetManager()))); - registerBackendType<QRenderAttachment>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderAttachment, Render::AttachmentManager>(d->m_renderer->attachmentManager()))); - registerBackendType<QSortCriterion>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::SortCriterion, Render::SortCriterionManager>(d->m_renderer->sortCriterionManager()))); - registerBackendType<QClearBuffer>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ClearBuffer, QClearBuffer>(d->m_renderer->frameGraphManager()))); - registerBackendType<QTechniqueFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter>(d->m_renderer->frameGraphManager()))); - registerBackendType<QViewport>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport>(d->m_renderer->frameGraphManager()))); - registerBackendType<QRenderPassFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter>(d->m_renderer->frameGraphManager()))); - registerBackendType<QCameraSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector>(d->m_renderer->frameGraphManager()))); - registerBackendType<QRenderTargetSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector>(d->m_renderer->frameGraphManager()))); - registerBackendType<QLayerFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter>(d->m_renderer->frameGraphManager()))); - registerBackendType<QSortMethod>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::SortMethod, QSortMethod>(d->m_renderer->frameGraphManager()))); - registerBackendType<QFrameGraphSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::FrameGraphSubtreeSelector, QFrameGraphSelector>(d->m_renderer->frameGraphManager()))); + Qt3DRender::Render::NodeManagers *nodeManagers = d->m_renderer->nodeManagers(); + + registerBackendType<Qt3DCore::QEntity>(QBackendNodeFunctorPtr(new Render::RenderEntityFunctor(nodeManagers))); + registerBackendType<Qt3DCore::QTransform>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Transform, Render::TransformManager>(nodeManagers->transformManager()))); + registerBackendType<QMaterial>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Material, Render::MaterialManager>(nodeManagers->materialManager()))); + registerBackendType<QTechnique>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Technique, Render::TechniqueManager>(nodeManagers->techniqueManager()))); + registerBackendType<QAbstractTextureProvider>(QBackendNodeFunctorPtr(new Render::TextureFunctor(nodeManagers->textureManager(), nodeManagers->textureImageManager(), nodeManagers->textureDataManager()))); + registerBackendType<QShaderProgram>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Shader, Render::ShaderManager>(nodeManagers->shaderManager()))); + registerBackendType<QEffect>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Effect, Render::EffectManager>(nodeManagers->effectManager()))); + registerBackendType<QAnnotation>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Annotation, Render::CriterionManager>(nodeManagers->criterionManager()))); + registerBackendType<Qt3DCore::QCameraLens>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::CameraLens, Render::CameraManager>(nodeManagers->cameraManager()))); + registerBackendType<QLayer>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Layer, Render::LayerManager>(nodeManagers->layerManager()))); + registerBackendType<QRenderPass>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager>(nodeManagers->renderPassManager()))); + registerBackendType<QAbstractSceneLoader>(QBackendNodeFunctorPtr(new Render::RenderSceneFunctor(nodeManagers->sceneManager()))); + registerBackendType<QRenderTarget>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderTarget, Render::RenderTargetManager>(nodeManagers->renderTargetManager()))); + registerBackendType<QRenderAttachment>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderAttachment, Render::AttachmentManager>(nodeManagers->attachmentManager()))); + registerBackendType<QSortCriterion>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::SortCriterion, Render::SortCriterionManager>(nodeManagers->sortCriterionManager()))); + registerBackendType<QClearBuffer>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ClearBuffer, QClearBuffer>(nodeManagers->frameGraphManager()))); + registerBackendType<QTechniqueFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter>(nodeManagers->frameGraphManager()))); + registerBackendType<QViewport>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport>(nodeManagers->frameGraphManager()))); + registerBackendType<QRenderPassFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter>(nodeManagers->frameGraphManager()))); + registerBackendType<QCameraSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector>(nodeManagers->frameGraphManager()))); + registerBackendType<QRenderTargetSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector>(nodeManagers->frameGraphManager()))); + registerBackendType<QLayerFilter>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter>(nodeManagers->frameGraphManager()))); + registerBackendType<QSortMethod>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::SortMethod, QSortMethod>(nodeManagers->frameGraphManager()))); + registerBackendType<QFrameGraphSelector>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::FrameGraphSubtreeSelector, QFrameGraphSelector>(nodeManagers->frameGraphManager()))); registerBackendType<QFrameGraph>(QBackendNodeFunctorPtr(new Render::FrameGraphComponentFunctor(d->m_renderer))); - registerBackendType<QParameter>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Parameter, Render::ParameterManager>(d->m_renderer->parameterManager()))); - registerBackendType<QShaderData>(QBackendNodeFunctorPtr(new Render::RenderShaderDataFunctor(d->m_renderer->shaderDataManager()))); - registerBackendType<QAbstractTextureImage>(QBackendNodeFunctorPtr(new Render::TextureImageFunctor(d->m_renderer->textureManager(), d->m_renderer->textureImageManager(), d->m_renderer->textureDataManager()))); - registerBackendType<QStateSet>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::StateSetNode, QStateSet>(d->m_renderer->frameGraphManager()))); - registerBackendType<QNoDraw>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw>(d->m_renderer->frameGraphManager()))); - registerBackendType<QBuffer>(QBackendNodeFunctorPtr(new Render::BufferFunctor(d->m_renderer->bufferManager()))); - registerBackendType<QAttribute>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Attribute, Render::AttributeManager>(d->m_renderer->attributeManager()))); - registerBackendType<QGeometry>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Geometry, Render::GeometryManager>(d->m_renderer->geometryManager()))); - registerBackendType<QGeometryRenderer>(QBackendNodeFunctorPtr(new Render::GeometryRendererFunctor(d->m_renderer->geometryRendererManager()))); - registerBackendType<QObjectPicker>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager>(d->m_renderer->objectPickerManager()))); - registerBackendType<QBoundingVolumeDebug>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::BoundingVolumeDebug, Render::BoundingVolumeDebugManager>(d->m_renderer->boundingVolumeDebugManager()))); + registerBackendType<QParameter>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Parameter, Render::ParameterManager>(nodeManagers->parameterManager()))); + registerBackendType<QShaderData>(QBackendNodeFunctorPtr(new Render::RenderShaderDataFunctor(nodeManagers->shaderDataManager()))); + registerBackendType<QAbstractTextureImage>(QBackendNodeFunctorPtr(new Render::TextureImageFunctor(nodeManagers->textureManager(), nodeManagers->textureImageManager(), nodeManagers->textureDataManager()))); + registerBackendType<QStateSet>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::StateSetNode, QStateSet>(nodeManagers->frameGraphManager()))); + registerBackendType<QNoDraw>(QBackendNodeFunctorPtr(new Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw>(nodeManagers->frameGraphManager()))); + registerBackendType<QBuffer>(QBackendNodeFunctorPtr(new Render::BufferFunctor(nodeManagers->bufferManager()))); + registerBackendType<QAttribute>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Attribute, Render::AttributeManager>(nodeManagers->attributeManager()))); + registerBackendType<QGeometry>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Geometry, Render::GeometryManager>(nodeManagers->geometryManager()))); + registerBackendType<QGeometryRenderer>(QBackendNodeFunctorPtr(new Render::GeometryRendererFunctor(nodeManagers->geometryRendererManager()))); + registerBackendType<QObjectPicker>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager>(nodeManagers->objectPickerManager()))); + registerBackendType<QBoundingVolumeDebug>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::BoundingVolumeDebug, Render::BoundingVolumeDebugManager>(nodeManagers->boundingVolumeDebugManager()))); } void QRenderAspect::renderInitialize(QOpenGLContext *context) @@ -287,6 +291,8 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time) // Create jobs to load in any meshes that are pending if (d->m_renderer != Q_NULLPTR && d->m_renderer->isRunning()) { + Render::NodeManagers *manager = d->m_renderer->nodeManagers(); + // Create the jobs to build the frame d->m_framePreparationJob->setRoot(d->m_renderer->renderSceneRoot()); d->m_worldTransformJob->setRoot(d->m_renderer->renderSceneRoot()); @@ -294,16 +300,16 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time) d->m_calculateBoundingVolumeJob->setRoot(d->m_renderer->renderSceneRoot()); d->m_pickBoundingVolumeJob->setRoot(d->m_renderer->renderSceneRoot()); - const QVector<QNodeId> texturesPending = d->m_renderer->textureDataManager()->texturesPending(); + const QVector<QNodeId> texturesPending = manager->textureDataManager()->texturesPending(); Q_FOREACH (const QNodeId &textureId, texturesPending) { Render::LoadTextureDataJobPtr loadTextureJob(new Render::LoadTextureDataJob(textureId)); - loadTextureJob->setRenderer(d->m_renderer); + loadTextureJob->setNodeManagers(manager); jobs.append(loadTextureJob); } // 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 QVector<Render::LoadSceneJobPtr> sceneJobs = d->m_renderer->sceneManager()->pendingSceneLoaderJobs(); + const QVector<Render::LoadSceneJobPtr> sceneJobs = manager->sceneManager()->pendingSceneLoaderJobs(); Q_FOREACH (Render::LoadSceneJobPtr job, sceneJobs) { job->setRenderer(d->m_renderer); jobs.append(job); @@ -322,16 +328,18 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time) jobs.append(d->m_framePreparationJob); jobs.append(d->m_pickBoundingVolumeJob); - - // Traverse the current framegraph and create jobs to populate - // RenderBins with RenderCommands - QVector<QAspectJobPtr> renderBinJobs = d->m_renderer->createRenderBinJobs(); - // TODO: Add wrapper around ThreadWeaver::Collection - for (int i = 0; i < renderBinJobs.size(); ++i) { - QAspectJobPtr renderBinJob = renderBinJobs.at(i); - renderBinJob->addDependency(d->m_updateBoundingVolumeJob); - jobs.append(renderBinJob); - d->m_cleanupJob->addDependency(renderBinJob); + // Do not create any more jobs when the platform surface is gone. + if (d->m_renderer->surface()) { + // Traverse the current framegraph and create jobs to populate + // RenderBins with RenderCommands + QVector<QAspectJobPtr> renderBinJobs = d->m_renderer->createRenderBinJobs(); + // TODO: Add wrapper around ThreadWeaver::Collection + for (int i = 0; i < renderBinJobs.size(); ++i) { + QAspectJobPtr renderBinJob = renderBinJobs.at(i); + renderBinJob->addDependency(d->m_updateBoundingVolumeJob); + jobs.append(renderBinJob); + d->m_cleanupJob->addDependency(renderBinJob); + } } jobs.append(d->m_cleanupJob); } @@ -367,7 +375,7 @@ void QRenderAspect::setRootEntity(Qt3DCore::QEntity *rootObject) Q_D(QRenderAspect); QNodeVisitor visitor; visitor.traverse(rootObject, this, &QRenderAspect::visitNode); - d->m_renderer->setSceneGraphRoot(d->m_renderer->renderNodesManager()->lookupResource(rootObject->id())); + d->m_renderer->setSceneGraphRoot(d->m_renderer->nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootObject->id())); } void QRenderAspect::onInitialize(const QVariantMap &data) @@ -379,11 +387,13 @@ void QRenderAspect::onInitialize(const QVariantMap &data) // Register the VSyncFrameAdvanceService to drive the aspect manager loop // depending on the vsync - services()->registerServiceProvider(Qt3DCore::QServiceLocator::FrameAdvanceService, - d->m_renderer->vsyncFrameAdvanceService()); + if (d->m_aspectManager) { + services()->registerServiceProvider(Qt3DCore::QServiceLocator::FrameAdvanceService, + d->m_renderer->vsyncFrameAdvanceService()); + } d->m_renderer->setQRenderAspect(this); - d->m_renderer->createAllocators(); + d->m_renderer->createAllocators(jobManager()); d->m_initialized = true; } @@ -395,7 +405,8 @@ void QRenderAspect::onInitialize(const QVariantMap &data) if (surface) d->setSurface(surface); - d->m_renderer->registerEventFilter(services()->eventFilterService()); + if (d->m_aspectManager) + d->m_renderer->registerEventFilter(services()->eventFilterService()); } void QRenderAspect::onStartup() diff --git a/src/render/graphicshelpers/graphicscontext.cpp b/src/render/graphicshelpers/graphicscontext.cpp index 7972e85e3..7d29a784a 100644 --- a/src/render/graphicshelpers/graphicscontext.cpp +++ b/src/render/graphicshelpers/graphicscontext.cpp @@ -50,6 +50,7 @@ #include <Qt3DRender/private/rendertarget_p.h> #include <Qt3DRender/private/graphicshelperinterface_p.h> #include <Qt3DRender/private/renderer_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/managers_p.h> #include <Qt3DRender/private/attachmentpack_p.h> #include <QOpenGLShaderProgram> @@ -400,9 +401,10 @@ void GraphicsContext::activateRenderTarget(RenderTarget *renderTarget, const Att fboId = m_renderTargets.value(renderTarget->peerUuid()); // We need to check if one of the attachment was resized + TextureManager *textureManager = m_renderer->nodeManagers()->textureManager(); bool needsResize = false; Q_FOREACH (const Attachment &attachment, attachments.attachments()) { - Texture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid); + Texture *rTex = textureManager->lookupResource(attachment.m_textureUuid); if (rTex != Q_NULLPTR) needsResize |= rTex->isTextureReset(); } @@ -423,8 +425,9 @@ void GraphicsContext::bindFrameBufferAttachmentHelper(GLuint fboId, const Attach // Set FBO attachments QSize fboSize; + TextureManager *textureManager = m_renderer->nodeManagers()->textureManager(); Q_FOREACH (const Attachment &attachment, attachments.attachments()) { - Texture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid); + Texture *rTex =textureManager->lookupResource(attachment.m_textureUuid); if (rTex != Q_NULLPTR) { QOpenGLTexture *glTex = rTex->getOrCreateGLTexture(); if (glTex != Q_NULLPTR) { @@ -612,12 +615,12 @@ QGraphicsApiFilter *GraphicsContext::contextInfo() const * it is simulated with a loop. */ void GraphicsContext::drawElementsInstanced(GLenum primitiveType, - GLsizei primitiveCount, - GLint indexType, - void *indices, - GLsizei instances, - GLint baseVertex, - GLint baseInstance) + GLsizei primitiveCount, + GLint indexType, + void *indices, + GLsizei instances, + GLint baseVertex, + GLint baseInstance) { m_glHelper->drawElementsInstanced(primitiveType, primitiveCount, @@ -632,9 +635,9 @@ void GraphicsContext::drawElementsInstanced(GLenum primitiveType, * Wraps an OpenGL call to glDrawArraysInstanced. */ void GraphicsContext::drawArraysInstanced(GLenum primitiveType, - GLint first, - GLsizei count, - GLsizei instances) + GLint first, + GLsizei count, + GLsizei instances) { m_glHelper->drawArraysInstanced(primitiveType, first, @@ -646,10 +649,10 @@ void GraphicsContext::drawArraysInstanced(GLenum primitiveType, * Wraps an OpenGL call to glDrawElements. */ void GraphicsContext::drawElements(GLenum primitiveType, - GLsizei primitiveCount, - GLint indexType, - void *indices, - GLint baseVertex) + GLsizei primitiveCount, + GLint indexType, + void *indices, + GLint baseVertex) { m_glHelper->drawElements(primitiveType, primitiveCount, @@ -662,8 +665,8 @@ void GraphicsContext::drawElements(GLenum primitiveType, * Wraps an OpenGL call to glDrawArrays. */ void GraphicsContext::drawArrays(GLenum primitiveType, - GLint first, - GLsizei count) + GLint first, + GLsizei count) { m_glHelper->drawArrays(primitiveType, first, @@ -848,12 +851,14 @@ void GraphicsContext::setUniforms(QUniformPack &uniforms) // Set the pinned texture of the previous material texture // to pinable so that we should easily find an available texture unit + NodeManagers *manager = m_renderer->nodeManagers(); + deactivateTexturesWithScope(TextureScopeMaterial); // Update the uniforms with the correct texture unit id's const QHash<QString, const QUniformValue *> &uniformValues = uniforms.uniforms(); for (int i = 0; i < uniforms.textures().size(); ++i) { const QUniformPack::NamedTexture &namedTex = uniforms.textures().at(i); - Texture *t = m_renderer->textureManager()->lookupResource(namedTex.texId); + Texture *t = manager->lookupResource<Texture, TextureManager>(namedTex.texId); const TextureUniform *texUniform = Q_NULLPTR; // TO DO : Rework the way textures are loaded if (t != Q_NULLPTR) { @@ -873,8 +878,8 @@ void GraphicsContext::setUniforms(QUniformPack &uniforms) for (int i = 0; i < blockToUbos.length(); ++i) { const ShaderUniformBlock &block = m_activeShader->uniformBlock(blockToUbos[i].m_blockIndex); if (block.m_index != -1 && block.m_size > 0) { - ubo = m_renderer->uboManager()->lookupResource(ShaderDataShaderUboKey(blockToUbos[i].m_shaderDataID, - m_activeShader->peerUuid())); + ubo = manager->lookupResource<UniformBuffer, UBOManager>(ShaderDataShaderUboKey(blockToUbos[i].m_shaderDataID, + m_activeShader->peerUuid())); // bind Uniform Block of index ubos[i].m_index to binding point i bindUniformBlock(m_activeShader->getOrCreateProgram(this)->programId(), block.m_index, i); // bind the UBO to the binding point i diff --git a/src/render/jobs/calcboundingvolumejob.cpp b/src/render/jobs/calcboundingvolumejob.cpp index ca91ac547..b0a30210e 100644 --- a/src/render/jobs/calcboundingvolumejob.cpp +++ b/src/render/jobs/calcboundingvolumejob.cpp @@ -37,7 +37,7 @@ #include "calcboundingvolumejob_p.h" -#include <Qt3DRender/private/renderer_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/entity_p.h> #include <Qt3DRender/private/renderlogging_p.h> #include <Qt3DRender/private/managers_p.h> @@ -58,7 +58,7 @@ namespace Render { namespace { -void calculateLocalBoundingVolume(Renderer *renderer, Entity *node) +void calculateLocalBoundingVolume(NodeManagers *manager, Entity *node) { // TO DO: How do we set the object picker to dirty when the buffer // referenced by the pickVolumeAttribute changes or has its internal buffer @@ -66,18 +66,18 @@ void calculateLocalBoundingVolume(Renderer *renderer, Entity *node) GeometryRenderer *gRenderer = node->renderComponent<GeometryRenderer>(); if (gRenderer) { - Geometry *geom = renderer->geometryManager()->lookupResource(gRenderer->geometryId()); + Geometry *geom = manager->lookupResource<Geometry, GeometryManager>(gRenderer->geometryId()); // TO DO: We must not recompute this every frame // Find a way to detect that the bounding volume attribute or its buffer have changed if (geom) { - Qt3DRender::Render::Attribute *pickVolumeAttribute = renderer->attributeManager()->lookupResource(geom->boundingPositionAttribute()); + Qt3DRender::Render::Attribute *pickVolumeAttribute = manager->lookupResource<Attribute, AttributeManager>(geom->boundingPositionAttribute()); // Use the default position attribute if attribute is null if (!pickVolumeAttribute) { Q_FOREACH (const Qt3DCore::QNodeId attrId, geom->attributes()) { - pickVolumeAttribute = renderer->attributeManager()->lookupResource(attrId); + pickVolumeAttribute = manager->lookupResource<Attribute, AttributeManager>(attrId); if (pickVolumeAttribute && pickVolumeAttribute->name() == QAttribute::defaultPositionAttributeName()) break; @@ -93,7 +93,7 @@ void calculateLocalBoundingVolume(Renderer *renderer, Entity *node) return; } - Buffer *buf = renderer->bufferManager()->lookupResource(pickVolumeAttribute->bufferId()); + Buffer *buf = manager->lookupResource<Buffer, BufferManager>(pickVolumeAttribute->bufferId()); // No point in continuing if the positionAttribute doesn't have a suitable buffer if (!buf) { qWarning() << "ObjectPicker pickVolume Attribute not referencing a valid buffer"; @@ -121,20 +121,20 @@ void calculateLocalBoundingVolume(Renderer *renderer, Entity *node) } Q_FOREACH (Entity *child, node->children()) - calculateLocalBoundingVolume(renderer, child); + calculateLocalBoundingVolume(manager, child); } } // anonymous -CalculateBoundingVolumeJob::CalculateBoundingVolumeJob(Renderer *renderer) - : m_renderer(renderer), +CalculateBoundingVolumeJob::CalculateBoundingVolumeJob(NodeManagers *manager) + : m_manager(manager), m_node(Q_NULLPTR) { } void CalculateBoundingVolumeJob::run() { - calculateLocalBoundingVolume(m_renderer, m_node); + calculateLocalBoundingVolume(m_manager, m_node); } void CalculateBoundingVolumeJob::setRoot(Entity *node) diff --git a/src/render/jobs/calcboundingvolumejob_p.h b/src/render/jobs/calcboundingvolumejob_p.h index f8317419c..02a9a5481 100644 --- a/src/render/jobs/calcboundingvolumejob_p.h +++ b/src/render/jobs/calcboundingvolumejob_p.h @@ -58,13 +58,13 @@ QT_BEGIN_NAMESPACE namespace Qt3DRender { namespace Render { -class Renderer; +class NodeManagers; class Entity; -class CalculateBoundingVolumeJob : public Qt3DCore::QAspectJob +class Q_AUTOTEST_EXPORT CalculateBoundingVolumeJob : public Qt3DCore::QAspectJob { public: - explicit CalculateBoundingVolumeJob(Renderer *renderer); + explicit CalculateBoundingVolumeJob(NodeManagers *manager); void setRoot(Entity *node); @@ -72,7 +72,7 @@ protected: void run() Q_DECL_OVERRIDE; private: - Renderer *m_renderer; + NodeManagers *m_manager; Entity *m_node; }; diff --git a/src/render/jobs/framecleanupjob.cpp b/src/render/jobs/framecleanupjob.cpp index 34ded2f81..715ad03e6 100644 --- a/src/render/jobs/framecleanupjob.cpp +++ b/src/render/jobs/framecleanupjob.cpp @@ -36,6 +36,7 @@ #include "framecleanupjob_p.h" #include <private/renderer_p.h> +#include <private/nodemanagers_p.h> #include <private/entity_p.h> #include <private/shaderdata_p.h> #include <private/managers_p.h> @@ -60,14 +61,14 @@ void FrameCleanupJob::run() { // set each ShaderData to not need an update Q_FOREACH (const Qt3DCore::QNodeId &id, ShaderData::updatedShaderDataList()) { - ShaderData *shaderData = m_renderer->shaderDataManager()->lookupResource(id); + ShaderData *shaderData = m_renderer->nodeManagers()->shaderDataManager()->lookupResource(id); if (shaderData != Q_NULLPTR) shaderData->clearUpdate(); } ShaderData::clearShaderDataList(); // Cleanup texture handles - TextureDataManager *textureDataManager = m_renderer->textureDataManager(); + TextureDataManager *textureDataManager = m_renderer->nodeManagers()->textureDataManager(); textureDataManager->cleanup(); // Debug bounding volume debug diff --git a/src/render/jobs/loadbufferjob.cpp b/src/render/jobs/loadbufferjob.cpp index 64b0dad3d..8a7bbdc1e 100644 --- a/src/render/jobs/loadbufferjob.cpp +++ b/src/render/jobs/loadbufferjob.cpp @@ -49,7 +49,7 @@ namespace Render { LoadBufferJob::LoadBufferJob(const HBuffer &handle) : QAspectJob() , m_handle(handle) - , m_renderer(Q_NULLPTR) + , m_nodeManagers(Q_NULLPTR) { } @@ -61,7 +61,7 @@ void LoadBufferJob::run() { // Let's leave it for the moment until this has been properly tested qDebug() << Q_FUNC_INFO; - Buffer *buffer = m_renderer->bufferManager()->data(m_handle); + Buffer *buffer = m_nodeManagers->data<Buffer, BufferManager>(m_handle); buffer->executeFunctor(); } diff --git a/src/render/jobs/loadbufferjob_p.h b/src/render/jobs/loadbufferjob_p.h index ce7e31eba..34ee5f552 100644 --- a/src/render/jobs/loadbufferjob_p.h +++ b/src/render/jobs/loadbufferjob_p.h @@ -51,6 +51,7 @@ #include <QSharedPointer> #include <Qt3DCore/qaspectjob.h> #include <Qt3DRender/private/handle_types_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> QT_BEGIN_NAMESPACE @@ -58,7 +59,7 @@ namespace Qt3DRender { namespace Render { -class Renderer; +class NodeManagers; class LoadBufferJob : public Qt3DCore::QAspectJob { @@ -66,12 +67,12 @@ public: explicit LoadBufferJob(const HBuffer &handle); ~LoadBufferJob(); - void setRenderer(Renderer *renderer) { m_renderer = renderer; } + void setNodeManager(NodeManagers *nodeManagers) { m_nodeManagers = nodeManagers; } protected: void run() Q_DECL_OVERRIDE; HBuffer m_handle; - Renderer *m_renderer; + NodeManagers *m_nodeManagers; }; typedef QSharedPointer<LoadBufferJob> LoadBufferJobPtr; diff --git a/src/render/jobs/loadgeometryjob.cpp b/src/render/jobs/loadgeometryjob.cpp index 11dc2b3f3..2a11b08e0 100644 --- a/src/render/jobs/loadgeometryjob.cpp +++ b/src/render/jobs/loadgeometryjob.cpp @@ -35,7 +35,7 @@ ****************************************************************************/ #include "loadgeometryjob_p.h" -#include <Qt3DRender/private/renderer_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/geometryrenderermanager_p.h> QT_BEGIN_NAMESPACE @@ -56,7 +56,7 @@ LoadGeometryJob::~LoadGeometryJob() void LoadGeometryJob::run() { - GeometryRenderer *geometryRenderer = m_renderer->geometryRendererManager()->data(m_handle); + GeometryRenderer *geometryRenderer = m_nodeManagers->geometryRendererManager()->data(m_handle); if (geometryRenderer != Q_NULLPTR) geometryRenderer->executeFunctor(); } diff --git a/src/render/jobs/loadgeometryjob_p.h b/src/render/jobs/loadgeometryjob_p.h index 1ae5f4f8d..f94ae7284 100644 --- a/src/render/jobs/loadgeometryjob_p.h +++ b/src/render/jobs/loadgeometryjob_p.h @@ -58,7 +58,7 @@ namespace Qt3DRender { namespace Render { -class Renderer; +class NodeManagers; class LoadGeometryJob : public Qt3DCore::QAspectJob { @@ -66,12 +66,12 @@ public: explicit LoadGeometryJob(const HGeometryRenderer &handle); ~LoadGeometryJob(); - void setRenderer(Renderer *renderer) { m_renderer = renderer; } + void setNodeManagers(NodeManagers *nodeManagers) { m_nodeManagers = nodeManagers; } protected: void run() Q_DECL_OVERRIDE; HGeometryRenderer m_handle; - Renderer *m_renderer; + NodeManagers *m_nodeManagers; }; typedef QSharedPointer<LoadGeometryJob> LoadGeometryJobPtr; diff --git a/src/render/jobs/loadscenejob.cpp b/src/render/jobs/loadscenejob.cpp index 10358c3b9..4eb857775 100644 --- a/src/render/jobs/loadscenejob.cpp +++ b/src/render/jobs/loadscenejob.cpp @@ -36,6 +36,7 @@ #include "loadscenejob_p.h" #include <private/renderer_p.h> +#include <private/nodemanagers_p.h> #include <private/scenemanager_p.h> #include <Qt3DCore/qentity.h> #include <Qt3DRender/qabstractsceneparser.h> @@ -55,18 +56,18 @@ LoadSceneJob::LoadSceneJob(const QUrl &source, const Qt3DCore::QNodeId &m_sceneC void LoadSceneJob::run() { - Qt3DCore::QEntity *sceneTree = m_renderer->sceneManager()->sceneTreeFromSource(m_source); + Qt3DCore::QEntity *sceneTree = m_renderer->nodeManagers()->sceneManager()->sceneTreeFromSource(m_source); if (sceneTree == Q_NULLPTR) { Q_FOREACH (QAbstractSceneParser *parser, m_renderer->sceneParsers()) { if (parser->isExtensionSupported(m_source)) { parser->setSource(m_source); sceneTree = parser->scene(); - m_renderer->sceneManager()->addLoadedSceneTree(m_source, sceneTree); + m_renderer->nodeManagers()->sceneManager()->addLoadedSceneTree(m_source, sceneTree); } } } // set clone of sceneTree in sceneComponent - Scene *scene = m_renderer->sceneManager()->lookupResource(m_sceneComponent); + Scene *scene = m_renderer->nodeManagers()->sceneManager()->lookupResource(m_sceneComponent); scene->setSceneSubtree(sceneTree); } diff --git a/src/render/jobs/loadtexturedatajob.cpp b/src/render/jobs/loadtexturedatajob.cpp index 4b34690ef..5f4a9801b 100644 --- a/src/render/jobs/loadtexturedatajob.cpp +++ b/src/render/jobs/loadtexturedatajob.cpp @@ -35,9 +35,10 @@ ****************************************************************************/ #include "loadtexturedatajob_p.h" -#include <Qt3DRender/private/renderer_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/managers_p.h> #include <Qt3DRender/private/texturedatamanager_p.h> +#include <Qt3DRender/qtexturedata.h> #include <QThread> QT_BEGIN_NAMESPACE @@ -58,12 +59,13 @@ void LoadTextureDataJob::run() { qCDebug(Jobs) << "Entering" << Q_FUNC_INFO << QThread::currentThread(); - Texture *txt = m_renderer->textureManager()->lookupResource(m_textureId); + Texture *txt = m_manager->textureManager()->lookupResource(m_textureId); + TextureDataManager *textureDataManager = m_manager->manager<QTexImageData, TextureDataManager>(); if (txt != Q_NULLPTR) { // Load update each TextureImage Q_FOREACH (HTextureImage texImgHandle, txt->textureImages()) { - TextureImage *texImg = m_renderer->textureImageManager()->data(texImgHandle); + TextureImage *texImg = m_manager->textureImageManager()->data(texImgHandle); if (texImg != Q_NULLPTR && texImg->isDirty() && !texImg->dataFunctor().isNull()) { QTextureDataFunctorPtr functor = texImg->dataFunctor(); HTextureData textureDataHandle; @@ -71,29 +73,29 @@ void LoadTextureDataJob::run() // scoped for locker { - QMutexLocker locker(m_renderer->textureDataManager()->mutex()); + QMutexLocker locker(textureDataManager->mutex()); // We don't want to take the chance of having two jobs uploading the same functor // because of sync issues - textureDataHandle = m_renderer->textureDataManager()->textureDataFromFunctor(functor); + textureDataHandle = textureDataManager->textureDataFromFunctor(functor); // Texture data handle isn't null == there's already a matching TextureData if (!textureDataHandle.isNull()) { - data = m_renderer->textureDataManager()->data(textureDataHandle); + data = textureDataManager->data(textureDataHandle); } else { QTexImageDataPtr dataPtr = functor->operator ()(); if (dataPtr.isNull()) { qCDebug(Jobs) << Q_FUNC_INFO << "Texture has no raw data"; } else { // Save the QTexImageDataPtr with it's functor as a key - textureDataHandle = m_renderer->textureDataManager()->acquire(); - data = m_renderer->textureDataManager()->data(textureDataHandle); + textureDataHandle = textureDataManager->acquire(); + data = textureDataManager->data(textureDataHandle); *data = *(dataPtr.data()); - m_renderer->textureDataManager()->addTextureDataForFunctor(textureDataHandle, functor); + textureDataManager->addTextureDataForFunctor(textureDataHandle, functor); } } // Update HTextureImage Functor to release TextureData when needed - m_renderer->textureDataManager()->assignFunctorToTextureImage(functor, texImgHandle); + textureDataManager->assignFunctorToTextureImage(functor, texImgHandle); } // Set texture size of texture if the first layer / level / face has a valid size diff --git a/src/render/jobs/loadtexturedatajob_p.h b/src/render/jobs/loadtexturedatajob_p.h index 9826181b1..0c1061390 100644 --- a/src/render/jobs/loadtexturedatajob_p.h +++ b/src/render/jobs/loadtexturedatajob_p.h @@ -58,21 +58,21 @@ namespace Qt3DRender { namespace Render { -class Renderer; +class NodeManagers; class LoadTextureDataJob : public Qt3DCore::QAspectJob { public: LoadTextureDataJob(const Qt3DCore::QNodeId &textureId); ~LoadTextureDataJob(); - inline void setRenderer(Renderer *renderer) { m_renderer = renderer; } + inline void setNodeManagers(NodeManagers *manager) { m_manager = manager; } protected: void run() Q_DECL_FINAL; private: Qt3DCore::QNodeId m_textureId; - Renderer *m_renderer; + NodeManagers *m_manager; }; typedef QSharedPointer<LoadTextureDataJob> LoadTextureDataJobPtr; diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp index 2140d5cd3..f6c2acfff 100644 --- a/src/render/jobs/pickboundingvolumejob.cpp +++ b/src/render/jobs/pickboundingvolumejob.cpp @@ -36,6 +36,7 @@ #include "pickboundingvolumejob_p.h" #include <Qt3DRender/private/renderer_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/framegraphnode_p.h> #include <Qt3DRender/private/cameralens_p.h> #include <Qt3DRender/private/cameraselectornode_p.h> @@ -123,6 +124,7 @@ public: PickBoundingVolumeJob::PickBoundingVolumeJob(Renderer *renderer) : m_renderer(renderer) + , m_manager(renderer->nodeManagers()) , m_node(Q_NULLPTR) { } @@ -173,7 +175,7 @@ void PickBoundingVolumeJob::run() if (!vcPairs.empty()) { Q_FOREACH (const QMouseEvent &event, m_mouseEvents) { m_hoveredPickersToClear = m_hoveredPickers; - ObjectPicker *lastCurrentPicker = m_renderer->objectPickerManager()->data(m_currentPicker); + ObjectPicker *lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker); Q_FOREACH (const ViewportCameraPair &vc, vcPairs) { const QVector<Qt3DCore::QNodeId> hits = hitsForViewportAndCamera(event.pos(), vc.viewport, @@ -183,7 +185,7 @@ void PickBoundingVolumeJob::run() // If we have hits if (!hits.isEmpty()) { Q_FOREACH (const Qt3DCore::QNodeId &entityId, hits) { - Entity *entity = m_renderer->renderNodesManager()->lookupResource(entityId); + Entity *entity = m_manager->renderNodesManager()->lookupResource(entityId); HObjectPicker objectPickerHandle = entity->componentHandle<ObjectPicker, 16>(); // If the Entity which actually received the hit doesn't have @@ -194,7 +196,7 @@ void PickBoundingVolumeJob::run() objectPickerHandle = entity->componentHandle<ObjectPicker, 16>(); } - ObjectPicker *objectPicker = m_renderer->objectPickerManager()->data(objectPickerHandle); + ObjectPicker *objectPicker = m_manager->objectPickerManager()->data(objectPickerHandle); if (objectPicker != Q_NULLPTR) { // Send the corresponding event @@ -242,7 +244,7 @@ void PickBoundingVolumeJob::run() // The ObjectPicker was hit -> it is still being hovered m_hoveredPickersToClear.removeAll(objectPickerHandle); - lastCurrentPicker = m_renderer->objectPickerManager()->data(m_currentPicker); + lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker); } // Otherwise no hits @@ -292,7 +294,7 @@ void PickBoundingVolumeJob::viewMatrixForCamera(const Qt3DCore::QNodeId &cameraI QMatrix4x4 &projectionMatrix) const { Render::CameraLens *lens = Q_NULLPTR; - Entity *camNode = m_renderer->renderNodesManager()->lookupResource(cameraId); + Entity *camNode = m_manager->renderNodesManager()->lookupResource(cameraId); if (camNode != Q_NULLPTR && (lens = camNode->renderComponent<CameraLens>()) != Q_NULLPTR && lens->isEnabled()) { @@ -340,7 +342,7 @@ QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::hitsForViewportAndCamera(const void PickBoundingVolumeJob::clearPreviouslyHoveredPickers() { Q_FOREACH (const HObjectPicker &pickHandle, m_hoveredPickersToClear) { - ObjectPicker *pick = m_renderer->objectPickerManager()->data(pickHandle); + ObjectPicker *pick = m_manager->objectPickerManager()->data(pickHandle); if (pick) pick->onExited(); m_hoveredPickers.removeAll(pickHandle); diff --git a/src/render/jobs/pickboundingvolumejob_p.h b/src/render/jobs/pickboundingvolumejob_p.h index e52fcccf4..6edfa23b4 100644 --- a/src/render/jobs/pickboundingvolumejob_p.h +++ b/src/render/jobs/pickboundingvolumejob_p.h @@ -68,6 +68,7 @@ namespace Render { class Entity; class Renderer; +class NodeManagers; class Q_AUTOTEST_EXPORT PickBoundingVolumeJob : public Qt3DCore::QAspectJob, public Qt3DCore::QBoundingVolumeProvider { @@ -86,6 +87,7 @@ protected: private: Renderer *m_renderer; + NodeManagers *m_manager; Entity *m_node; QList<QMouseEvent> m_mouseEvents; diff --git a/src/render/jobs/renderviewjobutils.cpp b/src/render/jobs/renderviewjobutils.cpp index 1e80cb87c..ab5247098 100644 --- a/src/render/jobs/renderviewjobutils.cpp +++ b/src/render/jobs/renderviewjobutils.cpp @@ -44,7 +44,7 @@ #include <Qt3DRender/private/cameraselectornode_p.h> #include <Qt3DRender/private/clearbuffer_p.h> #include <Qt3DRender/private/layerfilternode_p.h> -#include <Qt3DRender/private/managers_p.h> +#include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/effect_p.h> #include <Qt3DRender/private/renderpassfilternode_p.h> #include <Qt3DRender/private/renderstateset_p.h> @@ -78,7 +78,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN // which is referenced by the Material which is referenced by the RenderMesh. So we can // only store the filter info in the RenderView structure and use it to do the resolving // when we build the RenderCommand list. - const Renderer *renderer = rv->renderer(); + const NodeManagers *manager = rv->nodeManagers(); const FrameGraphNode *node = fgLeaf; while (node) { @@ -89,7 +89,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN // Can be set only once and we take camera nearest to the leaf node if (!rv->renderCamera()) { const CameraSelector *cameraSelector = static_cast<const CameraSelector *>(node); - Entity *camNode = renderer->renderNodesManager()->lookupResource(cameraSelector->cameraUuid()); + Entity *camNode = manager->renderNodesManager()->lookupResource(cameraSelector->cameraUuid()); if (camNode) { CameraLens *lens = camNode->renderComponent<CameraLens>(); if (lens && lens->isEnabled()) { @@ -121,11 +121,11 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN // Can be set once and we take render target nearest to the leaf node const RenderTargetSelector *targetSelector = static_cast<const RenderTargetSelector *>(node); QNodeId renderTargetUid = targetSelector->renderTargetUuid(); - HTarget renderTargetHandle = renderer->renderTargetManager()->lookupHandle(renderTargetUid); + HTarget renderTargetHandle = manager->renderTargetManager()->lookupHandle(renderTargetUid); if (rv->renderTargetHandle().isNull()) { rv->setRenderTargetHandle(renderTargetHandle); - RenderTarget *renderTarget = renderer->renderTargetManager()->data(renderTargetHandle); + RenderTarget *renderTarget = manager->renderTargetManager()->data(renderTargetHandle); if (renderTarget) { // Add renderTarget Handle and build renderCommand AttachmentPack @@ -134,7 +134,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN // Copy attachments Q_FOREACH (const QNodeId &attachmentId, renderTarget->renderAttachments()) { - RenderAttachment *attachment = renderer->attachmentManager()->lookupResource(attachmentId); + RenderAttachment *attachment = manager->attachmentManager()->lookupResource(attachmentId); if (attachment) rv->addRenderAttachment(attachment->attachment()); } @@ -216,15 +216,17 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN \a effect specified by the \a renderView. */ Technique *findTechniqueForEffect(Renderer *renderer, - RenderView *renderView, - Effect *effect) + RenderView *renderView, + Effect *effect) { if (!effect) return Q_NULLPTR; + NodeManagers *manager = renderer->nodeManagers(); + // Iterate through the techniques in the effect Q_FOREACH (const QNodeId &techniqueId, effect->techniques()) { - Technique *technique = renderer->techniqueManager()->lookupResource(techniqueId); + Technique *technique = manager->techniqueManager()->lookupResource(techniqueId); if (!technique) continue; @@ -248,10 +250,10 @@ Technique *findTechniqueForEffect(Renderer *renderer, // technique that satisfies it Q_FOREACH (const QNodeId &filterAnnotationId, techniqueFilter->filters()) { foundMatch = false; - Annotation *filterAnnotation = renderer->criterionManager()->lookupResource(filterAnnotationId); + Annotation *filterAnnotation = manager->criterionManager()->lookupResource(filterAnnotationId); Q_FOREACH (const QNodeId &techniqueAnnotationId, technique->annotations()) { - Annotation *techniqueAnnotation = renderer->criterionManager()->lookupResource(techniqueAnnotationId); + Annotation *techniqueAnnotation = manager->criterionManager()->lookupResource(techniqueAnnotationId); if ((foundMatch = (*techniqueAnnotation == *filterAnnotation))) break; } @@ -273,16 +275,16 @@ Technique *findTechniqueForEffect(Renderer *renderer, } -RenderRenderPassList findRenderPassesForTechnique(Renderer *renderer, +RenderRenderPassList findRenderPassesForTechnique(NodeManagers *manager, RenderView *renderView, Technique *technique) { - Q_ASSERT(renderer); + Q_ASSERT(manager); Q_ASSERT(technique); RenderRenderPassList passes; Q_FOREACH (const QNodeId &passId, technique->renderPasses()) { - RenderPass *renderPass = renderer->renderPassManager()->lookupResource(passId); + RenderPass *renderPass = manager->renderPassManager()->lookupResource(passId); if (renderPass) { const RenderPassFilter *passFilter = renderView->renderPassFilter(); @@ -294,10 +296,10 @@ RenderRenderPassList findRenderPassesForTechnique(Renderer *renderer, // Iterate through the filter criteria and look for render passes with criteria that satisfy them Q_FOREACH (const QNodeId &filterAnnotationId, passFilter->filters()) { foundMatch = false; - Annotation *filterAnnotation = renderer->criterionManager()->lookupResource(filterAnnotationId); + Annotation *filterAnnotation = manager->criterionManager()->lookupResource(filterAnnotationId); Q_FOREACH (const QNodeId &passAnnotationId, renderPass->annotations()) { - Annotation *passAnnotation = renderer->criterionManager()->lookupResource(passAnnotationId); + Annotation *passAnnotation = manager->criterionManager()->lookupResource(passAnnotationId); if ((foundMatch = (*passAnnotation == *filterAnnotation))) break; } @@ -329,7 +331,7 @@ ParameterInfoList::iterator findParamInfo(ParameterInfoList *params, const QStri } void addParametersForIds(ParameterInfoList *params, ParameterManager *manager, - const QList<Qt3DCore::QNodeId> ¶meterIds) + const QList<Qt3DCore::QNodeId> ¶meterIds) { Q_FOREACH (const QNodeId ¶mId, parameterIds) { Parameter *param = manager->lookupResource(paramId); diff --git a/src/render/jobs/renderviewjobutils_p.h b/src/render/jobs/renderviewjobutils_p.h index 9064ab02c..aeca32268 100644 --- a/src/render/jobs/renderviewjobutils_p.h +++ b/src/render/jobs/renderviewjobutils_p.h @@ -72,6 +72,7 @@ class RenderStateSet; class Technique; class RenderView; class Renderer; +class NodeManagers; class ShaderDataManager; struct ShaderUniform; class ShaderData; @@ -81,11 +82,11 @@ Q_AUTOTEST_EXPORT void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphNode *fgLeaf); Q_AUTOTEST_EXPORT Technique *findTechniqueForEffect(Renderer *renderer, - RenderView *renderView, - Effect *effect); + RenderView *renderView, + Effect *effect); typedef QVarLengthArray<RenderPass*, 4> RenderRenderPassList; -Q_AUTOTEST_EXPORT RenderRenderPassList findRenderPassesForTechnique(Renderer *renderer, +Q_AUTOTEST_EXPORT RenderRenderPassList findRenderPassesForTechnique(NodeManagers *manager, RenderView *renderView, Technique *technique); |