Inheritance diagram for QOpenGLPaintEnginePrivate:

Public Functions
void	addItem (const QGLMaskTextureCache::CacheLocation &location)

void	cacheItemErased (int channel, const QRect &rect)

void	cleanupGLContextRefs (const QGLContext *context)

void	composite (const QRectF &rect, const QPoint &maskOffset=QPoint())

void	composite (GLuint primitive, const GLfloat *vertexArray, int vertexCount, const QPoint &maskOffset=QPoint())

void	copyDrawable (const QRectF &rect)

bool	createFragmentPrograms ()

void	createGradientPaletteTexture (const QGradient &g)

void	curveToStencil (const QPointF &cp1, const QPointF &cp2, const QPointF &ep)

void	deleteFragmentPrograms ()

void	disableClipping ()

void	drawFastRect (const QRectF &rect)

void	drawImageAsPath (const QRectF &r, const QImage &img, const QRectF &sr)

void	drawItem (const QDrawQueueItem &item)

void	drawOffscreenPath (const QPainterPath &path)

void	drawTiledImageAsPath (const QRectF &r, const QImage &img, qreal sx, qreal sy, const QPointF &offset)

void	drawVertexArrays ()

void	enableClipping ()

void	ensureDrawableTexture ()

void	fillPath (const QPainterPath &path)

void	fillPolygon_dev (const QPointF *polygonPoints, int pointCount, Qt::FillRule fill)

void	fillVertexArray (Qt::FillRule fillRule)

void	flushDrawQueue ()

bool	isFastRect (const QRectF &r)

void	lineToStencil (qreal x, qreal y)

void	pathToVertexArrays (const QPainterPath &path)

	QOpenGLPaintEnginePrivate ()

void	setGLBrush (const QColor &c)

void	setGLPen (const QColor &c)

void	setGradientOps (const QBrush &brush, const QRectF &bounds)

void	setInvMatrixData (const QTransform &inv_matrix)

void	setPorterDuffData (float a, float b, float x, float y, float z)

void	strokeLines (const QPainterPath &path)

void	strokePath (const QPainterPath &path, bool use_cache)

void	strokePathFastPen (const QPainterPath &path, bool needsResolving)

void	systemStateChanged ()

void	updateDepthClip ()

void	updateFastPen ()

void	updateFragmentProgramData (int locations[])

void	updateGLMatrix () const

void	updateGradient (const QBrush &brush, const QRectF &bounds)

void	updateUseEmulation ()

Public Functions inherited from QPaintEngineExPrivate
bool	hasClipOperations () const

	QPaintEngineExPrivate ()

void	replayClipOperations ()

	~QPaintEngineExPrivate ()

Public Functions inherited from QPaintEnginePrivate
void	drawBoxTextItem (const QPointF &p, const QTextItemInt &ti)

	QPaintEnginePrivate ()

void	setSystemTransform (const QTransform &xform)

void	setSystemViewport (const QRegion &region)

void	transformSystemClip ()

virtual	~QPaintEnginePrivate ()

Public Variables
float	angle_data [4]

GLubyte	brush_color [4]

QPointF	brush_origin

Qt::BrushStyle	brush_style

QBrush	cbrush

QPainter::CompositionMode	composition_mode

QPen	cpen

Qt::BrushStyle	current_style

QGLPaintDevice *	device

uint	dirty_drawable_texture: 1

QRegion	dirty_stencil

GLuint	drawable_texture

QSize	drawable_texture_size

QList< QDrawQueueItem >	drawQueue

float	fmp2_m_radius2_data [4]

float	fmp_data [4]

FragmentBrushType	fragment_brush

FragmentCompositionModeType	fragment_composition_mode

GLuint	grad_palette

uint	has_antialiasing: 1

uint	has_brush: 1

uint	has_fast_composition_mode: 1

uint	has_fast_pen: 1

uint	has_pen: 1

uint	has_stencil_face_ext: 1

uint	high_quality_antialiasing: 1

float	inv_matrix_data [3][4]

qreal	inverseScale

QPainterState *	last_created_state

float	linear_data [4]

float	mask_channel_data [4]

GLuint	mask_fragment_programs [num_fragment_masks]

float	mask_offset_data [4]

QTransform	matrix

int	max_texture_size

qreal	max_x

qreal	max_y

qreal	min_x

qreal	min_y

int	moveToCount

GLdouble	mv_matrix [4][4]

QGLOffscreen	offscreen

qreal	opacity

GLuint	painter_fragment_programs [num_fragment_brushes][num_fragment_composition_modes]

QPointF	path_start

Qt::BrushStyle	pen_brush_style

GLubyte	pen_color [4]

float	porterduff_ab_data [4]

float	porterduff_xyz_data [4]

GLdouble	projection_matrix [4][4]

QGLPrivateCleanup	ref_cleaner

QGLContext *	shader_ctx

QDataBuffer< QPointF >	tess_points

QVector< int >	tess_points_stops

QTransform::TransformationType	txop

uint	use_emulation: 1

uint	use_fragment_programs: 1

uint	use_smooth_pixmap_transform: 1

uint	use_stencil_method: 1

uint	use_system_clip: 1

Public Variables inherited from QPaintEngineExPrivate
QStrokerOps *	activeStroker

QDashStroker	dasher

QRect	exDeviceRect

StrokeHandler *	strokeHandler

QStroker	stroker

QPen	strokerPen

Public Variables inherited from QPaintEnginePrivate
QWidget *	currentClipWidget

uint	hasSystemTransform: 1

uint	hasSystemViewport: 1

QPaintDevice *	pdev

QPaintEngine *	q_ptr

QRegion	systemClip

QRect	systemRect

QTransform	systemTransform

QRegion	systemViewport

Friends
class	QGLMaskTextureCache

Detailed Description

Definition at line 650 of file qpaintengine_opengl.cpp.

Constructors and Destructors

◆ QOpenGLPaintEnginePrivate()

QOpenGLPaintEnginePrivate::QOpenGLPaintEnginePrivate ( )

inline

Definition at line 654 of file qpaintengine_opengl.cpp.

         : opacity(1)
         , composition_mode(QPainter::CompositionMode_SourceOver)
         , has_pen(false)
         , has_brush(false)
         , has_fast_pen(false)
         , use_stencil_method(false)
         , dirty_drawable_texture(false)
         , has_stencil_face_ext(false)
         , use_fragment_programs(false)
         , high_quality_antialiasing(false)
         , use_smooth_pixmap_transform(false)
         , use_emulation(false)
         , txop(QTransform::TxNone)
         , inverseScale(1)
         , moveToCount(0)
         , last_created_state(0)
         , shader_ctx(0)
         , grad_palette(0)
         , tess_points(0)
         , drawable_texture(0)
         , ref_cleaner(this)
         {}

Functions

◆ addItem()

void QOpenGLPaintEnginePrivate::addItem ( const QGLMaskTextureCache::CacheLocation & location )

Definition at line 5336 of file qpaintengine_opengl.cpp.

 {
     drawQueue << QDrawQueueItem(opacity, cbrush, brush_origin, composition_mode, matrix, location);
 }

◆ cacheItemErased()

void QOpenGLPaintEnginePrivate::cacheItemErased	(	int	channel,
		const QRect &	rect
	)

Definition at line 5321 of file qpaintengine_opengl.cpp.

 {
     bool isInDrawQueue = false;
 
     foreach (const QDrawQueueItem &item, drawQueue) {
         if (item.location.channel == channel && item.location.rect == rect) {
             isInDrawQueue = true;
             break;
         }
     }
 
     if (isInDrawQueue)
         flushDrawQueue();
 }

◆ cleanupGLContextRefs()

void QOpenGLPaintEnginePrivate::cleanupGLContextRefs ( const QGLContext * context )

inline

Definition at line 716 of file qpaintengine_opengl.cpp.

                                                          {
         if (context == shader_ctx)
             shader_ctx = 0;
     }

◆ composite() [1/2]

void QOpenGLPaintEnginePrivate::composite	(	const QRectF &	rect,
		const QPoint &	maskOffset = `QPoint()`
	)

Definition at line 5189 of file qpaintengine_opengl.cpp.

 {
 #ifdef Q_WS_QWS
     Q_UNUSED(rect);
     Q_UNUSED(maskOffset);
 #else
     GLfloat vertexArray[8];
     qt_add_rect_to_array(rect, vertexArray);
 
     composite(GL_TRIANGLE_FAN, vertexArray, 4, maskOffset);
 #endif
 }

◆ composite() [2/2]

