Einführung
Qt 3D verfügt über eine flexible und erweiterbare Architektur, die es uns ermöglicht, neue Funktionen einfach hinzuzufügen, ohne bestehende Funktionen zu beeinträchtigen. Die Funktionalität von Qt 3D ist in sogenannte Aspekte unterteilt, die jeweils einen bestimmten Themenbereich kapseln, wie etwa Rendering (Render Aspect), Eingabe (Input Aspect) oder Animation (Animation Aspect).
In dieser kurzen Artikelserie werden Sie durch den Prozess des Hinzufügens eines neuen Aspekts geführt, der Komponententypen und Verhalten für einen neuen Bereich bereitstellt, der von Qt 3D standardmäßig nicht abgedeckt wird. In diesem Beispiel haben wir uns entschieden, einen Aspekt zu implementieren, der es uns ermöglicht, die aktuelle durchschnittliche Framerate zu berechnen. Natürlich könnte dies dem Renderer hinzugefügt werden, aber es ist einfach genug, um ein gutes Beispiel für unsere heutigen Zwecke zu sein. Der vollständige Quellcode für das Beispiel steht unter download zur Verfügung.
Überprüfung
Die Anwendung, die wir erstellen werden, sieht so aus. Dies ist eine sehr einfache Qt-3D-Szene und ein Fenster, das die aktuelle durchschnittliche Bildrate anzeigt.
Es gibt mehrere Teile, die wir beim Hinzufügen neuer Funktionen berücksichtigen müssen:
- Aspect - ist verantwortlich für die Organisation aller Aufgaben, die die Ausführung jedes Frames erfordern, und für die Verwaltung der Speicherung externer Objekte.
- Komponenten - Von Ihrer Bibliothek oder Anwendung bereitgestellt, die zusammen dem endgültigen Objekt ein neues Verhalten verleihen. Komponenten sind die Haupt-API, die Sie erstellen müssen.
- Knoten (Knoten in der Abbildung) – wie bei Komponenten, außer dass Unterklassen von QNode normalerweise die von der Komponente benötigten Zusatzdaten bereitstellen. Beispielsweise ist QAnimationClipLoader ein Knoten, der Keyframe-Animationsdaten für die QClipAnimator-Komponente bereitstellt.
- Backend-Knoten (Backend-Knoten im Bild) – Backend-Kopien für alle externen Komponenten oder Knoten, die von Ihrer Bibliothek/Anwendung bereitgestellt werden. Dies sind Objekte, die normalerweise von Jobs verarbeitet werden, die im Thread-Pool ausgeführt werden, wie es der Aspekt selbst vorschreibt.
- Mapper - Benutzerdefinierte Maps, die sich unter Berücksichtigung dieses Aspekts registrieren und für das Erstellen, Abrufen und Zerstören interner Knoten bei Bedarf verantwortlich sind. Mapper wird von QAbstractAspect und QAspectEngine verwendet, um die Lebensdauer externer und interner Objekte zu synchronisieren.
- Jobs - vom Aspekt erstellt und geplant, verarbeiten die Basisknoten. Jobs können auch Ereignisse an externe Knoten und Komponenten senden, wenn sich Eigenschaften ändern.
- Change Arbiter - verantwortlich für die Übermittlung von Ereignissen zwischen Frontend- und Backend-Objekten. Sie brauchen nichts damit zu tun, aber seien Sie sich seiner Existenz bewusst.
Einen Aspekt hinzufügen
Das Schreiben des ursprünglichen Aspekts ist wirklich trivial. Erben Sie einfach QAbstractAspect und registrieren Sie es bei QAspectEngine:
customaspekt.h
class CustomAspect : public Qt3DCore::QAbstractAspect
{
Q_OBJECT
public:
explicit CustomAspect(QObject *parent = nullptr)
: Qt3DCore::QAbstractAspect(parent)
{}
protected:
QVector<Qt3DCore::QAspectJobPtr> jobsToExecute(qint64 time) override
{
qDebug() << Q_FUNC_INFO << "Frame time =" << time;
return {};
}
};
main.cpp
int main(int argc, char **argv)
{
QGuiApplication app(argc, argv);
Qt3DExtras::Quick::Qt3DQuickWindow view;
view.engine()->aspectEngine()->registerAspect(new CustomAspect);
view.setSource(QUrl("qrc:/main.qml"));
view.show();
return app.exec();
}
QAbstractAspect verfügt über virtuelle Methoden, die Sie bei Bedarf zum Initialisieren und Löschen überschreiben können. Für dieses einfache Beispiel müssen wir jedoch nur die virtuelle Methode jobsToExecute() implementieren. Wir werden es später verwenden, um für jeden Frame einen Job im Thread-Pool zu planen, aber im Moment geben wir nur Debug-Text aus, um einen leeren Vektor zurückzugeben (keine Jobs, die zur Ausführung bereit sind). Beachten Sie, dass diese virtuellen Funktionen nur aufgerufen werden, nachdem der Aspekt bei der QAspectEngine (siehe oben) als Teil der Simulation registriert wurde. Wir kommen zurück und beenden diesen Aspekt etwas später.
FpsMonitor-Komponente
Wir möchten eine Funktionalität hinzufügen, die Informationen über die durchschnittliche Framerate anzeigt, gemittelt über eine bestimmte Anzahl von Frames. Wir können eine API wie folgt schreiben:
fpsmonitor.h
class FpsMonitor : public Qt3DCore::QComponent
{
Q_OBJECT
Q_PROPERTY(int rollingMeanFrameCount READ rollingMeanFrameCount WRITE setRollingMeanFrameCount NOTIFY rollingMeanFrameCountChanged)
Q_PROPERTY(float framesPerSecond READ framesPerSecond NOTIFY framesPerSecondChanged)
public:
explicit FpsMonitor(Qt3DCore::QNode *parent = nullptr);
float framesPerSecond() const;
int rollingMeanFrameCount() const;
public slots:
void setRollingMeanFrameCount(int rollingMeanFrameCount);
signals:
void framesPerSecondChanged(float framesPerSecond);
void rollingMeanFrameCountChanged(int rollingMeanFrameCount);
private:
float m_framesPerSecond;
int m_rollingMeanFrameCount;
};
Bitte beachten Sie, dass wir eine eigenschaftsbasierte deklarative API verwenden, sodass diese Klasse problemlos sowohl von QML als auch von C++ verwendet werden kann. Die Eigenschaft rollingMeanFrameCount ist eine normale Lese-/Schreibeigenschaft, und die Implementierung der Setter- und Getter-Funktionen ist vollständig Standard. Diese Eigenschaft wird verwendet, um die Anzahl der Frames zu steuern, über die wir die gleitende durchschnittliche Framerate berechnen. Die Eigenschaft framesPerSecond ist eine schreibgeschützte Eigenschaft, die später von einem Job gesetzt wird, den wir schreiben werden, um FpsMonitor-Komponenten im Qt-3D-Thread-Pool zu verarbeiten.
Erstellen Sie eine kleine Testanwendung
Bevor wir unsere benutzerdefinierte Bean von QML verwenden können, müssen wir den Typ beim QML-Typsystem registrieren. Dies ist ein einfacher einzeiliger Code, den wir zu unserer Hauptfunktion hinzufügen können:
main.cpp
qmlRegisterType<FpsMonitor>("CustomModule", 1, 0, "FpsMonitor");
rootContext->setContextProperty("_window", &view);
wobei wir auch die Möglichkeit genutzt haben, das Fenster in einen QML-Kontext zu exportieren (das werden wir irgendwann brauchen).
Sobald dies erledigt ist, können wir das CustomModule-QML-Modul importieren und die FpsMonitor-Komponente wie alle integrierten Typen verwenden.
main.qml
Entity {
components: [
FpsMonitor {
rollingMeanFrameCount: 20
onFramesPerSecondChanged: {
var fpsString = parseFloat(Math.round(framesPerSecond * 100) / 100).toFixed(2);
_window.title = "CustomAspect: FPS = " + fpsString
+ " (" + rollingMeanFrameCount + " frame average)"
}
}
]
}
Im Moment macht FpsMonitor natürlich nichts anderes, als den Wert der Eigenschaft rollingMeanFrameCount zu setzen. Sobald wir das Backend fertig gestellt haben, aktualisiert der obige Code den Fenstertitel, um die aktuelle durchschnittliche Framerate und die Anzahl der Frames anzuzeigen, die zu ihrer Berechnung verwendet wurden.
Im nächsten Teil implementieren wir den entsprechenden Backend-Knoten für FpsMonitor und stellen sicher, dass er bei Bedarf erstellt und zerstört wird, und richten die Kommunikation zwischen dem Frontend und dem Backend ein.
Artikel geschrieben von: Sean Harmer | Samstag, 25.11.2017
