My Project
qtransform.h
1 #pragma once
2 #include "qmatrix.h"
3 #include "ParaRegion.h"
4 #include "ParaPoint.h"
5 #include "ParaRect.h"
6 #include "ParaLine.h"
7 
8 namespace ParaScripting{
9  class ParaPainter;
10 }
11 
12 namespace ParaEngine
13 {
14  class QTransform
15  {
16  public:
17  enum TransformationType {
18  TxNone = 0x00,
19  TxTranslate = 0x01,
20  TxScale = 0x02,
21  TxRotate = 0x04,
22  TxShear = 0x08,
23  TxProject = 0x10
24  };
25 
26  QTransform();
27  QTransform(float h11, float h12, float h13,
28  float h21, float h22, float h23,
29  float h31, float h32, float h33 = 1.0);
30  QTransform(float h11, float h12, float h21,
31  float h22, float dx, float dy);
32  explicit QTransform(const QMatrix &mtx);
33 
34  bool isAffine() const;
35  bool isIdentity() const;
36  bool isInvertible() const;
37  bool isScaling() const;
38  bool isRotating() const;
39  bool isTranslating() const;
40 
53  TransformationType type() const;
54 
55  inline float determinant() const;
56  float det() const;
57 
58  float m11() const;
59  float m12() const;
60  float m13() const;
61  float m21() const;
62  float m22() const;
63  float m23() const;
64  float m31() const;
65  float m32() const;
66  float m33() const;
67  float dx() const;
68  float dy() const;
69 
70  void setMatrix(float m11, float m12, float m13,
71  float m21, float m22, float m23,
72  float m31, float m32, float m33);
73 
74  QTransform inverted(bool *invertible = 0) const;
75  QTransform adjoint() const;
76  QTransform transposed() const;
77 
78  QTransform &translate(float dx, float dy);
79  QTransform &scale(float sx, float sy);
80  QTransform &shear(float sh, float sv);
81  QTransform &rotate(float a, ParaEngine::Axis axis = ZAxis);
82  QTransform &rotateRadians(float a, ParaEngine::Axis axis = ZAxis);
83 
84  bool operator==(const QTransform &) const;
85  bool operator!=(const QTransform &) const;
86 
87  QTransform &operator*=(const QTransform &);
88  QTransform operator*(const QTransform &o) const;
89 
90  QTransform &operator=(const QTransform &);
91 
92  void reset();
93  QPoint map(const QPoint &p) const;
94  QPointF map(const QPointF &p) const;
95  QLine map(const QLine &l) const;
96  QLineF map(const QLineF &l) const;
97  QRegion map(const QRegion &r) const;
98  QRect mapRect(const QRect &) const;
99  QRectF mapRect(const QRectF &) const;
100  void map(int x, int y, int *tx, int *ty) const;
101  void map(float x, float y, float *tx, float *ty) const;
102 
103  const QMatrix &toAffine() const;
104 
105  QTransform &operator*=(float div);
106  QTransform &operator/=(float div);
107  QTransform &operator+=(float div);
108  QTransform &operator-=(float div);
109 
110  static QTransform fromTranslate(float dx, float dy);
111  static QTransform fromScale(float dx, float dy);
112 
113  private:
114  friend class ParaPainter;
115  inline QTransform(float h11, float h12, float h13,
116  float h21, float h22, float h23,
117  float h31, float h32, float h33, bool)
118  : affine(h11, h12, h21, h22, h31, h32, true)
119  , m_13(h13), m_23(h23), m_33(h33)
120  , m_type(TxNone)
121  , m_dirty(TxProject) {}
122  inline QTransform(bool)
123  : affine(true)
124  , m_13(0), m_23(0), m_33(1)
125  , m_type(TxNone)
126  , m_dirty(TxNone) {}
127  inline TransformationType inline_type() const;
128  QMatrix affine;
129  float m_13;
130  float m_23;
131  float m_33;
132 
133  mutable unsigned int m_type : 5;
134  mutable unsigned int m_dirty : 5;
135  };
136 
137  /******* inlines *****/
138  inline QTransform::TransformationType QTransform::inline_type() const
139  {
140  if (m_dirty == TxNone)
141  return static_cast<TransformationType>(m_type);
142  return type();
143  }
144 
145  inline bool QTransform::isAffine() const
146  {
147  return inline_type() < TxProject;
148  }
149  inline bool QTransform::isIdentity() const
150  {
151  return inline_type() == TxNone;
152  }
153 
154  inline bool QTransform::isInvertible() const
155  {
156  return !Math::FuzzyIsNull(determinant());
157  }
158 
159  inline bool QTransform::isScaling() const
160  {
161  return type() >= TxScale;
162  }
163  inline bool QTransform::isRotating() const
164  {
165  return inline_type() >= TxRotate;
166  }
167 
168  inline bool QTransform::isTranslating() const
169  {
170  return inline_type() >= TxTranslate;
171  }
172 
173  inline float QTransform::determinant() const
174  {
175  return affine._m11*(m_33*affine._m22 - affine._dy*m_23) -
176  affine._m21*(m_33*affine._m12 - affine._dy*m_13) + affine._dx*(m_23*affine._m12 - affine._m22*m_13);
177  }
178  inline float QTransform::det() const
179  {
180  return determinant();
181  }
182  inline float QTransform::m11() const
183  {
184  return affine._m11;
185  }
186  inline float QTransform::m12() const
187  {
188  return affine._m12;
189  }
190  inline float QTransform::m13() const
191  {
192  return m_13;
193  }
194  inline float QTransform::m21() const
195  {
196  return affine._m21;
197  }
198  inline float QTransform::m22() const
199  {
200  return affine._m22;
201  }
202  inline float QTransform::m23() const
203  {
204  return m_23;
205  }
206  inline float QTransform::m31() const
207  {
208  return affine._dx;
209  }
210  inline float QTransform::m32() const
211  {
212  return affine._dy;
213  }
214  inline float QTransform::m33() const
215  {
216  return m_33;
217  }
218  inline float QTransform::dx() const
219  {
220  return affine._dx;
221  }
222  inline float QTransform::dy() const
223  {
224  return affine._dy;
225  }
226 
227  inline QTransform &QTransform::operator*=(float num)
228  {
229  if (num == 1.)
230  return *this;
231  affine._m11 *= num;
232  affine._m12 *= num;
233  m_13 *= num;
234  affine._m21 *= num;
235  affine._m22 *= num;
236  m_23 *= num;
237  affine._dx *= num;
238  affine._dy *= num;
239  m_33 *= num;
240  if (m_dirty < TxScale)
241  m_dirty = TxScale;
242  return *this;
243  }
244  inline QTransform &QTransform::operator/=(float div)
245  {
246  if (div == 0)
247  return *this;
248  div = 1 / div;
249  return operator*=(div);
250  }
251  inline QTransform &QTransform::operator+=(float num)
252  {
253  if (num == 0)
254  return *this;
255  affine._m11 += num;
256  affine._m12 += num;
257  m_13 += num;
258  affine._m21 += num;
259  affine._m22 += num;
260  m_23 += num;
261  affine._dx += num;
262  affine._dy += num;
263  m_33 += num;
264  m_dirty = TxProject;
265  return *this;
266  }
267  inline QTransform &QTransform::operator-=(float num)
268  {
269  if (num == 0)
270  return *this;
271  affine._m11 -= num;
272  affine._m12 -= num;
273  m_13 -= num;
274  affine._m21 -= num;
275  affine._m22 -= num;
276  m_23 -= num;
277  affine._dx -= num;
278  affine._dy -= num;
279  m_33 -= num;
280  m_dirty = TxProject;
281  return *this;
282  }
283 
284  inline bool FuzzyCompare(const QTransform& t1, const QTransform& t2)
285  {
286  return Math::FuzzyCompare(t1.m11(), t2.m11())
287  && Math::FuzzyCompare(t1.m12(), t2.m12())
288  && Math::FuzzyCompare(t1.m13(), t2.m13())
289  && Math::FuzzyCompare(t1.m21(), t2.m21())
290  && Math::FuzzyCompare(t1.m22(), t2.m22())
291  && Math::FuzzyCompare(t1.m23(), t2.m23())
292  && Math::FuzzyCompare(t1.m31(), t2.m31())
293  && Math::FuzzyCompare(t1.m32(), t2.m32())
294  && Math::FuzzyCompare(t1.m33(), t2.m33());
295  }
296 
297  // mathematical semantics
298  inline QPoint operator*(const QPoint &p, const QTransform &m)
299  {
300  return m.map(p);
301  }
302  inline QPointF operator*(const QPointF &p, const QTransform &m)
303  {
304  return m.map(p);
305  }
306  inline QLineF operator*(const QLineF &l, const QTransform &m)
307  {
308  return m.map(l);
309  }
310  inline QLine operator*(const QLine &l, const QTransform &m)
311  {
312  return m.map(l);
313  }
314 
315  inline QRegion operator *(const QRegion &r, const QTransform &m)
316  {
317  return m.map(r);
318  }
319 
320  inline QTransform operator *(const QTransform &a, float n)
321  {
322  QTransform t(a); t *= n; return t;
323  }
324  inline QTransform operator /(const QTransform &a, float n)
325  {
326  QTransform t(a); t /= n; return t;
327  }
328  inline QTransform operator +(const QTransform &a, float n)
329  {
330  QTransform t(a); t += n; return t;
331  }
332  inline QTransform operator -(const QTransform &a, float n)
333  {
334  QTransform t(a); t -= n; return t;
335  }
336 }
ParaEngine::QPointF
Definition: ParaPoint.h:203
ParaEngine
different physics engine has different winding order.
Definition: EventBinding.h:32
ParaEngine::QLineF
Definition: ParaLine.h:151
ParaEngine::QRectF
Definition: ParaRect.h:517
ParaEngine::QRect
when concerting QRect with QRectF and RECT, we ensure that their left, top and width, height are the same.
Definition: ParaRect.h:16
ParaEngine::QLine
Definition: ParaLine.h:6
ParaEngine::QTransform
Definition: qtransform.h:14
ParaEngine::QTransform::type
TransformationType type() const
Definition: qtransform.cpp:957
ParaEngine::QPoint
Definition: ParaPoint.h:5
ParaEngine::QRegion
Definition: ParaRegion.h:7
ParaEngine::QMatrix
Definition: qmatrix.h:12
ParaScripting
for luabind, The main drawback of this approach is that the compilation time will increase for the fi...
Definition: luaSQLite.cpp:1971
Generated by   doxygen 1.8.12