Qt 3D: Drahtgitter QML Beispiel

Qt 3D Wireframe Rendering veranschaulicht, wie ein einzelnes Objekt (ein Kleeblattknoten) unter Verwendung eines benutzerdefinierten Satzes von Shadern gezeichnet wird, um eine Single-Pass Wireframe-Rendering-Methode zu implementieren.

Ausführen des Beispiels

Um das Beispiel auszuführen Qt Creatorauszuführen, öffnen Sie den Modus Welcome und wählen Sie das Beispiel unter Examples aus. Weitere Informationen finden Sie unter Erstellen und Ausführen eines Beispiels.

Erstellen von Entitäten

Der Renderer-Aspekt sucht nach Entities, die eine Geometrie, ein Material und optional eine Transformation haben. Diese werden alle in Form von Unterklassen von QComponent angegeben, die in die QML-Engine in Form von Mesh, Material und Transform exportiert wurden. Wir verwenden diese Komponenten, um ein benutzerdefiniertes QML-Element in TrefoilKnot.qml zu erstellen.

Wir beginnen mit dem Import des Moduls Qt3D 2.0, das die Typ- und Wertetyp-Helfer von Entity bereitstellt, wie z. B. Qt.vector3d(). Wir importieren auch das Modul Qt3D.Renderer, das die Komponenten und andere Typen bereitstellt, die vom Renderer-Aspekt aufgenommen werden:

import Qt3D.Core 2.0
import Qt3D.Render 2.0

Um Komponenten aus anderen Aspekten zu verwenden, müssten wir auch das entsprechende QML-Modul importieren.

Wir verwenden dann einen Entity -Typ als Wurzelelement des benutzerdefinierten QML-Typs, der einige benutzerdefinierte Eigenschaften wie bei jedem anderen Typ in QML offenlegt:

