#include <qgl2pexvertexarray_p.h>

Public Functions
void	addPath (const QVectorPath &path, GLfloat curveInverseScale, bool outline=true)

void	addQuad (const QRectF &rect)

void	addRect (const QRectF &rect)

void	addVertex (const GLfloat x, const GLfloat y)

QGLRect	boundingRect () const

void	clear ()

QGLPoint *	data ()

void	lineToArray (const GLfloat x, const GLfloat y)

	QGL2PEXVertexArray ()

int	stopCount () const

int *	stops () const

int	vertexCount () const

Private Functions
void	addCentroid (const QVectorPath &path, int subPathIndex)

void	addClosingLine (int index)

Properties
bool	boundingRectDirty

GLfloat	maxX

GLfloat	maxY

GLfloat	minX

GLfloat	minY

QDataBuffer< QGLPoint >	vertexArray

QDataBuffer< int >	vertexArrayStops

Detailed Description

Definition at line 99 of file qgl2pexvertexarray_p.h.

Constructors and Destructors

◆ QGL2PEXVertexArray()

QGL2PEXVertexArray::QGL2PEXVertexArray ( )

inline

Definition at line 102 of file qgl2pexvertexarray_p.h.

                          :
         vertexArray(0), vertexArrayStops(0),
         maxX(-2e10), maxY(-2e10), minX(2e10), minY(2e10),
         boundingRectDirty(true)
     { }

Functions

◆ addCentroid()

void QGL2PEXVertexArray::addCentroid	(	const QVectorPath &	path,
		int	subPathIndex
	)

private

Definition at line 71 of file qgl2pexvertexarray.cpp.

Referenced by addPath().

 {
     const QPointF *const points = reinterpret_cast<const QPointF *>(path.points());
     const QPainterPath::ElementType *const elements = path.elements();
 
     QPointF sum = points[subPathIndex];
     int count = 1;
 
     for (int i = subPathIndex + 1; i < path.elementCount() && (!elements || elements[i] != QPainterPath::MoveToElement); ++i) {
         sum += points[i];
         ++count;
     }
 
     const QPointF centroid = sum / qreal(count);
     vertexArray.add(centroid);
 }

◆ addClosingLine()

void QGL2PEXVertexArray::addClosingLine ( int index )

private

Definition at line 64 of file qgl2pexvertexarray.cpp.

Referenced by addPath().

 {
     QPointF point(vertexArray.at(index));
     if (point != QPointF(vertexArray.last()))
         vertexArray.add(point);
 }

◆ addPath()

void QGL2PEXVertexArray::addPath	(	const QVectorPath &	path,
		GLfloat	curveInverseScale,
		bool	outline = `true`
	)

Definition at line 88 of file qgl2pexvertexarray.cpp.

Referenced by QGL2PaintEngineExPrivate::fill().

 {
     const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
     const QPainterPath::ElementType* const elements = path.elements();
 
     if (boundingRectDirty) {
         minX = maxX = points[0].x();
         minY = maxY = points[0].y();
         boundingRectDirty = false;
     }
 
     if (!outline && !path.isConvex())
         addCentroid(path, 0);
 
     int lastMoveTo = vertexArray.size();
     vertexArray.add(points[0]); // The first element is always a moveTo
 
     do {
         if (!elements) {
 //             qDebug("QVectorPath has no elements");
             // If the path has a null elements pointer, the elements implicitly
             // start with a moveTo (already added) and continue with lineTos:
             for (int i=1; i<path.elementCount(); ++i)
                 lineToArray(points[i].x(), points[i].y());
 
             break;
         }
 //         qDebug("QVectorPath has element types");
 
         for (int i=1; i<path.elementCount(); ++i) {
             switch (elements[i]) {
             case QPainterPath::MoveToElement:
                 if (!outline)
                     addClosingLine(lastMoveTo);
 //                qDebug("element[%d] is a MoveToElement", i);
                 vertexArrayStops.add(vertexArray.size());
                 if (!outline) {
                     if (!path.isConvex()) addCentroid(path, i);
                     lastMoveTo = vertexArray.size();
                 }
                 lineToArray(points[i].x(), points[i].y()); // Add the moveTo as a new vertex
                 break;
             case QPainterPath::LineToElement:
 //                qDebug("element[%d] is a LineToElement", i);
                 lineToArray(points[i].x(), points[i].y());
                 break;
             case QPainterPath::CurveToElement: {
                 QBezier b = QBezier::fromPoints(*(((const QPointF *) points) + i - 1),
                                                 points[i],
                                                 points[i+1],
                                                 points[i+2]);
                 QRectF bounds = b.bounds();
                 // threshold based on same algorithm as in qtriangulatingstroker.cpp
                 int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * 3.14f / (curveInverseScale * 6));
                 if (threshold < 3) threshold = 3;
                 qreal one_over_threshold_minus_1 = qreal(1) / (threshold - 1);
                 for (int t=0; t<threshold; ++t) {
                     QPointF pt = b.pointAt(t * one_over_threshold_minus_1);
                     lineToArray(pt.x(), pt.y());
                 }
                 i += 2;
                 break; }
             default:
                 break;
             }
         }
     } while (0);
 
     if (!outline)
         addClosingLine(lastMoveTo);
     vertexArrayStops.add(vertexArray.size());
 }

