Fixed some perspective transform rendering bugs.

The bugs were caused by not clipping to the near plane (w = 0) when
mapping primitives with perspective tranfsorms.

Task-id: 258961
Reviewed-by: Gunnar

4 files changed, 82 insertions, 155 deletions

diff --git a/src/gui/painting/qdatabuffer_p.h b/src/gui/painting/qdatabuffer_p.h
index b568f43..275ec13 100644
--- a/src/gui/painting/qdatabuffer_p.h
+++ b/src/gui/painting/qdatabuffer_p.h
@@ -114,23 +114,6 @@ public:
         qSwap(buffer, other.buffer);
     }
 
-    inline void insertBlank(int pos, int count) {
-        Q_ASSERT(pos >= 0);
-        Q_ASSERT(pos < siz);
-        reserve(siz + count);
-        for (int i = siz - pos - 1; i >= 0; --i)
-            buffer[pos + count + i] = buffer[pos + i];
-        siz += count;
-    }
-
-    inline void removeAndShift(int pos, int count) {
-        Q_ASSERT(pos >= 0);
-        Q_ASSERT(pos < siz);
-        for (int i=pos; i<siz-count; ++i)
-            buffer[i] = buffer[i+count];
-        siz -= count;
-    }
-
     inline QDataBuffer &operator<<(const Type &t) { add(t); return *this; }
 
 private:
diff --git a/src/gui/painting/qoutlinemapper.cpp b/src/gui/painting/qoutlinemapper.cpp
index 9c073f2..70125b9 100644
--- a/src/gui/painting/qoutlinemapper.cpp
+++ b/src/gui/painting/qoutlinemapper.cpp
@@ -40,7 +40,6 @@
 ****************************************************************************/
 
 #include "qoutlinemapper_p.h"
-#include "qbezier_p.h"
 
 #include "qmath.h"
 
@@ -199,70 +198,28 @@ void QOutlineMapper::endOutline()
                                           m_m22 * e.y() + m_m12 * e.x() + m_dy);
             }
         } else {
-            // ## TODO: this case needs to be plain code polygonal paths
-            QTransform matrix(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33);
-
-            if (m_element_types.isEmpty()) {
-                if (!m_elements.isEmpty())
-                    m_elements_dev << m_elements.at(0) * matrix;
-                for (int i=1; i<m_elements.size(); ++i)
-                    m_elements_dev << m_elements.at(i) * matrix;
-
-            } else {
-                for (int i=0, t=0; i<m_elements.size(); ++i) {
-                    switch (m_element_types.at(t)) {
-                    case QPainterPath::MoveToElement:
-                        m_elements_dev << m_elements.at(i) * matrix;
-                        ++t;
-                        break;
-                    case QPainterPath::LineToElement:
-                        m_elements_dev << m_elements.at(i) * matrix;
-                        ++t;
-                        break;
-                    case QPainterPath::CurveToElement: {
-                        QPolygonF segment = QBezier::fromPoints(m_elements.at(i-1),
-                                                                m_elements.at(i),
-                                                                m_elements.at(i+1),
-                                                                m_elements.at(i+2)).toPolygon();
-                        if (segment.size() > 3) 
-                            m_element_types.insertBlank(t, segment.size() - 3);
-                        else if (segment.size() < 3) 
-                            m_element_types.removeAndShift(t, 3 - segment.size());
-
-                        for (QPolygonF::const_iterator it = segment.constBegin();
-                            it < segment.constEnd(); ++it, ++t) {
-                            m_elements_dev << *it * matrix;
-                            m_element_types.at(t) = QPainterPath::LineToElement;
-                        }
-                        i += 2;
-                    } break;
-                    default:
-                        Q_ASSERT(false);
-                        break;
-                    }
-                }
-                element_count = m_elements_dev.size();
-            }
+            const QVectorPath vp((qreal *)m_elements.data(), m_elements.size(), m_element_types.data());
+            QPainterPath path = vp.convertToPainterPath();
+            path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path);
+            uint old_txop = m_txop;
+            m_txop = QTransform::TxNone;
+            if (path.isEmpty())
+                m_valid = false;
+            else
+                convertPath(path);
+            m_txop = old_txop;
+            return;
         }
         elements = m_elements_dev.data();
     }
 
     if (m_round_coords) {
         // round coordinates to match outlines drawn with drawLine_midpoint_i
-        for (int i = 0; i < element_count; ++i)
+        for (int i = 0; i < m_elements.size(); ++i)
             elements[i] = QPointF(qFloor(elements[i].x() + aliasedCoordinateDelta),
                                   qFloor(elements[i].y() + aliasedCoordinateDelta));
     }
 
-#ifdef QT_DEBUG_CONVERT
-    for (int i=0; i<element_count; ++i) {
-        printf("%d: (%.2f, %.2f)\n",
-               !m_element_types.isEmpty() ? m_element_types.at(i) : -1,
-               elements[i].x(),
-               elements[i].y());
-    }
-#endif
-
     controlPointRect = boundingRect(elements, element_count);
 
 #ifdef QT_DEBUG_CONVERT
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 8ec881e..ed9b858 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -421,7 +421,6 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
 
     const qreal *lastPoint = points + (pointCount<<1);
 
