Qt 4.8
Public Functions | Private Functions | Properties | List of all members
QTriangulatingStroker Class Reference

#include <qtriangulatingstroker_p.h>

Public Functions

void process (const QVectorPath &path, const QPen &pen, const QRectF &clip)
 
 QTriangulatingStroker ()
 
void setInvScale (qreal invScale)
 
int vertexCount () const
 
const float * vertices () const
 

Private Functions

void arcPoints (float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray< float > &points)
 
void cubicTo (const qreal *pts)
 
void emitLineSegment (float x, float y, float nx, float ny)
 
void endCap (const qreal *pts)
 
void endCapOrJoinClosed (const qreal *start, const qreal *cur, bool implicitClose, bool endsAtStart)
 
void join (const qreal *pts)
 
void lineTo (const qreal *pts)
 
void moveTo (const qreal *pts)
 
void normalVector (float x1, float y1, float x2, float y2, float *nx, float *ny)
 

Properties

Qt::PenCapStyle m_cap_style
 
qreal m_cos_theta
 
float m_curvyness_add
 
float m_curvyness_mul
 
float m_cx
 
float m_cy
 
qreal m_inv_scale
 
Qt::PenJoinStyle m_join_style
 
qreal m_miter_limit
 
float m_nvx
 
float m_nvy
 
int m_roundness
 
qreal m_sin_theta
 
QDataBuffer< float > m_vertices
 
float m_width
 

Detailed Description

Definition at line 54 of file qtriangulatingstroker_p.h.

Constructors and Destructors

◆ QTriangulatingStroker()

QTriangulatingStroker::QTriangulatingStroker ( )
inline

Definition at line 57 of file qtriangulatingstroker_p.h.

57 : m_vertices(0) {}
QDataBuffer< float > m_vertices

Functions

◆ arcPoints()

void QTriangulatingStroker::arcPoints ( float  cx,
float  cy,
float  fromX,
float  fromY,
float  toX,
float  toY,
QVarLengthArray< float > &  points 
)
private

Definition at line 426 of file qtriangulatingstroker.cpp.

Referenced by endCap(), join(), moveTo(), and setInvScale().

427 {
428  float dx1 = fromX - cx;
429  float dy1 = fromY - cy;
430  float dx2 = toX - cx;
431  float dy2 = toY - cy;
432 
433  // while more than 180 degrees left:
434  while (dx1 * dy2 - dx2 * dy1 < 0) {
435  float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta;
436  float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta;
437  dx1 = tmpx;
438  dy1 = tmpy;
439  points.append(cx + dx1);
440  points.append(cy + dy1);
441  }
442 
443  // while more than 90 degrees left:
444  while (dx1 * dx2 + dy1 * dy2 < 0) {
445  float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta;
446  float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta;
447  dx1 = tmpx;
448  dy1 = tmpy;
449  points.append(cx + dx1);
450  points.append(cy + dy1);
451  }
452 
453  // while more than 0 degrees left:
454  while (dx1 * dy2 - dx2 * dy1 > 0) {
455  float tmpx = dx1 * m_cos_theta - dy1 * m_sin_theta;
456  float tmpy = dx1 * m_sin_theta + dy1 * m_cos_theta;
457  dx1 = tmpx;
458  dy1 = tmpy;
459  points.append(cx + dx1);
460  points.append(cy + dy1);
461  }
462 
463  // remove last point which was rotated beyond [toX, toY].
464  if (!points.isEmpty())
465  points.resize(points.size() - 2);
466 }
void resize(int size)
void append(const T &t)
bool isEmpty() const
int size() const

◆ cubicTo()

void QTriangulatingStroker::cubicTo ( const qreal pts)
private

Definition at line 285 of file qtriangulatingstroker.cpp.

Referenced by process(), and setInvScale().

