ProceduralMesh QML Type

Permite la creación de Geometría a partir de QML. Más...

• Lista de todos los miembros, incluidos los heredados

Propiedades

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

Descripción detallada

ProceduralMesh es un tipo helper que permite la creación de instancias de Geometría desde QML. El componente Geometría es Abstracto, y normalmente se crea desde 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 }
    }
}

El código anterior define un componente TorusMesh que puede ser utilizado como Geometría para su uso con un componente Modelo. Cuando se modifiquen las propiedades ring, segments, radius o tubeRadius se actualizará la geometría.

El componente ProceduralMesh no es tan flexible ni tiene tanto rendimiento como la creación de Geometría en C++, pero lo compensa en comodidad y simplicidad. Las propiedades son listas fijas de atributos que al rellenarse generarán automáticamente los buffers necesarios.

Documentación de propiedades

binormals : List<QVector3D>

Contiene la lista de atributos binormales.

colors : List<QVector4D>

Esta propiedad define una lista de valores de color de vértice.

indexes : List<int>

Esta propiedad define una lista de índices en las listas de atributos. Si esta lista permanece vacía, se utilizarán directamente los valores del búfer de vértices.

joints : List<QVector4D>

Esta propiedad define una lista de índices de juntas para el despellejado.

normals : List<QVector3D>

Contiene la lista de atributos de las normales.

positions : List<QVector3D>

La lista de atributos de las posiciones. Si esta lista permanece vacía no se generará ninguna geometría.

primitiveMode : enumeration [default: ProceduralMesh.Triangles]

Esta propiedad define el modo primitivo a utilizar al renderizar la geometría.

subsets : List<ProceduralMeshSubset>

Esta propiedad define una lista de subconjuntos en los que dividir los datos geométricos. Cada subconjunto puede tener su propio material. El orden de esta matriz corresponde a la lista de materiales de Model cuando se utiliza esta geometría.

Esta propiedad es opcional y cuando está vacía da como resultado un único subconjunto.

tangents : List<QVector3D>

Contiene la lista de atributos de las tangentes.

uv0s : List<QVector2D>

Esta propiedad define una lista de coordenadas uv para el primer canal uv (uv0)

uv1s : List<QVector2D>

Esta propiedad define una lista de coordenadas uv para el segundo canal uv (uv1)

weights : List<QVector4D>

Esta propiedad define una lista de pesos conjuntos para el despellejado.