0028824: Possibility to build OCCT 7.1.0 and above using Visual Studio 2008
[occt.git] / src / BVH / BVH_Types.hxx
1 // Created on: 2013-12-20
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef _BVH_Types_Header
17 #define _BVH_Types_Header
18
19 // Use this macro to switch between STL and OCCT vector types
20 #define _BVH_USE_STD_VECTOR_
21
22 #include <vector>
23
24 #include <NCollection_Mat4.hxx>
25 #include <NCollection_Vec2.hxx>
26 #include <NCollection_Vec3.hxx>
27 #include <NCollection_Vector.hxx>
28 #include <Standard_Type.hxx>
29
30 // GCC supports shrink function only in C++11 mode
31 #if defined(_BVH_USE_STD_VECTOR_) && defined(_MSC_VER) && !defined(__INTEL_COMPILER)
32   #define _STD_VECTOR_SHRINK
33 #endif
34
35 namespace BVH
36 {
37   //! Tool class for selecting appropriate vector type (Eigen or NCollection).
38   //! \tparam T Numeric data type
39   //! \tparam N Component number
40   template<class T, int N> struct VectorType
41   {
42     // Not implemented
43   };
44
45   template<class T> struct VectorType<T, 1>
46   {
47     typedef T Type;
48   };
49
50   template<class T> struct VectorType<T, 2>
51   {
52     typedef NCollection_Vec2<T> Type;
53   };
54
55   template<class T> struct VectorType<T, 3>
56   {
57     typedef NCollection_Vec3<T> Type;
58   };
59
60   template<class T> struct VectorType<T, 4>
61   {
62     typedef NCollection_Vec4<T> Type;
63   };
64
65   //! Tool class for selecting appropriate matrix type (Eigen or NCollection).
66   //! \tparam T Numeric data type
67   //! \tparam N Matrix dimension
68   template<class T, int N> struct MatrixType
69   {
70     // Not implemented
71   };
72
73   template<class T> struct MatrixType<T, 4>
74   {
75     typedef NCollection_Mat4<T> Type;
76   };
77
78   //! Tool class for selecting type of array of vectors (STD or NCollection vector).
79   //! \tparam T Numeric data type
80   //! \tparam N Component number
81   template<class T, int N = 1> struct ArrayType
82   {
83   #ifndef _BVH_USE_STD_VECTOR_
84     typedef NCollection_Vector<typename VectorType<T, N>::Type> Type;
85   #else
86     typedef std::vector<typename VectorType<T, N>::Type> Type;
87   #endif
88   };
89 }
90
91 //! 2D vector of integers.
92 typedef BVH::VectorType<Standard_Integer, 2>::Type BVH_Vec2i;
93 //! 3D vector of integers.
94 typedef BVH::VectorType<Standard_Integer, 3>::Type BVH_Vec3i;
95 //! 4D vector of integers.
96 typedef BVH::VectorType<Standard_Integer, 4>::Type BVH_Vec4i;
97
98 //! Array of 2D vectors of integers.
99 typedef BVH::ArrayType<Standard_Integer, 2>::Type BVH_Array2i;
100 //! Array of 3D vectors of integers.
101 typedef BVH::ArrayType<Standard_Integer, 3>::Type BVH_Array3i;
102 //! Array of 4D vectors of integers.
103 typedef BVH::ArrayType<Standard_Integer, 4>::Type BVH_Array4i;
104
105 //! 2D vector of single precision reals.
106 typedef BVH::VectorType<Standard_ShortReal, 2>::Type BVH_Vec2f;
107 //! 3D vector of single precision reals.
108 typedef BVH::VectorType<Standard_ShortReal, 3>::Type BVH_Vec3f;
109 //! 4D vector of single precision reals.
110 typedef BVH::VectorType<Standard_ShortReal, 4>::Type BVH_Vec4f;
111
112 //! Array of 2D vectors of single precision reals.
113 typedef BVH::ArrayType<Standard_ShortReal, 2>::Type BVH_Array2f;
114 //! Array of 3D vectors of single precision reals.
115 typedef BVH::ArrayType<Standard_ShortReal, 3>::Type BVH_Array3f;
116 //! Array of 4D vectors of single precision reals.
117 typedef BVH::ArrayType<Standard_ShortReal, 4>::Type BVH_Array4f;
118
119 //! 2D vector of double precision reals.
120 typedef BVH::VectorType<Standard_Real, 2>::Type BVH_Vec2d;
121 //! 3D vector of double precision reals.
122 typedef BVH::VectorType<Standard_Real, 3>::Type BVH_Vec3d;
123 //! 4D vector of double precision reals.
124 typedef BVH::VectorType<Standard_Real, 4>::Type BVH_Vec4d;
125
126 //! Array of 2D vectors of double precision reals.
127 typedef BVH::ArrayType<Standard_Real, 2>::Type BVH_Array2d;
128 //! Array of 3D vectors of double precision reals.
129 typedef BVH::ArrayType<Standard_Real, 3>::Type BVH_Array3d;
130 //! Array of 4D vectors of double precision reals.
131 typedef BVH::ArrayType<Standard_Real, 4>::Type BVH_Array4d;
132
133 //! 4x4 matrix of single precision reals.
134 typedef BVH::MatrixType<Standard_ShortReal, 4>::Type BVH_Mat4f;
135
136 //! 4x4 matrix of double precision reals.
137 typedef BVH::MatrixType<Standard_Real, 4>::Type BVH_Mat4d;
138
139 namespace BVH
140 {
141   //! Tool class for accessing specific vector component (by index).
142   //! \tparam T Numeric data type
143   //! \tparam N Component number
144   template<class T, int N> struct VecComp
145   {
146     // Not implemented
147   };
148
149   template<class T> struct VecComp<T, 2>
150   {
151     typedef typename BVH::VectorType<T, 2>::Type BVH_Vec2t;
152
153     static T Get (const BVH_Vec2t& theVec, const Standard_Integer theAxis)
154     {
155       return theAxis == 0 ? theVec.x() : theVec.y();
156     }
157   };
158
159   template<class T> struct VecComp<T, 3>
160   {
161     typedef typename BVH::VectorType<T, 3>::Type BVH_Vec3t;
162
163     static T Get (const BVH_Vec3t& theVec, const Standard_Integer theAxis)
164     {
165       return theAxis == 0 ? theVec.x() : ( theAxis == 1 ? theVec.y() : theVec.z() );
166     }
167   };
168
169   template<class T> struct VecComp<T, 4>
170   {
171     typedef typename BVH::VectorType<T, 4>::Type BVH_Vec4t;
172
173     static T Get (const BVH_Vec4t& theVec, const Standard_Integer theAxis)
174     {
175       return theAxis == 0 ? theVec.x() :
176         (theAxis == 1 ? theVec.y() : ( theAxis == 2 ? theVec.z() : theVec.w() ));
177     }
178   };
179
180   //! Tool class providing typical operations on the array. It allows
181   //! for interoperability between STD vector and NCollection vector.
182   //! \tparam T Numeric data type
183   //! \tparam N Component number
184   template<class T, int N = 1> struct Array
185   {
186     typedef typename BVH::ArrayType<T, N>::Type BVH_ArrayNt;
187
188     //! Returns a const reference to the element with the given index.
189     static inline const typename BVH::VectorType<T, N>::Type& Value (
190         const BVH_ArrayNt& theArray, const Standard_Integer theIndex)
191     {
192 #ifdef _BVH_USE_STD_VECTOR_
193       return theArray[theIndex];
194 #else
195       return theArray.Value (theIndex);
196 #endif
197     }
198
199     //! Returns a reference to the element with the given index.
200     static inline typename BVH::VectorType<T, N>::Type& ChangeValue (
201       BVH_ArrayNt& theArray, const Standard_Integer theIndex)
202     {
203 #ifdef _BVH_USE_STD_VECTOR_
204       return theArray[theIndex];
205 #else
206       return theArray.ChangeValue (theIndex);
207 #endif
208     }
209
210     //! Adds the new element at the end of the array.
211     static inline void Append (BVH_ArrayNt& theArray,
212       const typename BVH::VectorType<T, N>::Type& theElement)
213     {
214 #ifdef _BVH_USE_STD_VECTOR_
215       theArray.push_back (theElement);
216 #else
217       theArray.Append (theElement);
218 #endif
219     }
220
221     //! Returns the number of elements in the given array.
222     static inline Standard_Integer Size (const BVH_ArrayNt& theArray)
223     {
224 #ifdef _BVH_USE_STD_VECTOR_
225       return static_cast<Standard_Integer> (theArray.size());
226 #else
227       return static_cast<Standard_Integer> (theArray.Size());
228 #endif
229     }
230
231     //! Removes all elements from the given array.
232     static inline void Clear (BVH_ArrayNt& theArray)
233     {
234 #ifdef _BVH_USE_STD_VECTOR_
235       theArray.clear();
236 #else
237       theArray.Clear();
238 #endif
239     }
240
241     //! Requests that the array capacity be at least enough to
242     //! contain given number of elements. This function has no
243     //! effect in case of NCollection based array.
244     static inline void Reserve (BVH_ArrayNt& theArray, const Standard_Integer theCount)
245     {
246 #ifdef _BVH_USE_STD_VECTOR_
247       if (Size (theArray) == theCount)
248       {
249 #ifdef _STD_VECTOR_SHRINK
250
251 #if(defined(_MSC_VER) && (_MSC_VER < 1600))
252         BVH_ArrayNt aTmpArray(theArray);
253         theArray.swap(aTmpArray);
254 #else
255         theArray.shrink_to_fit();
256 #endif
257
258 #endif
259       }
260       else
261       {
262         theArray.reserve (theCount);
263       }
264 #else
265       // do nothing
266 #endif
267     }
268   };
269
270   template<class T>
271   static inline Standard_Integer IntFloor (const T theValue)
272   {
273     const Standard_Integer aRes = static_cast<Standard_Integer> (theValue);
274
275     return aRes - static_cast<Standard_Integer> (aRes > theValue);
276   }
277 }
278
279 #endif // _BVH_Types_Header