void QOpenGLPaintEnginePrivate::composite	(	GLuint	primitive,
		const GLfloat *	vertexArray,
		int	vertexCount,
		const QPoint &	maskOffset = `QPoint()`
	)

Definition at line 5203 of file qpaintengine_opengl.cpp.

 {
 #ifdef QT_OPENGL_ES
     Q_UNUSED(primitive);
     Q_UNUSED(vertexArray);
     Q_UNUSED(vertexCount);
     Q_UNUSED(maskOffset);
 #else
     Q_Q(QOpenGLPaintEngine);
     QGL_FUNC_CONTEXT;
 
     if (current_style == Qt::NoBrush)
         return;
 
     DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Using compositing program: fragment_brush ="
                         << fragment_brush << ", fragment_composition_mode =" << fragment_composition_mode;
 
     if (has_fast_composition_mode)
         q->updateCompositionMode(composition_mode);
     else {
         qreal minX = 1e9, minY = 1e9, maxX = -1e9, maxY = -1e9;
 
         for (int i = 0; i < vertexCount; ++i) {
             qreal x = vertexArray[2 * i];
             qreal y = vertexArray[2 * i + 1];
 
             qreal tx, ty;
             matrix.map(x, y, &tx, &ty);
 
             minX = qMin(minX, tx);
             minY = qMin(minY, ty);
             maxX = qMax(maxX, tx);
             maxY = qMax(maxY, ty);
         }
 
         QRectF r(minX, minY, maxX - minX, maxY - minY);
         copyDrawable(r);
 
         glBlendFunc(GL_ONE, GL_ZERO);
     }
 
     int *locations = painter_variable_locations[fragment_brush][fragment_composition_mode];
 
     int texture_locations[] = { locations[VAR_DST_TEXTURE],
                                 locations[VAR_MASK_TEXTURE],
                                 locations[VAR_PALETTE] };
 
     int brush_texture_location = locations[VAR_BRUSH_TEXTURE];
 
     GLuint texture_targets[] = { GL_TEXTURE_2D,
                                  GL_TEXTURE_2D,
                                  GL_TEXTURE_1D };
 
     GLuint textures[] = { drawable_texture,
                           offscreen.offscreenTexture(),
                           grad_palette };
 
     const int num_textures = sizeof(textures) / sizeof(*textures);
 
     Q_ASSERT(num_textures == sizeof(texture_locations) / sizeof(*texture_locations));
     Q_ASSERT(num_textures == sizeof(texture_targets) / sizeof(*texture_targets));
 
     for (int i = 0; i < num_textures; ++i)
         if (texture_locations[i] >= 0) {
             glActiveTexture(GL_TEXTURE0 + texture_locations[i]);
             glBindTexture(texture_targets[i], textures[i]);
         }
 
     if (brush_texture_location >= 0) {
         glActiveTexture(GL_TEXTURE0 + brush_texture_location);
 
         if (current_style == Qt::TexturePattern)
             device->context()->d_func()->bindTexture(cbrush.textureImage(), GL_TEXTURE_2D, GL_RGBA,
                                                      QGLContext::InternalBindOption);
         else
             device->context()->d_func()->bindTexture(qt_imageForBrush(current_style, false),
                                                      GL_TEXTURE_2D, GL_RGBA,
                                                      QGLContext::InternalBindOption);
 
         updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, use_smooth_pixmap_transform);
     }
 
     glEnableClientState(GL_VERTEX_ARRAY);
     glVertexPointer(2, GL_FLOAT, 0, vertexArray);
     glEnable(GL_FRAGMENT_PROGRAM_ARB);
     GLuint program = qt_gl_program_cache()->getProgram(device->context(),
                                                        fragment_brush,
                                                        fragment_composition_mode, false);
     glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program);
 
     mask_offset_data[0] = maskOffset.x();
     mask_offset_data[1] = -maskOffset.y();
 
     updateFragmentProgramData(locations);
 
     glDrawArrays(primitive, 0, vertexCount);
 
     glDisable(GL_FRAGMENT_PROGRAM_ARB);
     glDisableClientState(GL_VERTEX_ARRAY);
 
     for (int i = 0; i < num_textures; ++i)
         if (texture_locations[i] >= 0) {
             glActiveTexture(GL_TEXTURE0 + texture_locations[i]);
             glBindTexture(texture_targets[i], 0);
         }
 
     if (brush_texture_location >= 0) {
         glActiveTexture(GL_TEXTURE0 + brush_texture_location);
         glBindTexture(GL_TEXTURE_2D, 0);
     }
 
     glActiveTexture(GL_TEXTURE0);
 
     if (!has_fast_composition_mode)
         q->updateCompositionMode(composition_mode);
 #endif
 }

◆ copyDrawable()

void QOpenGLPaintEnginePrivate::copyDrawable ( const QRectF & rect )

Definition at line 5167 of file qpaintengine_opengl.cpp.

 {
 #ifdef Q_WS_QWS
     Q_UNUSED(rect);
 #else
     ensureDrawableTexture();
 
     DEBUG_ONCE qDebug() << "Refreshing drawable_texture for rectangle" << rect;
     QRectF screen_rect = rect.adjusted(-1, -1, 1, 1);
 
     int left = qMax(0, static_cast<int>(screen_rect.left()));
     int width = qMin(device->size().width() - left, static_cast<int>(screen_rect.width()) + 1);
 
     int bottom = qMax(0, static_cast<int>(device->size().height() - screen_rect.bottom()));
     int height = qMin(device->size().height() - bottom, static_cast<int>(screen_rect.height()) + 1);
 
     glBindTexture(GL_TEXTURE_2D, drawable_texture);
     glCopyTexSubImage2D(GL_TEXTURE_2D, 0, left, bottom, left, bottom, width, height);
 #endif
 }

◆ createFragmentPrograms()

bool QOpenGLPaintEnginePrivate::createFragmentPrograms ( )

◆ createGradientPaletteTexture()

void QOpenGLPaintEnginePrivate::createGradientPaletteTexture ( const QGradient & g )

Definition at line 1174 of file qpaintengine_opengl.cpp.

 {
 #ifdef QT_OPENGL_ES //###
     Q_UNUSED(g);
 #else
     GLuint texId = qt_opengl_gradient_cache()->getBuffer(g, opacity, device->context());
     glBindTexture(GL_TEXTURE_1D, texId);
     grad_palette = texId;
     if (g.spread() == QGradient::RepeatSpread || g.type() == QGradient::ConicalGradient)
         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
     else if (g.spread() == QGradient::ReflectSpread)
         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT_IBM);
     else
         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 
     glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
 #endif
 }

◆ curveToStencil()

void QOpenGLPaintEnginePrivate::curveToStencil	(	const QPointF &	cp1,
		const QPointF &	cp2,
		const QPointF &	ep
	)

inline

Definition at line 1893 of file qpaintengine_opengl.cpp.

 {
     qreal inverseScaleHalf = inverseScale / 2;
 
     QBezier beziers[32];
     beziers[0] = QBezier::fromPoints(tess_points.last(), cp1, cp2, ep);
     QBezier *b = beziers;
     while (b >= beziers) {
         // check if we can pop the top bezier curve from the stack
         qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
         qreal d;
         if (l > inverseScale) {
             d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2) - (b->y4 - b->y1)*(b->x1 - b->x2) )
                 + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3) - (b->y4 - b->y1)*(b->x1 - b->x3) );
             d /= l;
         } else {
             d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
                 qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
         }
         if (d < inverseScaleHalf || b == beziers + 31) {
             // good enough, we pop it off and add the endpoint
             lineToStencil(b->x4, b->y4);
             --b;
         } else {
             // split, second half of the polygon goes lower into the stack
             b->split(b+1, b);
            ++b;
         }
     }
 }

◆ deleteFragmentPrograms()

void QOpenGLPaintEnginePrivate::deleteFragmentPrograms ( )

◆ disableClipping()

void QOpenGLPaintEnginePrivate::disableClipping ( )

Definition at line 2228 of file qpaintengine_opengl.cpp.

 {
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);
 }

◆ drawFastRect()

void QOpenGLPaintEnginePrivate::drawFastRect ( const QRectF & rect )