-    d->activeStroker->begin(d->strokeHandler);
     d->strokeHandler->types.reset();
     d->strokeHandler->pts.reset();
 
@@ -430,13 +429,13 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
     if (d->stroker.capStyle() == Qt::RoundCap || d->stroker.joinStyle() == Qt::RoundJoin)
         flags |= QVectorPath::CurvedShapeHint;
 
-    // ### Perspective Xforms are currently not supported...
     qreal txscale = 1;
     if (!(pen.isCosmetic() || (qt_scaleForTransform(state()->matrix, &txscale) && txscale != 1))) {
         // We include cosmetic pens in this case to avoid having to
         // change the current transform. Normal transformed,
         // non-cosmetic pens will be transformed as part of fill
         // later, so they are also covered here..
+        d->activeStroker->begin(d->strokeHandler);
         if (types) {
             while (points < lastPoint) {
                 switch (*types) {
@@ -491,79 +490,64 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
         const qreal strokeWidth = d->stroker.strokeWidth();
         d->stroker.setStrokeWidth(strokeWidth * txscale);
         // For cosmetic pens we need a bit of trickery... We to process xform the input points
-        if (types) {
-            bool isProject = state()->matrix.type() >= QTransform::TxProject;
-            while (points < lastPoint) {
-                switch (*types) {
-                case QPainterPath::MoveToElement: {
-                    QPointF pt = (*(QPointF *) points) * state()->matrix;
-                    d->activeStroker->moveTo(pt.x(), pt.y());
-                    points += 2;
-                    ++types;
-                    break;
-                }
-                case QPainterPath::LineToElement: {
-                    QPointF pt = (*(QPointF *) points) * state()->matrix;
-                    d->activeStroker->lineTo(pt.x(), pt.y());
-                    points += 2;
-                    ++types;
-                    break;
-                }
-                case QPainterPath::CurveToElement: {
-                    // Convert projective xformed curves to line
-                    // segments so they can be transformed more
-                    // accurately
-                    if (isProject) {
-                        // -1 access here is safe because there is
-                        // always an element prior to the cubicTo, we
-                        // just need the value..
-                        QPolygonF segment =
-                            QBezier::fromPoints(*(((QPointF *) points) - 1),
-                                                *((QPointF *) points),
-                                                *(((QPointF *) points) + 1),
-                                                *(((QPointF *) points) + 2)).toPolygon();
-
-                        for (QPolygonF::const_iterator it = segment.constBegin();
-                             it < segment.constEnd(); ++it) {
-                            const QPointF pt = *it * state()->matrix;
-                            d->activeStroker->lineTo(pt.x(), pt.y());
-                        }
-                    } else {
+        if (state()->matrix.type() >= QTransform::TxProject) {
+            QPainterPath painterPath = state()->matrix.map(path.convertToPainterPath());
+            d->activeStroker->strokePath(painterPath, d->strokeHandler, QTransform());
+        } else {
+            d->activeStroker->begin(d->strokeHandler);
+            if (types) {
+                while (points < lastPoint) {
+                    switch (*types) {
+                    case QPainterPath::MoveToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->moveTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::LineToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->lineTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::CurveToElement: {
                         QPointF c1 = ((QPointF *) points)[0] * state()->matrix;
                         QPointF c2 = ((QPointF *) points)[1] * state()->matrix;
                         QPointF e =  ((QPointF *) points)[2] * state()->matrix;
                         d->activeStroker->cubicTo(c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
+                        points += 6;
+                        types += 3;
+                        flags |= QVectorPath::CurvedShapeHint;
+                        break;
+                    }
+                    default:
+                        break;
                     }
-                    points += 6;
-                    types += 3;
-                    flags |= QVectorPath::CurvedShapeHint;
-                    break;
                 }
-                default:
-                    break;
+                if (path.hasImplicitClose()) {
+                    QPointF pt = * ((QPointF *) path.points()) * state()->matrix;
+                    d->activeStroker->lineTo(pt.x(), pt.y());
                 }
-            }
-            if (path.hasImplicitClose()) {
-                QPointF pt = * ((QPointF *) path.points()) * state()->matrix;
-                d->activeStroker->lineTo(pt.x(), pt.y());
-            }
 
-        } else {
-            QPointF p = ((QPointF *)points)[0] * state()->matrix;
-            d->activeStroker->moveTo(p.x(), p.y());
-            points += 2;
-            ++types;
-            while (points < lastPoint) {
+            } else {
                 QPointF p = ((QPointF *)points)[0] * state()->matrix;
-                d->activeStroker->lineTo(p.x(), p.y());
+                d->activeStroker->moveTo(p.x(), p.y());
                 points += 2;
                 ++types;
+                while (points < lastPoint) {
+                    QPointF p = ((QPointF *)points)[0] * state()->matrix;
+                    d->activeStroker->lineTo(p.x(), p.y());
+                    points += 2;
+                    ++types;
+                }
+                if (path.hasImplicitClose())
+                    d->activeStroker->lineTo(p.x(), p.y());
             }
-            if (path.hasImplicitClose())
-                d->activeStroker->lineTo(p.x(), p.y());
+            d->activeStroker->end();
         }
 
-        d->activeStroker->end();
         d->stroker.setStrokeWidth(strokeWidth);
         QVectorPath strokePath(d->strokeHandler->pts.data(),
                                d->strokeHandler->types.size(),
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index a322fe4..0a64e4e 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -48,6 +48,8 @@
 #include "qvariant.h"
 #include <qmath.h>
 
+#include <private/qbezier_p.h>
+
 QT_BEGIN_NAMESPACE
 
 #define Q_NEAR_CLIP 0.000001
@@ -1492,27 +1494,12 @@ static inline bool lineTo_clipped(QPainterPath &path, const QTransform &transfor
 
 static inline bool cubicTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d, bool needsMoveTo)
 {
-    const QHomogeneousCoordinate ha = mapHomogeneous(transform, a);
-    const QHomogeneousCoordinate hb = mapHomogeneous(transform, b);
-    const QHomogeneousCoordinate hc = mapHomogeneous(transform, c);
-    const QHomogeneousCoordinate hd = mapHomogeneous(transform, d);
-
-    if (ha.w < Q_NEAR_CLIP && hb.w < Q_NEAR_CLIP && hc.w < Q_NEAR_CLIP && hd.w < Q_NEAR_CLIP)
-        return false;
+    // Convert projective xformed curves to line
+    // segments so they can be transformed more accurately
+    QPolygonF segment = QBezier::fromPoints(a, b, c, d).toPolygon();
 
-    if (ha.w >= Q_NEAR_CLIP && hb.w >= Q_NEAR_CLIP && hc.w >= Q_NEAR_CLIP && hd.w >= Q_NEAR_CLIP) {
-        if (needsMoveTo)
-            path.moveTo(ha.toPoint());
-
-        path.cubicTo(hb.toPoint(), hc.toPoint(), hd.toPoint());
-        return true;
-    }
-
-    if (lineTo_clipped(path, transform, a, b, needsMoveTo))
-            needsMoveTo = false;
-    if (lineTo_clipped(path, transform, b, c, needsMoveTo))
-            needsMoveTo = false;
-    if (lineTo_clipped(path, transform, c, d, needsMoveTo))
+    for (int i = 0; i < segment.size() - 1; ++i)
+        if (lineTo_clipped(path, transform, segment.at(i), segment.at(i+1), needsMoveTo))
             needsMoveTo = false;
 
     return !needsMoveTo;
@@ -1793,6 +1780,14 @@ void QTransform::setMatrix(qreal m11, qreal m12, qreal m13,
     m_dirty = TxProject;
 }
 
+static inline bool needsPerspectiveClipping(const QRectF &rect, const QTransform &transform)
+{
+    const qreal wx = qMin(transform.m13() * rect.left(), transform.m13() * rect.right());
+    const qreal wy = qMin(transform.m23() * rect.top(), transform.m23() * rect.bottom());
+
+    return wx + wy + transform.m33() < Q_NEAR_CLIP;
+}
+
 QRect QTransform::mapRect(const QRect &rect) const
 {
     TransformationType t = inline_type();
@@ -1813,7 +1808,7 @@ QRect QTransform::mapRect(const QRect &rect) const
             y -= h;
         }
         return QRect(x, y, w, h);
-    } else {
+    } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) {
         // see mapToPolygon for explanations of the algorithm.
         qreal x = 0, y = 0;
         MAP(rect.left(), rect.top(), x, y);
@@ -1837,6 +1832,10 @@ QRect QTransform::mapRect(const QRect &rect) const
         xmax = qMax(xmax, x);
         ymax = qMax(ymax, y);
         return QRect(qRound(xmin), qRound(ymin), qRound(xmax)-qRound(xmin), qRound(ymax)-qRound(ymin));
+    } else {
+        QPainterPath path;
+        path.addRect(rect);
+        return map(path).boundingRect().toRect();
     }
 }
 
@@ -1879,7 +1878,7 @@ QRectF QTransform::mapRect(const QRectF &rect) const
             y -= h;
         }
         return QRectF(x, y, w, h);
-    } else {
+    } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) {
         qreal x = 0, y = 0;
         MAP(rect.x(), rect.y(), x, y);
         qreal xmin = x;
@@ -1902,6 +1901,10 @@ QRectF QTransform::mapRect(const QRectF &rect) const
         xmax = qMax(xmax, x);
         ymax = qMax(ymax, y);
         return QRectF(xmin, ymin, xmax-xmin, ymax - ymin);
+    } else {
+        QPainterPath path;
+        path.addRect(rect);
+        return map(path).boundingRect();
     }
 }