ProceduralMesh QML Type

Permet de créer des géométries à partir de QML. En savoir plus...

• 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 Geometry à partir de QML. Le composant Geometry est abstrait et est généralement créé en 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 pouvant servir de Geometry pour être utilisé avec un composant Model. Lorsque les propriétés ring, segments, radius ou tubeRadius sont modifiées, la géométrie est mise à jour.

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

Documentation des propriétés

binormals : List<QVector3D>

Contient la liste des attributs des binormales.

colors : List<QVector4D>

Cette propriété définit une liste de valeurs de couleur des sommets.

indexes : List<int>

Cette propriété définit une liste d'index pointant vers les listes d'attributs. Si cette liste reste vide, les valeurs du tampon de sommets seront utilisées directement.

joints : List<QVector4D>

Cette propriété définit une liste d’indices d’articulations pour le skinning.

normals : List<QVector3D>

Contient la liste des attributs de normales.

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 les données géométriques doivent être divisées. Chaque sous-ensemble peut disposer de 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 ; si elle est vide, un seul sous-ensemble est créé.

tangents : List<QVector3D>

Contient la liste des attributs « 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'articulations pour le skinning.