Definition at line 3406 of file qpaintengine_opengl.cpp.

 {
     Q_Q(QOpenGLPaintEngine);
     DEBUG_ONCE_STR("QOpenGLPaintEngine::drawRects(): drawing fast rect");
 
     GLfloat vertexArray[10];
     qt_add_rect_to_array(r, vertexArray);
 
     if (has_pen)
         QOpenGLCoordinateOffset::enableOffset(this);
 
     if (has_brush) {
         flushDrawQueue();
 
         bool temp = high_quality_antialiasing;
         high_quality_antialiasing = false;
 
         q->updateCompositionMode(composition_mode);
 
         setGradientOps(cbrush, r);
 
         bool fast_style = current_style == Qt::LinearGradientPattern
                           || current_style == Qt::SolidPattern;
 
         if (fast_style && has_fast_composition_mode) {
             glEnableClientState(GL_VERTEX_ARRAY);
             glVertexPointer(2, GL_FLOAT, 0, vertexArray);
             glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
             glDisableClientState(GL_VERTEX_ARRAY);
         } else {
             composite(r);
         }
 
         high_quality_antialiasing = temp;
 
         q->updateCompositionMode(composition_mode);
     }
 
     if (has_pen) {
         if (has_fast_pen && !high_quality_antialiasing) {
             setGradientOps(cpen.brush(), r);
 
             vertexArray[8] = vertexArray[0];
             vertexArray[9] = vertexArray[1];
 
             glVertexPointer(2, GL_FLOAT, 0, vertexArray);
             glEnableClientState(GL_VERTEX_ARRAY);
             glDrawArrays(GL_LINE_STRIP, 0, 5);
             glDisableClientState(GL_VERTEX_ARRAY);
         } else {
             QPainterPath path;
             path.setFillRule(Qt::WindingFill);
 
             qreal left = r.left();
             qreal right = r.right();
             qreal top = r.top();
             qreal bottom = r.bottom();
 
             path.moveTo(left, top);
             path.lineTo(right, top);
             path.lineTo(right, bottom);
             path.lineTo(left, bottom);
             path.lineTo(left, top);
 
             strokePath(path, false);
         }
 
         QOpenGLCoordinateOffset::disableOffset(this);
     }
 }

◆ drawImageAsPath()

void QOpenGLPaintEnginePrivate::drawImageAsPath	(	const QRectF &	r,
		const QImage &	img,
		const QRectF &	sr
	)

Definition at line 4222 of file qpaintengine_opengl.cpp.

 {
     QBrush old_brush = cbrush;
     QPointF old_brush_origin = brush_origin;
 
     qreal scaleX = r.width() / sr.width();
     qreal scaleY = r.height() / sr.height();
 
     QTransform brush_matrix = QTransform::fromTranslate(r.left(), r.top());
     brush_matrix.scale(scaleX, scaleY);
     brush_matrix.translate(-sr.left(), -sr.top());
 
     cbrush = QBrush(img);
     cbrush.setTransform(brush_matrix);
     brush_origin = QPointF();
 
     QPainterPath p;
     p.addRect(r);
     fillPath(p);
 
     cbrush = old_brush;
     brush_origin = old_brush_origin;
 }

◆ drawItem()

void QOpenGLPaintEnginePrivate::drawItem ( const QDrawQueueItem & item )

Definition at line 5341 of file qpaintengine_opengl.cpp.

 {
     Q_Q(QOpenGLPaintEngine);
 
     opacity = item.opacity;
     brush_origin = item.brush_origin;
     q->updateCompositionMode(item.composition_mode);
     matrix = item.matrix;
     cbrush = item.brush;
     brush_style = item.brush.style();
 
     mask_channel_data[0] = item.location.channel == 0;
     mask_channel_data[1] = item.location.channel == 1;
     mask_channel_data[2] = item.location.channel == 2;
     mask_channel_data[3] = item.location.channel == 3;
 
     setGradientOps(item.brush, item.location.screen_rect);
 
     composite(item.location.screen_rect, item.location.rect.topLeft() - item.location.screen_rect.topLeft()
                                          - QPoint(0, offscreen.offscreenSize().height() - device->size().height()));
 }

◆ drawOffscreenPath()

void QOpenGLPaintEnginePrivate::drawOffscreenPath ( const QPainterPath & path )

Definition at line 3388 of file qpaintengine_opengl.cpp.

 {
 #ifdef Q_WS_QWS
     Q_UNUSED(path);
 #else
     DEBUG_ONCE_STR("QOpenGLPaintEnginePrivate::drawOffscreenPath()");
 
     disableClipping();
 
     GLuint program = qt_gl_program_cache()->getProgram(device->context(),
                                                        FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
     QGLPathMaskGenerator maskGenerator(path, matrix, offscreen, program);
     addItem(qt_mask_texture_cache()->getMask(maskGenerator, this));
 
     enableClipping();
 #endif
 }

◆ drawTiledImageAsPath()

void QOpenGLPaintEnginePrivate::drawTiledImageAsPath	(	const QRectF &	r,
		const QImage &	img,
		qreal	sx,
		qreal	sy,
		const QPointF &	offset
	)

Definition at line 4246 of file qpaintengine_opengl.cpp.

 {
     QBrush old_brush = cbrush;
     QPointF old_brush_origin = brush_origin;
 
     QTransform brush_matrix = QTransform::fromTranslate(r.left(), r.top());
     brush_matrix.scale(sx, sy);
     brush_matrix.translate(-offset.x(), -offset.y());
 
     cbrush = QBrush(img);
     cbrush.setTransform(brush_matrix);
     brush_origin = QPointF();
 
     QPainterPath p;
     p.addRect(r);
     fillPath(p);
 
     cbrush = old_brush;
     brush_origin = old_brush_origin;
 }

◆ drawVertexArrays()

void QOpenGLPaintEnginePrivate::drawVertexArrays ( )

Definition at line 1958 of file qpaintengine_opengl.cpp.

 {
     if (tess_points_stops.count() == 0)
         return;
     glEnableClientState(GL_VERTEX_ARRAY);
     glVertexPointer(2, GL_DOUBLE, 0, tess_points.data());
     int previous_stop = 0;
     foreach(int stop, tess_points_stops) {
         glDrawArrays(GL_TRIANGLE_FAN, previous_stop, stop-previous_stop);
         previous_stop = stop;
     }
     glDisableClientState(GL_VERTEX_ARRAY);
 }

◆ enableClipping()

void QOpenGLPaintEnginePrivate::enableClipping ( )

Definition at line 2234 of file qpaintengine_opengl.cpp.

 {
     Q_Q(QOpenGLPaintEngine);
     if (!q->state()->hasClipping)
         return;
 
     if (q->state()->fastClip.isEmpty())
         glEnable(GL_DEPTH_TEST);
     else
         updateDepthClip(); // this will enable the scissor test
 }

◆ ensureDrawableTexture()

void QOpenGLPaintEnginePrivate::ensureDrawableTexture ( )

Definition at line 5615 of file qpaintengine_opengl.cpp.

 {
     if (!dirty_drawable_texture)
         return;
 
     dirty_drawable_texture = false;
 
 #ifndef QT_OPENGL_ES
     glGenTextures(1, &drawable_texture);
     glBindTexture(GL_TEXTURE_2D, drawable_texture);
 
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
             drawable_texture_size.width(),
             drawable_texture_size.height(), 0,
             GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 #endif
 }

◆ fillPath()

void QOpenGLPaintEnginePrivate::fillPath ( const QPainterPath & path )

Definition at line 2097 of file qpaintengine_opengl.cpp.

 {
     if (path.isEmpty())
         return;
 
     if (use_stencil_method && !high_quality_antialiasing) {
         pathToVertexArrays(path);
         fillVertexArray(path.fillRule());
         return;
     }
 
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
 
     if (high_quality_antialiasing)
         drawOffscreenPath(path);
     else {
         QPolygonF poly = path.toFillPolygon(matrix);
         fillPolygon_dev(poly.data(), poly.count(),
                         path.fillRule());
     }
 
     updateGLMatrix();
 }

◆ fillPolygon_dev()

void QOpenGLPaintEnginePrivate::fillPolygon_dev	(	const QPointF *	polygonPoints,
		int	pointCount,
		Qt::FillRule	fill
	)

Definition at line 1849 of file qpaintengine_opengl.cpp.

 {
     QOpenGLTrapezoidToArrayTessellator tessellator;
     tessellator.tessellate(polygonPoints, pointCount, fill == Qt::WindingFill);
 
     DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon with" << pointCount << "points using fillPolygon_dev";
 
     setGradientOps(cbrush, tessellator.bounds);
 
     bool fast_style = current_style == Qt::LinearGradientPattern
                       || current_style == Qt::SolidPattern;
 
 #ifndef QT_OPENGL_ES
     GLenum geometry_mode = GL_QUADS;
 #else
     GLenum geometry_mode = GL_TRIANGLES;
 #endif
 
     if (use_fragment_programs && !(fast_style && has_fast_composition_mode)) {
         composite(geometry_mode, tessellator.vertices, tessellator.size / 2);
     } else {
         glVertexPointer(2, GL_FLOAT, 0, tessellator.vertices);
         glEnableClientState(GL_VERTEX_ARRAY);
         glDrawArrays(geometry_mode, 0, tessellator.size/2);
         glDisableClientState(GL_VERTEX_ARRAY);
     }
 }

◆ fillVertexArray()

void QOpenGLPaintEnginePrivate::fillVertexArray ( Qt::FillRule fillRule )

Definition at line 1972 of file qpaintengine_opengl.cpp.

 {
     Q_Q(QOpenGLPaintEngine);
 
     QRect rect = dirty_stencil.boundingRect();
 
     if (use_system_clip)
         rect = q->systemClip().intersected(dirty_stencil).boundingRect();
 
     glStencilMask(~0);
 
     if (!rect.isEmpty()) {
         disableClipping();
 
         glEnable(GL_SCISSOR_TEST);
 
         const int left = rect.left();
         const int width = rect.width();
         const int bottom = device->size().height() - (rect.bottom() + 1);
         const int height = rect.height();
 
         glScissor(left, bottom, width, height);
 
         glClearStencil(0);
         glClear(GL_STENCIL_BUFFER_BIT);
         dirty_stencil -= rect;
 
         glDisable(GL_SCISSOR_TEST);
 
         enableClipping();
     }
 
     // Enable stencil.
     glEnable(GL_STENCIL_TEST);
 
     // Disable color writes.
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
     GLuint stencilMask = 0;
 
     if (fillRule == Qt::OddEvenFill) {
         stencilMask = 1;
 
         // Enable stencil writes.
         glStencilMask(stencilMask);
 
         // Set stencil xor mode.
         glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT);
 
         // Disable stencil func.
         glStencilFunc(GL_ALWAYS, 0, ~0);
 
         drawVertexArrays();
     } else if (fillRule == Qt::WindingFill) {
         stencilMask = ~0;
 
         if (has_stencil_face_ext) {
             QGL_FUNC_CONTEXT;
             glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 
             glActiveStencilFaceEXT(GL_BACK);
             glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
             glStencilFunc(GL_ALWAYS, 0, ~0);
 
             glActiveStencilFaceEXT(GL_FRONT);
             glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
             glStencilFunc(GL_ALWAYS, 0, ~0);
 
             drawVertexArrays();
 
             glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
         } else {
             glStencilFunc(GL_ALWAYS, 0, ~0);
             glEnable(GL_CULL_FACE);
 
             glCullFace(GL_BACK);
             glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
             drawVertexArrays();
 
             glCullFace(GL_FRONT);
             glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
             drawVertexArrays();
 
             glDisable(GL_CULL_FACE);
         }
     }
 
     // Enable color writes.
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glStencilMask(stencilMask);
 
     setGradientOps(cbrush, QRectF(QPointF(min_x, min_y), QSizeF(max_x - min_x, max_y - min_y)));
 
     bool fast_fill = has_fast_composition_mode && (current_style == Qt::LinearGradientPattern || current_style == Qt::SolidPattern);
 
     if (use_fragment_programs && !fast_fill) {
         DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon using stencil method (fragment programs)";
         QRectF rect(QPointF(min_x, min_y), QSizeF(max_x - min_x, max_y - min_y));
 
         // Enable stencil func.
         glStencilFunc(GL_NOTEQUAL, 0, stencilMask);
         glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
         composite(rect);
     } else {
         DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon using stencil method (no fragment programs)";
 
         // Enable stencil func.
         glStencilFunc(GL_NOTEQUAL, 0, stencilMask);
         glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
 #ifndef QT_OPENGL_ES
         glBegin(GL_QUADS);
         glVertex2f(min_x, min_y);
         glVertex2f(max_x, min_y);
         glVertex2f(max_x, max_y);
         glVertex2f(min_x, max_y);
         glEnd();
 #endif
     }
 
     // Disable stencil writes.
     glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
     glStencilMask(0);
     glDisable(GL_STENCIL_TEST);
 }

