Changeset 561 for trunk/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp (modified) (10 diffs)

trunk/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -44 +44 @@
 #include <private/qbezier_p.h>
 
+QT_BEGIN_NAMESPACE
+
 void QGL2PEXVertexArray::clear()
 {
     vertexArray.reset();
-    vertexArrayStops.clear();
+    vertexArrayStops.reset();
     boundingRectDirty = true;
 }
@@ -60 +62 @@
 }
 
-void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseScale)
+void QGL2PEXVertexArray::addRect(const QRectF &rect)
+{
+    vertexArray << rect.topLeft() << rect.topRight() << rect.bottomRight()
+                << rect.bottomRight() << rect.bottomLeft() << rect.topLeft();
+}
+
+void QGL2PEXVertexArray::addClosingLine(int index)
+{
+    if (QPointF(vertexArray.at(index)) != QPointF(vertexArray.last()))
+        vertexArray.add(vertexArray.at(index));
+}
+
+void QGL2PEXVertexArray::addCentroid(const QVectorPath &path, int subPathIndex)
+{
+    const QPointF *const points = reinterpret_cast<const QPointF *>(path.points());
+    const QPainterPath::ElementType *const elements = path.elements();
+
+    QPointF sum = points[subPathIndex];
+    int count = 1;
+
+    for (int i = subPathIndex + 1; i < path.elementCount() && (!elements || elements[i] != QPainterPath::MoveToElement); ++i) {
+        sum += points[i];
+        ++count;
+    }
+
+    const QPointF centroid = sum / qreal(count);
+    vertexArray.add(centroid);
+}
+
+void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline)
 {
     const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
@@ -71 +102 @@
     }
 
+    if (!outline && !path.isConvex())
+        addCentroid(path, 0);
+
+    int lastMoveTo = vertexArray.size();
     vertexArray.add(points[0]); // The first element is always a moveTo
 
@@ -86 +121 @@
 
         for (int i=1; i<path.elementCount(); ++i) {
-            const QPainterPath::ElementType elementType = elements[i];
-            switch (elementType) {
+            switch (elements[i]) {
             case QPainterPath::MoveToElement:
+                if (!outline)
+                    addClosingLine(lastMoveTo);
 //                qDebug("element[%d] is a MoveToElement", i);
-                vertexArrayStops.append(vertexArray.size());
-                vertexArray.add(points[i]); // Add the moveTo as a new vertex
+                vertexArrayStops.add(vertexArray.size());
+                if (!outline) {
+                    if (!path.isConvex()) addCentroid(path, i);
+                    lastMoveTo = vertexArray.size();
+                }
+                lineToArray(points[i].x(), points[i].y()); // Add the moveTo as a new vertex
                 break;
             case QPainterPath::LineToElement:
@@ -97 +137 @@
                 lineToArray(points[i].x(), points[i].y());
                 break;
-            case QPainterPath::CurveToElement:
-//                qDebug("element[%d] is a CurveToElement", i);
-                curveToArray(points[i], points[i+1], points[i+2], curveInverseScale);
-                i+=2;
-                break;
+            case QPainterPath::CurveToElement: {
+                QBezier b = QBezier::fromPoints(*(((const QPointF *) points) + i - 1),
+                                                points[i],
+                                                points[i+1],
+                                                points[i+2]);
+                QRectF bounds = b.bounds();
+                // threshold based on same algorithm as in qtriangulatingstroker.cpp
+                int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * 3.14f / (curveInverseScale * 6));
+                if (threshold < 3) threshold = 3;
+                qreal one_over_threshold_minus_1 = 1.f / (threshold - 1);
+                for (int t=0; t<threshold; ++t) {
+                    QPointF pt = b.pointAt(t * one_over_threshold_minus_1);
+                    lineToArray(pt.x(), pt.y());
+                }
+                i += 2;
+                break; }
             default:
                 break;
@@ -108 +159 @@
     } while (0);
 
-    vertexArrayStops.append(vertexArray.size());
+    if (!outline)
+        addClosingLine(lastMoveTo);
+    vertexArrayStops.add(vertexArray.size());
 }
 
@@ -125 +178 @@
 }
 
-void QGL2PEXVertexArray::curveToArray(const QGLPoint &cp1, const QGLPoint &cp2, const QGLPoint &ep, GLfloat inverseScale)
-{
-    qreal inverseScaleHalf = inverseScale / 2;
-
-    QBezier beziers[32];
-    beziers[0] = QBezier::fromPoints(vertexArray.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
-            lineToArray(b->x4, b->y4);
-            --b;
-        } else {
-            // split, second half of the polygon goes lower into the stack
-            b->split(b+1, b);
-           ++b;
-        }
-    }
-}
+QT_END_NAMESPACE