FCL/sf/mw/qt: comparison src/opengl/qpaintengine

equal deleted inserted replaced

-:93b982ccede2
+:5daf16870df6
 #include "qvarlengtharray.h"
 #include <private/qpainter_p.h>
 #include <private/qglpixelbuffer_p.h>
 #include <private/qbezier_p.h>
 #include <qglframebufferobject.h>
+#include <private/qstatictext_p.h>
 #include "private/qtessellator_p.h"
 #include "util/fragmentprograms_p.h"
 #ifdef Q_WS_QWS
 #include "private/qglwindowsurface_qws_p.h"
 #include "qwsmanager_qws.h"
 #include "private/qwsmanager_p.h"
-#endif
-#ifdef QT_OPENGL_ES_1_CL
-#include "qgl_cl_p.h"
 #endif
 #define QGL_FUNC_CONTEXT QGLContext *ctx = const_cast<QGLContext *>(device->context());
 #include <stdlib.h>
 , inverseScale(1)
 , moveToCount(0)
 , last_created_state(0)
 , shader_ctx(0)
 , grad_palette(0)
+, tess_points(0)
 , drawable_texture(0)
 , ref_cleaner(this)
 {}
 inline void setGLPen(const QColor &c) {
 void drawTiledImageAsPath(const QRectF &r, const QImage &img, qreal sx, qreal sy, const QPointF &offset);
 void drawOffscreenPath(const QPainterPath &path);
 void composite(const QRectF &rect, const QPoint &maskOffset = QPoint());
-void composite(GLuint primitive, const q_vertexType *vertexArray, int vertexCount, const QPoint &maskOffset = QPoint());
+void composite(GLuint primitive, const GLfloat *vertexArray, int vertexCount, const QPoint &maskOffset = QPoint());
 bool createFragmentPrograms();
 void deleteFragmentPrograms();
 void updateFragmentProgramData(int locations[]);
 }
 #endif
 d->device->endPaint();
 qt_mask_texture_cache()->maintainCache();
+#if defined(Q_WS_X11)
+// clear out the references we hold for textures bound with the
+// texture_from_pixmap extension
+ctx->d_func()->boundPixmaps.clear();
+#endif
 return true;
 }
 void QOpenGLPaintEngine::updateState(const QPaintEngineState &state)
 {
 class QOpenGLTrapezoidToArrayTessellator : public QOpenGLTessellator
 {
 public:
 QOpenGLTrapezoidToArrayTessellator() : vertices(0), allocated(0), size(0) {}
 ~QOpenGLTrapezoidToArrayTessellator() { free(vertices); }
-q_vertexType *vertices;
+GLfloat *vertices;
 int allocated;
 int size;
 QRectF bounds;
 void addTrap(const Trapezoid &trap);
 void tessellate(const QPointF *points, int nPoints, bool winding) {
 if (size > allocated - 8) {
 #else
 if (size > allocated - 12) {
 #endif
 allocated = qMax(2*allocated, 512);
-vertices = (q_vertexType *)realloc(vertices, allocated * sizeof(q_vertexType));
+vertices = (GLfloat *)realloc(vertices, allocated * sizeof(GLfloat));
 }
 QGLTrapezoid t = toGLTrapezoid(trap);
 #ifndef QT_OPENGL_ES
-vertices[size++] = f2vt(t.topLeftX);
+vertices[size++] = t.topLeftX;
-vertices[size++] = f2vt(t.top);
+vertices[size++] = t.top;
-vertices[size++] = f2vt(t.topRightX);
+vertices[size++] = t.topRightX;
-vertices[size++] = f2vt(t.top);
+vertices[size++] = t.top;
-vertices[size++] = f2vt(t.bottomRightX);
+vertices[size++] = t.bottomRightX;
-vertices[size++] = f2vt(t.bottom);
+vertices[size++] = t.bottom;
-vertices[size++] = f2vt(t.bottomLeftX);
+vertices[size++] = t.bottomLeftX;
-vertices[size++] = f2vt(t.bottom);
+vertices[size++] = t.bottom;
 #else
 // First triangle
-vertices[size++] = f2vt(t.topLeftX);
+vertices[size++] = t.topLeftX;
-vertices[size++] = f2vt(t.top);
+vertices[size++] = t.top;
-vertices[size++] = f2vt(t.topRightX);
+vertices[size++] = t.topRightX;
-vertices[size++] = f2vt(t.top);
+vertices[size++] = t.top;
-vertices[size++] = f2vt(t.bottomRightX);
+vertices[size++] = t.bottomRightX;
-vertices[size++] = f2vt(t.bottom);
+vertices[size++] = t.bottom;
 // Second triangle
-vertices[size++] = f2vt(t.bottomLeftX);
+vertices[size++] = t.bottomLeftX;
-vertices[size++] = f2vt(t.bottom);
+vertices[size++] = t.bottom;
-vertices[size++] = f2vt(t.topLeftX);
+vertices[size++] = t.topLeftX;
-vertices[size++] = f2vt(t.top);
+vertices[size++] = t.top;
-vertices[size++] = f2vt(t.bottomRightX);
+vertices[size++] = t.bottomRightX;
-vertices[size++] = f2vt(t.bottom);
+vertices[size++] = t.bottom;
 #endif
 }
 void QOpenGLPaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int pointCount,
 #endif
 if (use_fragment_programs && !(fast_style && has_fast_composition_mode)) {
 composite(geometry_mode, tessellator.vertices, tessellator.size / 2);
 } else {
-glVertexPointer(2, q_vertexTypeEnum, 0, tessellator.vertices);
+glVertexPointer(2, GL_FLOAT, 0, tessellator.vertices);
 glEnableClientState(GL_VERTEX_ARRAY);
 glDrawArrays(geometry_mode, 0, tessellator.size/2);
 glDisableClientState(GL_VERTEX_ARRAY);
 }
 }
 }
 void QOpenGLPaintEnginePrivate::drawVertexArrays()
 {
+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);
 glScissor(left, bottom, width, height);
 return;
 }