286 {
287  const QPointF *p = (const QPointF *) pts;
288  QBezier bezier = QBezier::fromPoints(*(p - 1), p[0], p[1], p[2]);
289 
290  QRectF bounds = bezier.bounds();
291  float rad = qMax(bounds.width(), bounds.height());
292  int threshold = qMin<float>(64, (rad + m_curvyness_add) * m_curvyness_mul);
293  if (threshold < 4)
294  threshold = 4;
295  qreal threshold_minus_1 = threshold - 1;
296  float vx, vy;
297 
298  float cx = m_cx, cy = m_cy;
299  float x, y;
300 
301  for (int i=1; i<threshold; ++i) {
302  qreal t = qreal(i) / threshold_minus_1;
303  QPointF p = bezier.pointAt(t);
304  x = p.x();
305  y = p.y();
306 
307  normalVector(cx, cy, x, y, &vx, &vy);
308 
309  emitLineSegment(x, y, vx, vy);
310 
311  cx = x;
312  cy = y;
313  }
314 
315  m_cx = cx;
316  m_cy = cy;
317 
318  m_nvx = vx;
319  m_nvy = vy;
320 }
double qreal
Definition: qglobal.h:1193
The QPointF class defines a point in the plane using floating point precision.
Definition: qpoint.h:214
QPointF pointAt(qreal t) const
Definition: qbezier_p.h:163
void emitLineSegment(float x, float y, float nx, float ny)
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
qreal x() const
Returns the x-coordinate of this point.
Definition: qpoint.h:282
static QBezier fromPoints(const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &p4)
Definition: qbezier.cpp:71
The QRectF class defines a rectangle in the plane using floating point precision. ...
Definition: qrect.h:511
void normalVector(float x1, float y1, float x2, float y2, float *nx, float *ny)
qreal height() const
Returns the height of the rectangle.
Definition: qrect.h:710
qreal width() const
Returns the width of the rectangle.
Definition: qrect.h:707
QRectF bounds() const
Definition: qbezier.cpp:223
qreal y() const
Returns the y-coordinate of this point.
Definition: qpoint.h:287

◆ emitLineSegment()

void QTriangulatingStroker::emitLineSegment ( float  x,
float  y,
float  nx,
float  ny 
)
inlineprivate

Definition at line 140 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), endCap(), join(), lineTo(), moveTo(), and setInvScale().

141 {
142  m_vertices.add(x + vx);
143  m_vertices.add(y + vy);
144  m_vertices.add(x - vx);
145  m_vertices.add(y - vy);
146 }
void add(const Type &t)
Definition: qdatabuffer_p.h:93
QDataBuffer< float > m_vertices

◆ endCap()

void QTriangulatingStroker::endCap ( const qreal pts)
private

Definition at line 397 of file qtriangulatingstroker.cpp.

Referenced by endCapOrJoinClosed(), and setInvScale().

398 {
399  switch (m_cap_style) {
400  case Qt::FlatCap:
401  break;
402  case Qt::SquareCap:
404  break;
405  case Qt::RoundCap: {
406  QVarLengthArray<float> points;
407  int count = m_vertices.size();
408  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);
409  int front = 0;
410  int end = points.size() / 2;
411  while (front != end) {
412  m_vertices.add(points[2 * end - 2]);
413  m_vertices.add(points[2 * end - 1]);
414  --end;
415  if (front == end)
416  break;
417  m_vertices.add(points[2 * front + 0]);
418  m_vertices.add(points[2 * front + 1]);
419  ++front;
420  }
421  break; }
422  default: break; // to shut gcc up...
423  }
424 }
void emitLineSegment(float x, float y, float nx, float ny)
Type & at(int i)
Definition: qdatabuffer_p.h:86
void add(const Type &t)
Definition: qdatabuffer_p.h:93
QDataBuffer< float > m_vertices
void arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray< float > &points)
static const KeyPair *const end
int size() const
int size() const
Definition: qdatabuffer_p.h:83

◆ endCapOrJoinClosed()

void QTriangulatingStroker::endCapOrJoinClosed ( const qreal start,
const qreal cur,
bool  implicitClose,
bool  endsAtStart 
)
private

Definition at line 52 of file qtriangulatingstroker.cpp.

Referenced by process(), and setInvScale().

54 {
55  if (endsAtStart) {
56  join(start + 2);
57  } else if (implicitClose) {
58  join(start);
59  lineTo(start);
60  join(start+2);
61  } else {
62  endCap(cur);
63  }
64  int count = m_vertices.size();
65 
66  // Copy the (x, y) values because QDataBuffer::add(const float& t)
67  // may resize the buffer, which will leave t pointing at the
68  // previous buffer's memory region if we don't copy first.
69  float x = m_vertices.at(count-2);
70  float y = m_vertices.at(count-1);
71  m_vertices.add(x);
72  m_vertices.add(y);
73 }
Type & at(int i)
Definition: qdatabuffer_p.h:86
void add(const Type &t)
Definition: qdatabuffer_p.h:93
QDataBuffer< float > m_vertices
void join(const qreal *pts)
void lineTo(const qreal *pts)
void endCap(const qreal *pts)
int size() const
Definition: qdatabuffer_p.h:83

