From 16f8afa5b1c906ae60f98619d17c34b40c21804e Mon Sep 17 00:00:00 2001 From: Kim Motoyoshi Kalland Date: Thu, 5 Jul 2012 17:01:25 +0200 Subject: Remove duplicate triangulating stroker implementation. Change-Id: I9d8f609c9ecb02dd25e588313bc98db4b9325974 Reviewed-by: Gunnar Sletta --- src/gui/opengl/opengl.pri | 4 +- src/gui/opengl/qopenglpaintengine.cpp | 1 - src/gui/opengl/qopenglpaintengine_p.h | 2 +- src/gui/opengl/qopengltriangulatingstroker.cpp | 585 --------------------- src/gui/opengl/qopengltriangulatingstroker_p.h | 157 ------ src/gui/opengl/qtriangulatingstroker.cpp | 585 +++++++++++++++++++++ src/gui/opengl/qtriangulatingstroker_p.h | 157 ++++++ .../gl2paintengineex/qpaintengineex_opengl2.cpp | 1 - .../gl2paintengineex/qtriangulatingstroker.cpp | 585 --------------------- .../gl2paintengineex/qtriangulatingstroker_p.h | 157 ------ src/opengl/opengl.pro | 2 - 11 files changed, 745 insertions(+), 1491 deletions(-) delete mode 100644 src/gui/opengl/qopengltriangulatingstroker.cpp delete mode 100644 src/gui/opengl/qopengltriangulatingstroker_p.h create mode 100644 src/gui/opengl/qtriangulatingstroker.cpp create mode 100644 src/gui/opengl/qtriangulatingstroker_p.h delete mode 100644 src/opengl/gl2paintengineex/qtriangulatingstroker.cpp delete mode 100644 src/opengl/gl2paintengineex/qtriangulatingstroker_p.h diff --git a/src/gui/opengl/opengl.pri b/src/gui/opengl/opengl.pri index 3becc2bcfe..c241354e9c 100644 --- a/src/gui/opengl/opengl.pri +++ b/src/gui/opengl/opengl.pri @@ -22,7 +22,7 @@ contains(QT_CONFIG, opengl)|contains(QT_CONFIG, opengles2) { opengl/qopenglpaintengine_p.h \ opengl/qopenglengineshadersource_p.h \ opengl/qopenglcustomshaderstage_p.h \ - opengl/qopengltriangulatingstroker_p.h \ + opengl/qtriangulatingstroker_p.h \ opengl/qopengltextureglyphcache_p.h \ opengl/qopenglshadercache_p.h \ opengl/qopenglshadercache_meego_p.h \ @@ -41,7 +41,7 @@ contains(QT_CONFIG, opengl)|contains(QT_CONFIG, opengles2) { opengl/qopengl2pexvertexarray.cpp \ opengl/qopenglpaintengine.cpp \ opengl/qopenglcustomshaderstage.cpp \ - opengl/qopengltriangulatingstroker.cpp \ + opengl/qtriangulatingstroker.cpp \ opengl/qopengltextureglyphcache.cpp \ opengl/qtriangulator.cpp diff --git a/src/gui/opengl/qopenglpaintengine.cpp b/src/gui/opengl/qopenglpaintengine.cpp index 138a11a469..2f84a0f295 100644 --- a/src/gui/opengl/qopenglpaintengine.cpp +++ b/src/gui/opengl/qopenglpaintengine.cpp @@ -85,7 +85,6 @@ #include "qopenglengineshadermanager_p.h" #include "qopengl2pexvertexarray_p.h" -#include "qopengltriangulatingstroker_p.h" #include "qopengltextureglyphcache_p.h" #include diff --git a/src/gui/opengl/qopenglpaintengine_p.h b/src/gui/opengl/qopenglpaintengine_p.h index 8b49ec250f..aa054c2557 100644 --- a/src/gui/opengl/qopenglpaintengine_p.h +++ b/src/gui/opengl/qopenglpaintengine_p.h @@ -62,7 +62,7 @@ #include #include #include -#include +#include #include diff --git a/src/gui/opengl/qopengltriangulatingstroker.cpp b/src/gui/opengl/qopengltriangulatingstroker.cpp deleted file mode 100644 index ccf4eb30e7..0000000000 --- a/src/gui/opengl/qopengltriangulatingstroker.cpp +++ /dev/null @@ -1,585 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). -** Contact: http://www.qt-project.org/ -** -** This file is part of the QtGui module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** GNU Lesser General Public License Usage -** This file may be used under the terms of the GNU Lesser General Public -** License version 2.1 as published by the Free Software Foundation and -** appearing in the file LICENSE.LGPL included in the packaging of this -** file. Please review the following information to ensure the GNU Lesser -** General Public License version 2.1 requirements 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.1, included in the file LGPL_EXCEPTION.txt in this package. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU General -** Public License version 3.0 as published by the Free Software Foundation -** and appearing in the file LICENSE.GPL included in the packaging of this -** file. Please review the following information to ensure the GNU General -** Public License version 3.0 requirements will be met: -** http://www.gnu.org/copyleft/gpl.html. -** -** Other Usage -** Alternatively, this file may be used in accordance with the terms and -** conditions contained in a signed written agreement between you and Nokia. -** -** -** -** -** -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qopengltriangulatingstroker_p.h" -#include - -QT_BEGIN_NAMESPACE - -#define CURVE_FLATNESS Q_PI / 8 - - - - -void QTriangulatingStroker::endCapOrJoinClosed(const qreal *start, const qreal *cur, - bool implicitClose, bool endsAtStart) -{ - if (endsAtStart) { - join(start + 2); - } else if (implicitClose) { - join(start); - lineTo(start); - join(start+2); - } else { - endCap(cur); - } - int count = m_vertices.size(); - - // Copy the (x, y) values because QDataBuffer::add(const float& t) - // may resize the buffer, which will leave t pointing at the - // previous buffer's memory region if we don't copy first. - float x = m_vertices.at(count-2); - float y = m_vertices.at(count-1); - m_vertices.add(x); - m_vertices.add(y); -} - - -void QTriangulatingStroker::process(const QVectorPath &path, const QPen &pen, const QRectF &) -{ - const qreal *pts = path.points(); - const QPainterPath::ElementType *types = path.elements(); - int count = path.elementCount(); - if (count < 2) - return; - - float realWidth = qpen_widthf(pen); - if (realWidth == 0) - realWidth = 1; - - m_width = realWidth / 2; - - bool cosmetic = pen.isCosmetic(); - if (cosmetic) { - m_width = m_width * m_inv_scale; - } - - m_join_style = qpen_joinStyle(pen); - m_cap_style = qpen_capStyle(pen); - m_vertices.reset(); - m_miter_limit = pen.miterLimit() * qpen_widthf(pen); - - // The curvyness is based on the notion that I originally wanted - // roughly one line segment pr 4 pixels. This may seem little, but - // because we sample at constantly incrementing B(t) E [0(4, realWidth * CURVE_FLATNESS); - } else { - m_curvyness_add = m_width; - m_curvyness_mul = CURVE_FLATNESS / m_inv_scale; - m_roundness = qMax(4, realWidth * m_curvyness_mul); - } - - // Over this level of segmentation, there doesn't seem to be any - // benefit, even for huge penWidth - if (m_roundness > 24) - m_roundness = 24; - - m_sin_theta = qFastSin(Q_PI / m_roundness); - m_cos_theta = qFastCos(Q_PI / m_roundness); - - const qreal *endPts = pts + (count<<1); - const qreal *startPts = 0; - - Qt::PenCapStyle cap = m_cap_style; - - if (!types) { - // skip duplicate points - while((pts + 2) < endPts && pts[0] == pts[2] && pts[1] == pts[3]) - pts += 2; - if ((pts + 2) == endPts) - return; - - startPts = pts; - - bool endsAtStart = startPts[0] == *(endPts-2) && startPts[1] == *(endPts-1); - - if (endsAtStart || path.hasImplicitClose()) - m_cap_style = Qt::FlatCap; - moveTo(pts); - m_cap_style = cap; - pts += 2; - lineTo(pts); - pts += 2; - while (pts < endPts) { - if (m_cx != pts[0] || m_cy != pts[1]) { - join(pts); - lineTo(pts); - } - pts += 2; - } - - endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart); - - } else { - bool endsAtStart = false; - while (pts < endPts) { - switch (*types) { - case QPainterPath::MoveToElement: { - if (pts != path.points()) - endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart); - - startPts = pts; - int end = (endPts - pts) / 2; - int i = 2; // Start looking to ahead since we never have two moveto's in a row - while (i points; - arcPoints(m_cx, m_cy, m_cx + m_nvx, m_cy + m_nvy, m_cx - m_nvx, m_cy - m_nvy, points); - m_vertices.resize(m_vertices.size() + points.size() + 2 * int(invisibleJump)); - int count = m_vertices.size(); - int front = 0; - int end = points.size() / 2; - while (front != end) { - m_vertices.at(--count) = points[2 * end - 1]; - m_vertices.at(--count) = points[2 * end - 2]; - --end; - if (front == end) - break; - m_vertices.at(--count) = points[2 * front + 1]; - m_vertices.at(--count) = points[2 * front + 0]; - ++front; - } - - if (invisibleJump) { - m_vertices.at(count - 1) = m_vertices.at(count + 1); - m_vertices.at(count - 2) = m_vertices.at(count + 0); - } - break; } - default: break; // ssssh gcc... - } - emitLineSegment(m_cx, m_cy, m_nvx, m_nvy); -} - -void QTriangulatingStroker::cubicTo(const qreal *pts) -{ - const QPointF *p = (const QPointF *) pts; - QBezier bezier = QBezier::fromPoints(*(p - 1), p[0], p[1], p[2]); - - QRectF bounds = bezier.bounds(); - float rad = qMax(bounds.width(), bounds.height()); - int threshold = qMin(64, (rad + m_curvyness_add) * m_curvyness_mul); - if (threshold < 4) - threshold = 4; - qreal threshold_minus_1 = threshold - 1; - float vx, vy; - - float cx = m_cx, cy = m_cy; - float x, y; - - for (int i=1; i (pts[0], pts[1]) - normalVector(m_cx, m_cy, pts[0], pts[1], &m_nvx, &m_nvy); - - switch (m_join_style) { - case Qt::BevelJoin: - break; - case Qt::SvgMiterJoin: - case Qt::MiterJoin: { - // Find out on which side the join should be. - int count = m_vertices.size(); - float prevNvx = m_vertices.at(count - 2) - m_cx; - float prevNvy = m_vertices.at(count - 1) - m_cy; - float xprod = prevNvx * m_nvy - prevNvy * m_nvx; - float px, py, qx, qy; - - // If the segments are parallel, use bevel join. - if (qFuzzyIsNull(xprod)) - break; - - // Find the corners of the previous and next segment to join. - if (xprod < 0) { - px = m_vertices.at(count - 2); - py = m_vertices.at(count - 1); - qx = m_cx - m_nvx; - qy = m_cy - m_nvy; - } else { - px = m_vertices.at(count - 4); - py = m_vertices.at(count - 3); - qx = m_cx + m_nvx; - qy = m_cy + m_nvy; - } - - // Find intersection point. - float pu = px * prevNvx + py * prevNvy; - float qv = qx * m_nvx + qy * m_nvy; - float ix = (m_nvy * pu - prevNvy * qv) / xprod; - float iy = (prevNvx * qv - m_nvx * pu) / xprod; - - // Check that the distance to the intersection point is less than the miter limit. - if ((ix - px) * (ix - px) + (iy - py) * (iy - py) <= m_miter_limit * m_miter_limit) { - m_vertices.add(ix); - m_vertices.add(iy); - m_vertices.add(ix); - m_vertices.add(iy); - } - // else - // Do a plain bevel join if the miter limit is exceeded or if - // the lines are parallel. This is not what the raster - // engine's stroker does, but it is both faster and similar to - // what some other graphics API's do. - - break; } - case Qt::RoundJoin: { - QVarLengthArray points; - int count = m_vertices.size(); - float prevNvx = m_vertices.at(count - 2) - m_cx; - float prevNvy = m_vertices.at(count - 1) - m_cy; - if (m_nvx * prevNvy - m_nvy * prevNvx < 0) { - arcPoints(0, 0, m_nvx, m_nvy, -prevNvx, -prevNvy, points); - for (int i = points.size() / 2; i > 0; --i) - emitLineSegment(m_cx, m_cy, points[2 * i - 2], points[2 * i - 1]); - } else { - arcPoints(0, 0, -prevNvx, -prevNvy, m_nvx, m_nvy, points); - for (int i = 0; i < points.size() / 2; ++i) - emitLineSegment(m_cx, m_cy, points[2 * i + 0], points[2 * i + 1]); - } - break; } - default: break; // gcc warn-- - } - - emitLineSegment(m_cx, m_cy, m_nvx, m_nvy); -} - -void QTriangulatingStroker::endCap(const qreal *) -{ - switch (m_cap_style) { - case Qt::FlatCap: - break; - case Qt::SquareCap: - emitLineSegment(m_cx + m_nvy, m_cy - m_nvx, m_nvx, m_nvy); - break; - case Qt::RoundCap: { - QVarLengthArray points; - int count = m_vertices.size(); - arcPoints(m_cx, m_cy, m_vertices.at(count - 2), m_vertices.at(count - 1), m_vertices.at(count - 4), m_vertices.at(count - 3), points); - int front = 0; - int end = points.size() / 2; - while (front != end) { - m_vertices.add(points[2 * end - 2]); - m_vertices.add(points[2 * end - 1]); - --end; - if (front == end) - break; - m_vertices.add(points[2 * front + 0]); - m_vertices.add(points[2 * front + 1]); - ++front; - } - break; } - default: break; // to shut gcc up... - } -} - -void QTriangulatingStroker::arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray &points) -{ - float dx1 = fromX - cx; - float dy1 = fromY - cy; - float dx2 = toX - cx; - float dy2 = toY - cy; - - // while more than 180 degrees left: - while (dx1 * dy2 - dx2 * dy1 < 0) { - float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; - float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; - dx1 = tmpx; - dy1 = tmpy; - points.append(cx + dx1); - points.append(cy + dy1); - } - - // while more than 90 degrees left: - while (dx1 * dx2 + dy1 * dy2 < 0) { - float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; - float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; - dx1 = tmpx; - dy1 = tmpy; - points.append(cx + dx1); - points.append(cy + dy1); - } - - // while more than 0 degrees left: - while (dx1 * dy2 - dx2 * dy1 > 0) { - float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; - float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; - dx1 = tmpx; - dy1 = tmpy; - points.append(cx + dx1); - points.append(cy + dy1); - } - - // remove last point which was rotated beyond [toX, toY]. - if (!points.isEmpty()) - points.resize(points.size() - 2); -} - -static void qdashprocessor_moveTo(qreal x, qreal y, void *data) -{ - ((QDashedStrokeProcessor *) data)->addElement(QPainterPath::MoveToElement, x, y); -} - -static void qdashprocessor_lineTo(qreal x, qreal y, void *data) -{ - ((QDashedStrokeProcessor *) data)->addElement(QPainterPath::LineToElement, x, y); -} - -static void qdashprocessor_cubicTo(qreal, qreal, qreal, qreal, qreal, qreal, void *) -{ - Q_ASSERT(0); // The dasher should not produce curves... -} - -QDashedStrokeProcessor::QDashedStrokeProcessor() - : m_points(0), m_types(0), - m_dash_stroker(0), m_inv_scale(1) -{ - m_dash_stroker.setMoveToHook(qdashprocessor_moveTo); - m_dash_stroker.setLineToHook(qdashprocessor_lineTo); - m_dash_stroker.setCubicToHook(qdashprocessor_cubicTo); -} - -void QDashedStrokeProcessor::process(const QVectorPath &path, const QPen &pen, const QRectF &clip) -{ - - const qreal *pts = path.points(); - const QPainterPath::ElementType *types = path.elements(); - int count = path.elementCount(); - - bool cosmetic = pen.isCosmetic(); - - m_points.reset(); - m_types.reset(); - m_points.reserve(path.elementCount()); - m_types.reserve(path.elementCount()); - - qreal width = qpen_widthf(pen); - if (width == 0) - width = 1; - - m_dash_stroker.setDashPattern(pen.dashPattern()); - m_dash_stroker.setStrokeWidth(cosmetic ? width * m_inv_scale : width); - m_dash_stroker.setDashOffset(pen.dashOffset()); - m_dash_stroker.setMiterLimit(pen.miterLimit()); - m_dash_stroker.setClipRect(clip); - - float curvynessAdd, curvynessMul; - - // simplify pens that are thin in device size (2px wide or less) - if (width < 2.5 && (cosmetic || m_inv_scale == 1)) { - curvynessAdd = 0.5; - curvynessMul = CURVE_FLATNESS / m_inv_scale; - } else if (cosmetic) { - curvynessAdd= width / 2; - curvynessMul= CURVE_FLATNESS; - } else { - curvynessAdd = width * m_inv_scale; - curvynessMul = CURVE_FLATNESS / m_inv_scale; - } - - if (count < 2) - return; - - const qreal *endPts = pts + (count<<1); - - m_dash_stroker.begin(this); - - if (!types) { - m_dash_stroker.moveTo(pts[0], pts[1]); - pts += 2; - while (pts < endPts) { - m_dash_stroker.lineTo(pts[0], pts[1]); - pts += 2; - } - } else { - while (pts < endPts) { - switch (*types) { - case QPainterPath::MoveToElement: - m_dash_stroker.moveTo(pts[0], pts[1]); - pts += 2; - ++types; - break; - case QPainterPath::LineToElement: - m_dash_stroker.lineTo(pts[0], pts[1]); - pts += 2; - ++types; - break; - case QPainterPath::CurveToElement: { - QBezier b = QBezier::fromPoints(*(((const QPointF *) pts) - 1), - *(((const QPointF *) pts)), - *(((const QPointF *) pts) + 1), - *(((const QPointF *) pts) + 2)); - QRectF bounds = b.bounds(); - float rad = qMax(bounds.width(), bounds.height()); - int threshold = qMin(64, (rad + curvynessAdd) * curvynessMul); - if (threshold < 4) - threshold = 4; - - qreal threshold_minus_1 = threshold - 1; - for (int i=0; i -#include -#include -#include -#include -#include - -QT_BEGIN_NAMESPACE - -class Q_GUI_EXPORT QTriangulatingStroker -{ -public: - QTriangulatingStroker() : m_vertices(0) {} - void process(const QVectorPath &path, const QPen &pen, const QRectF &clip); - - inline int vertexCount() const { return m_vertices.size(); } - inline const float *vertices() const { return m_vertices.data(); } - - inline void setInvScale(qreal invScale) { m_inv_scale = invScale; } - -private: - inline void emitLineSegment(float x, float y, float nx, float ny); - void moveTo(const qreal *pts); - inline void lineTo(const qreal *pts); - void cubicTo(const qreal *pts); - void join(const qreal *pts); - inline void normalVector(float x1, float y1, float x2, float y2, float *nx, float *ny); - void endCap(const qreal *pts); - void arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray &points); - void endCapOrJoinClosed(const qreal *start, const qreal *cur, bool implicitClose, bool endsAtStart); - - - QDataBuffer m_vertices; - - float m_cx, m_cy; // current points - float m_nvx, m_nvy; // normal vector... - float m_width; - qreal m_miter_limit; - - int m_roundness; // Number of line segments in a round join - qreal m_sin_theta; // sin(m_roundness / 360); - qreal m_cos_theta; // cos(m_roundness / 360); - qreal m_inv_scale; - float m_curvyness_mul; - float m_curvyness_add; - - Qt::PenJoinStyle m_join_style; - Qt::PenCapStyle m_cap_style; -}; - -class QDashedStrokeProcessor -{ -public: - QDashedStrokeProcessor(); - - void process(const QVectorPath &path, const QPen &pen, const QRectF &clip); - - inline void addElement(QPainterPath::ElementType type, qreal x, qreal y) { - m_points.add(x); - m_points.add(y); - m_types.add(type); - } - - inline int elementCount() const { return m_types.size(); } - inline qreal *points() const { return m_points.data(); } - inline QPainterPath::ElementType *elementTypes() const { return m_types.data(); } - - inline void setInvScale(qreal invScale) { m_inv_scale = invScale; } - -private: - QDataBuffer m_points; - QDataBuffer m_types; - QDashStroker m_dash_stroker; - qreal m_inv_scale; -}; - -inline void QTriangulatingStroker::normalVector(float x1, float y1, float x2, float y2, - float *nx, float *ny) -{ - float dx = x2 - x1; - float dy = y2 - y1; - - float pw; - - if (dx == 0) - pw = m_width / qAbs(dy); - else if (dy == 0) - pw = m_width / qAbs(dx); - else - pw = m_width / sqrt(dx*dx + dy*dy); - - *nx = -dy * pw; - *ny = dx * pw; -} - -inline void QTriangulatingStroker::emitLineSegment(float x, float y, float vx, float vy) -{ - m_vertices.add(x + vx); - m_vertices.add(y + vy); - m_vertices.add(x - vx); - m_vertices.add(y - vy); -} - -void QTriangulatingStroker::lineTo(const qreal *pts) -{ - emitLineSegment(pts[0], pts[1], m_nvx, m_nvy); - m_cx = pts[0]; - m_cy = pts[1]; -} - -QT_END_NAMESPACE - -#endif diff --git a/src/gui/opengl/qtriangulatingstroker.cpp b/src/gui/opengl/qtriangulatingstroker.cpp new file mode 100644 index 0000000000..c22b731ca0 --- /dev/null +++ b/src/gui/opengl/qtriangulatingstroker.cpp @@ -0,0 +1,585 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements 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.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qtriangulatingstroker_p.h" +#include + +QT_BEGIN_NAMESPACE + +#define CURVE_FLATNESS Q_PI / 8 + + + + +void QTriangulatingStroker::endCapOrJoinClosed(const qreal *start, const qreal *cur, + bool implicitClose, bool endsAtStart) +{ + if (endsAtStart) { + join(start + 2); + } else if (implicitClose) { + join(start); + lineTo(start); + join(start+2); + } else { + endCap(cur); + } + int count = m_vertices.size(); + + // Copy the (x, y) values because QDataBuffer::add(const float& t) + // may resize the buffer, which will leave t pointing at the + // previous buffer's memory region if we don't copy first. + float x = m_vertices.at(count-2); + float y = m_vertices.at(count-1); + m_vertices.add(x); + m_vertices.add(y); +} + + +void QTriangulatingStroker::process(const QVectorPath &path, const QPen &pen, const QRectF &) +{ + const qreal *pts = path.points(); + const QPainterPath::ElementType *types = path.elements(); + int count = path.elementCount(); + if (count < 2) + return; + + float realWidth = qpen_widthf(pen); + if (realWidth == 0) + realWidth = 1; + + m_width = realWidth / 2; + + bool cosmetic = pen.isCosmetic(); + if (cosmetic) { + m_width = m_width * m_inv_scale; + } + + m_join_style = qpen_joinStyle(pen); + m_cap_style = qpen_capStyle(pen); + m_vertices.reset(); + m_miter_limit = pen.miterLimit() * qpen_widthf(pen); + + // The curvyness is based on the notion that I originally wanted + // roughly one line segment pr 4 pixels. This may seem little, but + // because we sample at constantly incrementing B(t) E [0(4, realWidth * CURVE_FLATNESS); + } else { + m_curvyness_add = m_width; + m_curvyness_mul = CURVE_FLATNESS / m_inv_scale; + m_roundness = qMax(4, realWidth * m_curvyness_mul); + } + + // Over this level of segmentation, there doesn't seem to be any + // benefit, even for huge penWidth + if (m_roundness > 24) + m_roundness = 24; + + m_sin_theta = qFastSin(Q_PI / m_roundness); + m_cos_theta = qFastCos(Q_PI / m_roundness); + + const qreal *endPts = pts + (count<<1); + const qreal *startPts = 0; + + Qt::PenCapStyle cap = m_cap_style; + + if (!types) { + // skip duplicate points + while((pts + 2) < endPts && pts[0] == pts[2] && pts[1] == pts[3]) + pts += 2; + if ((pts + 2) == endPts) + return; + + startPts = pts; + + bool endsAtStart = startPts[0] == *(endPts-2) && startPts[1] == *(endPts-1); + + if (endsAtStart || path.hasImplicitClose()) + m_cap_style = Qt::FlatCap; + moveTo(pts); + m_cap_style = cap; + pts += 2; + lineTo(pts); + pts += 2; + while (pts < endPts) { + if (m_cx != pts[0] || m_cy != pts[1]) { + join(pts); + lineTo(pts); + } + pts += 2; + } + + endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart); + + } else { + bool endsAtStart = false; + while (pts < endPts) { + switch (*types) { + case QPainterPath::MoveToElement: { + if (pts != path.points()) + endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart); + + startPts = pts; + int end = (endPts - pts) / 2; + int i = 2; // Start looking to ahead since we never have two moveto's in a row + while (i points; + arcPoints(m_cx, m_cy, m_cx + m_nvx, m_cy + m_nvy, m_cx - m_nvx, m_cy - m_nvy, points); + m_vertices.resize(m_vertices.size() + points.size() + 2 * int(invisibleJump)); + int count = m_vertices.size(); + int front = 0; + int end = points.size() / 2; + while (front != end) { + m_vertices.at(--count) = points[2 * end - 1]; + m_vertices.at(--count) = points[2 * end - 2]; + --end; + if (front == end) + break; + m_vertices.at(--count) = points[2 * front + 1]; + m_vertices.at(--count) = points[2 * front + 0]; + ++front; + } + + if (invisibleJump) { + m_vertices.at(count - 1) = m_vertices.at(count + 1); + m_vertices.at(count - 2) = m_vertices.at(count + 0); + } + break; } + default: break; // ssssh gcc... + } + emitLineSegment(m_cx, m_cy, m_nvx, m_nvy); +} + +void QTriangulatingStroker::cubicTo(const qreal *pts) +{ + const QPointF *p = (const QPointF *) pts; + QBezier bezier = QBezier::fromPoints(*(p - 1), p[0], p[1], p[2]); + + QRectF bounds = bezier.bounds(); + float rad = qMax(bounds.width(), bounds.height()); + int threshold = qMin(64, (rad + m_curvyness_add) * m_curvyness_mul); + if (threshold < 4) + threshold = 4; + qreal threshold_minus_1 = threshold - 1; + float vx, vy; + + float cx = m_cx, cy = m_cy; + float x, y; + + for (int i=1; i (pts[0], pts[1]) + normalVector(m_cx, m_cy, pts[0], pts[1], &m_nvx, &m_nvy); + + switch (m_join_style) { + case Qt::BevelJoin: + break; + case Qt::SvgMiterJoin: + case Qt::MiterJoin: { + // Find out on which side the join should be. + int count = m_vertices.size(); + float prevNvx = m_vertices.at(count - 2) - m_cx; + float prevNvy = m_vertices.at(count - 1) - m_cy; + float xprod = prevNvx * m_nvy - prevNvy * m_nvx; + float px, py, qx, qy; + + // If the segments are parallel, use bevel join. + if (qFuzzyIsNull(xprod)) + break; + + // Find the corners of the previous and next segment to join. + if (xprod < 0) { + px = m_vertices.at(count - 2); + py = m_vertices.at(count - 1); + qx = m_cx - m_nvx; + qy = m_cy - m_nvy; + } else { + px = m_vertices.at(count - 4); + py = m_vertices.at(count - 3); + qx = m_cx + m_nvx; + qy = m_cy + m_nvy; + } + + // Find intersection point. + float pu = px * prevNvx + py * prevNvy; + float qv = qx * m_nvx + qy * m_nvy; + float ix = (m_nvy * pu - prevNvy * qv) / xprod; + float iy = (prevNvx * qv - m_nvx * pu) / xprod; + + // Check that the distance to the intersection point is less than the miter limit. + if ((ix - px) * (ix - px) + (iy - py) * (iy - py) <= m_miter_limit * m_miter_limit) { + m_vertices.add(ix); + m_vertices.add(iy); + m_vertices.add(ix); + m_vertices.add(iy); + } + // else + // Do a plain bevel join if the miter limit is exceeded or if + // the lines are parallel. This is not what the raster + // engine's stroker does, but it is both faster and similar to + // what some other graphics API's do. + + break; } + case Qt::RoundJoin: { + QVarLengthArray points; + int count = m_vertices.size(); + float prevNvx = m_vertices.at(count - 2) - m_cx; + float prevNvy = m_vertices.at(count - 1) - m_cy; + if (m_nvx * prevNvy - m_nvy * prevNvx < 0) { + arcPoints(0, 0, m_nvx, m_nvy, -prevNvx, -prevNvy, points); + for (int i = points.size() / 2; i > 0; --i) + emitLineSegment(m_cx, m_cy, points[2 * i - 2], points[2 * i - 1]); + } else { + arcPoints(0, 0, -prevNvx, -prevNvy, m_nvx, m_nvy, points); + for (int i = 0; i < points.size() / 2; ++i) + emitLineSegment(m_cx, m_cy, points[2 * i + 0], points[2 * i + 1]); + } + break; } + default: break; // gcc warn-- + } + + emitLineSegment(m_cx, m_cy, m_nvx, m_nvy); +} + +void QTriangulatingStroker::endCap(const qreal *) +{ + switch (m_cap_style) { + case Qt::FlatCap: + break; + case Qt::SquareCap: + emitLineSegment(m_cx + m_nvy, m_cy - m_nvx, m_nvx, m_nvy); + break; + case Qt::RoundCap: { + QVarLengthArray points; + int count = m_vertices.size(); + arcPoints(m_cx, m_cy, m_vertices.at(count - 2), m_vertices.at(count - 1), m_vertices.at(count - 4), m_vertices.at(count - 3), points); + int front = 0; + int end = points.size() / 2; + while (front != end) { + m_vertices.add(points[2 * end - 2]); + m_vertices.add(points[2 * end - 1]); + --end; + if (front == end) + break; + m_vertices.add(points[2 * front + 0]); + m_vertices.add(points[2 * front + 1]); + ++front; + } + break; } + default: break; // to shut gcc up... + } +} + +void QTriangulatingStroker::arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray &points) +{ + float dx1 = fromX - cx; + float dy1 = fromY - cy; + float dx2 = toX - cx; + float dy2 = toY - cy; + + // while more than 180 degrees left: + while (dx1 * dy2 - dx2 * dy1 < 0) { + float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; + float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; + dx1 = tmpx; + dy1 = tmpy; + points.append(cx + dx1); + points.append(cy + dy1); + } + + // while more than 90 degrees left: + while (dx1 * dx2 + dy1 * dy2 < 0) { + float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; + float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; + dx1 = tmpx; + dy1 = tmpy; + points.append(cx + dx1); + points.append(cy + dy1); + } + + // while more than 0 degrees left: + while (dx1 * dy2 - dx2 * dy1 > 0) { + float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; + float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; + dx1 = tmpx; + dy1 = tmpy; + points.append(cx + dx1); + points.append(cy + dy1); + } + + // remove last point which was rotated beyond [toX, toY]. + if (!points.isEmpty()) + points.resize(points.size() - 2); +} + +static void qdashprocessor_moveTo(qreal x, qreal y, void *data) +{ + ((QDashedStrokeProcessor *) data)->addElement(QPainterPath::MoveToElement, x, y); +} + +static void qdashprocessor_lineTo(qreal x, qreal y, void *data) +{ + ((QDashedStrokeProcessor *) data)->addElement(QPainterPath::LineToElement, x, y); +} + +static void qdashprocessor_cubicTo(qreal, qreal, qreal, qreal, qreal, qreal, void *) +{ + Q_ASSERT(0); // The dasher should not produce curves... +} + +QDashedStrokeProcessor::QDashedStrokeProcessor() + : m_points(0), m_types(0), + m_dash_stroker(0), m_inv_scale(1) +{ + m_dash_stroker.setMoveToHook(qdashprocessor_moveTo); + m_dash_stroker.setLineToHook(qdashprocessor_lineTo); + m_dash_stroker.setCubicToHook(qdashprocessor_cubicTo); +} + +void QDashedStrokeProcessor::process(const QVectorPath &path, const QPen &pen, const QRectF &clip) +{ + + const qreal *pts = path.points(); + const QPainterPath::ElementType *types = path.elements(); + int count = path.elementCount(); + + bool cosmetic = pen.isCosmetic(); + + m_points.reset(); + m_types.reset(); + m_points.reserve(path.elementCount()); + m_types.reserve(path.elementCount()); + + qreal width = qpen_widthf(pen); + if (width == 0) + width = 1; + + m_dash_stroker.setDashPattern(pen.dashPattern()); + m_dash_stroker.setStrokeWidth(cosmetic ? width * m_inv_scale : width); + m_dash_stroker.setDashOffset(pen.dashOffset()); + m_dash_stroker.setMiterLimit(pen.miterLimit()); + m_dash_stroker.setClipRect(clip); + + float curvynessAdd, curvynessMul; + + // simplify pens that are thin in device size (2px wide or less) + if (width < 2.5 && (cosmetic || m_inv_scale == 1)) { + curvynessAdd = 0.5; + curvynessMul = CURVE_FLATNESS / m_inv_scale; + } else if (cosmetic) { + curvynessAdd= width / 2; + curvynessMul= CURVE_FLATNESS; + } else { + curvynessAdd = width * m_inv_scale; + curvynessMul = CURVE_FLATNESS / m_inv_scale; + } + + if (count < 2) + return; + + const qreal *endPts = pts + (count<<1); + + m_dash_stroker.begin(this); + + if (!types) { + m_dash_stroker.moveTo(pts[0], pts[1]); + pts += 2; + while (pts < endPts) { + m_dash_stroker.lineTo(pts[0], pts[1]); + pts += 2; + } + } else { + while (pts < endPts) { + switch (*types) { + case QPainterPath::MoveToElement: + m_dash_stroker.moveTo(pts[0], pts[1]); + pts += 2; + ++types; + break; + case QPainterPath::LineToElement: + m_dash_stroker.lineTo(pts[0], pts[1]); + pts += 2; + ++types; + break; + case QPainterPath::CurveToElement: { + QBezier b = QBezier::fromPoints(*(((const QPointF *) pts) - 1), + *(((const QPointF *) pts)), + *(((const QPointF *) pts) + 1), + *(((const QPointF *) pts) + 2)); + QRectF bounds = b.bounds(); + float rad = qMax(bounds.width(), bounds.height()); + int threshold = qMin(64, (rad + curvynessAdd) * curvynessMul); + if (threshold < 4) + threshold = 4; + + qreal threshold_minus_1 = threshold - 1; + for (int i=0; i +#include +#include +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class Q_GUI_EXPORT QTriangulatingStroker +{ +public: + QTriangulatingStroker() : m_vertices(0) {} + void process(const QVectorPath &path, const QPen &pen, const QRectF &clip); + + inline int vertexCount() const { return m_vertices.size(); } + inline const float *vertices() const { return m_vertices.data(); } + + inline void setInvScale(qreal invScale) { m_inv_scale = invScale; } + +private: + inline void emitLineSegment(float x, float y, float nx, float ny); + void moveTo(const qreal *pts); + inline void lineTo(const qreal *pts); + void cubicTo(const qreal *pts); + void join(const qreal *pts); + inline void normalVector(float x1, float y1, float x2, float y2, float *nx, float *ny); + void endCap(const qreal *pts); + void arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray &points); + void endCapOrJoinClosed(const qreal *start, const qreal *cur, bool implicitClose, bool endsAtStart); + + + QDataBuffer m_vertices; + + float m_cx, m_cy; // current points + float m_nvx, m_nvy; // normal vector... + float m_width; + qreal m_miter_limit; + + int m_roundness; // Number of line segments in a round join + qreal m_sin_theta; // sin(m_roundness / 360); + qreal m_cos_theta; // cos(m_roundness / 360); + qreal m_inv_scale; + float m_curvyness_mul; + float m_curvyness_add; + + Qt::PenJoinStyle m_join_style; + Qt::PenCapStyle m_cap_style; +}; + +class Q_GUI_EXPORT QDashedStrokeProcessor +{ +public: + QDashedStrokeProcessor(); + + void process(const QVectorPath &path, const QPen &pen, const QRectF &clip); + + inline void addElement(QPainterPath::ElementType type, qreal x, qreal y) { + m_points.add(x); + m_points.add(y); + m_types.add(type); + } + + inline int elementCount() const { return m_types.size(); } + inline qreal *points() const { return m_points.data(); } + inline QPainterPath::ElementType *elementTypes() const { return m_types.data(); } + + inline void setInvScale(qreal invScale) { m_inv_scale = invScale; } + +private: + QDataBuffer m_points; + QDataBuffer m_types; + QDashStroker m_dash_stroker; + qreal m_inv_scale; +}; + +inline void QTriangulatingStroker::normalVector(float x1, float y1, float x2, float y2, + float *nx, float *ny) +{ + float dx = x2 - x1; + float dy = y2 - y1; + + float pw; + + if (dx == 0) + pw = m_width / qAbs(dy); + else if (dy == 0) + pw = m_width / qAbs(dx); + else + pw = m_width / sqrt(dx*dx + dy*dy); + + *nx = -dy * pw; + *ny = dx * pw; +} + +inline void QTriangulatingStroker::emitLineSegment(float x, float y, float vx, float vy) +{ + m_vertices.add(x + vx); + m_vertices.add(y + vy); + m_vertices.add(x - vx); + m_vertices.add(y - vy); +} + +void QTriangulatingStroker::lineTo(const qreal *pts) +{ + emitLineSegment(pts[0], pts[1], m_nvx, m_nvy); + m_cx = pts[0]; + m_cy = pts[1]; +} + +QT_END_NAMESPACE + +#endif diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp index ca32adcd6f..1972035e4a 100644 --- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp @@ -82,7 +82,6 @@ #include "qglengineshadermanager_p.h" #include "qgl2pexvertexarray_p.h" -#include "qtriangulatingstroker_p.h" #include "qtextureglyphcache_gl_p.h" #include diff --git a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp b/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp deleted file mode 100644 index 9009f80f8f..0000000000 --- a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp +++ /dev/null @@ -1,585 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). -** Contact: http://www.qt-project.org/ -** -** This file is part of the QtOpenGL module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** GNU Lesser General Public License Usage -** This file may be used under the terms of the GNU Lesser General Public -** License version 2.1 as published by the Free Software Foundation and -** appearing in the file LICENSE.LGPL included in the packaging of this -** file. Please review the following information to ensure the GNU Lesser -** General Public License version 2.1 requirements 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.1, included in the file LGPL_EXCEPTION.txt in this package. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU General -** Public License version 3.0 as published by the Free Software Foundation -** and appearing in the file LICENSE.GPL included in the packaging of this -** file. Please review the following information to ensure the GNU General -** Public License version 3.0 requirements will be met: -** http://www.gnu.org/copyleft/gpl.html. -** -** Other Usage -** Alternatively, this file may be used in accordance with the terms and -** conditions contained in a signed written agreement between you and Nokia. -** -** -** -** -** -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qtriangulatingstroker_p.h" -#include - -QT_BEGIN_NAMESPACE - -#define CURVE_FLATNESS Q_PI / 8 - - - - -void QTriangulatingStroker::endCapOrJoinClosed(const qreal *start, const qreal *cur, - bool implicitClose, bool endsAtStart) -{ - if (endsAtStart) { - join(start + 2); - } else if (implicitClose) { - join(start); - lineTo(start); - join(start+2); - } else { - endCap(cur); - } - int count = m_vertices.size(); - - // Copy the (x, y) values because QDataBuffer::add(const float& t) - // may resize the buffer, which will leave t pointing at the - // previous buffer's memory region if we don't copy first. - float x = m_vertices.at(count-2); - float y = m_vertices.at(count-1); - m_vertices.add(x); - m_vertices.add(y); -} - - -void QTriangulatingStroker::process(const QVectorPath &path, const QPen &pen, const QRectF &) -{ - const qreal *pts = path.points(); - const QPainterPath::ElementType *types = path.elements(); - int count = path.elementCount(); - if (count < 2) - return; - - float realWidth = qpen_widthf(pen); - if (realWidth == 0) - realWidth = 1; - - m_width = realWidth / 2; - - bool cosmetic = pen.isCosmetic(); - if (cosmetic) { - m_width = m_width * m_inv_scale; - } - - m_join_style = qpen_joinStyle(pen); - m_cap_style = qpen_capStyle(pen); - m_vertices.reset(); - m_miter_limit = pen.miterLimit() * qpen_widthf(pen); - - // The curvyness is based on the notion that I originally wanted - // roughly one line segment pr 4 pixels. This may seem little, but - // because we sample at constantly incrementing B(t) E [0(4, realWidth * CURVE_FLATNESS); - } else { - m_curvyness_add = m_width; - m_curvyness_mul = CURVE_FLATNESS / m_inv_scale; - m_roundness = qMax(4, realWidth * m_curvyness_mul); - } - - // Over this level of segmentation, there doesn't seem to be any - // benefit, even for huge penWidth - if (m_roundness > 24) - m_roundness = 24; - - m_sin_theta = qFastSin(Q_PI / m_roundness); - m_cos_theta = qFastCos(Q_PI / m_roundness); - - const qreal *endPts = pts + (count<<1); - const qreal *startPts = 0; - - Qt::PenCapStyle cap = m_cap_style; - - if (!types) { - // skip duplicate points - while((pts + 2) < endPts && pts[0] == pts[2] && pts[1] == pts[3]) - pts += 2; - if ((pts + 2) == endPts) - return; - - startPts = pts; - - bool endsAtStart = startPts[0] == *(endPts-2) && startPts[1] == *(endPts-1); - - if (endsAtStart || path.hasImplicitClose()) - m_cap_style = Qt::FlatCap; - moveTo(pts); - m_cap_style = cap; - pts += 2; - lineTo(pts); - pts += 2; - while (pts < endPts) { - if (m_cx != pts[0] || m_cy != pts[1]) { - join(pts); - lineTo(pts); - } - pts += 2; - } - - endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart); - - } else { - bool endsAtStart = false; - while (pts < endPts) { - switch (*types) { - case QPainterPath::MoveToElement: { - if (pts != path.points()) - endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart); - - startPts = pts; - int end = (endPts - pts) / 2; - int i = 2; // Start looking to ahead since we never have two moveto's in a row - while (i points; - arcPoints(m_cx, m_cy, m_cx + m_nvx, m_cy + m_nvy, m_cx - m_nvx, m_cy - m_nvy, points); - m_vertices.resize(m_vertices.size() + points.size() + 2 * int(invisibleJump)); - int count = m_vertices.size(); - int front = 0; - int end = points.size() / 2; - while (front != end) { - m_vertices.at(--count) = points[2 * end - 1]; - m_vertices.at(--count) = points[2 * end - 2]; - --end; - if (front == end) - break; - m_vertices.at(--count) = points[2 * front + 1]; - m_vertices.at(--count) = points[2 * front + 0]; - ++front; - } - - if (invisibleJump) { - m_vertices.at(count - 1) = m_vertices.at(count + 1); - m_vertices.at(count - 2) = m_vertices.at(count + 0); - } - break; } - default: break; // ssssh gcc... - } - emitLineSegment(m_cx, m_cy, m_nvx, m_nvy); -} - -void QTriangulatingStroker::cubicTo(const qreal *pts) -{ - const QPointF *p = (const QPointF *) pts; - QBezier bezier = QBezier::fromPoints(*(p - 1), p[0], p[1], p[2]); - - QRectF bounds = bezier.bounds(); - float rad = qMax(bounds.width(), bounds.height()); - int threshold = qMin(64, (rad + m_curvyness_add) * m_curvyness_mul); - if (threshold < 4) - threshold = 4; - qreal threshold_minus_1 = threshold - 1; - float vx, vy; - - float cx = m_cx, cy = m_cy; - float x, y; - - for (int i=1; i (pts[0], pts[1]) - normalVector(m_cx, m_cy, pts[0], pts[1], &m_nvx, &m_nvy); - - switch (m_join_style) { - case Qt::BevelJoin: - break; - case Qt::SvgMiterJoin: - case Qt::MiterJoin: { - // Find out on which side the join should be. - int count = m_vertices.size(); - float prevNvx = m_vertices.at(count - 2) - m_cx; - float prevNvy = m_vertices.at(count - 1) - m_cy; - float xprod = prevNvx * m_nvy - prevNvy * m_nvx; - float px, py, qx, qy; - - // If the segments are parallel, use bevel join. - if (qFuzzyIsNull(xprod)) - break; - - // Find the corners of the previous and next segment to join. - if (xprod < 0) { - px = m_vertices.at(count - 2); - py = m_vertices.at(count - 1); - qx = m_cx - m_nvx; - qy = m_cy - m_nvy; - } else { - px = m_vertices.at(count - 4); - py = m_vertices.at(count - 3); - qx = m_cx + m_nvx; - qy = m_cy + m_nvy; - } - - // Find intersection point. - float pu = px * prevNvx + py * prevNvy; - float qv = qx * m_nvx + qy * m_nvy; - float ix = (m_nvy * pu - prevNvy * qv) / xprod; - float iy = (prevNvx * qv - m_nvx * pu) / xprod; - - // Check that the distance to the intersection point is less than the miter limit. - if ((ix - px) * (ix - px) + (iy - py) * (iy - py) <= m_miter_limit * m_miter_limit) { - m_vertices.add(ix); - m_vertices.add(iy); - m_vertices.add(ix); - m_vertices.add(iy); - } - // else - // Do a plain bevel join if the miter limit is exceeded or if - // the lines are parallel. This is not what the raster - // engine's stroker does, but it is both faster and similar to - // what some other graphics API's do. - - break; } - case Qt::RoundJoin: { - QVarLengthArray points; - int count = m_vertices.size(); - float prevNvx = m_vertices.at(count - 2) - m_cx; - float prevNvy = m_vertices.at(count - 1) - m_cy; - if (m_nvx * prevNvy - m_nvy * prevNvx < 0) { - arcPoints(0, 0, m_nvx, m_nvy, -prevNvx, -prevNvy, points); - for (int i = points.size() / 2; i > 0; --i) - emitLineSegment(m_cx, m_cy, points[2 * i - 2], points[2 * i - 1]); - } else { - arcPoints(0, 0, -prevNvx, -prevNvy, m_nvx, m_nvy, points); - for (int i = 0; i < points.size() / 2; ++i) - emitLineSegment(m_cx, m_cy, points[2 * i + 0], points[2 * i + 1]); - } - break; } - default: break; // gcc warn-- - } - - emitLineSegment(m_cx, m_cy, m_nvx, m_nvy); -} - -void QTriangulatingStroker::endCap(const qreal *) -{ - switch (m_cap_style) { - case Qt::FlatCap: - break; - case Qt::SquareCap: - emitLineSegment(m_cx + m_nvy, m_cy - m_nvx, m_nvx, m_nvy); - break; - case Qt::RoundCap: { - QVarLengthArray points; - int count = m_vertices.size(); - arcPoints(m_cx, m_cy, m_vertices.at(count - 2), m_vertices.at(count - 1), m_vertices.at(count - 4), m_vertices.at(count - 3), points); - int front = 0; - int end = points.size() / 2; - while (front != end) { - m_vertices.add(points[2 * end - 2]); - m_vertices.add(points[2 * end - 1]); - --end; - if (front == end) - break; - m_vertices.add(points[2 * front + 0]); - m_vertices.add(points[2 * front + 1]); - ++front; - } - break; } - default: break; // to shut gcc up... - } -} - -void QTriangulatingStroker::arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray &points) -{ - float dx1 = fromX - cx; - float dy1 = fromY - cy; - float dx2 = toX - cx; - float dy2 = toY - cy; - - // while more than 180 degrees left: - while (dx1 * dy2 - dx2 * dy1 < 0) { - float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; - float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; - dx1 = tmpx; - dy1 = tmpy; - points.append(cx + dx1); - points.append(cy + dy1); - } - - // while more than 90 degrees left: - while (dx1 * dx2 + dy1 * dy2 < 0) { - float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; - float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; - dx1 = tmpx; - dy1 = tmpy; - points.append(cx + dx1); - points.append(cy + dy1); - } - - // while more than 0 degrees left: - while (dx1 * dy2 - dx2 * dy1 > 0) { - float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta; - float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta; - dx1 = tmpx; - dy1 = tmpy; - points.append(cx + dx1); - points.append(cy + dy1); - } - - // remove last point which was rotated beyond [toX, toY]. - if (!points.isEmpty()) - points.resize(points.size() - 2); -} - -static void qdashprocessor_moveTo(qreal x, qreal y, void *data) -{ - ((QDashedStrokeProcessor *) data)->addElement(QPainterPath::MoveToElement, x, y); -} - -static void qdashprocessor_lineTo(qreal x, qreal y, void *data) -{ - ((QDashedStrokeProcessor *) data)->addElement(QPainterPath::LineToElement, x, y); -} - -static void qdashprocessor_cubicTo(qreal, qreal, qreal, qreal, qreal, qreal, void *) -{ - Q_ASSERT(0); // The dasher should not produce curves... -} - -QDashedStrokeProcessor::QDashedStrokeProcessor() - : m_points(0), m_types(0), - m_dash_stroker(0), m_inv_scale(1) -{ - m_dash_stroker.setMoveToHook(qdashprocessor_moveTo); - m_dash_stroker.setLineToHook(qdashprocessor_lineTo); - m_dash_stroker.setCubicToHook(qdashprocessor_cubicTo); -} - -void QDashedStrokeProcessor::process(const QVectorPath &path, const QPen &pen, const QRectF &clip) -{ - - const qreal *pts = path.points(); - const QPainterPath::ElementType *types = path.elements(); - int count = path.elementCount(); - - bool cosmetic = pen.isCosmetic(); - - m_points.reset(); - m_types.reset(); - m_points.reserve(path.elementCount()); - m_types.reserve(path.elementCount()); - - qreal width = qpen_widthf(pen); - if (width == 0) - width = 1; - - m_dash_stroker.setDashPattern(pen.dashPattern()); - m_dash_stroker.setStrokeWidth(cosmetic ? width * m_inv_scale : width); - m_dash_stroker.setDashOffset(pen.dashOffset()); - m_dash_stroker.setMiterLimit(pen.miterLimit()); - m_dash_stroker.setClipRect(clip); - - float curvynessAdd, curvynessMul; - - // simplfy pens that are thin in device size (2px wide or less) - if (width < 2.5 && (cosmetic || m_inv_scale == 1)) { - curvynessAdd = 0.5; - curvynessMul = CURVE_FLATNESS / m_inv_scale; - } else if (cosmetic) { - curvynessAdd= width / 2; - curvynessMul= CURVE_FLATNESS; - } else { - curvynessAdd = width * m_inv_scale; - curvynessMul = CURVE_FLATNESS / m_inv_scale; - } - - if (count < 2) - return; - - const qreal *endPts = pts + (count<<1); - - m_dash_stroker.begin(this); - - if (!types) { - m_dash_stroker.moveTo(pts[0], pts[1]); - pts += 2; - while (pts < endPts) { - m_dash_stroker.lineTo(pts[0], pts[1]); - pts += 2; - } - } else { - while (pts < endPts) { - switch (*types) { - case QPainterPath::MoveToElement: - m_dash_stroker.moveTo(pts[0], pts[1]); - pts += 2; - ++types; - break; - case QPainterPath::LineToElement: - m_dash_stroker.lineTo(pts[0], pts[1]); - pts += 2; - ++types; - break; - case QPainterPath::CurveToElement: { - QBezier b = QBezier::fromPoints(*(((const QPointF *) pts) - 1), - *(((const QPointF *) pts)), - *(((const QPointF *) pts) + 1), - *(((const QPointF *) pts) + 2)); - QRectF bounds = b.bounds(); - float rad = qMax(bounds.width(), bounds.height()); - int threshold = qMin(64, (rad + curvynessAdd) * curvynessMul); - if (threshold < 4) - threshold = 4; - - qreal threshold_minus_1 = threshold - 1; - for (int i=0; i -#include -#include -#include -#include -#include - -QT_BEGIN_NAMESPACE - -class QTriangulatingStroker -{ -public: - QTriangulatingStroker() : m_vertices(0) {} - void process(const QVectorPath &path, const QPen &pen, const QRectF &clip); - - inline int vertexCount() const { return m_vertices.size(); } - inline const float *vertices() const { return m_vertices.data(); } - - inline void setInvScale(qreal invScale) { m_inv_scale = invScale; } - -private: - inline void emitLineSegment(float x, float y, float nx, float ny); - void moveTo(const qreal *pts); - inline void lineTo(const qreal *pts); - void cubicTo(const qreal *pts); - void join(const qreal *pts); - inline void normalVector(float x1, float y1, float x2, float y2, float *nx, float *ny); - void endCap(const qreal *pts); - void arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray &points); - void endCapOrJoinClosed(const qreal *start, const qreal *cur, bool implicitClose, bool endsAtStart); - - - QDataBuffer m_vertices; - - float m_cx, m_cy; // current points - float m_nvx, m_nvy; // normal vector... - float m_width; - qreal m_miter_limit; - - int m_roundness; // Number of line segments in a round join - qreal m_sin_theta; // sin(m_roundness / 360); - qreal m_cos_theta; // cos(m_roundness / 360); - qreal m_inv_scale; - float m_curvyness_mul; - float m_curvyness_add; - - Qt::PenJoinStyle m_join_style; - Qt::PenCapStyle m_cap_style; -}; - -class QDashedStrokeProcessor -{ -public: - QDashedStrokeProcessor(); - - void process(const QVectorPath &path, const QPen &pen, const QRectF &clip); - - inline void addElement(QPainterPath::ElementType type, qreal x, qreal y) { - m_points.add(x); - m_points.add(y); - m_types.add(type); - } - - inline int elementCount() const { return m_types.size(); } - inline qreal *points() const { return m_points.data(); } - inline QPainterPath::ElementType *elementTypes() const { return m_types.data(); } - - inline void setInvScale(qreal invScale) { m_inv_scale = invScale; } - -private: - QDataBuffer m_points; - QDataBuffer m_types; - QDashStroker m_dash_stroker; - qreal m_inv_scale; -}; - -inline void QTriangulatingStroker::normalVector(float x1, float y1, float x2, float y2, - float *nx, float *ny) -{ - float dx = x2 - x1; - float dy = y2 - y1; - - float pw; - - if (dx == 0) - pw = m_width / qAbs(dy); - else if (dy == 0) - pw = m_width / qAbs(dx); - else - pw = m_width / sqrt(dx*dx + dy*dy); - - *nx = -dy * pw; - *ny = dx * pw; -} - -inline void QTriangulatingStroker::emitLineSegment(float x, float y, float vx, float vy) -{ - m_vertices.add(x + vx); - m_vertices.add(y + vy); - m_vertices.add(x - vx); - m_vertices.add(y - vy); -} - -void QTriangulatingStroker::lineTo(const qreal *pts) -{ - emitLineSegment(pts[0], pts[1], m_nvx, m_nvy); - m_cx = pts[0]; - m_cy = pts[1]; -} - -QT_END_NAMESPACE - -#endif diff --git a/src/opengl/opengl.pro b/src/opengl/opengl.pro index 8c291c862b..c71790dfa8 100644 --- a/src/opengl/opengl.pro +++ b/src/opengl/opengl.pro @@ -48,7 +48,6 @@ HEADERS += qglshaderprogram.h \ gl2paintengineex/qpaintengineex_opengl2_p.h \ gl2paintengineex/qglengineshadersource_p.h \ gl2paintengineex/qglcustomshaderstage_p.h \ - gl2paintengineex/qtriangulatingstroker_p.h \ gl2paintengineex/qtextureglyphcache_gl_p.h \ gl2paintengineex/qglshadercache_p.h \ gl2paintengineex/qglshadercache_meego_p.h @@ -60,7 +59,6 @@ SOURCES += qglshaderprogram.cpp \ gl2paintengineex/qgl2pexvertexarray.cpp \ gl2paintengineex/qpaintengineex_opengl2.cpp \ gl2paintengineex/qglcustomshaderstage.cpp \ - gl2paintengineex/qtriangulatingstroker.cpp \ gl2paintengineex/qtextureglyphcache_gl.cpp SOURCES += qgl_qpa.cpp \ -- cgit v1.2.3