◆ flushDrawQueue()

void QOpenGLPaintEnginePrivate::flushDrawQueue ( )

Definition at line 5363 of file qpaintengine_opengl.cpp.

 {
 #ifndef QT_OPENGL_ES
     Q_Q(QOpenGLPaintEngine);
 
     offscreen.release();
 
     if (!drawQueue.isEmpty()) {
         DEBUG_ONCE qDebug() << "QOpenGLPaintEngine::flushDrawQueue():" << drawQueue.size() << "items";
 
         glPushMatrix();
         glLoadIdentity();
         qreal old_opacity = opacity;
         QPointF old_brush_origin = brush_origin;
         QPainter::CompositionMode old_composition_mode = composition_mode;
         QTransform old_matrix = matrix;
         QBrush old_brush = cbrush;
 
         bool hqaa_old = high_quality_antialiasing;
 
         high_quality_antialiasing = true;
 
         foreach (const QDrawQueueItem &item, drawQueue)
             drawItem(item);
 
         opacity = old_opacity;
         brush_origin = old_brush_origin;
         q->updateCompositionMode(old_composition_mode);
         matrix = old_matrix;
         cbrush = old_brush;
         brush_style = old_brush.style();
 
         high_quality_antialiasing = hqaa_old;
 
         setGLBrush(old_brush.color());
         qt_glColor4ubv(brush_color);
 
         drawQueue.clear();
 
         glPopMatrix();
     }
 #endif
 }

◆ isFastRect()

bool QOpenGLPaintEnginePrivate::isFastRect ( const QRectF & r )

Definition at line 3477 of file qpaintengine_opengl.cpp.

 {
     if (matrix.type() < QTransform::TxRotate) {
         QRectF r = matrix.mapRect(rect);
         return r.topLeft().toPoint() == r.topLeft()
             && r.bottomRight().toPoint() == r.bottomRight();
     }
 
     return false;
 }

◆ lineToStencil()

void QOpenGLPaintEnginePrivate::lineToStencil	(	qreal	x,
		qreal	y
	)

inline

Definition at line 1879 of file qpaintengine_opengl.cpp.

 {
     tess_points.add(QPointF(x, y));
 
     if (x > max_x)
         max_x = x;
     else if (x < min_x)
         min_x = x;
     if (y > max_y)
         max_y = y;
     else if (y < min_y)
         min_y = y;
 }

◆ pathToVertexArrays()

void QOpenGLPaintEnginePrivate::pathToVertexArrays ( const QPainterPath & path )

Definition at line 1925 of file qpaintengine_opengl.cpp.

 {
     const QPainterPath::Element &first = path.elementAt(0);
     min_x = max_x = first.x;
     min_y = max_y = first.y;
 
     tess_points.reset();
     tess_points_stops.clear();
     lineToStencil(first.x, first.y);
 
     for (int i=1; i<path.elementCount(); ++i) {
         const QPainterPath::Element &e = path.elementAt(i);
         switch (e.type) {
         case QPainterPath::MoveToElement:
             tess_points_stops.append(tess_points.size());
             lineToStencil(e.x, e.y);
             break;
         case QPainterPath::LineToElement:
             lineToStencil(e.x, e.y);
             break;
         case QPainterPath::CurveToElement:
             curveToStencil(e, path.elementAt(i+1), path.elementAt(i+2));
             i+=2;
             break;
         default:
             break;
         }
     }
     lineToStencil(first.x, first.y);
     tess_points_stops.append(tess_points.size());
 }

◆ setGLBrush()

void QOpenGLPaintEnginePrivate::setGLBrush ( const QColor & c )

inline

Definition at line 686 of file qpaintengine_opengl.cpp.

                                             {
         uint alpha = qRound(c.alpha() * opacity);
         brush_color[0] = qt_div_255(c.red() * alpha);
         brush_color[1] = qt_div_255(c.green() * alpha);
         brush_color[2] = qt_div_255(c.blue() * alpha);
         brush_color[3] = alpha;
     }

◆ setGLPen()

void QOpenGLPaintEnginePrivate::setGLPen ( const QColor & c )

inline

Definition at line 678 of file qpaintengine_opengl.cpp.

                                           {
         uint alpha = qRound(c.alpha() * opacity);
         pen_color[0] = qt_div_255(c.red() * alpha);
         pen_color[1] = qt_div_255(c.green() * alpha);
         pen_color[2] = qt_div_255(c.blue() * alpha);
         pen_color[3] = alpha;
     }

◆ setGradientOps()

void QOpenGLPaintEnginePrivate::setGradientOps	(	const QBrush &	brush,
		const QRectF &	bounds
	)