◆ join()

void QTriangulatingStroker::join ( const qreal pts)
private

Definition at line 322 of file qtriangulatingstroker.cpp.

Referenced by endCapOrJoinClosed(), process(), and setInvScale().

323 {
324  // Creates a join to the next segment (m_cx, m_cy) -> (pts[0], pts[1])
325  normalVector(m_cx, m_cy, pts[0], pts[1], &m_nvx, &m_nvy);
326 
327  switch (m_join_style) {
328  case Qt::BevelJoin:
329  break;
330  case Qt::SvgMiterJoin:
331  case Qt::MiterJoin: {
332  // Find out on which side the join should be.
333  int count = m_vertices.size();
334  float prevNvx = m_vertices.at(count - 2) - m_cx;
335  float prevNvy = m_vertices.at(count - 1) - m_cy;
336  float xprod = prevNvx * m_nvy - prevNvy * m_nvx;
337  float px, py, qx, qy;
338 
339  // If the segments are parallel, use bevel join.
340  if (qFuzzyIsNull(xprod))
341  break;
342 
343  // Find the corners of the previous and next segment to join.
344  if (xprod < 0) {
345  px = m_vertices.at(count - 2);
346  py = m_vertices.at(count - 1);
347  qx = m_cx - m_nvx;
348  qy = m_cy - m_nvy;
349  } else {
350  px = m_vertices.at(count - 4);
351  py = m_vertices.at(count - 3);
352  qx = m_cx + m_nvx;
353  qy = m_cy + m_nvy;
354  }
355 
356  // Find intersection point.
357  float pu = px * prevNvx + py * prevNvy;
358  float qv = qx * m_nvx + qy * m_nvy;
359  float ix = (m_nvy * pu - prevNvy * qv) / xprod;
360  float iy = (prevNvx * qv - m_nvx * pu) / xprod;
361 
362  // Check that the distance to the intersection point is less than the miter limit.
363  if ((ix - px) * (ix - px) + (iy - py) * (iy - py) <= m_miter_limit * m_miter_limit) {
364  m_vertices.add(ix);
365  m_vertices.add(iy);
366  m_vertices.add(ix);
367  m_vertices.add(iy);
368  }
369  // else
370  // Do a plain bevel join if the miter limit is exceeded or if
371  // the lines are parallel. This is not what the raster
372  // engine's stroker does, but it is both faster and similar to
373  // what some other graphics API's do.
374 
375  break; }
376  case Qt::RoundJoin: {
377  QVarLengthArray<float> points;
378  int count = m_vertices.size();
379  float prevNvx = m_vertices.at(count - 2) - m_cx;
380  float prevNvy = m_vertices.at(count - 1) - m_cy;
381  if (m_nvx * prevNvy - m_nvy * prevNvx < 0) {
382  arcPoints(0, 0, m_nvx, m_nvy, -prevNvx, -prevNvy, points);
383  for (int i = points.size() / 2; i > 0; --i)
384  emitLineSegment(m_cx, m_cy, points[2 * i - 2], points[2 * i - 1]);
385  } else {
386  arcPoints(0, 0, -prevNvx, -prevNvy, m_nvx, m_nvy, points);
387  for (int i = 0; i < points.size() / 2; ++i)
388  emitLineSegment(m_cx, m_cy, points[2 * i + 0], points[2 * i + 1]);
389  }
390  break; }
391  default: break; // gcc warn--
392  }
393 
394  emitLineSegment(m_cx, m_cy, m_nvx, m_nvy);
395 }
void emitLineSegment(float x, float y, float nx, float ny)
void normalVector(float x1, float y1, float x2, float y2, float *nx, float *ny)
Type & at(int i)
Definition: qdatabuffer_p.h:86
void add(const Type &t)
Definition: qdatabuffer_p.h:93
QDataBuffer< float > m_vertices
void arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray< float > &points)
static Q_DECL_CONSTEXPR bool qFuzzyIsNull(double d)
Definition: qglobal.h:2043
int size() const
int size() const
Definition: qdatabuffer_p.h:83

◆ lineTo()

void QTriangulatingStroker::lineTo ( const qreal pts)
inlineprivate

Definition at line 148 of file qtriangulatingstroker_p.h.

Referenced by endCapOrJoinClosed(), process(), and setInvScale().