-#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2)
 glClearDepthf(0.0f);
 #else
 glClearDepth(0.0f);
 #endif
 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<q_vertexType> clipVertex(rects.size()*2*3*2);
+QDataBuffer<GLfloat> clipVertex(rects.size()*2*3*2);
 for (int i = 0; i < rects.size(); ++i) {
-q_vertexType x = i2vt(rects.at(i).left());
+GLfloat x = GLfloat(rects.at(i).left());
-q_vertexType w = i2vt(rects.at(i).width());
+GLfloat w = GLfloat(rects.at(i).width());
-q_vertexType h = i2vt(rects.at(i).height());
+GLfloat h = GLfloat(rects.at(i).height());
-q_vertexType y = i2vt(rects.at(i).top());
+GLfloat y = GLfloat(rects.at(i).top());
 // First triangle
 clipVertex.add(x);
 clipVertex.add(y);
 if (rects.size()) {
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(2, q_vertexTypeEnum, 0, clipVertex.data());
+glVertexPointer(2, GL_FLOAT, 0, clipVertex.data());
 glDrawArrays(GL_TRIANGLES, 0, rects.size()*2*3);
 glDisableClientState(GL_VERTEX_ARRAY);
 updateGLMatrix();
 }
 ,  offscreen(&offs)
 ,  maskFragmentProgram(program)
 {
 }
-extern void qt_add_rect_to_array(const QRectF &r, q_vertexType *array);
+extern void qt_add_rect_to_array(const QRectF &r, GLfloat *array);
-extern void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, q_vertexType *array);
+extern void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, GLfloat *array);
 void QGLTrapezoidMaskGenerator::drawMask(const QRect &rect)
 {
 #ifdef QT_OPENGL_ES
 Q_UNUSED(rect);
 QVector<QGLTrapezoid> trapezoids = generateTrapezoids();
 // clear mask
 glBlendFunc(GL_ZERO, GL_ZERO); // clear
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
 glEnableClientState(GL_VERTEX_ARRAY);
 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 glDisableClientState(GL_VERTEX_ARRAY);
 glBlendFunc(GL_ONE, GL_ONE); // add mask
 QTransform translate(1, 0, 0, 1, -ellipseRect.center().x(), -ellipseRect.center().y());
 QTransform gl_to_qt(1, 0, 0, -1, 0, offscreen->drawableSize().height());
 QTransform inv_matrix = gl_to_qt * matrix().inverted() * translate;
-float m[3][4] = { { inv_matrix.m11(), inv_matrix.m12(), inv_matrix.m13() },
+float m[3][4] = { { float(inv_matrix.m11()), float(inv_matrix.m12()), float(inv_matrix.m13()) },
-{ inv_matrix.m21(), inv_matrix.m22(), inv_matrix.m23() },
+{ float(inv_matrix.m21()), float(inv_matrix.m22()), float(inv_matrix.m23()) },
-{ inv_matrix.m31(), inv_matrix.m32(), inv_matrix.m33() } };
+{ float(inv_matrix.m31()), float(inv_matrix.m32()), float(inv_matrix.m33()) } };
 QPoint offs(screen_rect.left() - rect.left(), (offscreen->drawableSize().height() - screen_rect.top())
 - (offscreen->offscreenSize().height() - rect.top()));
 // last component needs to be 1.0f to avoid Nvidia bug on linux
-float ellipse_offset[4] = { offs.x(), offs.y(), 0.0f, 1.0f };
+float ellipse_offset[4] = { float(offs.x()), float(offs.y()), 0.0f, 1.0f };
 GLfloat vertexArray[4 * 2];
 qt_add_rect_to_array(rect, vertexArray);
 glBlendFunc(GL_ONE, GL_ZERO); // set mask
 glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_INV_MATRIX_M2], m[2]);
 glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_ELLIPSE_OFFSET], ellipse_offset);
 glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 glDisableClientState(GL_VERTEX_ARRAY);
 glDisable(GL_FRAGMENT_PROGRAM_ARB);
 #endif
 }
 void QOpenGLPaintEnginePrivate::drawFastRect(const QRectF &r)
 {
 Q_Q(QOpenGLPaintEngine);
 DEBUG_ONCE_STR("QOpenGLPaintEngine::drawRects(): drawing fast rect");
-q_vertexType vertexArray[10];
+GLfloat vertexArray[10];
 qt_add_rect_to_array(r, vertexArray);
 if (has_pen)
 QOpenGLCoordinateOffset::enableOffset(this);
 bool fast_style = current_style == Qt::LinearGradientPattern
 || current_style == Qt::SolidPattern;
 if (fast_style && has_fast_composition_mode) {
 glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 glDisableClientState(GL_VERTEX_ARRAY);
 } else {
 composite(r);
 }
 setGradientOps(cpen.brush(), r);
 vertexArray[8] = vertexArray[0];
 vertexArray[9] = vertexArray[1];
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
 glEnableClientState(GL_VERTEX_ARRAY);
 glDrawArrays(GL_LINE_STRIP, 0, 5);
 glDisableClientState(GL_VERTEX_ARRAY);
 } else {
 QPainterPath path;
 }
 }
 }
 }
