1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the QtGui module of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 3 requirements |
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
24 | ** |
25 | ** GNU General Public License Usage |
26 | ** Alternatively, this file may be used under the terms of the GNU |
27 | ** General Public License version 2.0 or (at your option) the GNU General |
28 | ** Public license version 3 or any later version approved by the KDE Free |
29 | ** Qt Foundation. The licenses are as published by the Free Software |
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
31 | ** included in the packaging of this file. Please review the following |
32 | ** information to ensure the GNU General Public License requirements will |
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
35 | ** |
36 | ** $QT_END_LICENSE$ |
37 | ** |
38 | ****************************************************************************/ |
39 | |
40 | #include "qcosmeticstroker_p.h" |
41 | #include "private/qpainterpath_p.h" |
42 | #include "private/qrgba64_p.h" |
43 | #include <qdebug.h> |
44 | |
45 | QT_BEGIN_NAMESPACE |
46 | |
47 | #if 0 |
48 | inline QString capString(int caps) |
49 | { |
50 | QString str; |
51 | if (caps & QCosmeticStroker::CapBegin) { |
52 | str += "CapBegin " ; |
53 | } |
54 | if (caps & QCosmeticStroker::CapEnd) { |
55 | str += "CapEnd " ; |
56 | } |
57 | return str; |
58 | } |
59 | #endif |
60 | |
61 | #define toF26Dot6(x) ((int)((x)*64.)) |
62 | |
63 | static inline uint sourceOver(uint d, uint color) |
64 | { |
65 | return color + BYTE_MUL(d, qAlpha(~color)); |
66 | } |
67 | |
68 | inline static int F16Dot16FixedDiv(int x, int y) |
69 | { |
70 | if (qAbs(x) > 0x7fff) |
71 | return qlonglong(x) * (1<<16) / y; |
72 | return x * (1<<16) / y; |
73 | } |
74 | |
75 | typedef void (*DrawPixel)(QCosmeticStroker *stroker, int x, int y, int coverage); |
76 | |
77 | namespace { |
78 | |
79 | struct Dasher { |
80 | QCosmeticStroker *stroker; |
81 | int *pattern; |
82 | int offset; |
83 | int dashIndex; |
84 | int dashOn; |
85 | |
86 | Dasher(QCosmeticStroker *s, bool reverse, int start, int stop) |
87 | : stroker(s) |
88 | { |
89 | int delta = stop - start; |
90 | if (reverse) { |
91 | pattern = stroker->reversePattern; |
92 | offset = stroker->patternLength - stroker->patternOffset - delta - ((start & 63) - 32); |
93 | dashOn = 0; |
94 | } else { |
95 | pattern = stroker->pattern; |
96 | offset = stroker->patternOffset - ((start & 63) - 32); |
97 | dashOn = 1; |
98 | } |
99 | offset %= stroker->patternLength; |
100 | if (offset < 0) |
101 | offset += stroker->patternLength; |
102 | |
103 | dashIndex = 0; |
104 | while (offset>= pattern[dashIndex]) |
105 | ++dashIndex; |
106 | |
107 | // qDebug() << " dasher" << offset/64. << reverse << dashIndex; |
108 | stroker->patternOffset += delta; |
109 | stroker->patternOffset %= stroker->patternLength; |
110 | } |
111 | |
112 | bool on() const { |
113 | return (dashIndex + dashOn) & 1; |
114 | } |
115 | void adjust() { |
116 | offset += 64; |
117 | if (offset >= pattern[dashIndex]) { |
118 | ++dashIndex; |
119 | dashIndex %= stroker->patternSize; |
120 | } |
121 | offset %= stroker->patternLength; |
122 | // qDebug() << "dasher.adjust" << offset/64. << dashIndex; |
123 | } |
124 | }; |
125 | |
126 | struct NoDasher { |
127 | NoDasher(QCosmeticStroker *, bool, int, int) {} |
128 | bool on() const { return true; } |
129 | void adjust(int = 0) {} |
130 | }; |
131 | |
132 | }; |
133 | |
134 | /* |
135 | * The return value is the result of the clipLine() call performed at the start |
136 | * of each of the two functions, aka "false" means completely outside the devices |
137 | * rect. |
138 | */ |
139 | template<DrawPixel drawPixel, class Dasher> |
140 | static bool drawLine(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); |
141 | template<DrawPixel drawPixel, class Dasher> |
142 | static bool drawLineAA(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); |
143 | |
144 | inline void drawPixel(QCosmeticStroker *stroker, int x, int y, int coverage) |
145 | { |
146 | const QRect &cl = stroker->clip; |
147 | if (x < cl.x() || x > cl.right() || y < cl.y() || y > cl.bottom()) |
148 | return; |
149 | |
150 | if (stroker->current_span > 0) { |
151 | const int lastx = stroker->spans[stroker->current_span-1].x + stroker->spans[stroker->current_span-1].len ; |
152 | const int lasty = stroker->spans[stroker->current_span-1].y; |
153 | |
154 | if (stroker->current_span == QCosmeticStroker::NSPANS || y < lasty || (y == lasty && x < lastx)) { |
155 | stroker->blend(stroker->current_span, stroker->spans, &stroker->state->penData); |
156 | stroker->current_span = 0; |
157 | } |
158 | } |
159 | |
160 | stroker->spans[stroker->current_span].x = ushort(x); |
161 | stroker->spans[stroker->current_span].len = 1; |
162 | stroker->spans[stroker->current_span].y = y; |
163 | stroker->spans[stroker->current_span].coverage = coverage*stroker->opacity >> 8; |
164 | ++stroker->current_span; |
165 | } |
166 | |
167 | inline void drawPixelARGB32(QCosmeticStroker *stroker, int x, int y, int coverage) |
168 | { |
169 | const QRect &cl = stroker->clip; |
170 | if (x < cl.x() || x > cl.right() || y < cl.y() || y > cl.bottom()) |
171 | return; |
172 | |
173 | int offset = x + stroker->ppl*y; |
174 | uint c = BYTE_MUL(stroker->color, coverage); |
175 | stroker->pixels[offset] = sourceOver(stroker->pixels[offset], c); |
176 | } |
177 | |
178 | inline void drawPixelARGB32Opaque(QCosmeticStroker *stroker, int x, int y, int) |
179 | { |
180 | const QRect &cl = stroker->clip; |
181 | if (x < cl.x() || x > cl.right() || y < cl.y() || y > cl.bottom()) |
182 | return; |
183 | |
184 | int offset = x + stroker->ppl*y; |
185 | stroker->pixels[offset] = sourceOver(stroker->pixels[offset], stroker->color); |
186 | } |
187 | |
188 | enum StrokeSelection { |
189 | Aliased = 0, |
190 | AntiAliased = 1, |
191 | Solid = 0, |
192 | Dashed = 2, |
193 | RegularDraw = 0, |
194 | FastDraw = 4 |
195 | }; |
196 | |
197 | static StrokeLine strokeLine(int strokeSelection) |
198 | { |
199 | StrokeLine stroke; |
200 | |
201 | switch (strokeSelection) { |
202 | case Aliased|Solid|RegularDraw: |
203 | stroke = &QT_PREPEND_NAMESPACE(drawLine)<drawPixel, NoDasher>; |
204 | break; |
205 | case Aliased|Solid|FastDraw: |
206 | stroke = &QT_PREPEND_NAMESPACE(drawLine)<drawPixelARGB32Opaque, NoDasher>; |
207 | break; |
208 | case Aliased|Dashed|RegularDraw: |
209 | stroke = &QT_PREPEND_NAMESPACE(drawLine)<drawPixel, Dasher>; |
210 | break; |
211 | case Aliased|Dashed|FastDraw: |
212 | stroke = &QT_PREPEND_NAMESPACE(drawLine)<drawPixelARGB32Opaque, Dasher>; |
213 | break; |
214 | case AntiAliased|Solid|RegularDraw: |
215 | stroke = &QT_PREPEND_NAMESPACE(drawLineAA)<drawPixel, NoDasher>; |
216 | break; |
217 | case AntiAliased|Solid|FastDraw: |
218 | stroke = &QT_PREPEND_NAMESPACE(drawLineAA)<drawPixelARGB32, NoDasher>; |
219 | break; |
220 | case AntiAliased|Dashed|RegularDraw: |
221 | stroke = &QT_PREPEND_NAMESPACE(drawLineAA)<drawPixel, Dasher>; |
222 | break; |
223 | case AntiAliased|Dashed|FastDraw: |
224 | stroke = &QT_PREPEND_NAMESPACE(drawLineAA)<drawPixelARGB32, Dasher>; |
225 | break; |
226 | default: |
227 | Q_ASSERT(false); |
228 | stroke = 0; |
229 | } |
230 | return stroke; |
231 | } |
232 | |
233 | void QCosmeticStroker::setup() |
234 | { |
235 | blend = state->penData.blend; |
236 | if (state->clip && state->clip->enabled && state->clip->hasRectClip && !state->clip->clipRect.isEmpty()) { |
237 | clip &= state->clip->clipRect; |
238 | blend = state->penData.unclipped_blend; |
239 | } |
240 | |
241 | int strokeSelection = 0; |
242 | if (blend == state->penData.unclipped_blend |
243 | && state->penData.type == QSpanData::Solid |
244 | && (state->penData.rasterBuffer->format == QImage::Format_ARGB32_Premultiplied |
245 | || state->penData.rasterBuffer->format == QImage::Format_RGB32) |
246 | && state->compositionMode() == QPainter::CompositionMode_SourceOver) |
247 | strokeSelection |= FastDraw; |
248 | |
249 | if (state->renderHints & QPainter::Antialiasing) |
250 | strokeSelection |= AntiAliased; |
251 | |
252 | const QVector<qreal> &penPattern = state->lastPen.dashPattern(); |
253 | if (penPattern.isEmpty()) { |
254 | Q_ASSERT(!pattern && !reversePattern); |
255 | pattern = 0; |
256 | reversePattern = 0; |
257 | patternLength = 0; |
258 | patternSize = 0; |
259 | } else { |
260 | pattern = (int *)malloc(penPattern.size()*sizeof(int)); |
261 | reversePattern = (int *)malloc(penPattern.size()*sizeof(int)); |
262 | patternSize = penPattern.size(); |
263 | |
264 | patternLength = 0; |
265 | for (int i = 0; i < patternSize; ++i) { |
266 | patternLength += (int) qMax(1. , penPattern.at(i)*64.); |
267 | pattern[i] = patternLength; |
268 | } |
269 | patternLength = 0; |
270 | for (int i = 0; i < patternSize; ++i) { |
271 | patternLength += (int) qMax(1., penPattern.at(patternSize - 1 - i)*64.); |
272 | reversePattern[i] = patternLength; |
273 | } |
274 | strokeSelection |= Dashed; |
275 | // qDebug() << "setup: size=" << patternSize << "length=" << patternLength/64.; |
276 | } |
277 | |
278 | stroke = strokeLine(strokeSelection); |
279 | |
280 | qreal width = state->lastPen.widthF(); |
281 | if (width == 0) |
282 | opacity = 256; |
283 | else if (qt_pen_is_cosmetic(state->lastPen, state->renderHints)) |
284 | opacity = (int) 256*width; |
285 | else |
286 | opacity = (int) 256*width*state->txscale; |
287 | opacity = qBound(0, opacity, 256); |
288 | |
289 | drawCaps = state->lastPen.capStyle() != Qt::FlatCap; |
290 | |
291 | if (strokeSelection & FastDraw) { |
292 | color = multiplyAlpha256(state->penData.solidColor, opacity).toArgb32(); |
293 | QRasterBuffer *buffer = state->penData.rasterBuffer; |
294 | pixels = (uint *)buffer->buffer(); |
295 | ppl = buffer->stride<quint32>(); |
296 | } |
297 | |
298 | // line drawing produces different results with different clips, so |
299 | // we need to clip consistently when painting to the same device |
300 | |
301 | // setup FP clip bounds |
302 | xmin = deviceRect.left() - 1; |
303 | xmax = deviceRect.right() + 2; |
304 | ymin = deviceRect.top() - 1; |
305 | ymax = deviceRect.bottom() + 2; |
306 | |
307 | lastPixel.x = INT_MIN; |
308 | lastPixel.y = INT_MIN; |
309 | } |
310 | |
311 | // returns true if the whole line gets clipped away |
312 | bool QCosmeticStroker::clipLine(qreal &x1, qreal &y1, qreal &x2, qreal &y2) |
313 | { |
314 | // basic/rough clipping is done in floating point coordinates to avoid |
315 | // integer overflow problems. |
316 | if (x1 < xmin) { |
317 | if (x2 <= xmin) |
318 | goto clipped; |
319 | y1 += (y2 - y1)/(x2 - x1) * (xmin - x1); |
320 | x1 = xmin; |
321 | } else if (x1 > xmax) { |
322 | if (x2 >= xmax) |
323 | goto clipped; |
324 | y1 += (y2 - y1)/(x2 - x1) * (xmax - x1); |
325 | x1 = xmax; |
326 | } |
327 | if (x2 < xmin) { |
328 | lastPixel.x = INT_MIN; |
329 | y2 += (y2 - y1)/(x2 - x1) * (xmin - x2); |
330 | x2 = xmin; |
331 | } else if (x2 > xmax) { |
332 | lastPixel.x = INT_MIN; |
333 | y2 += (y2 - y1)/(x2 - x1) * (xmax - x2); |
334 | x2 = xmax; |
335 | } |
336 | |
337 | if (y1 < ymin) { |
338 | if (y2 <= ymin) |
339 | goto clipped; |
340 | x1 += (x2 - x1)/(y2 - y1) * (ymin - y1); |
341 | y1 = ymin; |
342 | } else if (y1 > ymax) { |
343 | if (y2 >= ymax) |
344 | goto clipped; |
345 | x1 += (x2 - x1)/(y2 - y1) * (ymax - y1); |
346 | y1 = ymax; |
347 | } |
348 | if (y2 < ymin) { |
349 | lastPixel.x = INT_MIN; |
350 | x2 += (x2 - x1)/(y2 - y1) * (ymin - y2); |
351 | y2 = ymin; |
352 | } else if (y2 > ymax) { |
353 | lastPixel.x = INT_MIN; |
354 | x2 += (x2 - x1)/(y2 - y1) * (ymax - y2); |
355 | y2 = ymax; |
356 | } |
357 | |
358 | return false; |
359 | |
360 | clipped: |
361 | lastPixel.x = INT_MIN; |
362 | return true; |
363 | } |
364 | |
365 | |
366 | void QCosmeticStroker::drawLine(const QPointF &p1, const QPointF &p2) |
367 | { |
368 | if (p1 == p2) { |
369 | drawPoints(&p1, 1); |
370 | return; |
371 | } |
372 | |
373 | QPointF start = p1 * state->matrix; |
374 | QPointF end = p2 * state->matrix; |
375 | |
376 | patternOffset = state->lastPen.dashOffset()*64; |
377 | lastPixel.x = INT_MIN; |
378 | |
379 | stroke(this, start.x(), start.y(), end.x(), end.y(), drawCaps ? CapBegin|CapEnd : 0); |
380 | |
381 | blend(current_span, spans, &state->penData); |
382 | current_span = 0; |
383 | } |
384 | |
385 | void QCosmeticStroker::drawPoints(const QPoint *points, int num) |
386 | { |
387 | const QPoint *end = points + num; |
388 | while (points < end) { |
389 | QPointF p = QPointF(*points) * state->matrix; |
390 | drawPixel(this, qRound(p.x()), qRound(p.y()), 255); |
391 | ++points; |
392 | } |
393 | |
394 | blend(current_span, spans, &state->penData); |
395 | current_span = 0; |
396 | } |
397 | |
398 | void QCosmeticStroker::drawPoints(const QPointF *points, int num) |
399 | { |
400 | const QPointF *end = points + num; |
401 | while (points < end) { |
402 | QPointF p = (*points) * state->matrix; |
403 | drawPixel(this, qRound(p.x()), qRound(p.y()), 255); |
404 | ++points; |
405 | } |
406 | |
407 | blend(current_span, spans, &state->penData); |
408 | current_span = 0; |
409 | } |
410 | |
411 | void QCosmeticStroker::calculateLastPoint(qreal rx1, qreal ry1, qreal rx2, qreal ry2) |
412 | { |
413 | // this is basically the same code as used in the aliased stroke method, |
414 | // but it only determines the direction and last point of a line |
415 | // |
416 | // This is being used to have proper dropout control for closed contours |
417 | // by calculating the direction and last pixel of the last segment in the contour. |
418 | // the info is then used to perform dropout control when drawing the first line segment |
419 | // of the contour |
420 | lastPixel.x = INT_MIN; |
421 | lastPixel.y = INT_MIN; |
422 | |
423 | if (clipLine(rx1, ry1, rx2, ry2)) |
424 | return; |
425 | |
426 | const int half = legacyRounding ? 31 : 0; |
427 | int x1 = toF26Dot6(rx1) + half; |
428 | int y1 = toF26Dot6(ry1) + half; |
429 | int x2 = toF26Dot6(rx2) + half; |
430 | int y2 = toF26Dot6(ry2) + half; |
431 | |
432 | int dx = qAbs(x2 - x1); |
433 | int dy = qAbs(y2 - y1); |
434 | |
435 | if (dx < dy) { |
436 | // vertical |
437 | bool swapped = false; |
438 | if (y1 > y2) { |
439 | swapped = true; |
440 | qSwap(y1, y2); |
441 | qSwap(x1, x2); |
442 | } |
443 | int xinc = F16Dot16FixedDiv(x2 - x1, y2 - y1); |
444 | int x = x1 * (1<<10); |
445 | |
446 | int y = (y1 + 32) >> 6; |
447 | int ys = (y2 + 32) >> 6; |
448 | |
449 | int round = (xinc > 0) ? 32 : 0; |
450 | if (y != ys) { |
451 | x += ((y * (1<<6)) + round - y1) * xinc >> 6; |
452 | |
453 | if (swapped) { |
454 | lastPixel.x = x >> 16; |
455 | lastPixel.y = y; |
456 | lastDir = QCosmeticStroker::BottomToTop; |
457 | } else { |
458 | lastPixel.x = (x + (ys - y - 1)*xinc) >> 16; |
459 | lastPixel.y = ys - 1; |
460 | lastDir = QCosmeticStroker::TopToBottom; |
461 | } |
462 | lastAxisAligned = qAbs(xinc) < (1 << 14); |
463 | } |
464 | } else { |
465 | // horizontal |
466 | if (!dx) |
467 | return; |
468 | |
469 | bool swapped = false; |
470 | if (x1 > x2) { |
471 | swapped = true; |
472 | qSwap(x1, x2); |
473 | qSwap(y1, y2); |
474 | } |
475 | int yinc = F16Dot16FixedDiv(y2 - y1, x2 - x1); |
476 | int y = y1 << 10; |
477 | |
478 | int x = (x1 + 32) >> 6; |
479 | int xs = (x2 + 32) >> 6; |
480 | |
481 | int round = (yinc > 0) ? 32 : 0; |
482 | if (x != xs) { |
483 | y += ((x * (1<<6)) + round - x1) * yinc >> 6; |
484 | |
485 | if (swapped) { |
486 | lastPixel.x = x; |
487 | lastPixel.y = y >> 16; |
488 | lastDir = QCosmeticStroker::RightToLeft; |
489 | } else { |
490 | lastPixel.x = xs - 1; |
491 | lastPixel.y = (y + (xs - x - 1)*yinc) >> 16; |
492 | lastDir = QCosmeticStroker::LeftToRight; |
493 | } |
494 | lastAxisAligned = qAbs(yinc) < (1 << 14); |
495 | } |
496 | } |
497 | // qDebug() << " moveTo: setting last pixel to x/y dir" << lastPixel.x << lastPixel.y << lastDir; |
498 | } |
499 | |
500 | static inline const QPainterPath::ElementType *subPath(const QPainterPath::ElementType *t, const QPainterPath::ElementType *end, |
501 | const qreal *points, bool *closed) |
502 | { |
503 | const QPainterPath::ElementType *start = t; |
504 | ++t; |
505 | |
506 | // find out if the subpath is closed |
507 | while (t < end) { |
508 | if (*t == QPainterPath::MoveToElement) |
509 | break; |
510 | ++t; |
511 | } |
512 | |
513 | int offset = t - start - 1; |
514 | // qDebug() << "subpath" << offset << points[0] << points[1] << points[2*offset] << points[2*offset+1]; |
515 | *closed = (points[0] == points[2*offset] && points[1] == points[2*offset + 1]); |
516 | |
517 | return t; |
518 | } |
519 | |
520 | void QCosmeticStroker::drawPath(const QVectorPath &path) |
521 | { |
522 | // qDebug() << ">>>> drawpath" << path.convertToPainterPath() |
523 | // << "antialiasing:" << (bool)(state->renderHints & QPainter::Antialiasing) << " implicit close:" << path.hasImplicitClose(); |
524 | if (path.isEmpty()) |
525 | return; |
526 | |
527 | const qreal *points = path.points(); |
528 | const QPainterPath::ElementType *type = path.elements(); |
529 | |
530 | if (type) { |
531 | const QPainterPath::ElementType *end = type + path.elementCount(); |
532 | |
533 | while (type < end) { |
534 | Q_ASSERT(type == path.elements() || *type == QPainterPath::MoveToElement); |
535 | |
536 | QPointF p = QPointF(points[0], points[1]) * state->matrix; |
537 | patternOffset = state->lastPen.dashOffset()*64; |
538 | lastPixel.x = INT_MIN; |
539 | lastPixel.y = INT_MIN; |
540 | |
541 | bool closed; |
542 | const QPainterPath::ElementType *e = subPath(type, end, points, &closed); |
543 | if (closed) { |
544 | const qreal *p = points + 2*(e-type); |
545 | QPointF p1 = QPointF(p[-4], p[-3]) * state->matrix; |
546 | QPointF p2 = QPointF(p[-2], p[-1]) * state->matrix; |
547 | calculateLastPoint(p1.x(), p1.y(), p2.x(), p2.y()); |
548 | } |
549 | int caps = (!closed && drawCaps) ? CapBegin : NoCaps; |
550 | // qDebug() << "closed =" << closed << capString(caps); |
551 | |
552 | points += 2; |
553 | ++type; |
554 | |
555 | while (type < e) { |
556 | QPointF p2 = QPointF(points[0], points[1]) * state->matrix; |
557 | switch (*type) { |
558 | case QPainterPath::MoveToElement: |
559 | Q_ASSERT(!"Logic error" ); |
560 | break; |
561 | |
562 | case QPainterPath::LineToElement: |
563 | if (!closed && drawCaps && type == e - 1) |
564 | caps |= CapEnd; |
565 | stroke(this, p.x(), p.y(), p2.x(), p2.y(), caps); |
566 | p = p2; |
567 | points += 2; |
568 | ++type; |
569 | break; |
570 | |
571 | case QPainterPath::CurveToElement: { |
572 | if (!closed && drawCaps && type == e - 3) |
573 | caps |= CapEnd; |
574 | QPointF p3 = QPointF(points[2], points[3]) * state->matrix; |
575 | QPointF p4 = QPointF(points[4], points[5]) * state->matrix; |
576 | renderCubic(p, p2, p3, p4, caps); |
577 | p = p4; |
578 | type += 3; |
579 | points += 6; |
580 | break; |
581 | } |
582 | case QPainterPath::CurveToDataElement: |
583 | Q_ASSERT(!"QPainterPath::toSubpathPolygons(), bad element type" ); |
584 | break; |
585 | } |
586 | caps = NoCaps; |
587 | } |
588 | } |
589 | } else { // !type, simple polygon |
590 | QPointF p = QPointF(points[0], points[1]) * state->matrix; |
591 | QPointF movedTo = p; |
592 | patternOffset = state->lastPen.dashOffset()*64; |
593 | lastPixel.x = INT_MIN; |
594 | lastPixel.y = INT_MIN; |
595 | |
596 | const qreal *begin = points; |
597 | const qreal *end = points + 2*path.elementCount(); |
598 | // handle closed path case |
599 | bool closed = path.hasImplicitClose() || (points[0] == end[-2] && points[1] == end[-1]); |
600 | int caps = (!closed && drawCaps) ? CapBegin : NoCaps; |
601 | if (closed) { |
602 | QPointF p2; |
603 | if (points[0] == end[-2] && points[1] == end[-1] && path.elementCount() > 2) |
604 | p2 = QPointF(end[-4], end[-3]) * state->matrix; |
605 | else |
606 | p2 = QPointF(end[-2], end[-1]) * state->matrix; |
607 | calculateLastPoint(p2.x(), p2.y(), p.x(), p.y()); |
608 | } |
609 | |
610 | bool fastPenAliased = (state->flags.fast_pen && !state->flags.antialiased); |
611 | points += 2; |
612 | while (points < end) { |
613 | QPointF p2 = QPointF(points[0], points[1]) * state->matrix; |
614 | |
615 | if (!closed && drawCaps && points == end - 2) |
616 | caps |= CapEnd; |
617 | |
618 | bool moveNextStart = stroke(this, p.x(), p.y(), p2.x(), p2.y(), caps); |
619 | |
620 | /* fix for gaps in polylines with fastpen and aliased in a sequence |
621 | of points with small distances: if current point p2 has been dropped |
622 | out, keep last non dropped point p. |
623 | |
624 | However, if the line was completely outside the devicerect, we |
625 | still need to update p to avoid drawing the line after this one from |
626 | a bad starting position. |
627 | */ |
628 | if (!fastPenAliased || moveNextStart || points == begin + 2 || points == end - 2) |
629 | p = p2; |
630 | points += 2; |
631 | caps = NoCaps; |
632 | } |
633 | if (path.hasImplicitClose()) |
634 | stroke(this, p.x(), p.y(), movedTo.x(), movedTo.y(), NoCaps); |
635 | } |
636 | |
637 | |
638 | blend(current_span, spans, &state->penData); |
639 | current_span = 0; |
640 | } |
641 | |
642 | void QCosmeticStroker::renderCubic(const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &p4, int caps) |
643 | { |
644 | // qDebug() << ">>>> renderCubic" << p1 << p2 << p3 << p4 << capString(caps); |
645 | const int maxSubDivisions = 6; |
646 | PointF points[3*maxSubDivisions + 4]; |
647 | |
648 | points[3].x = p1.x(); |
649 | points[3].y = p1.y(); |
650 | points[2].x = p2.x(); |
651 | points[2].y = p2.y(); |
652 | points[1].x = p3.x(); |
653 | points[1].y = p3.y(); |
654 | points[0].x = p4.x(); |
655 | points[0].y = p4.y(); |
656 | |
657 | PointF *p = points; |
658 | int level = maxSubDivisions; |
659 | |
660 | renderCubicSubdivision(p, level, caps); |
661 | } |
662 | |
663 | static void splitCubic(QCosmeticStroker::PointF *points) |
664 | { |
665 | const qreal half = .5; |
666 | qreal a, b, c, d; |
667 | |
668 | points[6].x = points[3].x; |
669 | c = points[1].x; |
670 | d = points[2].x; |
671 | points[1].x = a = ( points[0].x + c ) * half; |
672 | points[5].x = b = ( points[3].x + d ) * half; |
673 | c = ( c + d ) * half; |
674 | points[2].x = a = ( a + c ) * half; |
675 | points[4].x = b = ( b + c ) * half; |
676 | points[3].x = ( a + b ) * half; |
677 | |
678 | points[6].y = points[3].y; |
679 | c = points[1].y; |
680 | d = points[2].y; |
681 | points[1].y = a = ( points[0].y + c ) * half; |
682 | points[5].y = b = ( points[3].y + d ) * half; |
683 | c = ( c + d ) * half; |
684 | points[2].y = a = ( a + c ) * half; |
685 | points[4].y = b = ( b + c ) * half; |
686 | points[3].y = ( a + b ) * half; |
687 | } |
688 | |
689 | void QCosmeticStroker::renderCubicSubdivision(QCosmeticStroker::PointF *points, int level, int caps) |
690 | { |
691 | if (level) { |
692 | qreal dx = points[3].x - points[0].x; |
693 | qreal dy = points[3].y - points[0].y; |
694 | qreal len = ((qreal).25) * (qAbs(dx) + qAbs(dy)); |
695 | |
696 | if (qAbs(dx * (points[0].y - points[2].y) - dy * (points[0].x - points[2].x)) >= len || |
697 | qAbs(dx * (points[0].y - points[1].y) - dy * (points[0].x - points[1].x)) >= len) { |
698 | splitCubic(points); |
699 | |
700 | --level; |
701 | renderCubicSubdivision(points + 3, level, caps & CapBegin); |
702 | renderCubicSubdivision(points, level, caps & CapEnd); |
703 | return; |
704 | } |
705 | } |
706 | |
707 | stroke(this, points[3].x, points[3].y, points[0].x, points[0].y, caps); |
708 | } |
709 | |
710 | static inline int swapCaps(int caps) |
711 | { |
712 | return ((caps & QCosmeticStroker::CapBegin) << 1) | |
713 | ((caps & QCosmeticStroker::CapEnd) >> 1); |
714 | } |
715 | |
716 | // adjust line by half a pixel |
717 | static inline void capAdjust(int caps, int &x1, int &x2, int &y, int yinc) |
718 | { |
719 | if (caps & QCosmeticStroker::CapBegin) { |
720 | x1 -= 32; |
721 | y -= yinc >> 1; |
722 | } |
723 | if (caps & QCosmeticStroker::CapEnd) { |
724 | x2 += 32; |
725 | } |
726 | } |
727 | |
728 | /* |
729 | The hard part about this is dropout control and avoiding douple drawing of points when |
730 | the drawing shifts from horizontal to vertical or back. |
731 | */ |
732 | template<DrawPixel drawPixel, class Dasher> |
733 | static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, qreal ry2, int caps) |
734 | { |
735 | bool didDraw = qAbs(rx2 - rx1) + qAbs(ry2 - ry1) >= 1.0; |
736 | |
737 | if (stroker->clipLine(rx1, ry1, rx2, ry2)) |
738 | return true; |
739 | |
740 | const int half = stroker->legacyRounding ? 31 : 0; |
741 | int x1 = toF26Dot6(rx1) + half; |
742 | int y1 = toF26Dot6(ry1) + half; |
743 | int x2 = toF26Dot6(rx2) + half; |
744 | int y2 = toF26Dot6(ry2) + half; |
745 | |
746 | int dx = qAbs(x2 - x1); |
747 | int dy = qAbs(y2 - y1); |
748 | |
749 | QCosmeticStroker::Point last = stroker->lastPixel; |
750 | |
751 | // qDebug() << "stroke" << x1/64. << y1/64. << x2/64. << y2/64.; |
752 | |
753 | if (dx < dy) { |
754 | // vertical |
755 | QCosmeticStroker::Direction dir = QCosmeticStroker::TopToBottom; |
756 | |
757 | bool swapped = false; |
758 | if (y1 > y2) { |
759 | swapped = true; |
760 | qSwap(y1, y2); |
761 | qSwap(x1, x2); |
762 | caps = swapCaps(caps); |
763 | dir = QCosmeticStroker::BottomToTop; |
764 | } |
765 | int xinc = F16Dot16FixedDiv(x2 - x1, y2 - y1); |
766 | int x = x1 * (1<<10); |
767 | |
768 | if ((stroker->lastDir ^ QCosmeticStroker::VerticalMask) == dir) |
769 | caps |= swapped ? QCosmeticStroker::CapEnd : QCosmeticStroker::CapBegin; |
770 | |
771 | capAdjust(caps, y1, y2, x, xinc); |
772 | |
773 | int y = (y1 + 32) >> 6; |
774 | int ys = (y2 + 32) >> 6; |
775 | int round = (xinc > 0) ? 32 : 0; |
776 | |
777 | // If capAdjust made us round away from what calculateLastPoint gave us, |
778 | // round back the other way so we start and end on the right point. |
779 | if ((caps & QCosmeticStroker::CapBegin) && stroker->lastPixel.y == y + 1) |
780 | y++; |
781 | |
782 | if (y != ys) { |
783 | x += ((y * (1<<6)) + round - y1) * xinc >> 6; |
784 | |
785 | // calculate first and last pixel and perform dropout control |
786 | QCosmeticStroker::Point first; |
787 | first.x = x >> 16; |
788 | first.y = y; |
789 | last.x = (x + (ys - y - 1)*xinc) >> 16; |
790 | last.y = ys - 1; |
791 | if (swapped) |
792 | qSwap(first, last); |
793 | |
794 | bool axisAligned = qAbs(xinc) < (1 << 14); |
795 | if (stroker->lastPixel.x > INT_MIN) { |
796 | if (first.x == stroker->lastPixel.x && |
797 | first.y == stroker->lastPixel.y) { |
798 | // remove duplicated pixel |
799 | if (swapped) { |
800 | --ys; |
801 | } else { |
802 | ++y; |
803 | x += xinc; |
804 | } |
805 | } else if (stroker->lastDir != dir && |
806 | (((axisAligned && stroker->lastAxisAligned) && |
807 | stroker->lastPixel.x != first.x && stroker->lastPixel.y != first.y) || |
808 | (qAbs(stroker->lastPixel.x - first.x) > 1 || |
809 | qAbs(stroker->lastPixel.y - first.y) > 1))) { |
810 | // have a missing pixel, insert it |
811 | if (swapped) { |
812 | ++ys; |
813 | } else { |
814 | --y; |
815 | x -= xinc; |
816 | } |
817 | } else if (stroker->lastDir == dir && |
818 | ((qAbs(stroker->lastPixel.x - first.x) <= 1 && |
819 | qAbs(stroker->lastPixel.y - first.y) > 1))) { |
820 | x += xinc >> 1; |
821 | if (swapped) |
822 | last.x = (x >> 16); |
823 | else |
824 | last.x = (x + (ys - y - 1)*xinc) >> 16; |
825 | } |
826 | } |
827 | stroker->lastDir = dir; |
828 | stroker->lastAxisAligned = axisAligned; |
829 | |
830 | Dasher dasher(stroker, swapped, y * (1<<6), ys * (1<<6)); |
831 | |
832 | do { |
833 | if (dasher.on()) |
834 | drawPixel(stroker, x >> 16, y, 255); |
835 | dasher.adjust(); |
836 | x += xinc; |
837 | } while (++y < ys); |
838 | didDraw = true; |
839 | } |
840 | } else { |
841 | // horizontal |
842 | if (!dx) |
843 | return true; |
844 | |
845 | QCosmeticStroker::Direction dir = QCosmeticStroker::LeftToRight; |
846 | |
847 | bool swapped = false; |
848 | if (x1 > x2) { |
849 | swapped = true; |
850 | qSwap(x1, x2); |
851 | qSwap(y1, y2); |
852 | caps = swapCaps(caps); |
853 | dir = QCosmeticStroker::RightToLeft; |
854 | } |
855 | int yinc = F16Dot16FixedDiv(y2 - y1, x2 - x1); |
856 | int y = y1 * (1<<10); |
857 | |
858 | if ((stroker->lastDir ^ QCosmeticStroker::HorizontalMask) == dir) |
859 | caps |= swapped ? QCosmeticStroker::CapEnd : QCosmeticStroker::CapBegin; |
860 | |
861 | capAdjust(caps, x1, x2, y, yinc); |
862 | |
863 | int x = (x1 + 32) >> 6; |
864 | int xs = (x2 + 32) >> 6; |
865 | int round = (yinc > 0) ? 32 : 0; |
866 | |
867 | // If capAdjust made us round away from what calculateLastPoint gave us, |
868 | // round back the other way so we start and end on the right point. |
869 | if ((caps & QCosmeticStroker::CapBegin) && stroker->lastPixel.x == x + 1) |
870 | x++; |
871 | |
872 | if (x != xs) { |
873 | y += ((x * (1<<6)) + round - x1) * yinc >> 6; |
874 | |
875 | // calculate first and last pixel to perform dropout control |
876 | QCosmeticStroker::Point first; |
877 | first.x = x; |
878 | first.y = y >> 16; |
879 | last.x = xs - 1; |
880 | last.y = (y + (xs - x - 1)*yinc) >> 16; |
881 | if (swapped) |
882 | qSwap(first, last); |
883 | |
884 | bool axisAligned = qAbs(yinc) < (1 << 14); |
885 | if (stroker->lastPixel.x > INT_MIN) { |
886 | if (first.x == stroker->lastPixel.x && first.y == stroker->lastPixel.y) { |
887 | // remove duplicated pixel |
888 | if (swapped) { |
889 | --xs; |
890 | } else { |
891 | ++x; |
892 | y += yinc; |
893 | } |
894 | } else if (stroker->lastDir != dir && |
895 | (((axisAligned && stroker->lastAxisAligned) && |
896 | stroker->lastPixel.x != first.x && stroker->lastPixel.y != first.y) || |
897 | (qAbs(stroker->lastPixel.x - first.x) > 1 || |
898 | qAbs(stroker->lastPixel.y - first.y) > 1))) { |
899 | // have a missing pixel, insert it |
900 | if (swapped) { |
901 | ++xs; |
902 | } else { |
903 | --x; |
904 | y -= yinc; |
905 | } |
906 | } else if (stroker->lastDir == dir && |
907 | ((qAbs(stroker->lastPixel.x - first.x) <= 1 && |
908 | qAbs(stroker->lastPixel.y - first.y) > 1))) { |
909 | y += yinc >> 1; |
910 | if (swapped) |
911 | last.y = (y >> 16); |
912 | else |
913 | last.y = (y + (xs - x - 1)*yinc) >> 16; |
914 | } |
915 | } |
916 | stroker->lastDir = dir; |
917 | stroker->lastAxisAligned = axisAligned; |
918 | |
919 | Dasher dasher(stroker, swapped, x * (1<<6), xs * (1<<6)); |
920 | |
921 | do { |
922 | if (dasher.on()) |
923 | drawPixel(stroker, x, y >> 16, 255); |
924 | dasher.adjust(); |
925 | y += yinc; |
926 | } while (++x < xs); |
927 | didDraw = true; |
928 | } |
929 | } |
930 | stroker->lastPixel = last; |
931 | return didDraw; |
932 | } |
933 | |
934 | |
935 | template<DrawPixel drawPixel, class Dasher> |
936 | static bool drawLineAA(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, qreal ry2, int caps) |
937 | { |
938 | if (stroker->clipLine(rx1, ry1, rx2, ry2)) |
939 | return true; |
940 | |
941 | int x1 = toF26Dot6(rx1); |
942 | int y1 = toF26Dot6(ry1); |
943 | int x2 = toF26Dot6(rx2); |
944 | int y2 = toF26Dot6(ry2); |
945 | |
946 | int dx = x2 - x1; |
947 | int dy = y2 - y1; |
948 | |
949 | if (qAbs(dx) < qAbs(dy)) { |
950 | // vertical |
951 | |
952 | int xinc = F16Dot16FixedDiv(dx, dy); |
953 | |
954 | bool swapped = false; |
955 | if (y1 > y2) { |
956 | qSwap(y1, y2); |
957 | qSwap(x1, x2); |
958 | swapped = true; |
959 | caps = swapCaps(caps); |
960 | } |
961 | |
962 | int x = (x1 - 32) * (1<<10); |
963 | x -= ( ((y1 & 63) - 32) * xinc ) >> 6; |
964 | |
965 | capAdjust(caps, y1, y2, x, xinc); |
966 | |
967 | Dasher dasher(stroker, swapped, y1, y2); |
968 | |
969 | int y = y1 >> 6; |
970 | int ys = y2 >> 6; |
971 | |
972 | int alphaStart, alphaEnd; |
973 | if (y == ys) { |
974 | alphaStart = y2 - y1; |
975 | Q_ASSERT(alphaStart >= 0 && alphaStart < 64); |
976 | alphaEnd = 0; |
977 | } else { |
978 | alphaStart = 64 - (y1 & 63); |
979 | alphaEnd = (y2 & 63); |
980 | } |
981 | // qDebug() << "vertical" << x1/64. << y1/64. << x2/64. << y2/64.; |
982 | // qDebug() << " x=" << x << "dx=" << dx << "xi=" << (x>>16) << "xsi=" << ((x+(ys-y)*dx)>>16) << "y=" << y << "ys=" << ys; |
983 | |
984 | // draw first pixel |
985 | if (dasher.on()) { |
986 | uint alpha = (quint8)(x >> 8); |
987 | drawPixel(stroker, x>>16, y, (255-alpha) * alphaStart >> 6); |
988 | drawPixel(stroker, (x>>16) + 1, y, alpha * alphaStart >> 6); |
989 | } |
990 | dasher.adjust(); |
991 | x += xinc; |
992 | ++y; |
993 | if (y < ys) { |
994 | do { |
995 | if (dasher.on()) { |
996 | uint alpha = (quint8)(x >> 8); |
997 | drawPixel(stroker, x>>16, y, (255-alpha)); |
998 | drawPixel(stroker, (x>>16) + 1, y, alpha); |
999 | } |
1000 | dasher.adjust(); |
1001 | x += xinc; |
1002 | } while (++y < ys); |
1003 | } |
1004 | // draw last pixel |
1005 | if (alphaEnd && dasher.on()) { |
1006 | uint alpha = (quint8)(x >> 8); |
1007 | drawPixel(stroker, x>>16, y, (255-alpha) * alphaEnd >> 6); |
1008 | drawPixel(stroker, (x>>16) + 1, y, alpha * alphaEnd >> 6); |
1009 | } |
1010 | } else { |
1011 | // horizontal |
1012 | if (!dx) |
1013 | return true; |
1014 | |
1015 | int yinc = F16Dot16FixedDiv(dy, dx); |
1016 | |
1017 | bool swapped = false; |
1018 | if (x1 > x2) { |
1019 | qSwap(x1, x2); |
1020 | qSwap(y1, y2); |
1021 | swapped = true; |
1022 | caps = swapCaps(caps); |
1023 | } |
1024 | |
1025 | int y = (y1 - 32) * (1<<10); |
1026 | y -= ( ((x1 & 63) - 32) * yinc ) >> 6; |
1027 | |
1028 | capAdjust(caps, x1, x2, y, yinc); |
1029 | |
1030 | Dasher dasher(stroker, swapped, x1, x2); |
1031 | |
1032 | int x = x1 >> 6; |
1033 | int xs = x2 >> 6; |
1034 | |
1035 | // qDebug() << "horizontal" << x1/64. << y1/64. << x2/64. << y2/64.; |
1036 | // qDebug() << " y=" << y << "dy=" << dy << "x=" << x << "xs=" << xs << "yi=" << (y>>16) << "ysi=" << ((y+(xs-x)*dy)>>16); |
1037 | int alphaStart, alphaEnd; |
1038 | if (x == xs) { |
1039 | alphaStart = x2 - x1; |
1040 | Q_ASSERT(alphaStart >= 0 && alphaStart < 64); |
1041 | alphaEnd = 0; |
1042 | } else { |
1043 | alphaStart = 64 - (x1 & 63); |
1044 | alphaEnd = (x2 & 63); |
1045 | } |
1046 | |
1047 | // draw first pixel |
1048 | if (dasher.on()) { |
1049 | uint alpha = (quint8)(y >> 8); |
1050 | drawPixel(stroker, x, y>>16, (255-alpha) * alphaStart >> 6); |
1051 | drawPixel(stroker, x, (y>>16) + 1, alpha * alphaStart >> 6); |
1052 | } |
1053 | dasher.adjust(); |
1054 | y += yinc; |
1055 | ++x; |
1056 | // draw line |
1057 | if (x < xs) { |
1058 | do { |
1059 | if (dasher.on()) { |
1060 | uint alpha = (quint8)(y >> 8); |
1061 | drawPixel(stroker, x, y>>16, (255-alpha)); |
1062 | drawPixel(stroker, x, (y>>16) + 1, alpha); |
1063 | } |
1064 | dasher.adjust(); |
1065 | y += yinc; |
1066 | } while (++x < xs); |
1067 | } |
1068 | // draw last pixel |
1069 | if (alphaEnd && dasher.on()) { |
1070 | uint alpha = (quint8)(y >> 8); |
1071 | drawPixel(stroker, x, y>>16, (255-alpha) * alphaEnd >> 6); |
1072 | drawPixel(stroker, x, (y>>16) + 1, alpha * alphaEnd >> 6); |
1073 | } |
1074 | } |
1075 | return true; |
1076 | } |
1077 | |
1078 | QT_END_NAMESPACE |
1079 | |