◆ addQuad()

void QGL2PEXVertexArray::addQuad ( const QRectF & rect )

inline

Definition at line 123 of file qgl2pexvertexarray_p.h.

Referenced by QGL2PaintEngineExPrivate::drawCachedGlyphs().

     {
         qreal top = rect.top();
         qreal left = rect.left();
         qreal bottom = rect.bottom();
         qreal right = rect.right();
 
         vertexArray << QGLPoint(left, top)
                     << QGLPoint(right, top)
                     << QGLPoint(left, bottom)
                     << QGLPoint(right, bottom);
 
     }

◆ addRect()

void QGL2PEXVertexArray::addRect ( const QRectF & rect )

inline

Definition at line 108 of file qgl2pexvertexarray_p.h.

     {
         qreal top = rect.top();
         qreal left = rect.left();
         qreal bottom = rect.bottom();
         qreal right = rect.right();
     
         vertexArray << QGLPoint(left, top)
                     << QGLPoint(right, top)
                     << QGLPoint(right, bottom)
                     << QGLPoint(right, bottom)
                     << QGLPoint(left, bottom)
                     << QGLPoint(left, top);        
     }

◆ addVertex()

void QGL2PEXVertexArray::addVertex	(	const GLfloat	x,
		const GLfloat	y
	)

inline

Definition at line 137 of file qgl2pexvertexarray_p.h.

     {
         vertexArray.add(QGLPoint(x, y));
     }

◆ boundingRect()

QGLRect QGL2PEXVertexArray::boundingRect ( ) const

Definition at line 56 of file qgl2pexvertexarray.cpp.

Referenced by QGL2PaintEngineExPrivate::fill(), and QGL2PaintEngineExPrivate::fillStencilWithVertexArray().

 {
     if (boundingRectDirty)
         return QGLRect(0.0, 0.0, 0.0, 0.0);
     else
         return QGLRect(minX, minY, maxX, maxY);
 }

◆ clear()

void QGL2PEXVertexArray::clear ( )

Definition at line 48 of file qgl2pexvertexarray.cpp.

Referenced by QGL2PaintEngineExPrivate::drawCachedGlyphs(), and QGL2PaintEngineExPrivate::fill().

 {
     vertexArray.reset();
     vertexArrayStops.reset();
     boundingRectDirty = true;
 }

◆ data()

QGLPoint* QGL2PEXVertexArray::data ( )

inline

Definition at line 145 of file qgl2pexvertexarray_p.h.

Referenced by QGL2PaintEngineExPrivate::drawCachedGlyphs(), QGL2PaintEngineExPrivate::drawVertexArrays(), QGL2PaintEngineExPrivate::fill(), QGL2PaintEngineExPrivate::fillStencilWithVertexArray(), and QGL2PaintEngineExPrivate::transferMode().

145 {return vertexArray.data();}

QDataBuffer::data

Type * data() const

Definition: qdatabuffer_p.h:84

QGL2PEXVertexArray::vertexArray

QDataBuffer< QGLPoint > vertexArray

Definition: qgl2pexvertexarray_p.h:155

◆ lineToArray()

void QGL2PEXVertexArray::lineToArray	(	const GLfloat	x,
		const GLfloat	y
	)

Definition at line 161 of file qgl2pexvertexarray.cpp.

Referenced by addPath().

 {
     vertexArray.add(QGLPoint(x, y));
 
     if (x > maxX)
         maxX = x;
     else if (x < minX)
         minX = x;
     if (y > maxY)
         maxY = y;
     else if (y < minY)
         minY = y;
 }