-static void addQuadAsTriangle(q_vertexType *quad, q_vertexType *triangle)
+static void addQuadAsTriangle(GLfloat *quad, GLfloat *triangle)
 {
 triangle[0] = quad[0];
 triangle[1] = quad[1];
 triangle[2] = quad[2];
 }
 d->flushDrawQueue();
 if (d->has_fast_pen) {
-QVarLengthArray<q_vertexType> vertexArray(6 * pointCount);
+QVarLengthArray<GLfloat> vertexArray(6 * pointCount);
 glMatrixMode(GL_MODELVIEW);
 glPushMatrix();
 glLoadIdentity();
 int j = 0;
 for (int i = 0; i < pointCount; ++i) {
 QPointF mapped = d->matrix.map(points[i]);
-qreal xf = qRound(mapped.x());
+GLfloat x = GLfloat(qRound(mapped.x()));
-qreal yf = qRound(mapped.y());
+GLfloat y = GLfloat(qRound(mapped.y()));
-q_vertexType x = f2vt(xf);
-q_vertexType y = f2vt(yf);
 vertexArray[j++] = x;
-vertexArray[j++] = y - f2vt(0.5);
+vertexArray[j++] = y - 0.5f;
-vertexArray[j++] = x + f2vt(1.5);
+vertexArray[j++] = x + 1.5f;
-vertexArray[j++] = y + f2vt(1.0);
+vertexArray[j++] = y + 1.0f;
 vertexArray[j++] = x;
-vertexArray[j++] = y + f2vt(1.0);
+vertexArray[j++] = y + 1.0f;
 }
 glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
 glDrawArrays(GL_TRIANGLES, 0, pointCount*3);
 glDisableClientState(GL_VERTEX_ARRAY);
 glPopMatrix();
 Q_ASSERT(sizeof(QPointF) == 16);
 glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
 }
 else {
 Q_ASSERT(sizeof(QPointF) == 8);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
 }
 glEnableClientState(GL_VERTEX_ARRAY);
 glDrawArrays(GL_POINTS, 0, pointCount);
 glDisableClientState(GL_VERTEX_ARRAY);
 break;
 }
 }
 }