inline

Definition at line 1196 of file qpaintengine_opengl.cpp.

 {
     current_style = brush.style();
 
     if (current_style < Qt::LinearGradientPattern || current_style > Qt::ConicalGradientPattern) {
         setGLBrush(brush.color());
         qt_glColor4ubv(brush_color);
     }
 
     updateGradient(brush, bounds);
 
 #ifndef QT_OPENGL_ES //### GLES does not have GL_TEXTURE_GEN_ so we are falling back for gradients
     glDisable(GL_TEXTURE_GEN_S);
     glDisable(GL_TEXTURE_1D);
 
     if (current_style == Qt::LinearGradientPattern) {
         if (high_quality_antialiasing || !has_fast_composition_mode) {
             fragment_brush = FRAGMENT_PROGRAM_BRUSH_LINEAR;
         } else {
             glEnable(GL_TEXTURE_GEN_S);
             glEnable(GL_TEXTURE_1D);
         }
     } else {
         if (use_fragment_programs) {
             if (current_style == Qt::RadialGradientPattern)
                 fragment_brush = FRAGMENT_PROGRAM_BRUSH_RADIAL;
             else if (current_style == Qt::ConicalGradientPattern)
                 fragment_brush = FRAGMENT_PROGRAM_BRUSH_CONICAL;
             else if (current_style == Qt::SolidPattern)
                 fragment_brush = FRAGMENT_PROGRAM_BRUSH_SOLID;
             else if (current_style == Qt::TexturePattern && !brush.texture().isQBitmap())
                 fragment_brush = FRAGMENT_PROGRAM_BRUSH_TEXTURE;
             else
                 fragment_brush = FRAGMENT_PROGRAM_BRUSH_PATTERN;
         }
     }
 #endif
 }

◆ setInvMatrixData()

void QOpenGLPaintEnginePrivate::setInvMatrixData ( const QTransform & inv_matrix )

Definition at line 1542 of file qpaintengine_opengl.cpp.

 {
     inv_matrix_data[0][0] = inv_matrix.m11();
     inv_matrix_data[1][0] = inv_matrix.m21();
     inv_matrix_data[2][0] = inv_matrix.m31();
 
     inv_matrix_data[0][1] = inv_matrix.m12();
     inv_matrix_data[1][1] = inv_matrix.m22();
     inv_matrix_data[2][1] = inv_matrix.m32();
 
     inv_matrix_data[0][2] = inv_matrix.m13();
     inv_matrix_data[1][2] = inv_matrix.m23();
     inv_matrix_data[2][2] = inv_matrix.m33();
 }

◆ setPorterDuffData()

void QOpenGLPaintEnginePrivate::setPorterDuffData	(	float	a,
		float	b,
		float	x,
		float	y,
		float	z
	)

Definition at line 2478 of file qpaintengine_opengl.cpp.

 {
     porterduff_ab_data[0] = a;
     porterduff_ab_data[1] = b;
 
     porterduff_xyz_data[0] = x;
     porterduff_xyz_data[1] = y;
     porterduff_xyz_data[2] = z;
 }

◆ strokeLines()

void QOpenGLPaintEnginePrivate::strokeLines ( const QPainterPath & path )

Definition at line 3934 of file qpaintengine_opengl.cpp.

 {
     DEBUG_ONCE_STR("QOpenGLPaintEnginePrivate::strokeLines()");
 
     qreal penWidth = cpen.widthF();
 
     GLuint program = qt_gl_program_cache()->getProgram(device->context(),
                                                        FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
     QGLLineMaskGenerator maskGenerator(path, matrix, penWidth == 0 ? 1.0 : penWidth,
                                        offscreen, program);
 
     disableClipping();
 
     QBrush temp = cbrush;
     QPointF origin = brush_origin;
 
     cbrush = cpen.brush();
     brush_origin = QPointF();
 
     addItem(qt_mask_texture_cache()->getMask(maskGenerator, this));
 
     cbrush = temp;
     brush_origin = origin;
 
     enableClipping();
 }

◆ strokePath()

void QOpenGLPaintEnginePrivate::strokePath	(	const QPainterPath &	path,
		bool	use_cache
	)

Definition at line 3963 of file qpaintengine_opengl.cpp.

 {
     QBrush old_brush = cbrush;
     cbrush = cpen.brush();
 
     qreal txscale = 1;
     if (cpen.isCosmetic() || (qt_scaleForTransform(matrix, &txscale) && txscale != 1)) {
         QTransform temp = matrix;
         matrix = QTransform();
         glPushMatrix();
 
         if (has_antialiasing) {
             glLoadIdentity();
         } else {
             float offs_matrix[] =
               { 1, 0, 0, 0,
                 0, 1, 0, 0,
                 0, 0, 1, 0,
                 0.5, 0.5, 0, 1 };
             glLoadMatrixf(offs_matrix);
         }
 
         QPen pen = cpen;
         if (txscale != 1)
             pen.setWidthF(pen.widthF() * txscale);
         if (use_cache)
             fillPath(qt_opengl_stroke_cache()->getStrokedPath(temp.map(path), pen));
         else
             fillPath(strokeForPath(temp.map(path), pen));
 
         glPopMatrix();
         matrix = temp;
     } else if (use_cache) {
         fillPath(qt_opengl_stroke_cache()->getStrokedPath(path, cpen));
     } else {
         fillPath(strokeForPath(path, cpen));
     }
 
     cbrush = old_brush;
 }

◆ strokePathFastPen()

void QOpenGLPaintEnginePrivate::strokePathFastPen	(	const QPainterPath &	path,
		bool	needsResolving
	)

Definition at line 4004 of file qpaintengine_opengl.cpp.

 {
 #ifndef QT_OPENGL_ES
     QRectF bounds;
     if (needsResolving)
         bounds = path.controlPointRect();
     setGradientOps(cpen.brush(), bounds);
 
     QBezier beziers[32];
     for (int i=0; i<path.elementCount(); ++i) {
         const QPainterPath::Element &e = path.elementAt(i);
         switch (e.type) {
         case QPainterPath::MoveToElement:
             if (i != 0)
                 glEnd(); // GL_LINE_STRIP
             glBegin(GL_LINE_STRIP);
             glVertex2d(e.x, e.y);
 
             break;
         case QPainterPath::LineToElement:
             glVertex2d(e.x, e.y);
             break;
 
         case QPainterPath::CurveToElement:
         {
             QPointF sp = path.elementAt(i-1);
             QPointF cp2 = path.elementAt(i+1);
             QPointF ep = path.elementAt(i+2);
             i+=2;
 
             qreal inverseScaleHalf = inverseScale / 2;
             beziers[0] = QBezier::fromPoints(sp, e, cp2, ep);
             QBezier *b = beziers;
             while (b >= beziers) {
                 // check if we can pop the top bezier curve from the stack
                 qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
                 qreal d;
                 if (l > inverseScale) {
                     d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2)
                               - (b->y4 - b->y1)*(b->x1 - b->x2) )
                         + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3)
                                 - (b->y4 - b->y1)*(b->x1 - b->x3) );
                     d /= l;
                 } else {
                     d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
                         qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
                 }
                 if (d < inverseScaleHalf || b == beziers + 31) {
                     // good enough, we pop it off and add the endpoint
                     glVertex2d(b->x4, b->y4);
                     --b;
                 } else {
                     // split, second half of the polygon goes lower into the stack
                     b->split(b+1, b);
                     ++b;
                 }
             }
         } // case CurveToElement
         default:
             break;
         } // end of switch
     }
     glEnd(); // GL_LINE_STRIP
 #else
     // have to use vertex arrays on embedded
     QRectF bounds;
     if (needsResolving)
         bounds = path.controlPointRect();
     setGradientOps(cpen.brush(), bounds);
 
     glEnableClientState(GL_VERTEX_ARRAY);
     tess_points.reset();
     QBezier beziers[32];
     for (int i=0; i<path.elementCount(); ++i) {
         const QPainterPath::Element &e = path.elementAt(i);
         switch (e.type) {
         case QPainterPath::MoveToElement:
             if (i != 0) {
                 glVertexPointer(2, GL_FLOAT, 0, tess_points.data());
                 glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
                 tess_points.reset();
             }
             tess_points.add(QPointF(e.x, e.y));
 
             break;
         case QPainterPath::LineToElement:
             tess_points.add(QPointF(e.x, e.y));
             break;
 
         case QPainterPath::CurveToElement:
         {
             QPointF sp = path.elementAt(i-1);
             QPointF cp2 = path.elementAt(i+1);
             QPointF ep = path.elementAt(i+2);
             i+=2;
 
             qreal inverseScaleHalf = inverseScale / 2;
             beziers[0] = QBezier::fromPoints(sp, e, cp2, ep);
             QBezier *b = beziers;
             while (b >= beziers) {
                 // check if we can pop the top bezier curve from the stack
                 qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
                 qreal d;
                 if (l > inverseScale) {
                     d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2)
                               - (b->y4 - b->y1)*(b->x1 - b->x2) )
                         + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3)
                                 - (b->y4 - b->y1)*(b->x1 - b->x3) );
                     d /= l;
                 } else {
                     d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
                         qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
                 }
                 if (d < inverseScaleHalf || b == beziers + 31) {
                     // good enough, we pop it off and add the endpoint
                     tess_points.add(QPointF(b->x4, b->y4));
                     --b;
                 } else {
                     // split, second half of the polygon goes lower into the stack
                     b->split(b+1, b);
                     ++b;
                 }
             }
         } // case CurveToElement
         default:
             break;
         } // end of switch
     }
     glVertexPointer(2, GL_FLOAT, 0, tess_points.data());
     glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
     glDisableClientState(GL_VERTEX_ARRAY);
 #endif
 }