149 {
150  emitLineSegment(pts[0], pts[1], m_nvx, m_nvy);
151  m_cx = pts[0];
152  m_cy = pts[1];
153 }
void emitLineSegment(float x, float y, float nx, float ny)

◆ moveTo()

void QTriangulatingStroker::moveTo ( const qreal pts)
private

Definition at line 226 of file qtriangulatingstroker.cpp.

Referenced by process(), and setInvScale().

227 {
228  m_cx = pts[0];
229  m_cy = pts[1];
230 
231  float x2 = pts[2];
232  float y2 = pts[3];
233  normalVector(m_cx, m_cy, x2, y2, &m_nvx, &m_nvy);
234 
235 
236  // To acheive jumps we insert zero-area tringles. This is done by
237  // adding two identical points in both the end of previous strip
238  // and beginning of next strip
239  bool invisibleJump = m_vertices.size();
240 
241  switch (m_cap_style) {
242  case Qt::FlatCap:
243  if (invisibleJump) {
246  }
247  break;
248  case Qt::SquareCap: {
249  float sx = m_cx - m_nvy;
250  float sy = m_cy + m_nvx;
251  if (invisibleJump) {
252  m_vertices.add(sx + m_nvx);
253  m_vertices.add(sy + m_nvy);
254  }
255  emitLineSegment(sx, sy, m_nvx, m_nvy);
256  break; }
257  case Qt::RoundCap: {
258  QVarLengthArray<float> points;
259  arcPoints(m_cx, m_cy, m_cx + m_nvx, m_cy + m_nvy, m_cx - m_nvx, m_cy - m_nvy, points);
260  m_vertices.resize(m_vertices.size() + points.size() + 2 * int(invisibleJump));
261  int count = m_vertices.size();
262  int front = 0;
263  int end = points.size() / 2;
264  while (front != end) {
265  m_vertices.at(--count) = points[2 * end - 1];
266  m_vertices.at(--count) = points[2 * end - 2];
267  --end;
268  if (front == end)
269  break;
270  m_vertices.at(--count) = points[2 * front + 1];
271  m_vertices.at(--count) = points[2 * front + 0];
272  ++front;
273  }
274 
275  if (invisibleJump) {
276  m_vertices.at(count - 1) = m_vertices.at(count + 1);
277  m_vertices.at(count - 2) = m_vertices.at(count + 0);
278  }
279  break; }
280  default: break; // ssssh gcc...
281  }
282  emitLineSegment(m_cx, m_cy, m_nvx, m_nvy);
283 }
void resize(int size)
void emitLineSegment(float x, float y, float nx, float ny)
void normalVector(float x1, float y1, float x2, float y2, float *nx, float *ny)
Type & at(int i)
Definition: qdatabuffer_p.h:86
void add(const Type &t)
Definition: qdatabuffer_p.h:93
QDataBuffer< float > m_vertices
void arcPoints(float cx, float cy, float fromX, float fromY, float toX, float toY, QVarLengthArray< float > &points)
static const KeyPair *const end
int size() const
int size() const
Definition: qdatabuffer_p.h:83

◆ normalVector()

void QTriangulatingStroker::normalVector ( float  x1,
float  y1,
float  x2,
float  y2,
float *  nx,
float *  ny 
)
inlineprivate

Definition at line 121 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), join(), moveTo(), and setInvScale().

123 {
124  float dx = x2 - x1;
125  float dy = y2 - y1;
126 
127  float pw;
128 
129  if (dx == 0)
130  pw = m_width / qAbs(dy);
131  else if (dy == 0)
132  pw = m_width / qAbs(dx);
133  else
134  pw = m_width / sqrt(dx*dx + dy*dy);
135 
136  *nx = -dy * pw;
137  *ny = dx * pw;
138 }
Q_DECL_CONSTEXPR T qAbs(const T &t)
Definition: qglobal.h:1201

◆ process()

void QTriangulatingStroker::process ( const QVectorPath path,
const QPen pen,
const QRectF clip 
)

Definition at line 76 of file qtriangulatingstroker.cpp.

Referenced by QTriangulatingStroker().

