0025885: Visualization, ray tracing - Improve layer processing
[occt.git] / src / NCollection / NCollection_Vec2.hxx
1 // Created by: Kirill GAVRILOV
2 // Copyright (c) 2013-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifndef _NCollection_Vec2_H__
16 #define _NCollection_Vec2_H__
17
18 #include <cmath> // std::sqrt()
19
20 //! Auxiliary macros to define couple of similar access components as vector methods.
21 //! @return 2 components by their names in specified order
22 #define NCOLLECTION_VEC_COMPONENTS_2D(theX, theY) \
23   const NCollection_Vec2<Element_t> theX##theY() const { return NCollection_Vec2<Element_t>(theX(), theY()); } \
24   const NCollection_Vec2<Element_t> theY##theX() const { return NCollection_Vec2<Element_t>(theY(), theX()); }
25
26 //! Defines the 2D-vector template.
27 //! The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.).
28 template<typename Element_t>
29 class NCollection_Vec2
30 {
31
32 public:
33
34   //! Returns the number of components.
35   static int Length()
36   {
37     return 2;
38   }
39
40   //! Empty constructor. Construct the zero vector.
41   NCollection_Vec2()
42   {
43     v[0] = v[1] = Element_t(0);
44   }
45
46   //! Initialize ALL components of vector within specified value.
47   explicit NCollection_Vec2 (const Element_t theXY)
48   {
49     v[0] = v[1] = theXY;
50   }
51
52   //! Per-component constructor.
53   explicit NCollection_Vec2 (const Element_t theX,
54                              const Element_t theY)
55   {
56     v[0] = theX;
57     v[1] = theY;
58   }
59
60   //! Copy constructor.
61   NCollection_Vec2 (const NCollection_Vec2& theVec2)
62   {
63     v[0] = theVec2[0];
64     v[1] = theVec2[1];
65   }
66
67   //! Assignment operator.
68   const NCollection_Vec2& operator= (const NCollection_Vec2& theVec2)
69   {
70     v[0] = theVec2[0];
71     v[1] = theVec2[1];
72     return *this;
73   }
74
75   //! Alias to 1st component as X coordinate in XY.
76   Element_t x() const { return v[0]; }
77
78   //! Alias to 2nd component as Y coordinate in XY.
79   Element_t y() const { return v[1]; }
80
81   //! @return 2 components by their names in specified order (in GLSL-style)
82   NCOLLECTION_VEC_COMPONENTS_2D(x, y)
83
84   //! Alias to 1st component as X coordinate in XY.
85   Element_t& x() { return v[0]; }
86
87   //! Alias to 2nd component as Y coordinate in XY.
88   Element_t& y() { return v[1]; }
89
90   //! Raw access to the data (for OpenGL exchange).
91   const Element_t* GetData()    const { return v; }
92         Element_t* ChangeData()       { return v; }
93   operator const   Element_t*() const { return v; }
94   operator         Element_t*()       { return v; }
95
96   //! Compute per-component summary.
97   NCollection_Vec2& operator+= (const NCollection_Vec2& theAdd)
98   {
99     v[0] += theAdd.v[0];
100     v[1] += theAdd.v[1];
101     return *this;
102   }
103
104   //! Compute per-component summary.
105   friend NCollection_Vec2 operator+ (const NCollection_Vec2& theLeft,
106                                      const NCollection_Vec2& theRight)
107   {
108     return NCollection_Vec2 (theLeft.v[0] + theRight.v[0],
109                              theLeft.v[1] + theRight.v[1]);
110   }
111
112   //! Compute per-component subtraction.
113   NCollection_Vec2& operator-= (const NCollection_Vec2& theDec)
114   {
115     v[0] -= theDec.v[0];
116     v[1] -= theDec.v[1];
117     return *this;
118   }
119
120   //! Compute per-component subtraction.
121   friend NCollection_Vec2 operator- (const NCollection_Vec2& theLeft,
122                                      const NCollection_Vec2& theRight)
123   {
124     return NCollection_Vec2 (theLeft.v[0] - theRight.v[0],
125                              theLeft.v[1] - theRight.v[1]);
126   }
127
128   //! Unary -.
129   NCollection_Vec2 operator-() const
130   {
131     return NCollection_Vec2 (-x(), -y());
132   }
133
134   //! Compute per-component multiplication.
135   NCollection_Vec2& operator*= (const NCollection_Vec2& theRight)
136   {
137     v[0] *= theRight.v[0];
138     v[1] *= theRight.v[1];
139     return *this;
140   }
141
142   //! Compute per-component multiplication.
143   friend NCollection_Vec2 operator* (const NCollection_Vec2& theLeft,
144                                      const NCollection_Vec2& theRight)
145   {
146     return NCollection_Vec2 (theLeft.v[0] * theRight.v[0],
147                              theLeft.v[1] * theRight.v[1]);
148   }
149
150   //! Compute per-component multiplication by scale factor.
151   void Multiply (const Element_t theFactor)
152   {
153     v[0] *= theFactor;
154     v[1] *= theFactor;
155   }
156
157   //! Compute per-component multiplication by scale factor.
158   NCollection_Vec2 Multiplied (const Element_t theFactor) const
159   {
160     return NCollection_Vec2 (v[0] * theFactor,
161                              v[1] * theFactor);
162   }
163
164   //! Compute component-wise minimum of two vectors.
165   NCollection_Vec2 cwiseMin (const NCollection_Vec2& theVec) const
166   {
167     return NCollection_Vec2 (v[0] < theVec.v[0] ? v[0] : theVec.v[0],
168                              v[1] < theVec.v[1] ? v[1] : theVec.v[1]);
169   }
170
171   //! Compute component-wise maximum of two vectors.
172   NCollection_Vec2 cwiseMax (const NCollection_Vec2& theVec) const
173   {
174     return NCollection_Vec2 (v[0] > theVec.v[0] ? v[0] : theVec.v[0],
175                              v[1] > theVec.v[1] ? v[1] : theVec.v[1]);
176   }
177
178   //! Compute component-wise modulus of the vector.
179   NCollection_Vec2 cwiseAbs() const
180   {
181     return NCollection_Vec2 (std::abs (v[0]),
182                              std::abs (v[1]));
183   }
184
185   //! Compute maximum component of the vector.
186   Element_t maxComp() const
187   {
188     return v[0] > v[1] ? v[0] : v[1];
189   }
190
191   //! Compute minimum component of the vector.
192   Element_t minComp() const
193   {
194     return v[0] < v[1] ? v[0] : v[1];
195   }
196
197   //! Compute per-component multiplication by scale factor.
198   NCollection_Vec2& operator*= (const Element_t theFactor)
199   {
200     Multiply (theFactor);
201     return *this;
202   }
203
204   //! Compute per-component division by scale factor.
205   NCollection_Vec2& operator/= (const Element_t theInvFactor)
206   {
207     v[0] /= theInvFactor;
208     v[1] /= theInvFactor;
209     return *this;
210   }
211
212   //! Compute per-component multiplication by scale factor.
213   NCollection_Vec2 operator* (const Element_t theFactor) const
214   {
215     return Multiplied (theFactor);
216   }
217
218   //! Compute per-component division by scale factor.
219   NCollection_Vec2 operator/ (const Element_t theInvFactor) const
220   {
221     return NCollection_Vec2(v[0] / theInvFactor,
222             v[1] / theInvFactor);
223   }
224
225   //! Computes the dot product.
226   Element_t Dot (const NCollection_Vec2& theOther) const
227   {
228     return x() * theOther.x() + y() * theOther.y();
229   }
230
231   //! Computes the vector modulus (magnitude, length).
232   Element_t Modulus() const
233   {
234     return std::sqrt (x() * x() + y() * y());
235   }
236
237   //! Computes the square of vector modulus (magnitude, length).
238   //! This method may be used for performance tricks.
239   Element_t SquareModulus() const
240   {
241     return x() * x() + y() * y();
242   }
243
244   //! Constuct DX unit vector.
245   static NCollection_Vec2 DX()
246   {
247     return NCollection_Vec2 (Element_t(1), Element_t(0));
248   }
249
250   //! Constuct DY unit vector.
251   static NCollection_Vec2 DY()
252   {
253     return NCollection_Vec2 (Element_t(0), Element_t(1));
254   }
255
256 private:
257
258   Element_t v[2];
259
260 };
261
262 #endif // _NCollection_Vec2_H__