0.9.9 API documenation: setup.hpp Source File

| 0.9.9 API documenation

- Main Page
- Modules
- Files

- File List

setup.hpp
Go to the documentation of this file.
1
4 #pragma once
5
6 #if defined(GLM_FORCE_SWIZZLE) && defined(GLM_FORCE_UNRESTRICTED_GENTYPE)
7 # error "Both GLM_FORCE_SWIZZLE and GLM_FORCE_UNRESTRICTED_GENTYPE can't be defined at the same time"
8 #endif
9
11 // Messages
12
13 #define GLM_MESSAGES_ENABLED 1
14 #define GLM_MESSAGES_DISABLE 0
15
16 #if defined(GLM_FORCE_MESSAGES)
17 # define GLM_MESSAGES GLM_MESSAGES_ENABLED
18 #else
19 # define GLM_MESSAGES GLM_MESSAGES_DISABLE
20 #endif
21
22 #include <cassert>
23 #include <cstddef>
24 #include "../simd/platform.h"
25
27 // Version
28
29 #define GLM_VERSION 99
30 #define GLM_VERSION_MAJOR 0
31 #define GLM_VERSION_MINOR 9
32 #define GLM_VERSION_PATCH 9
33 #define GLM_VERSION_REVISION 0
34
35 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_VERSION_DISPLAYED)
36 # define GLM_MESSAGE_VERSION_DISPLAYED
37 # pragma message ("GLM: version 0.9.9.0")
38 #endif//GLM_MESSAGES
39
40 // Report compiler detection
41 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_COMPILER_DISPLAYED)
42 # define GLM_MESSAGE_COMPILER_DISPLAYED
43 # if GLM_COMPILER & GLM_COMPILER_CUDA
44 # pragma message("GLM: CUDA compiler detected")
45 # elif GLM_COMPILER & GLM_COMPILER_VC
46 # pragma message("GLM: Visual C++ compiler detected")
47 # elif GLM_COMPILER & GLM_COMPILER_CLANG
48 # pragma message("GLM: Clang compiler detected")
49 # elif GLM_COMPILER & GLM_COMPILER_INTEL
50 # pragma message("GLM: Intel Compiler detected")
51 # elif GLM_COMPILER & GLM_COMPILER_GCC
52 # pragma message("GLM: GCC compiler detected")
53 # else
54 # pragma message("GLM: Compiler not detected")
55 # endif
56 #endif//GLM_MESSAGES
57
59 // Build model
60
61 #if defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__)
62 # define GLM_MODEL GLM_MODEL_64
63 #elif defined(__i386__) || defined(__ppc__)
64 # define GLM_MODEL GLM_MODEL_32
65 #else
66 # define GLM_MODEL GLM_MODEL_32
67 #endif//
68
69 #if !defined(GLM_MODEL) && GLM_COMPILER != 0
70 # error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
71 #endif//GLM_MODEL
72
73 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_MODEL_DISPLAYED)
74 # define GLM_MESSAGE_MODEL_DISPLAYED
75 # if(GLM_MODEL == GLM_MODEL_64)
76 # pragma message("GLM: 64 bits model")
77 # elif(GLM_MODEL == GLM_MODEL_32)
78 # pragma message("GLM: 32 bits model")
79 # endif//GLM_MODEL
80 #endif//GLM_MESSAGES
81
82 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_ARCH_DISPLAYED)
83 # define GLM_MESSAGE_ARCH_DISPLAYED
84 # if(GLM_ARCH == GLM_ARCH_PURE)
85 # pragma message("GLM: Platform independent code")
86 # elif(GLM_ARCH == GLM_ARCH_AVX2)
87 # pragma message("GLM: AVX2 instruction set")
88 # elif(GLM_ARCH == GLM_ARCH_AVX)
89 # pragma message("GLM: AVX instruction set")
90 # elif(GLM_ARCH == GLM_ARCH_SSE42)
91 # pragma message("GLM: SSE4.2 instruction set")
92 # elif(GLM_ARCH == GLM_ARCH_SSE41)
93 # pragma message("GLM: SSE4.1 instruction set")
94 # elif(GLM_ARCH == GLM_ARCH_SSSE3)
95 # pragma message("GLM: SSSE3 instruction set")
96 # elif(GLM_ARCH == GLM_ARCH_SSE3)
97 # pragma message("GLM: SSE3 instruction set")
98 # elif(GLM_ARCH == GLM_ARCH_SSE2)
99 # pragma message("GLM: SSE2 instruction set")
100 # elif(GLM_ARCH == GLM_ARCH_X86)
101 # pragma message("GLM: x86 instruction set")
102 # elif(GLM_ARCH == GLM_ARCH_NEON)
103 # pragma message("GLM: NEON instruction set")
104 # elif(GLM_ARCH == GLM_ARCH_ARM)
105 # pragma message("GLM: ARM instruction set")
106 # elif(GLM_ARCH == GLM_ARCH_MIPS)
107 # pragma message("GLM: MIPS instruction set")
108 # elif(GLM_ARCH == GLM_ARCH_PPC)
109 # pragma message("GLM: PowerPC architechture")
110 # endif//GLM_ARCH
111 #endif//GLM_MESSAGES
112
114 // C++ Version
115
116 // User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14
117
118 #define GLM_LANG_CXX98_FLAG (1 << 1)
119 #define GLM_LANG_CXX03_FLAG (1 << 2)
120 #define GLM_LANG_CXX0X_FLAG (1 << 3)
121 #define GLM_LANG_CXX11_FLAG (1 << 4)
122 #define GLM_LANG_CXX1Y_FLAG (1 << 5)
123 #define GLM_LANG_CXX14_FLAG (1 << 6)
124 #define GLM_LANG_CXX1Z_FLAG (1 << 7)
125 #define GLM_LANG_CXXMS_FLAG (1 << 8)
126 #define GLM_LANG_CXXGNU_FLAG (1 << 9)
127
128 #define GLM_LANG_CXX98 GLM_LANG_CXX98_FLAG
129 #define GLM_LANG_CXX03 (GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG)
130 #define GLM_LANG_CXX0X (GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG)
131 #define GLM_LANG_CXX11 (GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG)
132 #define GLM_LANG_CXX1Y (GLM_LANG_CXX11 | GLM_LANG_CXX1Y_FLAG)
133 #define GLM_LANG_CXX14 (GLM_LANG_CXX1Y | GLM_LANG_CXX14_FLAG)
134 #define GLM_LANG_CXX1Z (GLM_LANG_CXX14 | GLM_LANG_CXX1Z_FLAG)
135 #define GLM_LANG_CXXMS GLM_LANG_CXXMS_FLAG
136 #define GLM_LANG_CXXGNU GLM_LANG_CXXGNU_FLAG
137
138 #if defined(GLM_FORCE_CXX14)
139 # if((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER <= GLM_COMPILER_GCC50)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER <= GLM_COMPILER_CLANG34))
140 # pragma message("GLM: Using GLM_FORCE_CXX14 with a compiler that doesn't fully support C++14")
141 # elif GLM_COMPILER & GLM_COMPILER_VC
142 # pragma message("GLM: Using GLM_FORCE_CXX14 but there is no known version of Visual C++ compiler that fully supports C++14")
143 # elif GLM_COMPILER & GLM_COMPILER_INTEL
144 # pragma message("GLM: Using GLM_FORCE_CXX14 but there is no known version of ICC compiler that fully supports C++14")
145 # endif
146 # define GLM_LANG GLM_LANG_CXX14
147 # define GLM_LANG_STL11_FORCED
148 #elif defined(GLM_FORCE_CXX11)
149 # if((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER <= GLM_COMPILER_GCC48)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER <= GLM_COMPILER_CLANG33))
150 # pragma message("GLM: Using GLM_FORCE_CXX11 with a compiler that doesn't fully support C++11")
151 # elif GLM_COMPILER & GLM_COMPILER_VC
152 # pragma message("GLM: Using GLM_FORCE_CXX11 but there is no known version of Visual C++ compiler that fully supports C++11")
153 # elif GLM_COMPILER & GLM_COMPILER_INTEL
154 # pragma message("GLM: Using GLM_FORCE_CXX11 but there is no known version of ICC compiler that fully supports C++11")
155 # endif
156 # define GLM_LANG GLM_LANG_CXX11
157 # define GLM_LANG_STL11_FORCED
158 #elif defined(GLM_FORCE_CXX03)
159 # define GLM_LANG GLM_LANG_CXX03
160 #elif defined(GLM_FORCE_CXX98)
161 # define GLM_LANG GLM_LANG_CXX98
162 #else
163 # if GLM_COMPILER & GLM_COMPILER_CLANG
164 # if __cplusplus >= 201402L // GLM_COMPILER_CLANG34 + -std=c++14
165 # define GLM_LANG GLM_LANG_CXX14
166 # elif __has_feature(cxx_decltype_auto) && __has_feature(cxx_aggregate_nsdmi) // GLM_COMPILER_CLANG33 + -std=c++1y
167 # define GLM_LANG GLM_LANG_CXX1Y
168 # elif __cplusplus >= 201103L // GLM_COMPILER_CLANG33 + -std=c++11
169 # define GLM_LANG GLM_LANG_CXX11
170 # elif __has_feature(cxx_static_assert) // GLM_COMPILER_CLANG29 + -std=c++11
171 # define GLM_LANG GLM_LANG_CXX0X
172 # elif __cplusplus >= 199711L
173 # define GLM_LANG GLM_LANG_CXX98
174 # else
175 # define GLM_LANG GLM_LANG_CXX
176 # endif
177 # elif GLM_COMPILER & GLM_COMPILER_GCC
178 # if __cplusplus >= 201402L
179 # define GLM_LANG GLM_LANG_CXX14
180 # elif __cplusplus >= 201103L
181 # define GLM_LANG GLM_LANG_CXX11
182 # elif defined(__GXX_EXPERIMENTAL_CXX0X__)
183 # define GLM_LANG GLM_LANG_CXX0X
184 # else
185 # define GLM_LANG GLM_LANG_CXX98
186 # endif
187 # elif GLM_COMPILER & GLM_COMPILER_VC
188 # ifdef _MSC_EXTENSIONS
189 # if __cplusplus >= 201402L
190 # define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
191 //# elif GLM_COMPILER >= GLM_COMPILER_VC14
192 //# define GLM_LANG (GLM_LANG_CXX1Y | GLM_LANG_CXXMS_FLAG)
193 # elif __cplusplus >= 201103L
194 # define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
195 # elif GLM_COMPILER >= GLM_COMPILER_VC10
196 # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
197 # elif __cplusplus >= 199711L
198 # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
199 # else
200 # define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
201 # endif
202 # else
203 # if __cplusplus >= 201402L
204 # define GLM_LANG GLM_LANG_CXX14
205 # elif __cplusplus >= 201103L
206 # define GLM_LANG GLM_LANG_CXX11
207 # elif GLM_COMPILER >= GLM_COMPILER_VC10
208 # define GLM_LANG GLM_LANG_CXX0X
209 # elif __cplusplus >= 199711L
210 # define GLM_LANG GLM_LANG_CXX98
211 # else
212 # define GLM_LANG GLM_LANG_CXX
213 # endif
214 # endif
215 # elif GLM_COMPILER & GLM_COMPILER_INTEL
216 # ifdef _MSC_EXTENSIONS
217 # define GLM_MSC_EXT GLM_LANG_CXXMS_FLAG
218 # else
219 # define GLM_MSC_EXT 0
220 # endif
221 # if __cplusplus >= 201402L
222 # define GLM_LANG (GLM_LANG_CXX14 | GLM_MSC_EXT)
223 # elif __cplusplus >= 201103L
224 # define GLM_LANG (GLM_LANG_CXX11 | GLM_MSC_EXT)
225 # elif __INTEL_CXX11_MODE__
226 # define GLM_LANG (GLM_LANG_CXX0X | GLM_MSC_EXT)
227 # elif __cplusplus >= 199711L
228 # define GLM_LANG (GLM_LANG_CXX98 | GLM_MSC_EXT)
229 # else
230 # define GLM_LANG (GLM_LANG_CXX | GLM_MSC_EXT)
231 # endif
232 # elif GLM_COMPILER & GLM_COMPILER_CUDA
233 # ifdef _MSC_EXTENSIONS
234 # define GLM_MSC_EXT GLM_LANG_CXXMS_FLAG
235 # else
236 # define GLM_MSC_EXT 0
237 # endif
238 # if GLM_COMPILER >= GLM_COMPILER_CUDA75
239 # define GLM_LANG (GLM_LANG_CXX0X | GLM_MSC_EXT)
240 # else
241 # define GLM_LANG (GLM_LANG_CXX98 | GLM_MSC_EXT)
242 # endif
243 # else // Unknown compiler
244 # if __cplusplus >= 201402L
245 # define GLM_LANG GLM_LANG_CXX14
246 # elif __cplusplus >= 201103L
247 # define GLM_LANG GLM_LANG_CXX11
248 # elif __cplusplus >= 199711L
249 # define GLM_LANG GLM_LANG_CXX98
250 # else
251 # define GLM_LANG GLM_LANG_CXX // Good luck with that!
252 # endif
253 # ifndef GLM_FORCE_PURE
254 # define GLM_FORCE_PURE
255 # endif
256 # endif
257 #endif
258
259 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_LANG_DISPLAYED)
260 # define GLM_MESSAGE_LANG_DISPLAYED
261
262 # if GLM_LANG & GLM_LANG_CXX1Z_FLAG
263 # pragma message("GLM: C++1z")
264 # elif GLM_LANG & GLM_LANG_CXX14_FLAG
265 # pragma message("GLM: C++14")
266 # elif GLM_LANG & GLM_LANG_CXX1Y_FLAG
267 # pragma message("GLM: C++1y")
268 # elif GLM_LANG & GLM_LANG_CXX11_FLAG
269 # pragma message("GLM: C++11")
270 # elif GLM_LANG & GLM_LANG_CXX0X_FLAG
271 # pragma message("GLM: C++0x")
272 # elif GLM_LANG & GLM_LANG_CXX03_FLAG
273 # pragma message("GLM: C++03")
274 # elif GLM_LANG & GLM_LANG_CXX98_FLAG
275 # pragma message("GLM: C++98")
276 # else
277 # pragma message("GLM: C++ language undetected")
278 # endif//GLM_LANG
279
280 # if GLM_LANG & (GLM_LANG_CXXGNU_FLAG | GLM_LANG_CXXMS_FLAG)
281 # pragma message("GLM: Language extensions enabled")
282 # endif//GLM_LANG
283 #endif//GLM_MESSAGES
284
286 // Has of C++ features
287
288 // http://clang.llvm.org/cxx_status.html
289 // http://gcc.gnu.org/projects/cxx0x.html
290 // http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx
291
292 // Android has multiple STLs but C++11 STL detection doesn't always work #284 #564
293 #if GLM_PLATFORM == GLM_PLATFORM_ANDROID && !defined(GLM_LANG_STL11_FORCED)
294 # define GLM_HAS_CXX11_STL 0
295 #elif GLM_COMPILER & GLM_COMPILER_CLANG
296 # if defined(_LIBCPP_VERSION) && GLM_LANG & GLM_LANG_CXX11_FLAG
297 # define GLM_HAS_CXX11_STL 1
298 # else
299 # define GLM_HAS_CXX11_STL 0
300 # endif
301 #else
302 # define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
303 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
304 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
305 ((GLM_PLATFORM != GLM_PLATFORM_WINDOWS) && (GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15))))
306 #endif
307
308 // N1720
309 #if GLM_COMPILER & GLM_COMPILER_CLANG
310 # define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert)
311 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
312 # define GLM_HAS_STATIC_ASSERT 1
313 #else
314 # define GLM_HAS_STATIC_ASSERT ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
315 ((GLM_COMPILER & GLM_COMPILER_GCC)) || \
316 ((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
317 ((GLM_COMPILER & GLM_COMPILER_VC))))
318 #endif
319
320 // N1988
321 #if GLM_LANG & GLM_LANG_CXX11_FLAG
322 # define GLM_HAS_EXTENDED_INTEGER_TYPE 1
323 #else
324 # define GLM_HAS_EXTENDED_INTEGER_TYPE (\
325 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11)) || \
326 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CUDA)) || \
327 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC)) || \
328 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CLANG)))
329 #endif
330
331 // N2235
332 #if GLM_COMPILER & GLM_COMPILER_CLANG
333 # define GLM_HAS_CONSTEXPR __has_feature(cxx_constexpr)
334 # define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
335 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
336 # define GLM_HAS_CONSTEXPR 1
337 # define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
338 #else
339 # define GLM_HAS_CONSTEXPR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
340 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
341 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)))) // GCC 4.6 support constexpr but there is a compiler bug causing a crash
342 # define GLM_HAS_CONSTEXPR_PARTIAL (GLM_HAS_CONSTEXPR || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)))
343 #endif
344
345 // N2672
346 #if GLM_COMPILER & GLM_COMPILER_CLANG
347 # define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers)
348 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
349 # define GLM_HAS_INITIALIZER_LISTS 1
350 #else
351 # define GLM_HAS_INITIALIZER_LISTS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
352 ((GLM_COMPILER & GLM_COMPILER_GCC)) || \
353 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
354 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75))))
355 #endif
356
357 // N2544 Unrestricted unions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
358 #if GLM_COMPILER & GLM_COMPILER_CLANG
359 # define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions)
360 #elif GLM_LANG & (GLM_LANG_CXX11_FLAG | GLM_LANG_CXXMS_FLAG)
361 # define GLM_HAS_UNRESTRICTED_UNIONS 1
362 #else
363 # define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
364 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS_FLAG)) || \
365 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75)) || \
366 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)))
367 #endif
368
369 // N2346
370 #if defined(GLM_FORCE_UNRESTRICTED_GENTYPE)
371 # define GLM_HAS_DEFAULTED_FUNCTIONS 0
372 #elif GLM_COMPILER & GLM_COMPILER_CLANG
373 # define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions)
374 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
375 # define GLM_HAS_DEFAULTED_FUNCTIONS 1
376 #else
377 # define GLM_HAS_DEFAULTED_FUNCTIONS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
378 ((GLM_COMPILER & GLM_COMPILER_GCC)) || \
379 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
380 ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL12)) || \
381 (GLM_COMPILER & GLM_COMPILER_CUDA)))
382 #endif
383
384 // N2118
385 #if GLM_COMPILER & GLM_COMPILER_CLANG
386 # define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
387 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
388 # define GLM_HAS_RVALUE_REFERENCES 1
389 #else
390 # define GLM_HAS_RVALUE_REFERENCES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
391 ((GLM_COMPILER & GLM_COMPILER_GCC)) || \
392 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11)) || \
393 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
394 #endif
395
396 // N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
397 #if GLM_COMPILER & GLM_COMPILER_CLANG
398 # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions)
399 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
400 # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1
401 #else
402 # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
403 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC45)) || \
404 ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
405 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
406 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
407 #endif
408
409 // N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
410 #if GLM_COMPILER & GLM_COMPILER_CLANG
411 # define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates)
412 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
413 # define GLM_HAS_TEMPLATE_ALIASES 1
414 #else
415 # define GLM_HAS_TEMPLATE_ALIASES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
416 ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL12_1)) || \
417 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC47)) || \
418 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
419 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
420 #endif
421
422 // N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html
423 #if GLM_COMPILER & GLM_COMPILER_CLANG
424 # define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for)
425 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
426 # define GLM_HAS_RANGE_FOR 1
427 #else
428 # define GLM_HAS_RANGE_FOR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
429 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \
430 ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL13)) || \
431 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11)) || \
432 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
433 #endif
434
435 // N2341 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
436 #if GLM_COMPILER & GLM_COMPILER_CLANG
437 # define GLM_HAS_ALIGNOF __has_feature(c_alignof)
438 #elif GLM_LANG & GLM_LANG_CXX11_FLAG
439 # define GLM_HAS_ALIGNOF 1
440 #else
441 # define GLM_HAS_ALIGNOF ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
442 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
443 ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)) || \
444 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)) || \
445 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA70))))
446 #endif
447
448 //
449 #if GLM_LANG & GLM_LANG_CXX11_FLAG
450 # define GLM_HAS_ASSIGNABLE 1
451 #else
452 # define GLM_HAS_ASSIGNABLE ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
453 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
454 ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49))))
455 #endif
456
457 //
458 #define GLM_HAS_TRIVIAL_QUERIES 0
459
460 //
461 #if GLM_LANG & GLM_LANG_CXX11_FLAG
462 # define GLM_HAS_MAKE_SIGNED 1
463 #else
464 # define GLM_HAS_MAKE_SIGNED ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
465 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
466 ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
467 #endif
468
469 #if GLM_ARCH == GLM_ARCH_PURE
470 # define GLM_HAS_BITSCAN_WINDOWS 0
471 #else
472 # define GLM_HAS_BITSCAN_WINDOWS ((GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\
473 ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
474 ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT))))
475 #endif
476
477 // OpenMP
478 #ifdef _OPENMP
479 # if GLM_COMPILER & GLM_COMPILER_GCC
480 # if GLM_COMPILER >= GLM_COMPILER_GCC61
481 # define GLM_HAS_OPENMP 45
482 # elif GLM_COMPILER >= GLM_COMPILER_GCC49
483 # define GLM_HAS_OPENMP 40
484 # elif GLM_COMPILER >= GLM_COMPILER_GCC47
485 # define GLM_HAS_OPENMP 31
486 # elif GLM_COMPILER >= GLM_COMPILER_GCC44
487 # define GLM_HAS_OPENMP 30
488 # elif GLM_COMPILER >= GLM_COMPILER_GCC42
489 # define GLM_HAS_OPENMP 25
490 # else
491 # define GLM_HAS_OPENMP 0
492 # endif
493 # elif GLM_COMPILER & GLM_COMPILER_CLANG
494 # if GLM_COMPILER >= GLM_COMPILER_CLANG38
495 # define GLM_HAS_OPENMP 31
496 # else
497 # define GLM_HAS_OPENMP 0
498 # endif
499 # elif GLM_COMPILER & GLM_COMPILER_VC
500 # if GLM_COMPILER >= GLM_COMPILER_VC10
501 # define GLM_HAS_OPENMP 20
502 # else
503 # define GLM_HAS_OPENMP 0
504 # endif
505 # elif GLM_COMPILER & GLM_COMPILER_INTEL
506 # if GLM_COMPILER >= GLM_COMPILER_INTEL16
507 # define GLM_HAS_OPENMP 40
508 # elif GLM_COMPILER >= GLM_COMPILER_INTEL12
509 # define GLM_HAS_OPENMP 31
510 # else
511 # define GLM_HAS_OPENMP 0
512 # endif
513 # else
514 # define GLM_HAS_OPENMP 0
515 # endif// GLM_COMPILER & GLM_COMPILER_VC
516 #endif
517
519 // Static assert
520
521 #if GLM_HAS_STATIC_ASSERT
522 # define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
523 #elif defined(BOOST_STATIC_ASSERT)
524 # define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
525 #elif GLM_COMPILER & GLM_COMPILER_VC
526 # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
527 #else
528 # define GLM_STATIC_ASSERT(x, message)
529 # define GLM_STATIC_ASSERT_NULL
530 #endif//GLM_LANG
531
533 // Qualifiers
534
535 #if GLM_COMPILER & GLM_COMPILER_CUDA
536 # define GLM_CUDA_FUNC_DEF __device__ __host__
537 # define GLM_CUDA_FUNC_DECL __device__ __host__
538 #else
539 # define GLM_CUDA_FUNC_DEF
540 # define GLM_CUDA_FUNC_DECL
541 #endif
542
543 #if GLM_COMPILER & GLM_COMPILER_GCC
544 # define GLM_VAR_USED __attribute__ ((unused))
545 #else
546 # define GLM_VAR_USED
547 #endif
548
549 #if defined(GLM_FORCE_INLINE)
550 # if GLM_COMPILER & GLM_COMPILER_VC
551 # define GLM_INLINE __forceinline
552 # define GLM_NEVER_INLINE __declspec((noinline))
553 # elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
554 # define GLM_INLINE inline __attribute__((__always_inline__))
555 # define GLM_NEVER_INLINE __attribute__((__noinline__))
556 # elif GLM_COMPILER & GLM_COMPILER_CUDA
557 # define GLM_INLINE __forceinline__
558 # define GLM_NEVER_INLINE __noinline__
559 # else
560 # define GLM_INLINE inline
561 # define GLM_NEVER_INLINE
562 # endif//GLM_COMPILER
563 #else
564 # define GLM_INLINE inline
565 # define GLM_NEVER_INLINE
566 #endif//defined(GLM_FORCE_INLINE)
567
568 #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
569 #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
570
572 // Swizzle operators
573
574 // User defines: GLM_FORCE_SWIZZLE
575
576 #define GLM_SWIZZLE_ENABLED 1
577 #define GLM_SWIZZLE_DISABLE 0
578
579 #if defined(GLM_FORCE_SWIZZLE)
580 # define GLM_SWIZZLE GLM_SWIZZLE_ENABLED
581 #else
582 # define GLM_SWIZZLE GLM_SWIZZLE_DISABLE
583 #endif
584
585 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)
586 # define GLM_MESSAGE_SWIZZLE_DISPLAYED
587 # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
588 # pragma message("GLM: Swizzling operators enabled")
589 # else
590 # pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators")
591 # endif
592 #endif//GLM_MESSAGES
593
595 // Allows using not basic types as genType
596
597 // #define GLM_FORCE_UNRESTRICTED_GENTYPE
598
599 #ifdef GLM_FORCE_UNRESTRICTED_GENTYPE
600 # define GLM_UNRESTRICTED_GENTYPE 1
601 #else
602 # define GLM_UNRESTRICTED_GENTYPE 0
603 #endif
604
605 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED)
606 # define GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED
607 # ifdef GLM_FORCE_UNRESTRICTED_GENTYPE
608 # pragma message("GLM: Use unrestricted genType")
609 # endif
610 #endif//GLM_MESSAGES
611
613 // Clip control
614
615 #define GLM_DEPTH_ZERO_TO_ONE 0x00000001
616 #define GLM_DEPTH_NEGATIVE_ONE_TO_ONE 0x00000002
617
618 #ifdef GLM_FORCE_DEPTH_ZERO_TO_ONE
619 # define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_ZERO_TO_ONE
620 #else
621 # define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_NEGATIVE_ONE_TO_ONE
622 #endif
623
624 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_DEPTH_DISPLAYED)
625 # define GLM_MESSAGE_DEPTH_DISPLAYED
626 # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
627 # pragma message("GLM: Depth clip space: Zero to one")
628 # else
629 # pragma message("GLM: Depth clip space: negative one to one")
630 # endif
631 #endif//GLM_MESSAGES
632
634 // Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM
635 // to use left handed coordinate system by default.
636
637 #define GLM_LEFT_HANDED 0x00000001 // For DirectX, Metal, Vulkan
638 #define GLM_RIGHT_HANDED 0x00000002 // For OpenGL, default in GLM
639
640 #ifdef GLM_FORCE_LEFT_HANDED
641 # define GLM_COORDINATE_SYSTEM GLM_LEFT_HANDED
642 #else
643 # define GLM_COORDINATE_SYSTEM GLM_RIGHT_HANDED
644 #endif
645
646 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_HANDED_DISPLAYED)
647 # define GLM_MESSAGE_HANDED_DISPLAYED
648 # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
649 # pragma message("GLM: Coordinate system: left handed")
650 # else
651 # pragma message("GLM: Coordinate system: right handed")
652 # endif
653 #endif//GLM_MESSAGES
654
656 // Qualifiers
657
658 #if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
659 # define GLM_DEPRECATED __declspec(deprecated)
660 # define GLM_ALIGN(x) __declspec(align(x))
661 # define GLM_ALIGNED_STRUCT(x) struct __declspec(align(x))
662 # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name
663 # define GLM_RESTRICT_FUNC __declspec(restrict)
664 # define GLM_RESTRICT __restrict
665 # if GLM_COMPILER >= GLM_COMPILER_VC12
666 # define GLM_VECTOR_CALL __vectorcall
667 # else
668 # define GLM_VECTOR_CALL
669 # endif
670 #elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG | GLM_COMPILER_INTEL)
671 # define GLM_DEPRECATED __attribute__((__deprecated__))
672 # define GLM_ALIGN(x) __attribute__((aligned(x)))
673 # define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
674 # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment)))
675 # define GLM_RESTRICT_FUNC __restrict__
676 # define GLM_RESTRICT __restrict__
677 # if GLM_COMPILER & GLM_COMPILER_CLANG
678 # if GLM_COMPILER >= GLM_COMPILER_CLANG37
679 # define GLM_VECTOR_CALL __vectorcall
680 # else
681 # define GLM_VECTOR_CALL
682 # endif
683 # else
684 # define GLM_VECTOR_CALL
685 # endif
686 #elif GLM_COMPILER & GLM_COMPILER_CUDA
687 # define GLM_DEPRECATED
688 # define GLM_ALIGN(x) __align__(x)
689 # define GLM_ALIGNED_STRUCT(x) struct __align__(x)
690 # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __align__(x)
691 # define GLM_RESTRICT_FUNC __restrict__
692 # define GLM_RESTRICT __restrict__
693 # define GLM_VECTOR_CALL
694 #else
695 # define GLM_DEPRECATED
696 # define GLM_ALIGN
697 # define GLM_ALIGNED_STRUCT(x) struct
698 # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name
699 # define GLM_RESTRICT_FUNC
700 # define GLM_RESTRICT
701 # define GLM_VECTOR_CALL
702 #endif//GLM_COMPILER
703
704 #if GLM_HAS_DEFAULTED_FUNCTIONS
705 # define GLM_DEFAULT = default
706 # ifdef GLM_FORCE_NO_CTOR_INIT
707 # define GLM_DEFAULT_CTOR = default
708 # else
709 # define GLM_DEFAULT_CTOR
710 # endif
711 #else
712 # define GLM_DEFAULT
713 # define GLM_DEFAULT_CTOR
714 #endif
715
716 #if GLM_HAS_CONSTEXPR
717 # define GLM_CONSTEXPR constexpr
718 # define GLM_CONSTEXPR_CTOR constexpr
719 # define GLM_RELAXED_CONSTEXPR constexpr
720 #elif GLM_HAS_CONSTEXPR_PARTIAL
721 # define GLM_CONSTEXPR constexpr
722 # define GLM_CONSTEXPR_CTOR
723 # define GLM_RELAXED_CONSTEXPR const
724 #else
725 # define GLM_CONSTEXPR
726 # define GLM_CONSTEXPR_CTOR
727 # define GLM_RELAXED_CONSTEXPR const
728 #endif
729
730 #if GLM_ARCH == GLM_ARCH_PURE
731 # define GLM_CONSTEXPR_SIMD GLM_CONSTEXPR_CTOR
732 #else
733 # define GLM_CONSTEXPR_SIMD
734 #endif
735
736 #ifdef GLM_FORCE_EXPLICIT_CTOR
737 # define GLM_EXPLICIT explicit
738 #else
739 # define GLM_EXPLICIT
740 #endif
741
743
744 #define GLM_HAS_ALIGNED_TYPE GLM_HAS_UNRESTRICTED_UNIONS
745
747 // Length type
748
749 // User defines: GLM_FORCE_SIZE_T_LENGTH GLM_FORCE_SIZE_FUNC
750
751 namespace glm
752 {
753 using std::size_t;
754 # if defined(GLM_FORCE_SIZE_T_LENGTH)
755 typedef size_t length_t;
756 # else
757 typedef int length_t;
758 # endif
759 }//namespace glm
760
761 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH)
762 # define GLM_MESSAGE_FORCE_SIZE_T_LENGTH
763 # if defined GLM_FORCE_SIZE_T_LENGTH
764 # pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t")
765 # else
766 # pragma message("GLM: .length() returns glm::length_t, a typedef of int following the GLSL specification")
767 # endif
768 #endif//GLM_MESSAGES
769
771 // countof
772
773 #ifndef __has_feature
774 # define __has_feature(x) 0 // Compatibility with non-clang compilers.
775 #endif
776
777 #if GLM_HAS_CONSTEXPR_PARTIAL
778 namespace glm
779 {
780 template <typename T, std::size_t N>
781 constexpr std::size_t countof(T const (&)[N])
782 {
783 return N;
784 }
785 }//namespace glm
786 # define GLM_COUNTOF(arr) glm::countof(arr)
787 #elif defined(_MSC_VER)
788 # define GLM_COUNTOF(arr) _countof(arr)
789 #else
790 # define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
791 #endif
792
794 // Uninitialize constructors
795
796 namespace glm
797 {
798 enum ctor{uninitialize};
799 }//namespace glm
glm
Definition: _noise.hpp:11