Entity {
    id: root

    property real x: 0.0
    property real y: 0.0
    property real z: 0.0
    property real scale: 1.0
    property real theta: 0.0
    property real phi: 0.0
    property Material material

Zusätzlich zur Aggregation von Komponenten kann der Typ Entity verwendet werden, um untergeordnete Objekte zusammenzufassen. Dies ist analog zur Verwendung des Typs Item in Qt Quick 2.

Spezifizierung von Transformationen

Wir instanziieren eine Transform Komponente und eine Mesh Komponente. Die Transform Komponente gibt an, wie der Renderer die Geometrie transformieren soll, wenn sie mit der OpenGL-Pipeline gezeichnet wird. Wir kombinieren einen geordneten Satz von Transformationen in einer einzigen Transform Komponente. Diese Informationen stehen unseren Shadern automatisch über standardmäßig benannte einheitliche Variablen zur Verfügung:

    Transform {
        id: transform
        translation: Qt.vector3d(root.x, root.y, root.z)
        rotation: fromEulerAngles(theta, phi, 0)
        scale: root.scale
    }

Laden von dynamischen Per-Vertex-Daten

Die Komponente Mesh ist sehr einfach. Wir verwenden ihre Quelleigenschaft, um einen statischen Satz von Geometriedaten (z. B. Vertex-Positionen, Normalenvektoren und Texturkoordinaten) aus einer Datei im Wavefront Obj-Format zu laden. Diese Daten wurden aus der Blender-Anwendung exportiert.

    Mesh {
        id: mesh
        source: "qrc:/assets/obj/trefoil.obj"
    }

Zusätzlich zum Element Mesh ermöglicht Qt 3D auch die dynamische Generierung von Attributdaten pro Vertex über C++-Hooks, die von der aufgabenbasierten Engine aufgerufen werden.

Aggregieren von Komponenten

Die bloße Instanziierung von Komponenten ist jedoch nicht ausreichend. Damit sie einer Entität ein spezielles Verhalten verleihen können, muss die Entität die Komponenten mit Hilfe ihrer Komponenteneigenschaft zusammenfassen:

    components: [ transform, mesh, root.material ]

Auf diese Weise können Komponenten sehr einfach von mehreren Entitäten gemeinsam genutzt werden. In diesem Beispiel haben wir Komponenten für die Transformation und das Netz, die im benutzerdefinierten Typ TrefoilKnot enthalten sind. Die letzte Komponente vom Typ Material wird durch eine Eigenschaft des benutzerdefinierten Typs TrefoilKnot bereitgestellt. Wir werden später das Aussehen der Entität anpassen.

Rendering von Kameras

Wir verwenden den benutzerdefinierten Typ TrefoilKnot in main.qml, um den Dreiblattknoten auf dem Bildschirm zu zeichnen.

Wir verwenden die gleichen Importanweisungen wie in TrefoilKnot.qml, mit dem Zusatz eines namentlichen Imports für das Qt Quick Modul, das wir für die Animationen benötigen:

import QtQuick 2.1 as QQ2
import Qt3D.Core 2.0
import Qt3D.Render 2.0

Wir verwenden einen Entity -Typ als Root-Typ, um einfach als Elternteil für seine Kinder zu fungieren. In diesem Sinne ist der Typ Entity dem Typ Item sehr ähnlich:

import Qt3D.Input 2.0
import Qt3D.Extras 2.0

Entity {
    id: root

Die Komponente RendererSettings verwendet den Typ ForwardRenderer, um den Renderer vollständig zu konfigurieren, ohne C++-Code zu berühren:

    // Render from the mainCamera
    components: [
        RenderSettings {
            activeFrameGraph: ForwardRenderer {
                id: renderer
                camera: mainCamera
            }
        },
        // Event Source will be set by the Qt3DQuickWindow
        InputSettings { }
    ]

Der BasicCamera-Typ ist ein trivialer Wrapper um den eingebauten Camera -Typ, der eine virtuelle Kamera darstellt. Er hat Eigenschaften für Dinge wie die nahe und ferne Ebene, das Sichtfeld, das Seitenverhältnis, den Projektionstyp, die Position und die Ausrichtung:

    BasicCamera {
        id: mainCamera
        position: Qt.vector3d( 0.0, 0.0, 15.0 )
    }

Der Typ Configuration bietet eine vorübergehende Lösung für die Maussteuerung der Kamera, während die eigentliche Implementierung, die Aspekte und Komponenten verwendet, abgeschlossen wird:

    FirstPersonCameraController { camera: mainCamera }

Es ist trivial, mehrere Kameras zu verwenden und zwischen ihnen zu wählen, indem man den Framegraph für das gesamte oder einen Teil des Renderings der Szene verwendet.

Mapping-Materialien

Qt 3D verfügt über ein robustes und sehr flexibles Materialsystem, das mehrere Ebenen der Anpassung erlaubt. Wir verwenden den benutzerdefinierten Typ WireframeMaterial, um den Typ Material zu umhüllen:

    WireframeMaterial {
        id: wireframeMaterial
        effect: WireframeEffect {}
        ambient: Qt.rgba( 0.2, 0.0, 0.0, 1.0 )
        diffuse: Qt.rgba( 0.8, 0.0, 0.0, 1.0 )

Anschließend instanziieren wir den Typ TrefoilKnot und legen das Material darauf fest:

    TrefoilKnot {
        id: trefoilKnot
        material: wireframeMaterial
    }

Die Qt 3D -Engine verfügt nun in Verbindung mit dem Renderer-Aspekt über genügend Informationen, um unser Mesh mit dem von uns angegebenen Material zu rendern.

Verwendung von Animationselementen

Wir verwenden die von Qt Quick 2 bereitgestellten Animationselemente, um die Eigenschaften der Typen TrefoilKnot und WireframeMaterial zu animieren. Die Eigenschaften der Komponenten eines Typs werden mit Hilfe des QML-Eigenschaftsbindungsmechanismus aktualisiert:

        QQ2.SequentialAnimation {
            loops: QQ2.Animation.Infinite
            running: true

            QQ2.NumberAnimation {
                target: wireframeMaterial;
                property: "lineWidth";
                duration: 1000;
                from: 0.8
                to: 1.8
            }

            QQ2.NumberAnimation {
                target: wireframeMaterial;
                property: "lineWidth";
                duration: 1000;
                from: 1.8
                to: 0.8
            }

            QQ2.PauseAnimation { duration: 1500 }
        }

Die Aktualisierungen der Eigenschaften werden von der Basisklasse QNode bemerkt und automatisch an die entsprechenden Objekte im Renderer-Aspekt weitergeleitet. Der Renderer kümmert sich dann um die Übersetzung der Eigenschaftsaktualisierungen in neue Werte für einheitliche Variablen in den GLSL-Shader-Programmen.

Führen Sie das Beispiel aus, um den Kleeblattknoten mit der pulsierenden Breite der Drahtgitterlinien zu sehen. Die gesamte Schwerstarbeit wird von der GPU erledigt. Die CPU muss nur die Eigenschaftsanimationen ausführen und den Szenegraphen und den Framegraph in rohe OpenGL-Aufrufe übersetzen.

Es ist auch möglich, Animationen auf der GPU über ein benutzerdefiniertes Shader-Programm und Material auszuführen.

Beispielprojekt @ code.qt.io