◆ systemStateChanged()

void QOpenGLPaintEnginePrivate::systemStateChanged ( )

virtual

Reimplemented from QPaintEnginePrivate.

Definition at line 2338 of file qpaintengine_opengl.cpp.

 {
     Q_Q(QOpenGLPaintEngine);
     if (q->painter()->hasClipping())
         q->updateClipRegion(q->painter()->clipRegion(), Qt::ReplaceClip);
     else
         q->updateClipRegion(QRegion(), Qt::NoClip);
 }

◆ updateDepthClip()

void QOpenGLPaintEnginePrivate::updateDepthClip ( )

Definition at line 2246 of file qpaintengine_opengl.cpp.

 {
     Q_Q(QOpenGLPaintEngine);
 
     ++q->state()->depthClipId;
 
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);
 
     if (!q->state()->hasClipping)
         return;
 
     QRect fastClip;
     if (q->state()->clipEnabled) {
         fastClip = q->state()->fastClip;
     } else if (use_system_clip && q->systemClip().rects().count() == 1) {
         fastClip = q->systemClip().rects().at(0);
     }
 
     if (!fastClip.isEmpty()) {
         glEnable(GL_SCISSOR_TEST);
 
         const int left = fastClip.left();
         const int width = fastClip.width();
         const int bottom = device->size().height() - (fastClip.bottom() + 1);
         const int height = fastClip.height();
 
         glScissor(left, bottom, width, height);
         return;
     }
 
 #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2)
     glClearDepthf(0.0f);
 #else
     glClearDepth(0.0f);
 #endif
 
     glEnable(GL_DEPTH_TEST);
     glDepthMask(GL_TRUE);
     glClear(GL_DEPTH_BUFFER_BIT);
 
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
     glDepthFunc(GL_ALWAYS);
 
     const QVector<QRect> rects = q->state()->clipEnabled ? q->state()->clipRegion.rects() : q->systemClip().rects();
 
     // rectangle count * 2 (triangles) * vertex count * component count (Z omitted)
     QDataBuffer<GLfloat> clipVertex(rects.size()*2*3*2);
     for (int i = 0; i < rects.size(); ++i) {
         GLfloat x = GLfloat(rects.at(i).left());
         GLfloat w = GLfloat(rects.at(i).width());
         GLfloat h = GLfloat(rects.at(i).height());
         GLfloat y = GLfloat(rects.at(i).top());
 
         // First triangle
         clipVertex.add(x);
         clipVertex.add(y);
 
         clipVertex.add(x);
         clipVertex.add(y + h);
 
         clipVertex.add(x + w);
         clipVertex.add(y);
 
         // Second triangle
         clipVertex.add(x);
         clipVertex.add(y + h);
 
         clipVertex.add(x + w);
         clipVertex.add(y + h);
 
         clipVertex.add (x + w);
         clipVertex.add(y);
     }
 
     if (rects.size()) {
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
 
         glEnableClientState(GL_VERTEX_ARRAY);
         glVertexPointer(2, GL_FLOAT, 0, clipVertex.data());
 
         glDrawArrays(GL_TRIANGLES, 0, rects.size()*2*3);
         glDisableClientState(GL_VERTEX_ARRAY);
         updateGLMatrix();
     }
 
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glDepthMask(GL_FALSE);
     glDepthFunc(GL_LEQUAL);
 }

◆ updateFastPen()

void QOpenGLPaintEnginePrivate::updateFastPen ( )

inline

Definition at line 721 of file qpaintengine_opengl.cpp.

                                 {
         qreal pen_width = cpen.widthF();
         has_fast_pen =
             ((pen_width == 0 || (pen_width <= 1 && matrix.type() <= QTransform::TxTranslate))
              || cpen.isCosmetic())
             && cpen.style() == Qt::SolidLine
             && cpen.isSolid();
 
     }

◆ updateFragmentProgramData()

void QOpenGLPaintEnginePrivate::updateFragmentProgramData ( int locations[] )

Definition at line 5078 of file qpaintengine_opengl.cpp.

 {
 #ifdef Q_WS_QWS
     Q_UNUSED(locations);
 #else
     QGL_FUNC_CONTEXT;
 
     QSize sz = offscreen.offscreenSize();
 
     float inv_mask_size_data[4] = { 1.0f / sz.width(), 1.0f / sz.height(), 0.0f, 0.0f };
 
     sz = drawable_texture_size;
 
     float inv_dst_size_data[4] = { 1.0f / sz.width(), 1.0f / sz.height(), 0.0f, 0.0f };
 
     // default inv size 0.125f == 1.0f / 8.0f for pattern brushes
     float inv_brush_texture_size_data[4] = { 0.125f, 0.125f };
 
     // texture patterns have their own size
     if (current_style == Qt::TexturePattern) {
         QSize sz = cbrush.texture().size();
 
         inv_brush_texture_size_data[0] = 1.0f / sz.width();
         inv_brush_texture_size_data[1] = 1.0f / sz.height();
     }
 
     for (unsigned int i = 0; i < num_fragment_variables; ++i) {
         int location = locations[i];
 
         if (location < 0)
             continue;
 
         switch (i) {
         case VAR_ANGLE:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, angle_data);
             break;
         case VAR_LINEAR:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, linear_data);
             break;
         case VAR_FMP:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, fmp_data);
             break;
         case VAR_FMP2_M_RADIUS2:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, fmp2_m_radius2_data);
             break;
         case VAR_INV_MASK_SIZE:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_mask_size_data);
             break;
         case VAR_INV_DST_SIZE:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_dst_size_data);
             break;
         case VAR_INV_MATRIX_M0:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[0]);
             break;
         case VAR_INV_MATRIX_M1:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[1]);
             break;
         case VAR_INV_MATRIX_M2:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[2]);
             break;
         case VAR_PORTERDUFF_AB:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, porterduff_ab_data);
             break;
         case VAR_PORTERDUFF_XYZ:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, porterduff_xyz_data);
             break;
         case VAR_INV_BRUSH_TEXTURE_SIZE:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_brush_texture_size_data);
             break;
         case VAR_MASK_OFFSET:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, mask_offset_data);
             break;
         case VAR_MASK_CHANNEL:
             glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, mask_channel_data);
             break;
         case VAR_DST_TEXTURE:
         case VAR_MASK_TEXTURE:
         case VAR_PALETTE:
         case VAR_BRUSH_TEXTURE:
             // texture variables, not handled here
             break;
         default:
             qDebug() << "QOpenGLPaintEnginePrivate: Unhandled fragment variable:" << i;
         }
     }
 #endif
 }

◆ updateGLMatrix()

void QOpenGLPaintEnginePrivate::updateGLMatrix ( ) const

Definition at line 2218 of file qpaintengine_opengl.cpp.

Referenced by QOpenGLCoordinateOffset::enableOffset().

 {
     glMatrixMode(GL_MODELVIEW);
 #ifndef QT_OPENGL_ES
     glLoadMatrixd(&mv_matrix[0][0]);
 #else
     glLoadMatrixf(&mv_matrix[0][0]);
 #endif
 }

◆ updateGradient()

void QOpenGLPaintEnginePrivate::updateGradient	(	const QBrush &	brush,
		const QRectF &	bounds
	)