77 {
78  const qreal *pts = path.points();
80  int count = path.elementCount();
81  if (count < 2)
82  return;
83 
84  float realWidth = qpen_widthf(pen);
85  if (realWidth == 0)
86  realWidth = 1;
87 
88  m_width = realWidth / 2;
89 
90  bool cosmetic = pen.isCosmetic();
91  if (cosmetic) {
93  }
94 
97  m_vertices.reset();
98  m_miter_limit = pen.miterLimit() * qpen_widthf(pen);
99 
100  // The curvyness is based on the notion that I originally wanted
101  // roughly one line segment pr 4 pixels. This may seem little, but
102  // because we sample at constantly incrementing B(t) E [0<t<1], we
103  // will get longer segments where the curvature is small and smaller
104  // segments when the curvature is high.
105  //
106  // To get a rough idea of the length of each curve, I pretend that
107  // the curve is a 90 degree arc, whose radius is
108  // qMax(curveBounds.width, curveBounds.height). Based on this
109  // logic we can estimate the length of the outline edges based on
110  // the radius + a pen width and adjusting for scale factors
111  // depending on if the pen is cosmetic or not.
112  //
113  // The curvyness value of PI/14 was based on,
114  // arcLength = 2*PI*r/4 = PI*r/2 and splitting length into somewhere
115  // between 3 and 8 where 5 seemed to be give pretty good results
116  // hence: Q_PI/14. Lower divisors will give more detail at the
117  // direct cost of performance.
118 
119  // simplfy pens that are thin in device size (2px wide or less)
120  if (realWidth < 2.5 && (cosmetic || m_inv_scale == 1)) {
121  if (m_cap_style == Qt::RoundCap)
125  m_curvyness_add = 0.5;
127  m_roundness = 1;
128  } else if (cosmetic) {
129  m_curvyness_add = realWidth / 2;
131  m_roundness = qMax<int>(4, realWidth * CURVE_FLATNESS);
132  } else {
135  m_roundness = qMax<int>(4, realWidth * m_curvyness_mul);
136  }
137 
138  // Over this level of segmentation, there doesn't seem to be any
139  // benefit, even for huge penWidth
140  if (m_roundness > 24)
141  m_roundness = 24;
142 
145 
146  const qreal *endPts = pts + (count<<1);
147  const qreal *startPts = 0;
148 
150 
151  if (!types) {
152  // skip duplicate points
153  while((pts + 2) < endPts && pts[0] == pts[2] && pts[1] == pts[3])
154  pts += 2;
155  if ((pts + 2) == endPts)
156  return;
157 
158  startPts = pts;
159 
160  bool endsAtStart = startPts[0] == *(endPts-2) && startPts[1] == *(endPts-1);
161 
162  if (endsAtStart || path.hasImplicitClose())
164  moveTo(pts);
165  m_cap_style = cap;
166  pts += 2;
167  lineTo(pts);
168  pts += 2;
169  while (pts < endPts) {
170  if (m_cx != pts[0] || m_cy != pts[1]) {
171  join(pts);
172  lineTo(pts);
173  }
174  pts += 2;
175  }
176 
177  endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart);
178 
179  } else {
180  bool endsAtStart = false;
181  while (pts < endPts) {
182  switch (*types) {
184  if (pts != path.points())
185  endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart);
186 
187  startPts = pts;
188  int end = (endPts - pts) / 2;
189  int i = 2; // Start looking to ahead since we never have two moveto's in a row
190  while (i<end && types[i] != QPainterPath::MoveToElement) {
191  ++i;
192  }
193  endsAtStart = startPts[0] == pts[i*2 - 2] && startPts[1] == pts[i*2 - 1];
194  if (endsAtStart || path.hasImplicitClose())
196 
197  moveTo(pts);
198  m_cap_style = cap;
199  pts+=2;
200  ++types;
201  break; }
203  if (*(types - 1) != QPainterPath::MoveToElement)
204  join(pts);
205  lineTo(pts);
206  pts+=2;
207  ++types;
208  break;
210  if (*(types - 1) != QPainterPath::MoveToElement)
211  join(pts);
212  cubicTo(pts);
213  pts+=6;
214  types+=3;
215  break;
216  default:
217  Q_ASSERT(false);
218  break;
219  }
220  }
221 
222  endCapOrJoinClosed(startPts, pts-2, path.hasImplicitClose(), endsAtStart);
223  }
224 }
ElementType
This enum describes the types of elements used to connect vertices in subpaths.
Definition: qpainterpath.h:70
double qreal
Definition: qglobal.h:1193
int elementCount() const
void cubicTo(const qreal *pts)
qreal qFastSin(qreal x)
Definition: qmath.h:264
#define CURVE_FLATNESS
Qt::PenJoinStyle qpen_joinStyle(const QPen &p)
Definition: qpainter_p.h:91
Qt::PenCapStyle qpen_capStyle(const QPen &p)
Definition: qpainter_p.h:90
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
const QPainterPath::ElementType * elements() const
PenCapStyle
Definition: qnamespace.h:1147
void endCapOrJoinClosed(const qreal *start, const qreal *cur, bool implicitClose, bool endsAtStart)
bool isCosmetic() const
Returns true if the pen is cosmetic; otherwise returns false.
Definition: qpen.cpp:840
qreal qpen_widthf(const QPen &p)
Definition: qpainter_p.h:88
QDataBuffer< float > m_vertices
static const struct @32 types[]
qreal miterLimit() const
Returns the miter limit of the pen.
Definition: qpen.cpp:589
void join(const qreal *pts)
qreal qFastCos(qreal x)
Definition: qmath.h:274
const qreal * points() const
void lineTo(const qreal *pts)
bool hasImplicitClose() const
void moveTo(const qreal *pts)
static const KeyPair *const end
void reset()
Definition: qdatabuffer_p.h:79
static const qreal Q_PI
Definition: qmath_p.h:61