-q_vertexType endCap = f2vt(d->cpen.capStyle() == Qt::FlatCap ? 0 : 0.5);
+GLfloat endCap = d->cpen.capStyle() == Qt::FlatCap ? 0.0f : 0.5f;
 if (useRects) {
-QVarLengthArray<q_vertexType> vertexArray(12 * lineCount);
+QVarLengthArray<GLfloat> vertexArray(12 * lineCount);
-q_vertexType quad[8];
+GLfloat quad[8];
 for (int i = 0; i < lineCount; ++i) {
-q_vertexType x1 = f2vt(lines[i].x1());
+GLfloat x1 = lines[i].x1();
-q_vertexType x2 = f2vt(lines[i].x2());
+GLfloat x2 = lines[i].x2();
-q_vertexType y1 = f2vt(lines[i].y1());
+GLfloat y1 = lines[i].y1();
-q_vertexType y2 = f2vt(lines[i].y2());
+GLfloat y2 = lines[i].y2();
 if (x1 == x2) {
 if (y1 > y2)
 qSwap(y1, y2);
-quad[0] = x1 - f2vt(0.5);
+quad[0] = x1 - 0.5f;
 quad[1] = y1 - endCap;
-quad[2] = x1 + f2vt(0.5);
+quad[2] = x1 + 0.5f;
 quad[3] = y1 - endCap;
-quad[4] = x1 + f2vt(0.5);
+quad[4] = x1 + 0.5f;
 quad[5] = y2 + endCap;
-quad[6] = x1 - f2vt(0.5);
+quad[6] = x1 - 0.5f;
 quad[7] = y2 + endCap;
 } else {
 if (x1 > x2)
 qSwap(x1, x2);
 quad[0] = x1 - endCap;
-quad[1] = y1 + f2vt(0.5);
+quad[1] = y1 + 0.5f;
 quad[2] = x1 - endCap;
-quad[3] = y1 - f2vt(0.5);
+quad[3] = y1 - 0.5f;
 quad[4] = x2 + endCap;
-quad[5] = y1 - f2vt(0.5);
+quad[5] = y1 - 0.5f;
 quad[6] = x2 + endCap;
-quad[7] = y1 + f2vt(0.5);
+quad[7] = y1 + 0.5f;
 }
 addQuadAsTriangle(quad, &vertexArray[12*i]);
 }
 glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
 glDrawArrays(GL_TRIANGLES, 0, lineCount*6);
 glDisableClientState(GL_VERTEX_ARRAY);
 } else {
-QVarLengthArray<q_vertexType> vertexArray(4 * lineCount);
+QVarLengthArray<GLfloat> vertexArray(4 * lineCount);
 for (int i = 0; i < lineCount; ++i) {
 const QPointF a = lines[i].p1();
-vertexArray[4*i]   = f2vt(lines[i].x1());
+vertexArray[4*i]   = lines[i].x1();
-vertexArray[4*i+1] = f2vt(lines[i].y1());
+vertexArray[4*i+1] = lines[i].y1();
-vertexArray[4*i+2] = f2vt(lines[i].x2());
+vertexArray[4*i+2] = lines[i].x2();
-vertexArray[4*i+3] = f2vt(lines[i].y2());
+vertexArray[4*i+3] = lines[i].y2();
 }
 glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
 glDrawArrays(GL_LINES, 0, lineCount*2);
-glVertexPointer(2, q_vertexTypeEnum, 4*sizeof(q_vertexType), vertexArray.constData() + 2);
+glVertexPointer(2, GL_FLOAT, 4*sizeof(GLfloat), vertexArray.constData() + 2);
 glDrawArrays(GL_POINTS, 0, lineCount);
 glDisableClientState(GL_VERTEX_ARRAY);
 }
 } else {
 Q_ASSERT(sizeof(QPointF) == 16);
 glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
 }
 else {
 Q_ASSERT(sizeof(QPointF) == 8);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
 }
 glEnableClientState(GL_VERTEX_ARRAY);
 glDrawArrays(GL_TRIANGLE_FAN, 0, pointCount);
 glDisableClientState(GL_VERTEX_ARRAY);
 }
 if (d->has_pen) {
 if (d->has_fast_pen && !d->high_quality_antialiasing) {
 d->setGradientOps(d->cpen.brush(), bounds);
-QVarLengthArray<q_vertexType> vertexArray(pointCount*2 + 2);
+QVarLengthArray<GLfloat> vertexArray(pointCount*2 + 2);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
 int i;
 for (i=0; i<pointCount; ++i) {
-vertexArray[i*2] = f2vt(points[i].x());
+vertexArray[i*2] = points[i].x();
-vertexArray[i*2+1] = f2vt(points[i].y());
+vertexArray[i*2+1] = points[i].y();
 }
 glEnableClientState(GL_VERTEX_ARRAY);
 if (mode != PolylineMode) {
 vertexArray[i*2] = vertexArray[0];
 brush_origin = origin;
 enableClipping();
 }
-extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
+Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
 void QOpenGLPaintEnginePrivate::strokePath(const QPainterPath &path, bool use_cache)
 {
 QBrush old_brush = cbrush;
 cbrush = cpen.brush();
 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, q_vertexTypeEnum, 0, tess_points.data());
+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));
 } // case CurveToElement
 default:
 break;
 } // end of switch
 }
-glVertexPointer(2, q_vertexTypeEnum, 0, tess_points.data());
+glVertexPointer(2, GL_FLOAT, 0, tess_points.data());
 glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
 glDisableClientState(GL_VERTEX_ARRAY);
 #endif
 }
 glPushMatrix();
 glRotatef(180.0, 0.0, 1.0, 0.0);
 glRotatef(180.0, 0.0, 0.0, 1.0);
 }
-q_vertexType vertexArray[4*2];
+GLfloat vertexArray[4*2];
-q_vertexType texCoordArray[4*2];
+GLfloat texCoordArray[4*2];
 double offset_x = offset.x() / pm.width();
 double offset_y = offset.y() / pm.height();
 qt_add_rect_to_array(r, vertexArray);
 qt_add_texcoords_to_array(offset_x, offset_y,
 tc_w + offset_x, tc_h + offset_y, texCoordArray);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
-glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
 glEnableClientState(GL_VERTEX_ARRAY);
 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 x2 = sr.right();
 y1 = sr.bottom();
 y2 = sr.y();
 }
-q_vertexType vertexArray[4*2];
+GLfloat vertexArray[4*2];
-q_vertexType texCoordArray[4*2];
+GLfloat texCoordArray[4*2];
 qt_add_rect_to_array(r, vertexArray);
 qt_add_texcoords_to_array(x1, y2, x2, y1, texCoordArray);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
-glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
 glEnableClientState(GL_VERTEX_ARRAY);
 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 Q_OBJECT
 public:
 QGLGlyphCache() : QObject(0) { current_cache = 0; }
 ~QGLGlyphCache();
 QGLGlyphCoord *lookup(QFontEngine *, glyph_t);
-void cacheGlyphs(QGLContext *, const QTextItemInt &, const QVarLengthArray<glyph_t> &);
+void cacheGlyphs(QGLContext *, QFontEngine *, glyph_t *glyphs, int numGlyphs);
 void cleanCache();
 void allocTexture(int width, int height, GLuint texture);
 public slots:
 void cleanupContext(const QGLContext *);
 delete old_tex_data;
 return im;
 }
 #endif
-void QGLGlyphCache::cacheGlyphs(QGLContext *context, const QTextItemInt &ti,
+void QGLGlyphCache::cacheGlyphs(QGLContext *context, QFontEngine *fontEngine,
-const QVarLengthArray<glyph_t> &glyphs)
+glyph_t *glyphs, int numGlyphs)
 {
 QGLContextHash::const_iterator dev_it = qt_context_cache.constFind(context);
 QGLFontGlyphHash *font_cache = 0;
 const QGLContext *context_key = 0;
 } else {
 font_cache = dev_it.value();
 }
 Q_ASSERT(font_cache != 0);
-QGLFontGlyphHash::const_iterator cache_it = font_cache->constFind(ti.fontEngine);
+QGLFontGlyphHash::const_iterator cache_it = font_cache->constFind(fontEngine);
 QGLGlyphHash *cache = 0;
 if (cache_it == font_cache->constEnd()) {
 cache = new QGLGlyphHash;
-font_cache->insert(ti.fontEngine, cache);
+font_cache->insert(fontEngine, cache);
-connect(ti.fontEngine, SIGNAL(destroyed(QObject*)), SLOT(fontEngineDestroyed(QObject*)));
+connect(fontEngine, SIGNAL(destroyed(QObject*)), SLOT(fontEngineDestroyed(QObject*)));
 } else {
 cache = cache_it.value();
 }
 current_cache = cache;
 quint64 font_key = (reinterpret_cast<quint64>(context_key ? context_key : context) << 32)
-| reinterpret_cast<quint64>(ti.fontEngine);
+| reinterpret_cast<quint64>(fontEngine);
 QGLFontTexHash::const_iterator it = qt_font_textures.constFind(font_key);
 QGLFontTexture *font_tex;
 if (it == qt_font_textures.constEnd()) {
 GLuint font_texture;
 glGenTextures(1, &font_texture);
-GLint tex_height = qt_next_power_of_two(qRound(ti.ascent.toReal() + ti.descent.toReal())+2);
+GLint tex_height = qt_next_power_of_two(qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2);
 GLint tex_width = qt_next_power_of_two(tex_height*30); // ###
 GLint max_tex_size;
 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size);
 Q_ASSERT(max_tex_size > 0);
 if (tex_width > max_tex_size)
 } else {
 font_tex = it.value();
 glBindTexture(GL_TEXTURE_2D, font_tex->texture);
 }