Definition at line 1558 of file qpaintengine_opengl.cpp.

 {
 #ifdef QT_OPENGL_ES
     Q_UNUSED(brush);
 #else
     bool has_mirrored_repeat = QGLExtensions::glExtensions() & QGLExtensions::MirroredRepeat;
     Qt::BrushStyle style = brush.style();
 
     if (has_mirrored_repeat && style == Qt::LinearGradientPattern) {
         const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
         QTransform m = brush.transform();
         QPointF realStart = g->start();
         QPointF realFinal = g->finalStop();
         QPointF start = m.map(realStart);
         QPointF stop;
 
         if (qFuzzyCompare(m.m11(), m.m22()) && m.m12() == 0.0 && m.m21() == 0.0) {
             // It is a simple uniform scale and/or translation
             stop = m.map(realFinal);
         } else {
             // It is not enough to just transform the endpoints.
             // We have to make sure the _pattern_ is transformed correctly.
 
             qreal odx = realFinal.x() - realStart.x();
             qreal ody = realFinal.y() - realStart.y();
 
             // nx, ny and dx, dy are normal and gradient direction after transform:
             qreal nx = m.m11()*ody - m.m21()*odx;
             qreal ny = m.m12()*ody - m.m22()*odx;
 
             qreal dx = m.m11()*odx + m.m21()*ody;
             qreal dy = m.m12()*odx + m.m22()*ody;
 
             qreal lx = 1 / (dx - dy*nx/ny);
             qreal ly = 1 / (dy - dx*ny/nx);
             qreal l = 1 / qSqrt(lx*lx+ly*ly);
 
             stop = start + QPointF(-ny, nx) * l/qSqrt(nx*nx+ny*ny);
         }
 
         float tr[4], f;
         tr[0] = stop.x() - start.x();
         tr[1] = stop.y() - start.y();
         f = 1.0 / (tr[0]*tr[0] + tr[1]*tr[1]);
         tr[0] *= f;
         tr[1] *= f;
         tr[2] = 0;
         tr[3] = -(start.x()*tr[0] + start.y()*tr[1]);
         brush_color[0] = brush_color[1] = brush_color[2] = brush_color[3] = 255;
         qt_glColor4ubv(brush_color);
         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
         glTexGenfv(GL_S, GL_OBJECT_PLANE, tr);
     }
 
     if (use_fragment_programs) {
         if (style == Qt::RadialGradientPattern) {
             const QRadialGradient *g = static_cast<const QRadialGradient *>(brush.gradient());
             QPointF realCenter = g->center();
             QPointF realFocal  = g->focalPoint();
             qreal   realRadius = g->radius();
             QTransform translate(1, 0, 0, 1, -realFocal.x(), -realFocal.y());
             QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
             QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
             QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
 
             setInvMatrixData(inv_matrix);
 
             fmp_data[0] = realCenter.x() - realFocal.x();
             fmp_data[1] = realCenter.y() - realFocal.y();
 
             fmp2_m_radius2_data[0] = -fmp_data[0] * fmp_data[0] - fmp_data[1] * fmp_data[1] + realRadius * realRadius;
         } else if (style == Qt::ConicalGradientPattern) {
             const QConicalGradient *g = static_cast<const QConicalGradient *>(brush.gradient());
             QPointF realCenter = g->center();
             QTransform translate(1, 0, 0, 1, -realCenter.x(), -realCenter.y());
             QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
             QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
             QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
 
             setInvMatrixData(inv_matrix);
 
             angle_data[0] = -(g->angle() * 2 * Q_PI) / 360.0;
         } else if (style == Qt::LinearGradientPattern) {
             const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
 
             QPointF realStart = g->start();
             QPointF realFinal = g->finalStop();
             QTransform translate(1, 0, 0, 1, -realStart.x(), -realStart.y());
             QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
             QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
             QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
 
             setInvMatrixData(inv_matrix);
 
             QPointF l = realFinal - realStart;
 
             linear_data[0] = l.x();
             linear_data[1] = l.y();
 
             linear_data[2] = 1.0f / (l.x() * l.x() + l.y() * l.y());
         } else if (style != Qt::SolidPattern) {
             QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
             QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
             QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted();
 
             setInvMatrixData(inv_matrix);
         }
     }
 
     if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
         createGradientPaletteTexture(*brush.gradient());
     }
 #endif
 }

◆ updateUseEmulation()

void QOpenGLPaintEnginePrivate::updateUseEmulation ( )

Definition at line 2131 of file qpaintengine_opengl.cpp.

 {
     use_emulation = (!use_fragment_programs
                      && ((has_pen && needsEmulation(pen_brush_style))
                          || (has_brush && needsEmulation(brush_style))))
                     || (has_pen && qt_isExtendedRadialGradient(cpen.brush()))
                     || (has_brush && qt_isExtendedRadialGradient(cbrush));
 }

Friends and Related Functions

◆ QGLMaskTextureCache

friend class QGLMaskTextureCache

friend

Definition at line 849 of file qpaintengine_opengl.cpp.

Properties

◆ angle_data

float QOpenGLPaintEnginePrivate::angle_data[4]

Definition at line 810 of file qpaintengine_opengl.cpp.

◆ brush_color

GLubyte QOpenGLPaintEnginePrivate::brush_color[4]

Definition at line 765 of file qpaintengine_opengl.cpp.

◆ brush_origin

QPointF QOpenGLPaintEnginePrivate::brush_origin

Definition at line 738 of file qpaintengine_opengl.cpp.

◆ brush_style

Qt::BrushStyle QOpenGLPaintEnginePrivate::brush_style

Definition at line 737 of file qpaintengine_opengl.cpp.

◆ cbrush

QBrush QOpenGLPaintEnginePrivate::cbrush

Definition at line 736 of file qpaintengine_opengl.cpp.

◆ composition_mode

QPainter::CompositionMode QOpenGLPaintEnginePrivate::composition_mode

Definition at line 741 of file qpaintengine_opengl.cpp.

◆ cpen

QPen QOpenGLPaintEnginePrivate::cpen

Definition at line 735 of file qpaintengine_opengl.cpp.

◆ current_style

Qt::BrushStyle QOpenGLPaintEnginePrivate::current_style

Definition at line 743 of file qpaintengine_opengl.cpp.

◆ device

QGLPaintDevice* QOpenGLPaintEnginePrivate::device

Definition at line 767 of file qpaintengine_opengl.cpp.

◆ dirty_drawable_texture

uint QOpenGLPaintEnginePrivate::dirty_drawable_texture

Definition at line 749 of file qpaintengine_opengl.cpp.

◆ dirty_stencil

QRegion QOpenGLPaintEnginePrivate::dirty_stencil

Definition at line 759 of file qpaintengine_opengl.cpp.

◆ drawable_texture

GLuint QOpenGLPaintEnginePrivate::drawable_texture

Definition at line 843 of file qpaintengine_opengl.cpp.

◆ drawable_texture_size

QSize QOpenGLPaintEnginePrivate::drawable_texture_size

Definition at line 844 of file qpaintengine_opengl.cpp.

◆ drawQueue

QList<QDrawQueueItem> QOpenGLPaintEnginePrivate::drawQueue

Definition at line 841 of file qpaintengine_opengl.cpp.

◆ fmp2_m_radius2_data

float QOpenGLPaintEnginePrivate::fmp2_m_radius2_data[4]

Definition at line 809 of file qpaintengine_opengl.cpp.

◆ fmp_data

float QOpenGLPaintEnginePrivate::fmp_data[4]

Definition at line 808 of file qpaintengine_opengl.cpp.

◆ fragment_brush

FragmentBrushType QOpenGLPaintEnginePrivate::fragment_brush

Definition at line 819 of file qpaintengine_opengl.cpp.

◆ fragment_composition_mode

FragmentCompositionModeType QOpenGLPaintEnginePrivate::fragment_composition_mode

Definition at line 820 of file qpaintengine_opengl.cpp.

◆ grad_palette

GLuint QOpenGLPaintEnginePrivate::grad_palette

Definition at line 802 of file qpaintengine_opengl.cpp.

◆ has_antialiasing

uint QOpenGLPaintEnginePrivate::has_antialiasing

Definition at line 753 of file qpaintengine_opengl.cpp.

Referenced by QOpenGLCoordinateOffset::disableOffset(), and QOpenGLCoordinateOffset::enableOffset().

◆ has_brush

uint QOpenGLPaintEnginePrivate::has_brush

Definition at line 746 of file qpaintengine_opengl.cpp.

◆ has_fast_composition_mode

uint QOpenGLPaintEnginePrivate::has_fast_composition_mode

Definition at line 754 of file qpaintengine_opengl.cpp.