◆ setInvScale()

void QTriangulatingStroker::setInvScale ( qreal  invScale)
inline

Definition at line 63 of file qtriangulatingstroker_p.h.

Referenced by QGL2PaintEngineExPrivate::updateMatrix().

63 { m_inv_scale = invScale; }

◆ vertexCount()

int QTriangulatingStroker::vertexCount ( ) const
inline

Definition at line 60 of file qtriangulatingstroker_p.h.

60 { return m_vertices.size(); }
QDataBuffer< float > m_vertices
int size() const
Definition: qdatabuffer_p.h:83

◆ vertices()

const float* QTriangulatingStroker::vertices ( ) const
inline

Definition at line 61 of file qtriangulatingstroker_p.h.

61 { return m_vertices.data(); }
Type * data() const
Definition: qdatabuffer_p.h:84
QDataBuffer< float > m_vertices

Properties

◆ m_cap_style

Qt::PenCapStyle QTriangulatingStroker::m_cap_style
private

Definition at line 92 of file qtriangulatingstroker_p.h.

Referenced by endCap(), moveTo(), and process().

◆ m_cos_theta

qreal QTriangulatingStroker::m_cos_theta
private

Definition at line 86 of file qtriangulatingstroker_p.h.

Referenced by arcPoints(), and process().

◆ m_curvyness_add

float QTriangulatingStroker::m_curvyness_add
private

Definition at line 89 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), and process().

◆ m_curvyness_mul

float QTriangulatingStroker::m_curvyness_mul
private

Definition at line 88 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), and process().

◆ m_cx

float QTriangulatingStroker::m_cx
private

Definition at line 79 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), endCap(), join(), lineTo(), moveTo(), and process().

◆ m_cy

float QTriangulatingStroker::m_cy
private

Definition at line 79 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), endCap(), join(), lineTo(), moveTo(), and process().

◆ m_inv_scale

qreal QTriangulatingStroker::m_inv_scale
private

◆ m_join_style

Qt::PenJoinStyle QTriangulatingStroker::m_join_style
private

Definition at line 91 of file qtriangulatingstroker_p.h.

Referenced by join(), and process().

◆ m_miter_limit

qreal QTriangulatingStroker::m_miter_limit
private

Definition at line 82 of file qtriangulatingstroker_p.h.

Referenced by join(), and process().

◆ m_nvx

float QTriangulatingStroker::m_nvx
private

Definition at line 80 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), endCap(), join(), lineTo(), and moveTo().

◆ m_nvy

float QTriangulatingStroker::m_nvy
private

Definition at line 80 of file qtriangulatingstroker_p.h.

Referenced by cubicTo(), endCap(), join(), lineTo(), and moveTo().

◆ m_roundness

int QTriangulatingStroker::m_roundness
private

Definition at line 84 of file qtriangulatingstroker_p.h.

Referenced by process().

◆ m_sin_theta

qreal QTriangulatingStroker::m_sin_theta
private

Definition at line 85 of file qtriangulatingstroker_p.h.

Referenced by arcPoints(), and process().

◆ m_vertices

QDataBuffer<float> QTriangulatingStroker::m_vertices
private

◆ m_width

float QTriangulatingStroker::m_width
private

Definition at line 81 of file qtriangulatingstroker_p.h.

Referenced by normalVector(), and process().


The documentation for this class was generated from the following files: