ProceduralMesh QML Type

Permet de créer une géométrie à partir de QML. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• 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>

Description détaillée

ProceduralMesh est un type d'aide qui permet de créer des instances de géométrie à partir de QML. Le composant Geometry est abstrait et est généralement créé à partir de C++.

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 }
    }
}

Le code ci-dessus définit un composant TorusMesh qui peut être utilisé comme géométrie avec un composant Model. Lorsque les propriétés anneau, segments, rayon ou tubeRadius sont modifiées, la géométrie est mise à jour.

Le composant ProceduralMesh n'est pas aussi flexible ni aussi performant que la création de géométrie en C++, mais il le compense par sa commodité et sa simplicité. Les propriétés sont des listes d'attributs fixes qui, une fois remplies, génèrent automatiquement les tampons nécessaires.

Documentation sur les propriétés

binormals : List<QVector3D>

Contient la liste des attributs binormaux.

colors : List<QVector4D>

Cette propriété définit une liste de valeurs de couleurs de vertex.

indexes : List<int>

Cette propriété définit une liste d'index dans les listes d'attributs. Si cette liste reste vide, les valeurs de la mémoire tampon des vertex seront utilisées directement.

joints : List<QVector4D>

Cette propriété définit une liste d'indices de jointure pour l'écorchage.

normals : List<QVector3D>

Contient la liste des attributs normaux.

positions : List<QVector3D>

La liste des attributs de position. Si cette liste reste vide, aucune géométrie ne sera générée.

primitiveMode : enumeration [default: ProceduralMesh.Triangles]

Cette propriété définit le mode primitif à utiliser lors du rendu de la géométrie.

subsets : List<ProceduralMeshSubset>

Cette propriété définit une liste de sous-ensembles dans lesquels diviser les données géométriques. Chaque sous-ensemble peut avoir son propre matériau. L'ordre de ce tableau correspond à la liste des matériaux du modèle lors de l'utilisation de cette géométrie.

Cette propriété est facultative et, lorsqu'elle est vide, elle ne produit qu'un seul sous-ensemble.

tangents : List<QVector3D>

Contient la liste des attributs des tangentes.

uv0s : List<QVector2D>

Cette propriété définit une liste de coordonnées uv pour le premier canal uv (uv0).

uv1s : List<QVector2D>

Cette propriété définit une liste de coordonnées uv pour le deuxième canal uv (uv1).

weights : List<QVector4D>

Cette propriété définit une liste de poids d'articulation pour l'écorchage.