QGeometryData Class

 QGeometryData myData;
 if (processed)
    myData = processedData();

Member Function Documentation

QGeometryData::QGeometryData()

Construct an empty QGeometryData

QGeometryData::QGeometryData(const QGeometryData & other)

Construct QGeometryData as a copy of other

QGeometryData::QGeometryData(quint32 fields)

Construct an empty QGeometryData with the fields enabled.

QGeometryData::~QGeometryData()

Destroys this QGeometryData recovering any resources.

void QGeometryData::appendAttribute(float a0, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the float a0 to this geometry data, as an attribute field.

void QGeometryData::appendAttribute(float a0, float a1, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the float a0 and a1 to this geometry data, as an attribute field.

void QGeometryData::appendAttribute(float a0, float a1, float a2, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the floats a0, a1 and a2 to this geometry data, as attribute field.

void QGeometryData::appendAttribute(float a0, float a1, float a2, float a3, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the floats a0, a1, a2 and a3 to this geometry data, as attribute field.

void QGeometryData::appendAttribute(const QVector2D & a, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the 2D point a to this geometry data, as an attribute field.

void QGeometryData::appendAttribute(const QVector3D & v, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the 3D point v to this geometry data, as an attribute field.

void QGeometryData::appendAttribute(const QVariant & a, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the variant value a to this geometry data, as an attribute field.

void QGeometryData::appendAttributeArray(const QCustomDataArray & ary, QGL::VertexAttribute field = QGL::CustomVertex0)

Append the points in ary to this geometry data, as an attribute field entries.

void QGeometryData::appendColor(const QColor4ub & c0)

Append the color c0 to this geometry data, as an color field.

void QGeometryData::appendColor(const QColor4ub & c0, const QColor4ub & c1)

Append the color c0 and c1 to this geometry data, as color fields.

void QGeometryData::appendColor(const QColor4ub & c0, const QColor4ub & c1, const QColor4ub & c2)

Append the color c0, c1 and c2 to this geometry data, as color fields.

void QGeometryData::appendColor(const QColor4ub & c0, const QColor4ub & c1, const QColor4ub & c2, const QColor4ub & c3)

Append the color c0, c1, c2 and c3 to this geometry data, as color fields.

void QGeometryData::appendColorArray(const QArray<QColor4ub> & ary)

Append the colors in ary to this geometry data, as color fields.

void QGeometryData::appendGeometry(const QGeometryData & data)

Appends the geometry in data to this. If this is empty, then all fields of data are appended; otherwise (when this has existing fields) only those fields that exist in both are appended.

This does not change the indices - to reference the new geometry add indices via the appendIndices() functions.

void QGeometryData::appendIndex(int index)

Appends index to the vertex index array.

See also appendIndices() and indices().

void QGeometryData::appendIndices(int index1, int index2, int index3)

Appends index1, index2, and index3 to the geometry's index array.

See also appendIndex() and indices().

void QGeometryData::appendIndices(const QGL::IndexArray & indices)

Appends the indices to the geometry's index array.

void QGeometryData::appendNormal(const QVector3D & n0)

Append the vector n0 to this geometry data, as a lighting normal.

void QGeometryData::appendNormal(const QVector3D & n0, const QVector3D & n1)

Append the vectors n0 and n1 to this geometry data, as lighting normals.

void QGeometryData::appendNormal(const QVector3D & n0, const QVector3D & n1, const QVector3D & n2)

Append the vectors n0, n1 and n2 to this geometry data, as lighting normals.

void QGeometryData::appendNormal(const QVector3D & n0, const QVector3D & n1, const QVector3D & n2, const QVector3D & n3)

Append the vectors n0, n1, n2 and n3 to this geometry data, as lighting normals.

void QGeometryData::appendNormalArray(const QVector3DArray & ary)

Append the vectors in ary to this geometry data, as lighting normals.

void QGeometryData::appendTexCoord(const QVector2D & t0, QGL::VertexAttribute field = QGL::TextureCoord0)

Append the point t0 to this geometry data, as an texture field.

void QGeometryData::appendTexCoord(const QVector2D & t0, const QVector2D & t1, QGL::VertexAttribute field = QGL::TextureCoord0)

Append the points t0 and t1 to this geometry data, as texture fields.

void QGeometryData::appendTexCoord(const QVector2D & t0, const QVector2D & t1, const QVector2D & t2, QGL::VertexAttribute field = QGL::TextureCoord0)

Append the points t0, t1 and t2 to this geometry data, as texture fields.

void QGeometryData::appendTexCoord(const QVector2D & t0, const QVector2D & t1, const QVector2D & t2, const QVector2D & t3, QGL::VertexAttribute field = QGL::TextureCoord0)

Append the points t0, t1, t2 and t3 to this geometry data, as texture fields.

void QGeometryData::appendTexCoordArray(const QVector2DArray & ary, QGL::VertexAttribute field = QGL::TextureCoord0)

Append the 2D points in ary to this geometry data, as texture field entries.

int QGeometryData::appendVertex(const QLogicalVertex & v)

Appends all the data fields in QLogicalVertex v to this QGeometryData object.

void QGeometryData::appendVertex(const QVector3D & v0)

Append the point v0 to this geometry data as a position field.

void QGeometryData::appendVertex(const QVector3D & v0, const QVector3D & v1)

Append the points v0 and v1 to this geometry data as position fields.

void QGeometryData::appendVertex(const QVector3D & v0, const QVector3D & v1, const QVector3D & v2)

Append the points v0, v1 and v2 to this geometry data as position fields.

void QGeometryData::appendVertex(const QVector3D & v0, const QVector3D & v1, const QVector3D & v2, const QVector3D & v3)

Append the points v0, v1, v2 and v3 to this geometry data as position fields.

void QGeometryData::appendVertexArray(const QVector3DArray & ary)

Append the points in ary to this geometry data as position fields.

QGLAttributeValue QGeometryData::attributeValue(QGL::VertexAttribute field) const

Returns the attribute value for the field, suitable for passing to QGLPainter.

See also QGLPainter::setVertexAttribute().

QCustomDataArray QGeometryData::attributes(QGL::VertexAttribute field = QGL::CustomVertex0) const

Returns a copy of the field attribute data.

QBox3D QGeometryData::boundingBox() const

Calculate and return a bounding box for the vertex data in this geometry.

BufferStrategy QGeometryData::bufferStrategy() const

Returns the buffer strategy for this geometry. The default is QGL::BufferIfPossible | QGL::KeepClientData.

See also setBufferStrategy().

QVector3D QGeometryData::center() const

Returns the coordinates of the center of the geometry.

The center is calculated as the centroid or geometric barycenter of the vertices (the average of the vertices). For a convex hull this is guaranteed to be inside the figure.

void QGeometryData::clear()

Clear all data structures. The actual fields are retained, but they have no contents.

 QGeometryData data;
 data.appendVertex(a);
 data.appendTexCoord(t);

 // prints "1"
 qDebug() << data.count();

 // x == a
 QVector3D x = data.vertexAt(0);

 quint32 flds = QGL::fieldMask(QGL::Position) | QGL::fieldMask(QGL::TextureCoord0);
 qDebug() << (flds == data.fields());  // prints "true"

 data.clear();
 qDebug() << data.count();             // prints "0"
 QVector3D x = data.vertexAt(0);       // asserts - no data in vertices
 qDebug() << (flds == data.fields());  // still prints "true"

To clear a specific field and its data use data.clear(field) below.

To clear all fields and data, simply set this to an empty geometry:

 data = QGeometryData();

void QGeometryData::clear(QGL::VertexAttribute field)

Clears the data from field, and removes the field. After this call hasField() will return false for this field.

QColor4ub & QGeometryData::color(int i)

Returns a modifiable reference to the color data at index i.

const QColor4ub & QGeometryData::colorAt(int i) const

Returns a non-modifiable reference to the color data at index i.

QArray<QColor4ub> QGeometryData::colors() const

Returns a copy of the color data.

int QGeometryData::count() const

Returns the count of logical vertices stored. This is effectively the max() of QArray::count() over all of the enabled data types.

int QGeometryData::count(QGL::VertexAttribute field) const

Returns the count of data stored in field. This will always be at most count(), but could be less.

void QGeometryData::detach()

Force this geometry to ensure it has its own unshared internal data block, making a copy in the case that it is currently shared.

void QGeometryData::draw(QGLPainter * painter, int start, int count, GLenum mode = QGL::Triangles, qreal drawWidth = 1.0)

Draws this geometry on the painter, from start for count elements in mode. The drawing mode is by default QGL::Triangles. This function Also calls the upload() method to ensure that the geometry is resident on the graphics hardware if appropriate.

If the geometry is a point or line, then the drawWidth value specified the width/size of the line/point.

void QGeometryData::enableField(QGL::VertexAttribute field)

Enables this geometry to contain data of type field. Generally it is not necessary to call this function since it is called by all the append functions.

quint32 QGeometryData::fields() const

Return a bit-mask of the supported fields in this geometry. The QGL::VertexAttribute enum can be recovered from this bit-mask by

 quint32 fields = fields();
 QGL::VertexAttribute attr = static_cast<QGL::VertexAttribute>(fields);

float & QGeometryData::floatAttribute(int i, QGL::VertexAttribute field = QGL::CustomVertex0)

Returns a modifiable reference to the float field attribute data at index i.

float QGeometryData::floatAttributeAt(int i, QGL::VertexAttribute field = QGL::CustomVertex0) const

Returns a copy of the float field attribute data at index i.

void QGeometryData::generateTextureCoordinates(Qt::Orientation orientation = Qt::Horizontal, QGL::VertexAttribute field = QGL::TextureCoord0)

Modifies this geometry data by generating texture data based on QGL::Position values. If orientation is Qt::Horizontal (the default) then x-coordinate values are generated, and y-coordinate values are set to 0.0; otherwise y-coordinate values are generated and x-coordinate values are set to 0.0. The values are appended to the texture coordinate field.

The method of calculation is based on the assumption that the vertex data is a list of extents which span across the texture space horizontally, from x = 0.0 to x = 1.0, in the case of Qt::Horizontal; or vertically in the case of Qt::Vertical. The texture space of 1.0 is divided up proportionately by the length of each extent.

In this diagram the large blue numbers are the lengths of each extent, and the texture coordinates generated are shown as t(7/16, 1) and so on.

Thus the texture coordinate t0 for vertex v0, is 0.0; t1 for vertex v1 is (v1 - v0).length() / totalLength and so on.

The code to produce the texture coordinates for the quads in the image is:

 QGeometryData top;

 // add data to the primitive
 top.appendVertex(QVector3D(0.0, 0.0, 0.0));
 top.appendVertex(QVector3D(6.0, 3.6, 0.0));    // (v1 - v0).length() = 7.0
 top.appendVertex(QVector3D(10.0, 0.6, 0.0));   // (v2 - v1).length() = 5.0
 top.appendVertex(QVector3D(13.0, 3.24, 0.0));  // (v3 - v2).length() = 4.0

 // generate x (Qt::Horizontal) texture coordinates over the primitive
 top.generateTextureCoordinates();              // spread over 7 + 5 + 4 = 16

 // make a copy translated down, the copy has y texture coordinates all 0
 QGeometryData bottom = top.translated(QVector3D(0, 0, -1));

 // now modify the top so its y texture coordinates are all 1
 for (int i = 0; i < top.count(); ++i)
     top.texCoordRef(QGL::TextureCoord0).setY(1.0);

 displayList->addQuadsZipped(top, bottom);

bool QGeometryData::hasField(QGL::VertexAttribute attr) const

Returns true if this geometry has the field corresponding to attr. Note that it is still possible for no data to have been added for that field.

quint64 QGeometryData::id() const

Return an opaque value that can be used to identify which data block is being used by this QGeometryData instance. See the class documentation relating to explicit sharing.

QGLIndexBuffer QGeometryData::indexBuffer() const

Returns a reference to the index buffer for this geometry.

See also vertexBundle().

int QGeometryData::indexCount() const

Returns the number of index values stored in this geometry data.

This value is exactly the same as indices().size() (but does not incur the copy).

QGL::IndexArray QGeometryData::indices() const

Returns the index array that was created by appendIndex().

See also appendIndex() and appendIndices().

void QGeometryData::interleaveWith(const QGeometryData & other)

Sets this QGeometryData to contain alternating vertices from this geometry and other. The resulting geometry contains N * 2 vertices where N == qMin(count(), other.count()), and has only the fields that are in both geometries.

QGeometryData QGeometryData::interleavedWith(const QGeometryData & other) const

Returns a QGeometryData instance containing alternating vertices from this geometry and other. The resulting geometry contains N vertices where N == qMin(count(), other.count()), and has only the fields that are in both geometries.

bool QGeometryData::isEmpty() const

Returns true if this geometry is empty - that is it contains no vertices or other data - and returns false otherwise. If an existing geometry has been made empty by a call to clear() then this will be true (but isNull() will be false).

See also isNull().

bool QGeometryData::isNull() const

Returns true if this geometry is uninitialized - that is it contains no internal data structures. A newly constructed QGeometryData object is null until some data is added or changed.

See also isEmpty().

QLogicalVertex QGeometryData::logicalVertexAt(int i) const

Returns a QLogicalVertex that references the i'th logical vertex of this geometry.

QVector3D & QGeometryData::normal(int i)

Returns a modifiable reference to the normal data at index i.

const QVector3D & QGeometryData::normalAt(int i) const

Returns a non-modifiable reference to the normal data at index i.

void QGeometryData::normalizeNormals()

Normalize all the normal vectors in this geometry to unit length.

QVector3DArray QGeometryData::normals() const

Returns a copy of the lighting normal data.

void QGeometryData::reserve(int amount)

Sets the geometry data to handle an amount of data. This is generally not required unless its anticipated that a large amount of data will be appended and realloc overhead is desired to be avoided. If amount is less than the amount already reserved, or if this object has more than the amount of data items, then this function exits without doing anything. This function will never delete data.

QGeometryData QGeometryData::reversed() const

Returns a copy of this geometry data with elements in reverse order.

void QGeometryData::setBufferStrategy(BufferStrategy strategy)

Sets the buffer strategy for this geometry.

See also bufferStrategy().

QVector2D & QGeometryData::texCoord(int i, QGL::VertexAttribute field = QGL::TextureCoord0)

Returns a modifiable reference to the field texture coordinate data at index i.

const QVector2D & QGeometryData::texCoordAt(int i, QGL::VertexAttribute field = QGL::TextureCoord0) const

Returns a non-modifiable reference to the texture coordinate data at index i for field.

QVector2DArray QGeometryData::texCoords(QGL::VertexAttribute field = QGL::TextureCoord0) const

Returns a copy of the field texture coordinate data.

QGeometryData QGeometryData::translated(const QVector3D & t) const

Returns a copy of this geometry data with QGL::Position data translated by the vector t. The other fields are unchanged.

bool QGeometryData::upload()

Uploads this geometry data to the graphics hardware if appropriate. If the data is already uploaded and has not been modified since it was last uploaded, then this function does nothing.

If the bufferStrategy() does not specify QGL::BufferIfPossible then this function does nothing.

If the data was successfully uploaded, and the bufferStrategy() does not specify QGL::KeepClientData then the data will be removed with a call to the clear() function.

If the data was successfully uploaded, on this call or previously, then this function will return true. Otherwise it returns false.

QVector2D & QGeometryData::vector2DAttribute(int i, QGL::VertexAttribute field = QGL::CustomVertex0)

Returns a modifiable reference to the 2D vector field attribute data at index i.

QVector2D QGeometryData::vector2DAttributeAt(int i, QGL::VertexAttribute field = QGL::CustomVertex0) const

Returns a copy of the 2D vector field attribute data at index i.

QVector3D & QGeometryData::vector3DAttribute(int i, QGL::VertexAttribute field = QGL::CustomVertex0)

Returns a modifiable reference to the 3D vector field attribute data at index i.

QVector3D QGeometryData::vector3DAttributeAt(int i, QGL::VertexAttribute field = QGL::CustomVertex0) const

Returns a copy of the 3D vector field attribute data at index i.

QVector3D & QGeometryData::vertex(int i)

Returns a modifiable reference to the vertex data at index i.

const QVector3D & QGeometryData::vertexAt(int i) const

Returns a non-modifiable reference to the vertex position data at index i.

QGLVertexBundle QGeometryData::vertexBundle() const

Returns a reference to the vertex buffer for this geometry.

See also indexBuffer().

QVector3DArray QGeometryData::vertices() const

Returns a copy of the vertex position data.

QGeometryData & QGeometryData::operator=(const QGeometryData & other)

Assigns this QGeometryData to be a copy of other.

bool QGeometryData::operator==(const QGeometryData & other) const

Returns true if this geometry is identical to the other; and false otherwise.