FCL/sf/mw/qt: comparison src/opengl/gl2paintengineex/qpaintengineex_opengl2

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
 **
 ImageArrayDrawingMode
 };
 QT_BEGIN_NAMESPACE
+#define GL_STENCIL_HIGH_BIT         GLuint(0x80)
+#define QT_BRUSH_TEXTURE_UNIT       GLuint(0)
+#define QT_IMAGE_TEXTURE_UNIT       GLuint(0) //Can be the same as brush texture unit
+#define QT_MASK_TEXTURE_UNIT        GLuint(1)
+#define QT_BACKGROUND_TEXTURE_UNIT  GLuint(2)
 class QGL2PaintEngineExPrivate;
 class QOpenGL2PaintEngineState : public QPainterState
 {
 public:
 QGL2PaintEngineEx();
 ~QGL2PaintEngineEx();
 bool begin(QPaintDevice *device);
+void ensureActive();
 bool end();
-void ensureActive();
-virtual void fill(const QVectorPath &path, const QBrush &brush);
-virtual void stroke(const QVectorPath &path, const QPen &pen);
-virtual void clip(const QVectorPath &path, Qt::ClipOperation op);
 virtual void clipEnabledChanged();
 virtual void penChanged();
 virtual void brushChanged();
 virtual void brushOriginChanged();
 virtual void opacityChanged();
 virtual void compositionModeChanged();
 virtual void renderHintsChanged();
 virtual void transformChanged();
+virtual void drawTexture(const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr);
 virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+virtual void drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints hints);
 virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
 Qt::ImageConversionFlags flags = Qt::AutoColor);
-virtual void drawTexture(const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr);
 virtual void drawTextItem(const QPointF &p, const QTextItem &textItem);
+virtual void fill(const QVectorPath &path, const QBrush &brush);
-virtual void drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints hints);
+virtual void stroke(const QVectorPath &path, const QPen &pen);
+virtual void clip(const QVectorPath &path, Qt::ClipOperation op);
 Type type() const { return OpenGL2; }
-void setState(QPainterState *s);
+virtual void setState(QPainterState *s);
-QPainterState *createState(QPainterState *orig) const;
+virtual QPainterState *createState(QPainterState *orig) const;
 inline QOpenGL2PaintEngineState *state() {
 return static_cast<QOpenGL2PaintEngineState *>(QPaintEngineEx::state());
 }
 inline const QOpenGL2PaintEngineState *state() const {
 return static_cast<const QOpenGL2PaintEngineState *>(QPaintEngineEx::state());
 }
 void beginNativePainting();
 void endNativePainting();
-const QGLContext* context();
 QPixmapFilter *pixmapFilter(int type, const QPixmapFilter *prototype);
 void setRenderTextActive(bool);
 TriStripStrokeFillMode
 };
 QGL2PaintEngineExPrivate(QGL2PaintEngineEx *q_ptr) :
 q(q_ptr),
+shaderManager(0),
 width(0), height(0),
 ctx(0),
-inverseScale(1),
+useSystemClip(true),
-shaderManager(0),
+snapToPixelGrid(false),
-inRenderText(false)
+addOffset(false),
+inverseScale(1)
 { }
 ~QGL2PaintEngineExPrivate();
 void updateBrushTexture();
 void updateBrushUniforms();
 void updateMatrix();
 void updateCompositionMode();
 void updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id = -1);
-void setBrush(const QBrush& brush);
-void transferMode(EngineMode newMode);
 void resetGLState();
-// fill, drawOutline, drawTexture & drawCachedGlyphs are the rendering entry points:
+// fill, stroke, drawTexture, drawPixmaps & drawCachedGlyphs are the main rendering entry-points,
+// however writeClip can also be thought of as en entry point as it does similar things.
 void fill(const QVectorPath &path);
+void stroke(const QVectorPath &path, const QPen &pen);
 void drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern = false);
+void drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints hints);
 void drawCachedGlyphs(const QPointF &p, QFontEngineGlyphCache::Type glyphType, const QTextItemInt &ti);
+// Calls glVertexAttributePointer if the pointer has changed
+inline void setVertexAttributePointer(unsigned int arrayIndex, const GLfloat *pointer);
+// draws whatever is in the vertex array:
 void drawVertexArrays(const float *data, int *stops, int stopCount, GLenum primitive);
 void drawVertexArrays(QGL2PEXVertexArray &vertexArray, GLenum primitive) {
 drawVertexArrays((const float *) vertexArray.data(), vertexArray.stops(), vertexArray.stopCount(), primitive);
 }
-// ^ draws whatever is in the vertex array
+// Composites the bounding rect onto dest buffer:
 void composite(const QGLRect& boundingRect);
-// ^ Composites the bounding rect onto dest buffer
+// Calls drawVertexArrays to render into stencil buffer:
 void fillStencilWithVertexArray(const float *data, int count, int *stops, int stopCount, const QGLRect &bounds, StencilFillMode mode);
 void fillStencilWithVertexArray(QGL2PEXVertexArray& vertexArray, bool useWindingFill) {
 fillStencilWithVertexArray((const float *) vertexArray.data(), 0, vertexArray.stops(), vertexArray.stopCount(),
 vertexArray.boundingRect(),
 useWindingFill ? WindingFillMode : OddEvenFillMode);
 }