-for (int i=0; i< glyphs.size(); ++i) {
+for (int i=0; i< numGlyphs; ++i) {
 QGLGlyphHash::const_iterator it = cache->constFind(glyphs[i]);
 if (it == cache->constEnd()) {
 // render new glyph and put it in the cache
-glyph_metrics_t metrics = ti.fontEngine->boundingBox(glyphs[i]);
+glyph_metrics_t metrics = fontEngine->boundingBox(glyphs[i]);
 int glyph_width = qRound(metrics.width.toReal())+2;
-int glyph_height = qRound(ti.ascent.toReal() + ti.descent.toReal())+2;
+int glyph_height = qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2;
 if (font_tex->x_offset + glyph_width + x_margin > font_tex->width) {
-int strip_height = qt_next_power_of_two(qRound(ti.ascent.toReal() + ti.descent.toReal())+2);
+int strip_height = qt_next_power_of_two(qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2);
 font_tex->x_offset = x_margin;
 font_tex->y_offset += strip_height;
 if (font_tex->y_offset >= font_tex->height) {
 // get hold of the old font texture
 uchar *old_tex_data = (uchar *) malloc(font_tex->width*font_tex->height*2);
 ++it;
 }
 }
 }
-QImage glyph_im(ti.fontEngine->alphaMapForGlyph(glyphs[i]));
+QImage glyph_im(fontEngine->alphaMapForGlyph(glyphs[i]));
 glyph_im = glyph_im.convertToFormat(QImage::Format_Indexed8);
 glyph_width = glyph_im.width();
 Q_ASSERT(glyph_width >= 0);
 // pad the glyph width to an even number
 if (glyph_width%2 != 0)
 void qgl_cleanup_glyph_cache(QGLContext *ctx)
 {
 qt_glyph_cache()->cleanupContext(ctx);
 }
+void QOpenGLPaintEngine::drawStaticTextItem(QStaticTextItem *textItem)
+{
+Q_D(QOpenGLPaintEngine);
+d->flushDrawQueue();
+// make sure the glyphs we want to draw are in the cache
+qt_glyph_cache()->cacheGlyphs(d->device->context(), textItem->fontEngine, textItem->glyphs,
+textItem->numGlyphs);
+d->setGradientOps(Qt::SolidPattern, QRectF()); // turns off gradient ops
+qt_glColor4ubv(d->pen_color);
+glEnable(GL_TEXTURE_2D);
+#ifdef Q_WS_QWS
+// XXX: it is necessary to disable alpha writes on GLES/embedded because we don't want
+// text rendering to update the alpha in the window surface.
+// XXX: This may not be needed as this behavior does seem to be caused by driver bug
+glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
+#endif
+// do the actual drawing
+GLfloat vertexArray[4*2];
+GLfloat texCoordArray[4*2];
+glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
+glEnableClientState(GL_VERTEX_ARRAY);
+glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+bool antialias = !(textItem->fontEngine->fontDef.styleStrategy & QFont::NoAntialias)
+				   && (d->matrix.type() > QTransform::TxTranslate);
+glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+for (int i=0; i< textItem->numGlyphs; ++i) {
+QGLGlyphCoord *g = qt_glyph_cache()->lookup(textItem->fontEngine, textItem->glyphs[i]);
+// we don't cache glyphs with no width/height
+if (!g)
+continue;
+qreal x1, x2, y1, y2;
+x1 = g->x;
+y1 = g->y;
+x2 = x1 + g->width;
+y2 = y1 + g->height;
+QPointF logical_pos((textItem->glyphPositions[i].x - g->x_offset).toReal(),
+(textItem->glyphPositions[i].y + g->y_offset).toReal());
+qt_add_rect_to_array(QRectF(logical_pos, QSizeF(g->log_width, g->log_height)), vertexArray);
+qt_add_texcoords_to_array(x1, y1, x2, y2, texCoordArray);
+glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+}
+glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+glDisableClientState(GL_VERTEX_ARRAY);
+glDisable(GL_TEXTURE_2D);
+#ifdef Q_WS_QWS
+// XXX: This may not be needed as this behavior does seem to be caused by driver bug
+glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+#endif
+}
 void QOpenGLPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
 {
 Q_D(QOpenGLPaintEngine);
 const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
 && d->pen_brush_style <= Qt::ConicalGradientPattern)) {
 QPaintEngine::drawTextItem(p, textItem);
 return;
 }
-d->flushDrawQueue();
 // add the glyphs used to the glyph texture cache
 QVarLengthArray<QFixedPoint> positions;
 QVarLengthArray<glyph_t> glyphs;
 QTransform matrix = QTransform::fromTranslate(qRound(p.x()), qRound(p.y()));
 ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
-// make sure the glyphs we want to draw are in the cache
+{
-qt_glyph_cache()->cacheGlyphs(d->device->context(), ti, glyphs);
+QStaticTextItem staticTextItem;
+staticTextItem.chars = ti.chars;
-d->setGradientOps(Qt::SolidPattern, QRectF()); // turns off gradient ops
+staticTextItem.fontEngine = ti.fontEngine;
-qt_glColor4ubv(d->pen_color);
+staticTextItem.glyphs = glyphs.data();
-glEnable(GL_TEXTURE_2D);
+staticTextItem.numChars = ti.num_chars;
+staticTextItem.numGlyphs = glyphs.size();
-#ifdef Q_WS_QWS
+staticTextItem.glyphPositions = positions.data();
-// XXX: it is necessary to disable alpha writes on GLES/embedded because we don't want
+drawStaticTextItem(&staticTextItem);
-// text rendering to update the alpha in the window surface.
+}
-// XXX: This may not be needed as this behavior does seem to be caused by driver bug
-glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
-#endif
-// do the actual drawing
-q_vertexType vertexArray[4*2];
-q_vertexType texCoordArray[4*2];
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
-glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
-glEnableClientState(GL_VERTEX_ARRAY);
-glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-bool antialias = !(ti.fontEngine->fontDef.styleStrategy & QFont::NoAntialias)
-&& (d->matrix.type() > QTransform::TxTranslate);
-glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
-glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
-for (int i=0; i< glyphs.size(); ++i) {
-QGLGlyphCoord *g = qt_glyph_cache()->lookup(ti.fontEngine, glyphs[i]);
-// we don't cache glyphs with no width/height
-if (!g)
-continue;
-qreal x1, x2, y1, y2;
-x1 = g->x;
-y1 = g->y;
-x2 = x1 + g->width;
-y2 = y1 + g->height;
-QPointF logical_pos((positions[i].x - g->x_offset).toReal(),
-(positions[i].y + g->y_offset).toReal());
-qt_add_rect_to_array(QRectF(logical_pos, QSizeF(g->log_width, g->log_height)), vertexArray);
-qt_add_texcoords_to_array(x1, y1, x2, y2, texCoordArray);
-glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-}
-glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-glDisableClientState(GL_VERTEX_ARRAY);
-glDisable(GL_TEXTURE_2D);
-#ifdef Q_WS_QWS
-// XXX: This may not be needed as this behavior does seem to be caused by driver bug
-glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-#endif
 }
 void QOpenGLPaintEngine::drawEllipse(const QRectF &rect)
 {
 {
 #ifdef Q_WS_QWS
 Q_UNUSED(rect);
 Q_UNUSED(maskOffset);
 #else
-q_vertexType vertexArray[8];
+GLfloat vertexArray[8];
 qt_add_rect_to_array(rect, vertexArray);
 composite(GL_TRIANGLE_FAN, vertexArray, 4, maskOffset);
 #endif
 }
-void QOpenGLPaintEnginePrivate::composite(GLuint primitive, const q_vertexType *vertexArray, int vertexCount, const QPoint &maskOffset)
+void QOpenGLPaintEnginePrivate::composite(GLuint primitive, const GLfloat *vertexArray, int vertexCount, const QPoint &maskOffset)
 {
 #ifdef QT_OPENGL_ES
 Q_UNUSED(primitive);
 Q_UNUSED(vertexArray);
 Q_UNUSED(vertexCount);
 q->updateCompositionMode(composition_mode);
 else {
 qreal minX = 1e9, minY = 1e9, maxX = -1e9, maxY = -1e9;
 for (int i = 0; i < vertexCount; ++i) {
-qreal x = vt2f(vertexArray[2 * i]);
+qreal x = vertexArray[2 * i];
-qreal y = vt2f(vertexArray[2 * i + 1]);
+qreal y = vertexArray[2 * i + 1];
 qreal tx, ty;
 matrix.map(x, y, &tx, &ty);
 minX = qMin(minX, tx);
 updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, use_smooth_pixmap_transform);
 }
 glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+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);

branch	GCC_SURGE
changeset 31	5daf16870df6
parent 30	5dc02b23752f
child 33	3e2da88830cd