Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qsggeometry.h"
++ #include "qsggeometry_p.h"
++
++ #ifdef Q_OS_QNX
++ #include <malloc.h>
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++
++ QSGGeometry::Attribute QSGGeometry::Attribute::create(int attributeIndex, int tupleSize, int primitiveType, bool isPrimitive)
++ {
++ Attribute a = { attributeIndex, tupleSize, primitiveType, isPrimitive, UnknownAttribute, 0 };
++ return a;
++ }
++
++ QSGGeometry::Attribute QSGGeometry::Attribute::createWithAttributeType(int pos, int tupleSize, int primitiveType, AttributeType attributeType)
++ {
++ Attribute a;
++ a.position = pos;
++ a.tupleSize = tupleSize;
++ a.type = primitiveType;
++ a.isVertexCoordinate = attributeType == PositionAttribute;
++ a.attributeType = attributeType;
++ a.reserved = 0;
++ return a;
++ }
++
++ /*!
++ Convenience function which returns attributes to be used for 2D solid
++ color drawing.
++ */
++
++ const QSGGeometry::AttributeSet &QSGGeometry::defaultAttributes_Point2D()
++ {
++ static Attribute data[] = {
++ Attribute::createWithAttributeType(0, 2, FloatType, PositionAttribute)
++ };
++ static AttributeSet attrs = { 1, sizeof(float) * 2, data };
++ return attrs;
++ }
++
++ /*!
++ Convenience function which returns attributes to be used for textured 2D drawing.
++ */
++
++ const QSGGeometry::AttributeSet &QSGGeometry::defaultAttributes_TexturedPoint2D()
++ {
++ static Attribute data[] = {
++ Attribute::createWithAttributeType(0, 2, FloatType, PositionAttribute),
++ Attribute::createWithAttributeType(1, 2, FloatType, TexCoordAttribute)
++ };
++ static AttributeSet attrs = { 2, sizeof(float) * 4, data };
++ return attrs;
++ }
++
++ /*!
++ Convenience function which returns attributes to be used for per vertex colored 2D drawing.
++ */
++
++ const QSGGeometry::AttributeSet &QSGGeometry::defaultAttributes_ColoredPoint2D()
++ {
++ static Attribute data[] = {
++ Attribute::createWithAttributeType(0, 2, FloatType, PositionAttribute),
++ Attribute::createWithAttributeType(1, 4, UnsignedByteType, ColorAttribute)
++ };
++ static AttributeSet attrs = { 2, 2 * sizeof(float) + 4 * sizeof(char), data };
++ return attrs;
++ }
++
++
++ /*!
++ \class QSGGeometry::Attribute
++ \brief The QSGGeometry::Attribute describes a single vertex attribute in a QSGGeometry.
++ \inmodule QtQuick
++
++ The QSGGeometry::Attribute struct describes the attribute register position,
++ the size of the attribute tuple and the attribute type.
++
++ It also contains a hint to the renderer if this attribute is the attribute
++ describing the position. The scene graph renderer may use this information
++ to perform optimizations.
++
++ It contains a number of bits which are reserved for future use.
++
++ \sa QSGGeometry
++ */
++
++ /*!
++ \fn QSGGeometry::Attribute QSGGeometry::Attribute::create(int pos, int tupleSize, int primitiveType, bool isPosition)
++
++ Creates a new QSGGeometry::Attribute for attribute register \a pos with \a
++ tupleSize. The \a primitiveType can be any of the supported types from
++ QSGGeometry::Type, such as QSGGeometry::FloatType or
++ QSGGeometry::UnsignedByteType.
++
++ If the attribute describes the position for the vertex, the \a isPosition
++ hint should be set to \c true. The scene graph renderer may use this
++ information to perform optimizations.
++
++ Use the create function to construct the attribute, rather than an
++ initialization list, to ensure that all fields are initialized.
++ */
++
++ /*!
++ \fn QSGGeometry::Attribute QSGGeometry::Attribute::createWithAttributeType(int pos, int tupleSize, int primitiveType, AttributeType attributeType)
++
++ Creates a new QSGGeometry::Attribute for attribute register \a pos with \a
++ tupleSize. The \a primitiveType can be any of the supported types from
++ QSGGeometry::Type, such as QSGGeometry::FloatType or
++ QSGGeometry::UnsignedByteType.
++
++ \a attributeType describes the intended use of the attribute.
++
++ Use the create function to construct the attribute, rather than an
++ initialization list, to ensure that all fields are initialized.
++ */
++
++
++ /*!
++ \class QSGGeometry::AttributeSet
++ \brief The QSGGeometry::AttributeSet describes how the vertices in a QSGGeometry
++ are built up.
++ \inmodule QtQuick
++
++ \sa QSGGeometry
++ */
++
++
++ /*!
++ \class QSGGeometry::Point2D
++ \brief The QSGGeometry::Point2D struct is a convenience struct for accessing
++ 2D Points.
++
++ \inmodule QtQuick
++ */
++
++
++ /*!
++ \fn void QSGGeometry::Point2D::set(float x, float y)
++
++ Sets the x and y values of this point to \a x and \a y.
++ */
++
++
++ /*!
++ \class QSGGeometry::ColoredPoint2D
++ \brief The QSGGeometry::ColoredPoint2D struct is a convenience struct for accessing
++ 2D Points with a color.
++
++ \inmodule QtQuick
++ */
++
++
++ /*!
++ \fn void QSGGeometry::ColoredPoint2D::set(float x, float y, uchar red, uchar green, uchar blue, uchar alpha)
++
++ Sets the position of the vertex to \a x and \a y and the color to \a red, \a
++ green, \a blue, and \a alpha.
++ */
++
++
++ /*!
++ \class QSGGeometry::TexturedPoint2D
++ \brief The QSGGeometry::TexturedPoint2D struct is a convenience struct for accessing
++ 2D Points with texture coordinates.
++
++ \inmodule QtQuick
++ */
++
++
++ /*!
++ \fn void QSGGeometry::TexturedPoint2D::set(float x, float y, float tx, float ty)
++
++ Sets the position of the vertex to \a x and \a y and the texture coordinate
++ to \a tx and \a ty.
++ */
++
++
++
++ /*!
++ \class QSGGeometry
++
++ \brief The QSGGeometry class provides low-level
++ storage for graphics primitives in the \l{Qt Quick Scene Graph}.
++
++ \inmodule QtQuick
++
++ The QSGGeometry class stores the geometry of the primitives rendered
++ with the scene graph. It contains vertex data and optionally index
++ data. The mode used to draw the geometry, also called primitive
++ topology, is specified with setDrawingMode().
++
++ Vertices can be as simple as points defined by x and y values or
++ can be more complex where each vertex contains a normal, texture
++ coordinates and a 3D position. The QSGGeometry::AttributeSet is
++ used to describe how the vertex data is built up. The attribute
++ set can only be specified on construction. The QSGGeometry class
++ provides a few convenience attributes and attribute sets by
++ default. The defaultAttributes_Point2D() function returns an
++ attribute set to be used in normal solid color rectangles, while
++ the defaultAttributes_TexturedPoint2D function returns attributes
++ to be used for textured 2D geometry. The vertex data is internally
++ stored as a \c {void *} and is accessible with the vertexData()
++ function. Convenience accessors for the common attribute sets are
++ available with vertexDataAsPoint2D() and
++ vertexDataAsTexturedPoint2D(). Vertex data is allocated by passing
++ a vertex count to the constructor or by calling allocate() later.
++
++ The number of vertices and indices can be changed after construction
++ by using the allocate() method to resize the data buffer. However,
++ allocate() requires updating all vertex and index data each time
++ called. Since Qt 6.10, setVertexCount() and setIndexCount() allow
++ adjusting the number of vertices or indices without reallocating the
++ data buffer and only require updating new vertices or indices. In
++ either case, the caller must mark the geometry node as dirty, by calling
++ \c{node->markDirty(QSGNode::DirtyGeometry)}, to ensure that the renderer
++ has a chance to update internal buffers.
++
++ The QSGGeometry can optionally contain indices of either unsigned
++ 32-bit, unsigned 16-bit, or unsigned 8-bit integers. The index type
++ must be specified during construction and cannot be changed.
++
++ Below is a snippet illustrating how a geometry composed of
++ position and color vertices can be built.
++
++ \code
++ struct MyPoint2D {
++ float x;
++ float y;
++ float r;
++ float g;
++ float b;
++ float a;
++
++ void set(float x_, float y_, float r_, float g_, float b_, float a_) {
++ x = x_;
++ y = y_;
++ r = r_;
++ g = g_;
++ b = b_;
++ a = a_;
++ }
++ };
++
++ QSGGeometry::Attribute MyPoint2D_Attributes[] = {
++ QSGGeometry::Attribute::create(0, 2, FloatType, true),
++ QSGGeometry::Attribute::create(1, 4, FloatType, false)
++ };
++
++ QSGGeometry::AttributeSet MyPoint2D_AttributeSet = {
++ 2,
++ sizeof(MyPoint2D),
++ MyPoint2D_Attributes
++ };
++
++ ...
++
++ geometry = new QSGGeometry(MyPoint2D_AttributeSet, 2);
++ geometry->setDrawingMode(DrawLines);
++
++ MyPoint2D *vertices = static_cast<MyPoint2D *>(geometry->vertexData());
++ vertices[0].set(0, 0, 1, 0, 0, 1);
++ vertices[1].set(width(), height(), 0, 0, 1, 1);
++ \endcode
++
++ The QSGGeometry is a software buffer and client-side in terms of
++ accelerated rendering, as the buffers used in 2D graphics typically consist of
++ many small buffers that change every frame and do not benefit from
++ being uploaded to graphics memory. However, the QSGGeometry
++ supports hinting to the renderer that a buffer should be
++ uploaded using the setVertexDataPattern() and
++ setIndexDataPattern() functions. Whether this hint is respected or
++ not is implementation specific.
++
++ \sa QSGGeometryNode, {Scene Graph - Custom Geometry}
++
++ \note All classes with QSG prefix should be used solely on the scene graph's
++ rendering thread. See \l {Scene Graph and Rendering} for more information.
++
++ */
++
++ /*!
++ \fn int QSGGeometry::attributeCount() const
++
++ Returns the number of attributes in the attrbute set used by this geometry.
++ */
++
++ /*!
++ \fn QSGGeometry::Attribute *QSGGeometry::attributes() const
++
++ Returns an array with the attributes of this geometry. The size of the array
++ is given with attributeCount().
++ */
++
++ /*!
++ \fn uint *QSGGeometry::indexDataAsUInt()
++
++ Convenience function to access the index data as a mutable array of
++ 32-bit unsigned integers.
++ */
++
++ /*!
++ \fn const uint *QSGGeometry::indexDataAsUInt() const
++
++ Convenience function to access the index data as an immutable array of
++ 32-bit unsigned integers.
++ */
++
++ /*!
++ \fn quint16 *QSGGeometry::indexDataAsUShort()
++
++ Convenience function to access the index data as a mutable array of
++ 16-bit unsigned integers.
++ */
++
++ /*!
++ \fn const quint16 *QSGGeometry::indexDataAsUShort() const
++
++ Convenience function to access the index data as an immutable array of
++ 16-bit unsigned integers.
++ */
++
++ /*!
++ \fn const QSGGeometry::ColoredPoint2D *QSGGeometry::vertexDataAsColoredPoint2D() const
++
++ Convenience function to access the vertex data as an immutable
++ array of QSGGeometry::ColoredPoint2D.
++ */
++
++ /*!
++ \fn QSGGeometry::ColoredPoint2D *QSGGeometry::vertexDataAsColoredPoint2D()
++
++ Convenience function to access the vertex data as a mutable
++ array of QSGGeometry::ColoredPoint2D.
++ */
++
++ /*!
++ \fn const QSGGeometry::TexturedPoint2D *QSGGeometry::vertexDataAsTexturedPoint2D() const
++
++ Convenience function to access the vertex data as an immutable
++ array of QSGGeometry::TexturedPoint2D.
++ */
++
++ /*!
++ \fn QSGGeometry::TexturedPoint2D *QSGGeometry::vertexDataAsTexturedPoint2D()
++
++ Convenience function to access the vertex data as a mutable
++ array of QSGGeometry::TexturedPoint2D.
++ */
++
++ /*!
++ \fn const QSGGeometry::Point2D *QSGGeometry::vertexDataAsPoint2D() const
++
++ Convenience function to access the vertex data as an immutable
++ array of QSGGeometry::Point2D.
++ */
++
++ /*!
++ \fn QSGGeometry::Point2D *QSGGeometry::vertexDataAsPoint2D()
++
++ Convenience function to access the vertex data as a mutable
++ array of QSGGeometry::Point2D.
++ */
++
++
++ /*!
++ Constructs a geometry object based on \a attributes.
++
++ The object allocate space for \a vertexCount vertices based on the
++ accumulated size in \a attributes and for \a indexCount.
++
++ The \a indexType can be UnsignedShortType or \c
++ UnsignedIntType. Support for the latter depends on the graphics API
++ implementation used at run time, and may not always be available.
++
++ Geometry objects are constructed by default with DrawTriangleStrip as
++ the drawing mode.
++
++ \note \a attributes and the \l Attribute objects referenced by it must
++ stay valid for the entire lifetime of the QSGGeometry.
++ QSGGeometry stores a reference to \a attributes and does not delete
++ the \l Attribute objects.
++ */
++
++ QSGGeometry::QSGGeometry(const QSGGeometry::AttributeSet &attributes,
++ int vertexCount,
++ int indexCount,
++ int indexType)
++ : m_drawing_mode(DrawTriangleStrip)
++ , m_vertex_count(0)
++ , m_index_count(0)
++ , m_index_type(indexType)
++ , m_attributes(attributes)
++ , m_data(nullptr)
++ , m_index_data_offset(-1)
++ , m_server_data(nullptr)
++ , m_owns_data(false)
++ , m_index_usage_pattern(AlwaysUploadPattern)
++ , m_vertex_usage_pattern(AlwaysUploadPattern)
++ , m_line_width(1.0)
++ {
++ Q_UNUSED(m_reserved_bits);
++ Q_ASSERT(m_attributes.count > 0);
++ Q_ASSERT(m_attributes.stride > 0);
++ if (indexType != UnsignedByteType
++ && indexType != UnsignedShortType
++ && indexType != UnsignedIntType) {
++ qFatal("QSGGeometry: Unsupported index type, %x.\n", indexType);
++ }
++
++ // Because allocate reads m_vertex_count, m_index_count and m_owns_data, these
++ // need to be set before calling allocate...
++ allocate(vertexCount, indexCount);
++ }
++
++ /*!
++ \fn int QSGGeometry::sizeOfVertex() const
++
++ Returns the size in bytes of one vertex.
++
++ This value comes from the attributes.
++ */
++
++ /*!
++ \fn int QSGGeometry::sizeOfIndex() const
++
++ Returns the byte size of the index type.
++
++ This value is either \c 2 when the index type is UnsignedShortType, or
++ \c 4 when the index type is UnsignedIntType.
++ */
++
++ /*!
++ Destroys the geometry object and the vertex and index data it has allocated.
++ */
++
++ QSGGeometry::~QSGGeometry()
++ {
++ if (m_owns_data)
++ free(m_data);
++
++ if (m_server_data)
++ delete m_server_data;
++ }
++
++ /*!
++ \fn int QSGGeometry::vertexCount() const
++
++ Returns the number of vertices that can be rendered, or if indices are used,
++ it returns the number of vertices that can be accessed through indices.
++
++ \sa setVertexCount()
++ */
++
++ /*!
++ Sets the number of vertices to be rendered.
++
++ The \a count is not validated and it is the users responsibility to ensure
++ that only values between zero and the number of allocated vertices are
++ specified.
++
++ Vertex data is not invalidated after this call, but the caller must mark
++ the geometry node as dirty, by calling \c{node->markDirty(QSGNode::DirtyGeometry)},
++ to ensure that the renderer has a chance to update internal buffers.
++
++ \since 6.10
++
++ \sa vertexCount()
++ */
++ void QSGGeometry::setVertexCount(int count)
++ {
++ m_vertex_count = count;
++ }
++
++
++ /*!
++ \fn int QSGGeometry::indexCount() const
++
++ Returns the number of indices that are processed when the geometry object
++ is rendered.
++
++ \sa setIndexCount()
++ */
++
++ /*!
++ Sets the number of indices to be processed each time the geometry object is
++ rendered.
++
++ The \a count is not validated and it is the users responsibility to ensure
++ that only values between zero and the number of allocated indices are
++ specified.
++
++ Vertex and index data is not invalidated after this call, but the caller must
++ mark the geometry node as dirty, by calling \c{node->markDirty(QSGNode::DirtyGeometry)},
++ to ensure that the renderer has a chance to update internal buffers.
++
++ \since 6.10
++
++ \sa indexCount()
++ */
++ void QSGGeometry::setIndexCount(int count)
++ {
++ m_index_count = count;
++ }
++
++
++ /*!
++ \fn void *QSGGeometry::vertexData()
++
++ Returns a pointer to the raw vertex data of this geometry object.
++
++ \sa vertexDataAsPoint2D(), vertexDataAsTexturedPoint2D()
++ */
++
++ /*!
++ \fn const void *QSGGeometry::vertexData() const
++
++ Returns a pointer to the raw vertex data of this geometry object.
++
++ \sa vertexDataAsPoint2D(), vertexDataAsTexturedPoint2D()
++ */
++
++ /*!
++ Returns a pointer to the raw index data of this geometry object.
++
++ \sa indexDataAsUShort(), indexDataAsUInt()
++ */
++ void *QSGGeometry::indexData()
++ {
++ return m_index_data_offset < 0
++ ? nullptr
++ : ((char *) m_data + m_index_data_offset);
++ }
++
++ /*!
++ Returns a pointer to the raw index data of this geometry object.
++
++ \sa indexDataAsUShort(), indexDataAsUInt()
++ */
++ const void *QSGGeometry::indexData() const
++ {
++ return m_index_data_offset < 0
++ ? nullptr
++ : ((char *) m_data + m_index_data_offset);
++ }
++
++ /*!
++ \enum QSGGeometry::DrawingMode
++
++ Specifies the drawing mode, also called primitive topology.
++
++ \note Starting with Qt 6 the scene graph only exposes topologies that are
++ supported across all the supported 3D graphics APIs. As a result, the
++ values \c DrawLineLoop and \c DrawTriangleFan are no longer supported at
++ run time in Qt 6, even though the enum values themselves are still present.
++
++ \value DrawPoints
++ \value DrawLines
++ \omitvalue DrawLineLoop
++ \value DrawLineStrip
++ \value DrawTriangles
++ \value DrawTriangleStrip
++ \omitvalue DrawTriangleFan
++ */
++
++ /*!
++ \enum QSGGeometry::Type
++
++ Specifies the component type in the vertex data.
++
++ \value ByteType
++ \value UnsignedByteType
++ \value ShortType
++ \value UnsignedShortType
++ \value IntType
++ \value UnsignedIntType
++ \value FloatType
++ \value Bytes2Type Added in Qt 5.14.
++ \value Bytes3Type Added in Qt 5.14.
++ \value Bytes4Type Added in Qt 5.14.
++ \value DoubleType Added in Qt 5.14.
++ */
++
++ /*!
++ Sets the \a mode to be used for drawing this geometry.
++
++ The default value is QSGGeometry::DrawTriangleStrip.
++
++ \sa DrawingMode
++ */
++ void QSGGeometry::setDrawingMode(unsigned int mode)
++ {
++ m_drawing_mode = mode;
++ }
++
++ /*!
++ Gets the current line or point width or to be used for this geometry. This
++ property only applies to line width when the drawingMode is DrawLines or
++ DrawLineStrip. When supported, it also applies to point size when the
++ drawingMode is DrawPoints.
++
++ The default value is \c 1.0
++
++ \note Support for point and line drawing may be limited at run time,
++ depending on the platform and graphics API. For example, some APIs do
++ not support point sprites and so setting a size other than 1 is not
++ possible.
++
++ \note The width of \c 1.0 is always supported.
++
++ \sa setLineWidth(), drawingMode()
++ */
++ float QSGGeometry::lineWidth() const
++ {
++ return m_line_width;
++ }
++
++ /*!
++ Sets the line or point width to be used for this geometry to \a width. This
++ property only applies to line width when the drawingMode is DrawLines or
++ DrawLineStrip. When supported, it also applies to point size when the
++ drawingMode is DrawPoints.
++
++ \note Support for point and line drawing may be limited at run time,
++ depending on the platform and graphics API. For example, some APIs do
++ not support point sprites and so setting a size other than 1 is not
++ possible.
++
++ \note The width of \c 1.0 is always supported.
++
++ \sa lineWidth(), drawingMode()
++ */
++ void QSGGeometry::setLineWidth(float width)
++ {
++ m_line_width = width;
++ }
++
++ /*!
++ \fn int QSGGeometry::drawingMode() const
++
++ Returns the drawing mode of this geometry.
++
++ The default value is DrawTriangleStrip.
++ */
++
++ /*!
++ \fn int QSGGeometry::indexType() const
++
++ Returns the primitive type used for indices in this
++ geometry object.
++ */
++
++
++ /*!
++ Resizes the vertex and index data of this geometry object to fit \a vertexCount
++ vertices and \a indexCount indices and sets the number of vertices and
++ indices accordingly.
++
++ Use setVertexCount() or setIndexCount() to change the number of vertices
++ or indices without calling allocate() again.
++
++ Vertex and index data will be invalidated after this call and the caller must
++ mark the associated geometry node as dirty, by calling
++ \c{node->markDirty(QSGNode::DirtyGeometry)}, to ensure that the renderer has
++ a chance to update internal buffers.
++
++ \sa setVertexCount(), setIndexCount()
++ */
++ void QSGGeometry::allocate(int vertexCount, int indexCount)
++ {
++ if (vertexCount == m_vertex_count && indexCount == m_index_count)
++ return;
++
++ m_vertex_count = vertexCount;
++ m_index_count = indexCount;
++
++ bool canUsePrealloc = m_index_count <= 0;
++ int vertexByteSize = m_attributes.stride * m_vertex_count;
++
++ if (m_owns_data)
++ free(m_data);
++
++ if (canUsePrealloc && vertexByteSize <= (int) sizeof(m_prealloc)) {
++ // The preallocated buffer is suitable for simple geometry objects like
++ // rectangles and avoids a malloc/free but does not support index data.
++ m_data = (void *) &m_prealloc[0];
++ m_index_data_offset = -1;
++ m_owns_data = false;
++ } else {
++ Q_ASSERT(m_index_type == UnsignedIntType || m_index_type == UnsignedShortType);
++ int indexByteSize = indexCount * (m_index_type == UnsignedShortType ? sizeof(quint16) : sizeof(quint32));
++ m_data = (void *) malloc(vertexByteSize + indexByteSize);
++ Q_CHECK_PTR(m_data);
++ m_index_data_offset = vertexByteSize;
++ m_owns_data = true;
++ }
++
++ // If we have associated vbo data we could potentially crash later if
++ // the old buffers are used with the new vertex and index count, so we force
++ // an update in the renderer in that case. This is really the users responsibility
++ // but it is cheap for us to enforce this, so why not...
++ if (m_server_data) {
++ markIndexDataDirty();
++ markVertexDataDirty();
++ }
++ }
++
++ /*!
++ Updates the geometry \a g with the coordinates in \a rect.
++
++ The function assumes the geometry object contains a single triangle strip
++ of QSGGeometry::Point2D vertices
++ */
++ void QSGGeometry::updateRectGeometry(QSGGeometry *g, const QRectF &rect)
++ {
++ Point2D *v = g->vertexDataAsPoint2D();
++ v[0].x = rect.left();
++ v[0].y = rect.top();
++
++ v[1].x = rect.left();
++ v[1].y = rect.bottom();
++
++ v[2].x = rect.right();
++ v[2].y = rect.top();
++
++ v[3].x = rect.right();
++ v[3].y = rect.bottom();
++ }
++
++ /*!
++ Updates the geometry \a g with the coordinates in \a rect and texture
++ coordinates from \a textureRect.
++
++ \a textureRect should be in normalized coordinates.
++
++ \a g is assumed to be a triangle strip of four vertices of type
++ QSGGeometry::TexturedPoint2D.
++ */
++ void QSGGeometry::updateTexturedRectGeometry(QSGGeometry *g, const QRectF &rect, const QRectF &textureRect)
++ {
++ TexturedPoint2D *v = g->vertexDataAsTexturedPoint2D();
++ v[0].x = rect.left();
++ v[0].y = rect.top();
++ v[0].tx = textureRect.left();
++ v[0].ty = textureRect.top();
++
++ v[1].x = rect.left();
++ v[1].y = rect.bottom();
++ v[1].tx = textureRect.left();
++ v[1].ty = textureRect.bottom();
++
++ v[2].x = rect.right();
++ v[2].y = rect.top();
++ v[2].tx = textureRect.right();
++ v[2].ty = textureRect.top();
++
++ v[3].x = rect.right();
++ v[3].y = rect.bottom();
++ v[3].tx = textureRect.right();
++ v[3].ty = textureRect.bottom();
++ }
++
++ /*!
++ Updates the geometry \a g with the coordinates in \a rect.
++
++ The function assumes the geometry object contains a single triangle strip
++ of QSGGeometry::ColoredPoint2D vertices
++ */
++ void QSGGeometry::updateColoredRectGeometry(QSGGeometry *g, const QRectF &rect)
++ {
++ ColoredPoint2D *v = g->vertexDataAsColoredPoint2D();
++ v[0].x = rect.left();
++ v[0].y = rect.top();
++
++ v[1].x = rect.left();
++ v[1].y = rect.bottom();
++
++ v[2].x = rect.right();
++ v[2].y = rect.top();
++
++ v[3].x = rect.right();
++ v[3].y = rect.bottom();
++ }
++
++ /*!
++ \enum QSGGeometry::AttributeType
++
++ This enum identifies several attribute types.
++
++ \value UnknownAttribute Don't care
++ \value PositionAttribute Position
++ \value ColorAttribute Color
++ \value TexCoordAttribute Texture coordinate
++ \value TexCoord1Attribute Texture coordinate 1
++ \value TexCoord2Attribute Texture coordinate 2
++
++ */
++
++ /*!
++ \enum QSGGeometry::DataPattern
++
++ The DataPattern enum is used to specify the use pattern for the
++ vertex and index data in a geometry object.
++
++ \value AlwaysUploadPattern The data is always uploaded. This means
++ that the user does not need to explicitly mark index and vertex
++ data as dirty after changing it. This is the default.
++
++ \value DynamicPattern The data is modified repeatedly and drawn
++ many times. This is a hint that may provide better
++ performance. When set the user must make sure to mark the data as
++ dirty after changing it.
++
++ \value StaticPattern The data is modified once and drawn many
++ times. This is a hint that may provide better performance. When
++ set the user must make sure to mark the data as dirty after
++ changing it.
++
++ \value StreamPattern The data is modified for almost every time it
++ is drawn. This is a hint that may provide better performance. When
++ set, the user must make sure to mark the data as dirty after
++ changing it.
++ */
++
++
++ /*!
++ \fn QSGGeometry::DataPattern QSGGeometry::indexDataPattern() const
++
++ Returns the usage pattern for indices in this geometry. The default
++ pattern is AlwaysUploadPattern.
++ */
++
++ /*!
++ Sets the usage pattern for indices to \a p.
++
++ The default is AlwaysUploadPattern. When set to anything other than
++ the default, the user must call markIndexDataDirty() after changing
++ the index data, in addition to calling QSGNode::markDirty() with
++ QSGNode::DirtyGeometry.
++ */
++
++ void QSGGeometry::setIndexDataPattern(DataPattern p)
++ {
++ m_index_usage_pattern = p;
++ }
++
++
++
++
++ /*!
++ \fn QSGGeometry::DataPattern QSGGeometry::vertexDataPattern() const
++
++ Returns the usage pattern for vertices in this geometry. The default
++ pattern is AlwaysUploadPattern.
++ */
++
++ /*!
++ Sets the usage pattern for vertices to \a p.
++
++ The default is AlwaysUploadPattern. When set to anything other than
++ the default, the user must call markVertexDataDirty() after changing
++ the vertex data, in addition to calling QSGNode::markDirty() with
++ QSGNode::DirtyGeometry.
++ */
++
++ void QSGGeometry::setVertexDataPattern(DataPattern p)
++ {
++ m_vertex_usage_pattern = p;
++ }
++
++
++
++
++ /*!
++ Mark that the vertices in this geometry has changed and must be uploaded
++ again.
++
++ This function only has an effect when the usage pattern for vertices is
++ StaticData and the renderer that renders this geometry uploads the geometry
++ into Vertex Buffer Objects (VBOs).
++ */
++ void QSGGeometry::markIndexDataDirty()
++ {
++ m_dirty_index_data = true;
++ }
++
++
++
++ /*!
++ Mark that the vertices in this geometry has changed and must be uploaded
++ again.
++
++ This function only has an effect when the usage pattern for vertices is
++ StaticData and the renderer that renders this geometry uploads the geometry
++ into Vertex Buffer Objects (VBOs).
++ */
++ void QSGGeometry::markVertexDataDirty()
++ {
++ m_dirty_vertex_data = true;
++ }
++
++
++ QT_END_NAMESPACE