ProceduralMesh QML Type

Allows creation of Geometry from QML. More...

• List of all members, including inherited members

Properties

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

Detailed Description

ProceduralMesh is a helper type that allows creation of Geometry instances from QML. The Geometry component is Abstract, and is usually created from 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 }
     }
 }

The above code defines a component TorusMesh that can be used as Geometry for use with a Model component. When the ring, segments, radius or tubeRadius properties are modified the geometry will be updated.

The ProceduralMesh component is not as flexible nor as performant as creating Geometry in C++, but makes up for it in convenience and simplicity. The properties are fixed attribute lists that when filled will automatically generate the necessary buffers.

Property Documentation