ProceduralMesh QML Type

Ermöglicht die Erstellung von Geometrie aus QML. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

• binormals : List<QVector3D>
• colors : List<QVector4D>
• indexes : List<int>
• joints : List<QVector4D>
• normals : List<QVector3D>
• positions : List<QVector3D>
• primitiveMode : enumeration
• subsets : List<ProceduralMeshSubset>
• tangents : List<QVector3D>
• uv0s : List<QVector2D>
• uv1s : List<QVector2D>
• weights : List<QVector4D>

Ausführliche Beschreibung

ProceduralMesh ist ein Hilfstyp, der die Erstellung von Geometry-Instanzen aus QML ermöglicht. Die Geometry-Komponente ist abstrakt und wird in der Regel in C++ erstellt.

component TorusMesh : ProceduralMesh {
    property real rings: 50
    property real segments: 50
    property real radius: 100.0
    property real tubeRadius: 10.0
    property var meshArrays: generateTorus(rings, segments, radius, tubeRadius)
    positions: meshArrays.verts
    normals: meshArrays.normals
    uv0s: meshArrays.uvs
    indexes: meshArrays.indices

    function generateTorus(rings: real, segments: real, radius: real, tubeRadius: real) {
        let verts = []
        let normals = []
        let uvs = []
        let indices = []

        for (let i = 0; i <= rings; ++i) {
            for (let j = 0; j <= segments; ++j) {
                let u = i / rings * Math.PI * 2;
                let v = j / segments * Math.PI * 2;

                let centerX = radius * Math.cos(u);
                let centerZ = radius * Math.sin(u);

                let posX = centerX + tubeRadius * Math.cos(v) * Math.cos(u);
                let posY = tubeRadius * Math.sin(v);
                let posZ = centerZ + tubeRadius * Math.cos(v) * Math.sin(u);

                verts.push(Qt.vector3d(posX, posY, posZ));

                let normal = Qt.vector3d(posX - centerX, posY, posZ - centerZ).normalized();
                normals.push(normal);

                uvs.push(Qt.vector2d(i / rings, j / segments));
            }
        }

        for (let i = 0; i < rings; ++i) {
            for (let j = 0; j < segments; ++j) {
                let a = (segments + 1) * i + j;
                let b = (segments + 1) * (i + 1) + j;
                let c = (segments + 1) * (i + 1) + j + 1;
                let d = (segments + 1) * i + j + 1;

                // Generate two triangles for each quad in the mesh
                // Adjust order to be counter-clockwise
                indices.push(a, d, b);
                indices.push(b, d, c);
            }
        }
        return { verts: verts, normals: normals, uvs: uvs, indices: indices }
    }
}

Der obige Code definiert eine Komponente namens „TorusMesh“, die als „Geometry“ für die Verwendung mit einer „Model“-Komponente genutzt werden kann. Wenn die Eigenschaften „ring“, „segments“, „radius“ oder „tubeRadius“ geändert werden, wird die Geometrie aktualisiert.

Die „ProceduralMesh“-Komponente ist zwar nicht so flexibel und leistungsfähig wie die Erstellung von „Geometry“ in C++, macht dies jedoch durch Komfort und Einfachheit wieder wett. Die Eigenschaften sind festgelegte Attributlisten, die bei Ausfüllen automatisch die erforderlichen Puffer generieren.

Dokumentation zu den Eigenschaften

binormals : List<QVector3D>

Enthält die Attributliste der Binormalen.

colors : List<QVector4D>

Diese Eigenschaft definiert eine Liste von Scheitelpunktfarbenwerten.

indexes : List<int>

Diese Eigenschaft definiert eine Liste von Indizes für die Attributlisten. Bleibt diese Liste leer, werden die Werte aus dem Vertex-Puffer direkt verwendet.

joints : List<QVector4D>

Diese Eigenschaft definiert eine Liste von Gelenkindizes für das Skinning.

normals : List<QVector3D>

Enthält die Liste der Normalvektoren.

positions : List<QVector3D>

Die Liste der Positionsattribute. Bleibt diese Liste leer, wird keine Geometrie generiert.

primitiveMode : enumeration [default: ProceduralMesh.Triangles]

Diese Eigenschaft legt den Primitivmodus fest, der beim Rendern der Geometrie verwendet werden soll.

subsets : List<ProceduralMeshSubset>

Diese Eigenschaft definiert eine Liste von Teilmengen, in die die Geometriedaten aufgeteilt werden sollen. Jede Teilmenge kann ein eigenes Material haben. Die Reihenfolge dieses Arrays entspricht der Materialliste des Modells, wenn diese Geometrie verwendet wird.

Diese Eigenschaft ist optional und führt, wenn sie leer ist, zu einer einzigen Teilmenge.

tangents : List<QVector3D>

Enthält die Liste der Tangentenattribute.

uv0s : List<QVector2D>

Diese Eigenschaft definiert eine Liste von UV-Koordinaten für den ersten UV-Kanal (uv0)

uv1s : List<QVector2D>

Diese Eigenschaft definiert eine Liste von UV-Koordinaten für den zweiten UV-Kanal (uv1)

weights : List<QVector4D>

Diese Eigenschaft definiert eine Liste von Gelenkgewichten für das Skinning.