◆ has_fast_pen

uint QOpenGLPaintEnginePrivate::has_fast_pen

Definition at line 747 of file qpaintengine_opengl.cpp.

◆ has_pen

uint QOpenGLPaintEnginePrivate::has_pen

Definition at line 745 of file qpaintengine_opengl.cpp.

◆ has_stencil_face_ext

uint QOpenGLPaintEnginePrivate::has_stencil_face_ext

Definition at line 750 of file qpaintengine_opengl.cpp.

◆ high_quality_antialiasing

uint QOpenGLPaintEnginePrivate::high_quality_antialiasing

Definition at line 752 of file qpaintengine_opengl.cpp.

◆ inv_matrix_data

float QOpenGLPaintEnginePrivate::inv_matrix_data[3][4]

Definition at line 807 of file qpaintengine_opengl.cpp.

◆ inverseScale

qreal QOpenGLPaintEnginePrivate::inverseScale

Definition at line 770 of file qpaintengine_opengl.cpp.

◆ last_created_state

QPainterState* QOpenGLPaintEnginePrivate::last_created_state

mutable

Definition at line 799 of file qpaintengine_opengl.cpp.

◆ linear_data

float QOpenGLPaintEnginePrivate::linear_data[4]

Definition at line 811 of file qpaintengine_opengl.cpp.

◆ mask_channel_data

float QOpenGLPaintEnginePrivate::mask_channel_data[4]

Definition at line 817 of file qpaintengine_opengl.cpp.

◆ mask_fragment_programs

GLuint QOpenGLPaintEnginePrivate::mask_fragment_programs[num_fragment_masks]

Definition at line 805 of file qpaintengine_opengl.cpp.

◆ mask_offset_data

float QOpenGLPaintEnginePrivate::mask_offset_data[4]

Definition at line 816 of file qpaintengine_opengl.cpp.

◆ matrix

QTransform QOpenGLPaintEnginePrivate::matrix

Definition at line 763 of file qpaintengine_opengl.cpp.

◆ max_texture_size

int QOpenGLPaintEnginePrivate::max_texture_size

Definition at line 846 of file qpaintengine_opengl.cpp.

◆ max_x

qreal QOpenGLPaintEnginePrivate::max_x

Definition at line 825 of file qpaintengine_opengl.cpp.

◆ max_y

qreal QOpenGLPaintEnginePrivate::max_y

Definition at line 826 of file qpaintengine_opengl.cpp.

◆ min_x

qreal QOpenGLPaintEnginePrivate::min_x

Definition at line 827 of file qpaintengine_opengl.cpp.

◆ min_y

qreal QOpenGLPaintEnginePrivate::min_y

Definition at line 828 of file qpaintengine_opengl.cpp.

◆ moveToCount

int QOpenGLPaintEnginePrivate::moveToCount

Definition at line 772 of file qpaintengine_opengl.cpp.

◆ mv_matrix

GLdouble QOpenGLPaintEnginePrivate::mv_matrix[4][4]

Definition at line 838 of file qpaintengine_opengl.cpp.

Referenced by QOpenGLCoordinateOffset::disableOffset(), and QOpenGLCoordinateOffset::enableOffset().

◆ offscreen

QGLOffscreen QOpenGLPaintEnginePrivate::offscreen

Definition at line 768 of file qpaintengine_opengl.cpp.

◆ opacity

qreal QOpenGLPaintEnginePrivate::opacity

Definition at line 740 of file qpaintengine_opengl.cpp.

◆ painter_fragment_programs

GLuint QOpenGLPaintEnginePrivate::painter_fragment_programs[num_fragment_brushes][num_fragment_composition_modes]

Definition at line 804 of file qpaintengine_opengl.cpp.

◆ path_start

QPointF QOpenGLPaintEnginePrivate::path_start

Definition at line 773 of file qpaintengine_opengl.cpp.

◆ pen_brush_style

Qt::BrushStyle QOpenGLPaintEnginePrivate::pen_brush_style

Definition at line 739 of file qpaintengine_opengl.cpp.

◆ pen_color

GLubyte QOpenGLPaintEnginePrivate::pen_color[4]

Definition at line 764 of file qpaintengine_opengl.cpp.

◆ porterduff_ab_data

float QOpenGLPaintEnginePrivate::porterduff_ab_data[4]

Definition at line 813 of file qpaintengine_opengl.cpp.

◆ porterduff_xyz_data

float QOpenGLPaintEnginePrivate::porterduff_xyz_data[4]

Definition at line 814 of file qpaintengine_opengl.cpp.

◆ projection_matrix

GLdouble QOpenGLPaintEnginePrivate::projection_matrix[4][4]

Definition at line 833 of file qpaintengine_opengl.cpp.

◆ ref_cleaner

QGLPrivateCleanup QOpenGLPaintEnginePrivate::ref_cleaner

Definition at line 848 of file qpaintengine_opengl.cpp.

◆ shader_ctx

QGLContext* QOpenGLPaintEnginePrivate::shader_ctx

Definition at line 801 of file qpaintengine_opengl.cpp.

◆ tess_points

QDataBuffer<QPointF> QOpenGLPaintEnginePrivate::tess_points

Definition at line 830 of file qpaintengine_opengl.cpp.

◆ tess_points_stops

QVector<int> QOpenGLPaintEnginePrivate::tess_points_stops

Definition at line 831 of file qpaintengine_opengl.cpp.

◆ txop

QTransform::TransformationType QOpenGLPaintEnginePrivate::txop

Definition at line 766 of file qpaintengine_opengl.cpp.

◆ use_emulation

uint QOpenGLPaintEnginePrivate::use_emulation

Definition at line 757 of file qpaintengine_opengl.cpp.

◆ use_fragment_programs

uint QOpenGLPaintEnginePrivate::use_fragment_programs

Definition at line 751 of file qpaintengine_opengl.cpp.

◆ use_smooth_pixmap_transform

uint QOpenGLPaintEnginePrivate::use_smooth_pixmap_transform

Definition at line 755 of file qpaintengine_opengl.cpp.

◆ use_stencil_method

uint QOpenGLPaintEnginePrivate::use_stencil_method

Definition at line 748 of file qpaintengine_opengl.cpp.

◆ use_system_clip

uint QOpenGLPaintEnginePrivate::use_system_clip

Definition at line 756 of file qpaintengine_opengl.cpp.

The documentation for this class was generated from the following file:

/src/opengl/qpaintengine_opengl.cpp

Public Functions

Public Variables

Friends

Detailed Description

Constructors and Destructors

◆ QOpenGLPaintEnginePrivate()

Functions

◆ addItem()

◆ cacheItemErased()

◆ cleanupGLContextRefs()

◆ composite() [1/2]

◆ composite() [2/2]

◆ copyDrawable()

◆ createFragmentPrograms()

◆ createGradientPaletteTexture()

◆ curveToStencil()

◆ deleteFragmentPrograms()

◆ disableClipping()

◆ drawFastRect()

◆ drawImageAsPath()

◆ drawItem()

◆ drawOffscreenPath()

◆ drawTiledImageAsPath()

◆ drawVertexArrays()

◆ enableClipping()

◆ ensureDrawableTexture()

◆ fillPath()

◆ fillPolygon_dev()

◆ fillVertexArray()

◆ flushDrawQueue()

◆ isFastRect()

◆ lineToStencil()

◆ pathToVertexArrays()

◆ setGLBrush()

◆ setGLPen()

◆ setGradientOps()

◆ setInvMatrixData()

◆ setPorterDuffData()

◆ strokeLines()

◆ strokePath()

◆ strokePathFastPen()

◆ systemStateChanged()

◆ updateDepthClip()

◆ updateFastPen()

◆ updateFragmentProgramData()

◆ updateGLMatrix()

◆ updateGradient()

◆ updateUseEmulation()

Friends and Related Functions

◆ QGLMaskTextureCache

Properties

◆ angle_data

◆ brush_color

◆ brush_origin

◆ brush_style

◆ cbrush

◆ composition_mode

◆ cpen

◆ current_style

◆ device

◆ dirty_drawable_texture

◆ dirty_stencil

◆ drawable_texture

◆ drawable_texture_size

◆ drawQueue

◆ fmp2_m_radius2_data

◆ fmp_data

◆ fragment_brush

◆ fragment_composition_mode

◆ grad_palette

◆ has_antialiasing

◆ has_brush

◆ has_fast_composition_mode

◆ has_fast_pen

◆ has_pen

◆ has_stencil_face_ext

◆ high_quality_antialiasing

◆ inv_matrix_data

◆ inverseScale

◆ last_created_state