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 "qabstractaspect.h"
#include "qabstractaspect_p.h"
#include <QMetaObject>
#include <QMetaProperty>
#include <Qt3DCore/qcomponent.h>
#include <Qt3DCore/qentity.h>
#include <Qt3DCore/private/corelogging_p.h>
#include <Qt3DCore/private/qaspectjobmanager_p.h>
#include <Qt3DCore/private/qaspectmanager_p.h>
#include <Qt3DCore/private/qnodevisitor_p.h>
#include <Qt3DCore/private/qnode_p.h>
#include <Qt3DCore/private/qscene_p.h>
#include <Qt3DCore/private/qnode_p.h>
#include <Qt3DCore/private/vector_helper_p.h>
QT_BEGIN_NAMESPACE
namespace Qt3DCore {
QAbstractAspectPrivate::QAbstractAspectPrivate()
: QObjectPrivate()
, m_root(nullptr)
, m_rootId()
, m_aspectManager(nullptr)
, m_jobManager(nullptr)
, m_arbiter(nullptr)
{
}
QAbstractAspectPrivate::~QAbstractAspectPrivate()
{
}
QAbstractAspectPrivate *QAbstractAspectPrivate::get(QAbstractAspect *aspect)
{
return aspect->d_func();
}
/*!
* \internal
* Called in the context of the main thread
*/
void QAbstractAspectPrivate::onEngineAboutToShutdown()
{
}
/*! \internal */
void QAbstractAspectPrivate::unregisterBackendType(const QMetaObject &mo)
{
m_backendCreatorFunctors.remove(&mo);
}
/*!
* \class Qt3DCore::QAbstractAspect
* \inheaderfile Qt3DCore/QAbstractAspect
* \inherits QObject
* \inmodule Qt3DCore
* \brief QAbstractAspect is the base class for aspects that provide a vertical slice of behavior.
*/
/*!
* \fn template <class Frontend> void Qt3DCore::QAbstractAspect::registerBackendType(const Qt3DCore::QBackendNodeMapperPtr &functor)
* Registers backend with \a functor.
*/
/*!
* \macro QT3D_REGISTER_ASPECT(name, AspectType)
* \relates Qt3DCore::QAbstractAspect
*
* Convenience macro for registering \a AspectType for instantiation by the
* currently set Qt3DCore::QAspectFactory. This makes it possible to create an
* instance of \a AspectType in the aspect thread by later passing \a name to
* Qt3DCore::QAspectEngine::registerAspect(const QString &name).
*
* \note It is also possible to register a new aspect without using this macro
* by instead using Qt3DCore::QAspectEngine::registerAspect(QAbstractAspect *aspect)
* which will handle moving a previously created aspect instance to the aspect
* thread context.
*
* KDAB has published a few articles about writing custom Qt3D aspects
* provide an excellent starting point if you wish to learn more about it.
*/
/*!
* Constructs a new QAbstractAspect with \a parent
*/
QAbstractAspect::QAbstractAspect(QObject *parent)
: QAbstractAspect(*new QAbstractAspectPrivate, parent) {}
/*!
* \typedef Qt3DCore::QAspectJobPtr
* \relates Qt3DCore::QAbstractAspect
*
* A shared pointer for QAspectJob.
*/
/*!
* \typedef Qt3DCore::QBackendNodeMapperPtr
* \relates Qt3DCore::QAbstractAspect
*
* A shared pointer for QBackendNodeMapper.
*/
/*!
* \internal
*/
QAbstractAspect::QAbstractAspect(QAbstractAspectPrivate &dd, QObject *parent)
: QObject(dd, parent)
{
}
/*!
\internal
*/
QAbstractAspect::~QAbstractAspect()
{
}
/*!
* \return root entity node id.
*/
QNodeId QAbstractAspect::rootEntityId() const noexcept
{
Q_D(const QAbstractAspect);
return d->m_rootId;
}
/*!
* Registers backend with \a obj and \a functor.
*/
void QAbstractAspect::registerBackendType(const QMetaObject &obj, const QBackendNodeMapperPtr &functor)
{
Q_D(QAbstractAspect);
d->m_backendCreatorFunctors.insert(&obj, functor);
}
void QAbstractAspect::unregisterBackendType(const QMetaObject &obj)
{
Q_D(QAbstractAspect);
d->m_backendCreatorFunctors.remove(&obj);
}
QVariant QAbstractAspect::executeCommand(const QStringList &args)
{
Q_UNUSED(args);
return QVariant();
}
std::vector<QAspectJobPtr> QAbstractAspect::jobsToExecute(qint64 time)
{
Q_UNUSED(time);
return {};
}
QBackendNodeMapperPtr QAbstractAspectPrivate::mapperForNode(const QMetaObject *metaObj) const
{
Q_ASSERT(metaObj);
QBackendNodeMapperPtr mapper;
while (metaObj != nullptr && mapper.isNull()) {
mapper = m_backendCreatorFunctors.value(metaObj);
metaObj = metaObj->superClass();
}
return mapper;
}
void QAbstractAspectPrivate::syncDirtyFrontEndNodes(const QList<QNode *> &nodes)
{
for (auto node: std::as_const(nodes)) {
const QMetaObject *metaObj = QNodePrivate::get(node)->m_typeInfo;
const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
if (!backendNodeMapper)
continue;
QBackendNode *backend = backendNodeMapper->get(node->id());
if (!backend)
continue;
syncDirtyFrontEndNode(node, backend, false);
}
}
void QAbstractAspectPrivate::syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const
{
backend->syncFromFrontEnd(node, firstTime);
}
void QAbstractAspectPrivate::syncDirtyEntityComponentNodes(const QList<ComponentRelationshipChange> &changes)
{
auto getBackend = [this] (QNode *node) -> QBackendNode* {
const QMetaObject *metaObj = QNodePrivate::get(node)->m_typeInfo;
const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
if (!backendNodeMapper)
return nullptr;
return backendNodeMapper->get(node->id());
};
for (const auto &change: std::as_const(changes)) {
auto entityBackend = getBackend(change.node);
if (!entityBackend)
continue;
auto componentBackend = getBackend(change.subNode);
if (!componentBackend)
continue;
switch (change.change) {
case ComponentRelationshipChange::Added:
QBackendNodePrivate::get(entityBackend)->componentAdded(change.subNode);
QBackendNodePrivate::get(componentBackend)->addedToEntity(change.node);
break;
case ComponentRelationshipChange::Removed:
QBackendNodePrivate::get(entityBackend)->componentRemoved(change.subNode);
QBackendNodePrivate::get(componentBackend)->removedFromEntity(change.node);
break;
}
}
}
QBackendNode *QAbstractAspectPrivate::createBackendNode(const NodeTreeChange &change) const
{
const QMetaObject *metaObj = change.metaObj;
const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
if (!backendNodeMapper)
return nullptr;
QBackendNode *backend = backendNodeMapper->get(change.id);
if (backend != nullptr)
return backend;
QNode *node = change.node;
QNodeId nodeId = qIdForNode(node);
backend = backendNodeMapper->create(nodeId);
if (!backend)
return nullptr;
// TODO: Find some place else to do all of this function from the arbiter
backend->setPeerId(nodeId);
// Backend could be null if the user decides that his functor should only
// perform some action when encountering a given type of item but doesn't need to
// return a QBackendNode pointer.
QBackendNodePrivate *backendPriv = QBackendNodePrivate::get(backend);
backendPriv->setEnabled(node->isEnabled());
syncDirtyFrontEndNode(node, backend, true);
return backend;
}
void QAbstractAspectPrivate::clearBackendNode(const NodeTreeChange &change) const
{
const QMetaObject *metaObj = change.metaObj;
const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
if (!backendNodeMapper)
return;
backendNodeMapper->destroy(change.id);
}
void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QList<NodeTreeChange> &nodesChanges)
{
qCDebug(Aspects) << Q_FUNC_INFO << "rootObject =" << rootObject;
if (rootObject == m_root)
return;
m_root = rootObject;
m_rootId = rootObject->id();
for (const NodeTreeChange &change : nodesChanges)
createBackendNode(change);
}
QServiceLocator *QAbstractAspectPrivate::services() const
{
return m_aspectManager ? m_aspectManager->serviceLocator() : nullptr;
}
QAbstractAspectJobManager *QAbstractAspectPrivate::jobManager() const
{
return m_jobManager;
}
std::vector<QAspectJobPtr> QAbstractAspectPrivate::jobsToExecute(qint64 time)
{
Q_Q(QAbstractAspect);
auto res = q->jobsToExecute(time);
{
QMutexLocker lock(&m_singleShotMutex);
Qt3DCore::moveAtEnd(res, std::move(m_singleShotJobs));
m_singleShotJobs.clear();
}
return res;
}
void QAbstractAspectPrivate::jobsDone()
{
}
void QAbstractAspectPrivate::frameDone()
{
}
/*!
* Called in the context of the aspect thread once the aspect has been registered.
* This provides an opportunity for the aspect to do any initialization tasks that
* require to be in the aspect thread context such as creating QObject subclasses that
* must have affinity with this thread.
*
* \sa onUnregistered
*/
void QAbstractAspect::onRegistered()
{
}
/*!
* Called in the context of the aspect thread during unregistration
* of the aspect. This gives the aspect a chance to do any final pieces of
* cleanup that it would not do when just changing to a new scene.
*
* \sa onRegistered
*/
void QAbstractAspect::onUnregistered()
{
}
/*!
*
* Called in the QAspectThread context
*/
void QAbstractAspect::onEngineStartup()
{
}
/*!
*
* Called in the QAspectThread context
*/
void QAbstractAspect::onEngineShutdown()
{
}
/*!
* Called in the main thread once all the jobs have been executed.
*
* \note This is called after QAspectJob::postFrame is called on every jobs.
*
* \sa QAspectJob::postFrame
*/
void QAbstractAspect::jobsDone()
{
Q_D(QAbstractAspect);
d->jobsDone();
}
/*!
* Called in the main thread when the frame processing is complete.
*/
void QAbstractAspect::frameDone()
{
Q_D(QAbstractAspect);
d->frameDone();
}
void QAbstractAspect::scheduleSingleShotJob(const Qt3DCore::QAspectJobPtr &job)
{
Q_D(QAbstractAspect);
QMutexLocker lock(&d->m_singleShotMutex);
d->m_singleShotJobs.push_back(job);
}
QStringList QAbstractAspect::dependencies() const
{
return {};
}
namespace Debug {
AsynchronousCommandReply::AsynchronousCommandReply(const QString &commandName, QObject *parent)
: QObject(parent)
, m_commandName(commandName)
, m_finished(false)
{
}
void AsynchronousCommandReply::setFinished(bool replyFinished)
{
m_finished = replyFinished;
if (m_finished)
emit finished(this);
}
void AsynchronousCommandReply::setData(const QByteArray &data)
{
m_data = data;
}
} // Debug
} // of namespace Qt3DCore
QT_END_NAMESPACE
#include "moc_qabstractaspect_p.cpp"
#include "moc_qabstractaspect.cpp"