-// ^ Calls drawVertexArrays to render into stencil buffer
+void setBrush(const QBrush& brush);
-bool prepareForDraw(bool srcPixelsAreOpaque);
+void transferMode(EngineMode newMode);
-// ^ returns whether the current program changed or not
+bool prepareForDraw(bool srcPixelsAreOpaque); // returns true if the program has changed
 inline void useSimpleShader();
+inline GLuint location(const QGLEngineShaderManager::Uniform uniform) {
-void prepareDepthRangeForRenderText();
+return shaderManager->getUniformLocation(uniform);
-void restoreDepthRangeForRenderText();
+}
+void clearClip(uint value);
+void writeClip(const QVectorPath &path, uint value);
+void resetClipIfNeeded();
+void updateClipScissorTest();
+void setScissor(const QRect &rect);
+void regenerateClip();
+void systemStateChanged();
 static QGLEngineShaderManager* shaderManagerForEngine(QGL2PaintEngineEx *engine) { return engine->d_func()->shaderManager; }
 static QGL2PaintEngineExPrivate *getData(QGL2PaintEngineEx *engine) { return engine->d_func(); }
+static void cleanupVectorPath(QPaintEngineEx *engine, void *data);
 QGL2PaintEngineEx* q;
+QGLEngineShaderManager* shaderManager;
 QGLPaintDevice* device;
 int width, height;
 QGLContext *ctx;
 EngineMode mode;
 QFontEngineGlyphCache::Type glyphCacheType;
 // Dirty flags
 bool matrixDirty; // Implies matrix uniforms are also dirty
 bool compositionModeDirty;
 bool brushTextureDirty;
 bool brushUniformsDirty;
-bool simpleShaderMatrixUniformDirty;
-bool shaderMatrixUniformDirty;
 bool opacityUniformDirty;
 bool stencilClean; // Has the stencil not been used for clipping so far?
+bool useSystemClip;
 QRegion dirtyStencilRegion;
 QRect currentScissorBounds;
 uint maxClip;
 QBrush currentBrush; // May not be the state's brush!
+const QBrush noBrush;
-GLfloat     inverseScale;
 QGL2PEXVertexArray vertexCoordinateArray;
 QGL2PEXVertexArray textureCoordinateArray;
 QDataBuffer<GLfloat> opacityArray;
 GLfloat staticVertexCoordinateArray[8];
 GLfloat staticTextureCoordinateArray[8];
-GLfloat pmvMatrix[4][4];
+bool snapToPixelGrid;
+bool addOffset; // When enabled, adds a 0.49,0.49 offset to matrix in updateMatrix
-QGLEngineShaderManager* shaderManager;
+GLfloat pmvMatrix[3][3];
+GLfloat inverseScale;
-void clearClip(uint value);
-void writeClip(const QVectorPath &path, uint value);
+GLuint lastTextureUsed;
-void resetClipIfNeeded();
-void updateClipScissorTest();
-void setScissor(const QRect &rect);
-void regenerateClip();
-void systemStateChanged();
-uint use_system_clip : 1;
-uint location(QGLEngineShaderManager::Uniform uniform)
-{
-return shaderManager->getUniformLocation(uniform);
-}
-GLuint lastTexture;
 bool needsSync;
-bool inRenderText;
 bool multisamplingAlwaysEnabled;
 GLfloat depthRange[2];
 float textureInvertedY;
 QTriangulatingStroker stroker;
 QDashedStrokeProcessor dasher;
-QTransform temporaryTransform;
 QScopedPointer<QPixmapFilter> convolutionFilter;
 QScopedPointer<QPixmapFilter> colorizeFilter;
 QScopedPointer<QPixmapFilter> blurFilter;
 QScopedPointer<QPixmapFilter> dropShadowFilter;
 QSet<QVectorPath::CacheEntry *> pathCaches;
 QVector<GLuint> unusedVBOSToClean;
+const GLfloat *vertexAttribPointers[3];
 };
+void QGL2PaintEngineExPrivate::setVertexAttributePointer(unsigned int arrayIndex, const GLfloat *pointer)
+{
+Q_ASSERT(arrayIndex < 3);
+if (pointer == vertexAttribPointers[arrayIndex])
+return;
+vertexAttribPointers[arrayIndex] = pointer;
+if (arrayIndex == QT_OPACITY_ATTR)
+glVertexAttribPointer(arrayIndex, 1, GL_FLOAT, GL_FALSE, 0, pointer);
+else
+glVertexAttribPointer(arrayIndex, 2, GL_FLOAT, GL_FALSE, 0, pointer);
+}
 QT_END_NAMESPACE
 #endif

changeset 7	f7bc934e204c
parent 3	41300fa6a67c
child 30	5dc02b23752f