1 /////////////////////////////////////////////////////////////////////////////////// 2 /// OpenGL Mathematics (glm.g-truc.net) 3 /// 4 /// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net) 5 /// Permission is hereby granted, free of charge, to any person obtaining a copy 6 /// of this software and associated documentation files (the "Software"), to deal 7 /// in the Software without restriction, including without limitation the rights 8 /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 /// copies of the Software, and to permit persons to whom the Software is 10 /// furnished to do so, subject to the following conditions: 11 /// 12 /// The above copyright notice and this permission notice shall be included in 13 /// all copies or substantial portions of the Software. 14 /// 15 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 /// THE SOFTWARE. 22 /// 23 /// @ref core 24 /// @file glm/core/setup.hpp 25 /// @date 2006-11-13 / 2013-03-30 26 /// @author Christophe Riccio 27 /////////////////////////////////////////////////////////////////////////////////// 28 29 #ifndef GLM_SETUP_INCLUDED 30 #define GLM_SETUP_INCLUDED 31 32 #include <cassert> 33 34 /////////////////////////////////////////////////////////////////////////////////////////////////// 35 // Version 36 37 #define GLM_VERSION 95 38 #define GLM_VERSION_MAJOR 0 39 #define GLM_VERSION_MINOR 9 40 #define GLM_VERSION_PATCH 5 41 #define GLM_VERSION_REVISION 3 42 43 /////////////////////////////////////////////////////////////////////////////////////////////////// 44 // Platform 45 46 #define GLM_PLATFORM_UNKNOWN 0x00000000 47 #define GLM_PLATFORM_WINDOWS 0x00010000 48 #define GLM_PLATFORM_LINUX 0x00020000 49 #define GLM_PLATFORM_APPLE 0x00040000 50 //#define GLM_PLATFORM_IOS 0x00080000 51 #define GLM_PLATFORM_ANDROID 0x00100000 52 #define GLM_PLATFORM_CHROME_NACL 0x00200000 53 #define GLM_PLATFORM_UNIX 0x00400000 54 #define GLM_PLATFORM_QNXNTO 0x00800000 55 #define GLM_PLATFORM_WINCE 0x01000000 56 57 #ifdef GLM_FORCE_PLATFORM_UNKNOWN 58 # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN 59 #elif defined(__QNXNTO__) 60 # define GLM_PLATFORM GLM_PLATFORM_QNXNTO 61 #elif defined(__APPLE__) 62 # define GLM_PLATFORM GLM_PLATFORM_APPLE 63 #elif defined(WINCE) 64 # define GLM_PLATFORM GLM_PLATFORM_WINCE 65 #elif defined(_WIN32) 66 # define GLM_PLATFORM GLM_PLATFORM_WINDOWS 67 #elif defined(__native_client__) 68 # define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL 69 #elif defined(__ANDROID__) 70 # define GLM_PLATFORM GLM_PLATFORM_ANDROID 71 #elif defined(__linux) 72 # define GLM_PLATFORM GLM_PLATFORM_LINUX 73 #elif defined(__unix) 74 # define GLM_PLATFORM GLM_PLATFORM_UNIX 75 #else 76 # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN 77 #endif// 78 79 // Report platform detection 80 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED)) 81 # define GLM_MESSAGE_PLATFORM_DISPLAYED 82 # if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO) 83 # pragma message("GLM: QNX platform detected") 84 //# elif(GLM_PLATFORM & GLM_PLATFORM_IOS) 85 //# pragma message("GLM: iOS platform detected") 86 # elif(GLM_PLATFORM & GLM_PLATFORM_APPLE) 87 # pragma message("GLM: Apple platform detected") 88 # elif(GLM_PLATFORM & GLM_PLATFORM_WINCE) 89 # pragma message("GLM: WinCE platform detected") 90 # elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS) 91 # pragma message("GLM: Windows platform detected") 92 # elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL) 93 # pragma message("GLM: Native Client detected") 94 # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) 95 # pragma message("GLM: Android platform detected") 96 # elif(GLM_PLATFORM & GLM_PLATFORM_LINUX) 97 # pragma message("GLM: Linux platform detected") 98 # elif(GLM_PLATFORM & GLM_PLATFORM_UNIX) 99 # pragma message("GLM: UNIX platform detected") 100 # elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN) 101 # pragma message("GLM: platform unknown") 102 # else 103 # pragma message("GLM: platform not detected") 104 # endif 105 #endif//GLM_MESSAGE 106 107 /////////////////////////////////////////////////////////////////////////////////////////////////// 108 // Compiler 109 110 // User defines: GLM_FORCE_COMPILER_UNKNOWN 111 // TODO ? __llvm__ 112 113 #define GLM_COMPILER_UNKNOWN 0x00000000 114 115 // Intel 116 #define GLM_COMPILER_INTEL 0x00100000 117 #define GLM_COMPILER_INTEL9 0x00100010 118 #define GLM_COMPILER_INTEL10_0 0x00100020 119 #define GLM_COMPILER_INTEL10_1 0x00100030 120 #define GLM_COMPILER_INTEL11_0 0x00100040 121 #define GLM_COMPILER_INTEL11_1 0x00100050 122 #define GLM_COMPILER_INTEL12_0 0x00100060 123 #define GLM_COMPILER_INTEL12_1 0x00100070 124 #define GLM_COMPILER_INTEL13_0 0x00100080 125 126 // Visual C++ defines 127 #define GLM_COMPILER_VC 0x01000000 128 #define GLM_COMPILER_VC8 0x01000070 129 #define GLM_COMPILER_VC9 0x01000080 130 #define GLM_COMPILER_VC10 0x01000090 131 #define GLM_COMPILER_VC11 0x010000A0 132 #define GLM_COMPILER_VC12 0x010000B0 133 134 // GCC defines 135 #define GLM_COMPILER_GCC 0x02000000 136 #define GLM_COMPILER_GCC34 0x02000050 137 #define GLM_COMPILER_GCC35 0x02000060 138 #define GLM_COMPILER_GCC40 0x02000070 139 #define GLM_COMPILER_GCC41 0x02000080 140 #define GLM_COMPILER_GCC42 0x02000090 141 #define GLM_COMPILER_GCC43 0x020000A0 142 #define GLM_COMPILER_GCC44 0x020000B0 143 #define GLM_COMPILER_GCC45 0x020000C0 144 #define GLM_COMPILER_GCC46 0x020000D0 145 #define GLM_COMPILER_GCC47 0x020000E0 146 #define GLM_COMPILER_GCC48 0x020000F0 147 #define GLM_COMPILER_GCC49 0x02000100 148 149 // Borland C++ 150 #define GLM_COMPILER_BC 0x04000000 151 152 // CodeWarrior 153 #define GLM_COMPILER_CODEWARRIOR 0x08000000 154 155 // CUDA 156 #define GLM_COMPILER_CUDA 0x10000000 157 #define GLM_COMPILER_CUDA30 0x10000010 158 #define GLM_COMPILER_CUDA31 0x10000020 159 #define GLM_COMPILER_CUDA32 0x10000030 160 #define GLM_COMPILER_CUDA40 0x10000040 161 #define GLM_COMPILER_CUDA41 0x10000050 162 #define GLM_COMPILER_CUDA42 0x10000060 163 164 // Clang 165 #define GLM_COMPILER_CLANG 0x20000000 166 #define GLM_COMPILER_CLANG26 0x20000010 167 #define GLM_COMPILER_CLANG27 0x20000020 168 #define GLM_COMPILER_CLANG28 0x20000030 169 #define GLM_COMPILER_CLANG29 0x20000040 170 #define GLM_COMPILER_CLANG30 0x20000050 171 #define GLM_COMPILER_CLANG31 0x20000060 172 #define GLM_COMPILER_CLANG32 0x20000070 173 #define GLM_COMPILER_CLANG33 0x20000080 174 #define GLM_COMPILER_CLANG40 0x20000090 175 #define GLM_COMPILER_CLANG41 0x200000A0 176 #define GLM_COMPILER_CLANG42 0x200000B0 177 #define GLM_COMPILER_CLANG43 0x200000C0 178 #define GLM_COMPILER_CLANG50 0x200000D0 179 180 // LLVM GCC 181 #define GLM_COMPILER_LLVM_GCC 0x40000000 182 183 // Build model 184 #define GLM_MODEL_32 0x00000010 185 #define GLM_MODEL_64 0x00000020 186 187 // Force generic C++ compiler 188 #ifdef GLM_FORCE_COMPILER_UNKNOWN 189 # define GLM_COMPILER GLM_COMPILER_UNKNOWN 190 191 #elif defined(__INTEL_COMPILER) 192 # if __INTEL_COMPILER == 900 193 # define GLM_COMPILER GLM_COMPILER_INTEL9 194 # elif __INTEL_COMPILER == 1000 195 # define GLM_COMPILER GLM_COMPILER_INTEL10_0 196 # elif __INTEL_COMPILER == 1010 197 # define GLM_COMPILER GLM_COMPILER_INTEL10_1 198 # elif __INTEL_COMPILER == 1100 199 # define GLM_COMPILER GLM_COMPILER_INTEL11_0 200 # elif __INTEL_COMPILER == 1110 201 # define GLM_COMPILER GLM_COMPILER_INTEL11_1 202 # elif __INTEL_COMPILER == 1200 203 # define GLM_COMPILER GLM_COMPILER_INTEL12_0 204 # elif __INTEL_COMPILER == 1210 205 # define GLM_COMPILER GLM_COMPILER_INTEL12_1 206 # elif __INTEL_COMPILER >= 1300 207 # define GLM_COMPILER GLM_COMPILER_INTEL13_0 208 # else 209 # define GLM_COMPILER GLM_COMPILER_INTEL 210 # endif 211 212 // CUDA 213 #elif defined(__CUDACC__) 214 # if !defined(CUDA_VERSION) && !defined(GLM_FORCE_CUDA) 215 # include <cuda.h> // make sure version is defined since nvcc does not define it itself! 216 # endif 217 # if CUDA_VERSION < 3000 218 # error "GLM requires CUDA 3.0 or higher" 219 # else 220 # define GLM_COMPILER GLM_COMPILER_CUDA 221 # endif 222 223 // Visual C++ 224 #elif defined(_MSC_VER) 225 # if _MSC_VER < 1400 226 # error "GLM requires Visual C++ 2005 or higher" 227 # elif _MSC_VER == 1400 228 # define GLM_COMPILER GLM_COMPILER_VC8 229 # elif _MSC_VER == 1500 230 # define GLM_COMPILER GLM_COMPILER_VC9 231 # elif _MSC_VER == 1600 232 # define GLM_COMPILER GLM_COMPILER_VC10 233 # elif _MSC_VER == 1700 234 # define GLM_COMPILER GLM_COMPILER_VC11 235 # elif _MSC_VER >= 1800 236 # define GLM_COMPILER GLM_COMPILER_VC12 237 # else//_MSC_VER 238 # define GLM_COMPILER GLM_COMPILER_VC 239 # endif//_MSC_VER 240 241 // Clang 242 #elif defined(__clang__) 243 # if (__clang_major__ <= 1) || ((__clang_major__ == 2) && (__clang_minor__ < 6)) 244 # error "GLM requires Clang 2.6 or higher" 245 # elif(__clang_major__ == 2) && (__clang_minor__ == 6) 246 # define GLM_COMPILER GLM_COMPILER_CLANG26 247 # elif(__clang_major__ == 2) && (__clang_minor__ == 7) 248 # define GLM_COMPILER GLM_COMPILER_CLANG27 249 # elif(__clang_major__ == 2) && (__clang_minor__ == 8) 250 # define GLM_COMPILER GLM_COMPILER_CLANG28 251 # elif(__clang_major__ == 2) && (__clang_minor__ == 9) 252 # define GLM_COMPILER GLM_COMPILER_CLANG29 253 # elif(__clang_major__ == 3) && (__clang_minor__ == 0) 254 # define GLM_COMPILER GLM_COMPILER_CLANG30 255 # elif(__clang_major__ == 3) && (__clang_minor__ == 1) 256 # define GLM_COMPILER GLM_COMPILER_CLANG31 257 # elif(__clang_major__ == 3) && (__clang_minor__ == 2) 258 # define GLM_COMPILER GLM_COMPILER_CLANG32 259 # elif(__clang_major__ == 3) && (__clang_minor__ == 3) 260 # define GLM_COMPILER GLM_COMPILER_CLANG33 261 # elif(__clang_major__ == 4) && (__clang_minor__ == 0) 262 # define GLM_COMPILER GLM_COMPILER_CLANG40 263 # elif(__clang_major__ == 4) && (__clang_minor__ == 1) 264 # define GLM_COMPILER GLM_COMPILER_CLANG41 265 # elif(__clang_major__ == 4) && (__clang_minor__ == 2) 266 # define GLM_COMPILER GLM_COMPILER_CLANG42 267 # elif(__clang_major__ == 4) && (__clang_minor__ >= 3) 268 # define GLM_COMPILER GLM_COMPILER_CLANG43 269 # elif(__clang_major__ > 4) 270 # define GLM_COMPILER GLM_COMPILER_CLANG50 271 # else 272 # define GLM_COMPILER GLM_COMPILER_CLANG 273 # endif 274 275 // G++ 276 #elif(defined(__GNUC__) || defined(__MINGW32__))// || defined(__llvm__) || defined(__clang__) 277 # if (__GNUC__ == 3) && (__GNUC_MINOR__ == 4) 278 # define GLM_COMPILER GLM_COMPILER_GCC34 279 # elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 5) 280 # define GLM_COMPILER GLM_COMPILER_GCC35 281 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 0) 282 # define GLM_COMPILER (GLM_COMPILER_GCC40) 283 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 1) 284 # define GLM_COMPILER (GLM_COMPILER_GCC41) 285 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 2) 286 # define GLM_COMPILER (GLM_COMPILER_GCC42) 287 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3) 288 # define GLM_COMPILER (GLM_COMPILER_GCC43) 289 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 4) 290 # define GLM_COMPILER (GLM_COMPILER_GCC44) 291 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 5) 292 # define GLM_COMPILER (GLM_COMPILER_GCC45) 293 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6) 294 # define GLM_COMPILER (GLM_COMPILER_GCC46) 295 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7) 296 # define GLM_COMPILER (GLM_COMPILER_GCC47) 297 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) 298 # define GLM_COMPILER (GLM_COMPILER_GCC48) 299 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9) 300 # define GLM_COMPILER (GLM_COMPILER_GCC49) 301 # elif (__GNUC__ > 4 ) 302 # define GLM_COMPILER (GLM_COMPILER_GCC49) 303 # else 304 # define GLM_COMPILER (GLM_COMPILER_GCC) 305 # endif 306 307 // Borland C++ 308 #elif defined(_BORLANDC_) 309 # define GLM_COMPILER GLM_COMPILER_BC 310 311 // Codewarrior 312 #elif defined(__MWERKS__) 313 # define GLM_COMPILER GLM_COMPILER_CODEWARRIOR 314 315 #else 316 # define GLM_COMPILER GLM_COMPILER_UNKNOWN 317 #endif 318 319 #ifndef GLM_COMPILER 320 #error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message." 321 #endif//GLM_COMPILER 322 323 // Report compiler detection 324 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED)) 325 # define GLM_MESSAGE_COMPILER_DISPLAYED 326 # if(GLM_COMPILER & GLM_COMPILER_CUDA) 327 # pragma message("GLM: CUDA compiler detected") 328 # elif(GLM_COMPILER & GLM_COMPILER_VC) 329 # pragma message("GLM: Visual C++ compiler detected") 330 # elif(GLM_COMPILER & GLM_COMPILER_CLANG) 331 # pragma message("GLM: Clang compiler detected") 332 # elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC) 333 # pragma message("GLM: LLVM GCC compiler detected") 334 # elif(GLM_COMPILER & GLM_COMPILER_INTEL) 335 # pragma message("GLM: Intel Compiler detected") 336 # elif(GLM_COMPILER & GLM_COMPILER_GCC) 337 # if(GLM_COMPILER == GLM_COMPILER_GCC_LLVM) 338 # pragma message("GLM: LLVM GCC compiler detected") 339 # elif(GLM_COMPILER == GLM_COMPILER_GCC_CLANG) 340 # pragma message("GLM: CLANG compiler detected") 341 # else 342 # pragma message("GLM: GCC compiler detected") 343 # endif 344 # elif(GLM_COMPILER & GLM_COMPILER_BC) 345 # pragma message("GLM: Borland compiler detected but not supported") 346 # elif(GLM_COMPILER & GLM_COMPILER_CODEWARRIOR) 347 # pragma message("GLM: Codewarrior compiler detected but not supported") 348 # else 349 # pragma message("GLM: Compiler not detected") 350 # endif 351 #endif//GLM_MESSAGE 352 353 ///////////////// 354 // Build model // 355 356 #if(defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__)) 357 # define GLM_MODEL GLM_MODEL_64 358 #elif(defined(__i386__) || defined(__ppc__)) 359 # define GLM_MODEL GLM_MODEL_32 360 #else 361 # define GLM_MODEL GLM_MODEL_32 362 #endif// 363 364 #if(!defined(GLM_MODEL) && GLM_COMPILER != 0) 365 # error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message." 366 #endif//GLM_MODEL 367 368 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_MODEL_DISPLAYED)) 369 # define GLM_MESSAGE_MODEL_DISPLAYED 370 # if(GLM_MODEL == GLM_MODEL_64) 371 # pragma message("GLM: 64 bits model") 372 # elif(GLM_MODEL == GLM_MODEL_32) 373 # pragma message("GLM: 32 bits model") 374 # endif//GLM_MODEL 375 #endif//GLM_MESSAGE 376 377 ///////////////// 378 // C++ Version // 379 380 // User defines: GLM_FORCE_CXX98 381 382 #define GLM_LANG_CXX_FLAG (1 << 0) 383 #define GLM_LANG_CXX98_FLAG (1 << 1) 384 #define GLM_LANG_CXX03_FLAG (1 << 2) 385 #define GLM_LANG_CXX0X_FLAG (1 << 3) 386 #define GLM_LANG_CXX11_FLAG (1 << 4) 387 #define GLM_LANG_CXX1Y_FLAG (1 << 5) 388 #define GLM_LANG_CXXMS_FLAG (1 << 6) 389 #define GLM_LANG_CXXGNU_FLAG (1 << 7) 390 391 #define GLM_LANG_CXX GLM_LANG_CXX_FLAG 392 #define GLM_LANG_CXX98 (GLM_LANG_CXX | GLM_LANG_CXX98_FLAG) 393 #define GLM_LANG_CXX03 (GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG) 394 #define GLM_LANG_CXX0X (GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG) 395 #define GLM_LANG_CXX11 (GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG) 396 #define GLM_LANG_CXX1Y (GLM_LANG_CXX11 | GLM_LANG_CXX1Y_FLAG) 397 #define GLM_LANG_CXXMS GLM_LANG_CXXMS_FLAG 398 #define GLM_LANG_CXXGNU GLM_LANG_CXXGNU_FLAG 399 400 #if(defined(GLM_FORCE_CXX1Y)) 401 # define GLM_LANG GLM_LANG_CXX1Y 402 #elif(defined(GLM_FORCE_CXX11)) 403 # define GLM_LANG GLM_LANG_CXX11 404 #elif(defined(GLM_FORCE_CXX03)) 405 # define GLM_LANG GLM_LANG_CXX03 406 #elif(defined(GLM_FORCE_CXX98)) 407 # define GLM_LANG GLM_LANG_CXX98 408 #else 409 # if(__cplusplus >= 201103L) 410 # define GLM_LANG GLM_LANG_CXX11 411 # elif((GLM_COMPILER & GLM_COMPILER_CLANG) == GLM_COMPILER_CLANG) 412 # if(GLM_PLATFORM == GLM_PLATFORM_APPLE) 413 # define GLM_DETAIL_MAJOR 1 414 # else 415 # define GLM_DETAIL_MAJOR 0 416 # endif 417 # if(__clang_major__ < (2 + GLM_DETAIL_MAJOR)) 418 # define GLM_LANG GLM_LANG_CXX 419 # elif(__has_feature(cxx_auto_type)) 420 # define GLM_LANG GLM_LANG_CXX0X 421 # else 422 # define GLM_LANG GLM_LANG_CXX98 423 # endif 424 # elif((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) 425 # if defined(__GXX_EXPERIMENTAL_CXX0X__) 426 # define GLM_LANG GLM_LANG_CXX0X 427 # else 428 # define GLM_LANG GLM_LANG_CXX98 429 # endif 430 # elif(GLM_COMPILER & GLM_COMPILER_VC) 431 # if(defined(_MSC_EXTENSIONS)) 432 # if(GLM_COMPILER >= GLM_COMPILER_VC10) 433 # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG) 434 # else 435 # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG) 436 # endif 437 # else 438 # if(GLM_COMPILER >= GLM_COMPILER_VC10) 439 # define GLM_LANG GLM_LANG_CXX0X 440 # else 441 # define GLM_LANG GLM_LANG_CXX98 442 # endif 443 # endif 444 # elif(GLM_COMPILER & GLM_COMPILER_INTEL) 445 # if(defined(_MSC_EXTENSIONS)) 446 # if(GLM_COMPILER >= GLM_COMPILER_INTEL13_0) 447 # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG) 448 # else 449 # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG) 450 # endif 451 # else 452 # if(GLM_COMPILER >= GLM_COMPILER_INTEL13_0) 453 # define GLM_LANG (GLM_LANG_CXX0X) 454 # else 455 # define GLM_LANG (GLM_LANG_CXX98) 456 # endif 457 # endif 458 # elif(__cplusplus >= 199711L) 459 # define GLM_LANG GLM_LANG_CXX98 460 # else 461 # define GLM_LANG GLM_LANG_CXX 462 # endif 463 #endif 464 465 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED)) 466 # define GLM_MESSAGE_LANG_DISPLAYED 467 # if(GLM_LANG & GLM_LANG_CXXGNU_FLAG) 468 # pragma message("GLM: C++ with language extensions") 469 # elif(GLM_LANG & GLM_LANG_CXXMS_FLAG) 470 # pragma message("GLM: C++ with language extensions") 471 # elif(GLM_LANG & GLM_LANG_CXX11_FLAG) 472 # pragma message("GLM: C++11") 473 # elif(GLM_LANG & GLM_LANG_CXX0X_FLAG) 474 # pragma message("GLM: C++0x") 475 # elif(GLM_LANG & GLM_LANG_CXX03_FLAG) 476 # pragma message("GLM: C++03") 477 # elif(GLM_LANG & GLM_LANG_CXX98_FLAG) 478 # pragma message("GLM: C++98") 479 # else 480 # pragma message("GLM: C++ language undetected") 481 # endif//GLM_MODEL 482 # pragma message("GLM: #define GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_LANG_CXX11 or GLM_FORCE_CXX1Y to force using a specific version of the C++ language") 483 #endif//GLM_MESSAGE 484 485 /////////////////////////////////////////////////////////////////////////////////////////////////// 486 // Has of C++ features 487 488 #ifndef __has_feature 489 # define __has_feature(x) 0 // Compatibility with non-clang compilers. 490 #endif 491 #ifndef __has_extension 492 # define __has_extension __has_feature // Compatibility with pre-3.0 compilers. 493 #endif 494 495 // http://clang.llvm.org/cxx_status.html 496 // http://gcc.gnu.org/projects/cxx0x.html 497 // http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx 498 499 // N1720 500 #define GLM_HAS_STATIC_ASSERT ( \ 501 (GLM_LANG & GLM_LANG_CXX11_FLAG) || \ 502 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC10)) || \ 503 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \ 504 __has_feature(cxx_static_assert)) 505 506 // N1988 507 #define GLM_HAS_EXTENDED_INTEGER_TYPE ( \ 508 (GLM_LANG & GLM_LANG_CXX11_FLAG) || \ 509 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11)) || \ 510 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \ 511 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER >= GLM_COMPILER_CLANG29))) 512 513 // N2235 514 #define GLM_HAS_CONSTEXPR ( \ 515 (GLM_LANG & GLM_LANG_CXX11_FLAG) || \ 516 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \ 517 __has_feature(cxx_constexpr)) 518 519 // N2672 520 #define GLM_HAS_INITIALIZER_LISTS ( \ 521 (GLM_LANG & GLM_LANG_CXX11_FLAG) || \ 522 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12))) || \ 523 ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC44)) || \ 524 __has_feature(cxx_generalized_initializers)) 525 526 // OpenMP 527 #ifdef _OPENMP 528 # if(GLM_COMPILER & GLM_COMPILER_GCC) 529 # if(GLM_COMPILER > GLM_COMPILER_GCC47) 530 # define GLM_HAS_OPENMP 31 531 # elif(GLM_COMPILER > GLM_COMPILER_GCC44) 532 # define GLM_HAS_OPENMP 30 533 # elif(GLM_COMPILER > GLM_COMPILER_GCC42) 534 # define GLM_HAS_OPENMP 25 535 # endif 536 # endif//(GLM_COMPILER & GLM_COMPILER_GCC) 537 538 # if(GLM_COMPILER & GLM_COMPILER_VC) 539 # if(GLM_COMPILER > GLM_COMPILER_VC8) 540 # define GLM_HAS_OPENMP 20 541 # endif 542 # endif//(GLM_COMPILER & GLM_COMPILER_GCC) 543 #endif 544 545 // Not standard 546 #define GLM_HAS_ANONYMOUS_UNION (GLM_LANG & GLM_LANG_CXXMS_FLAG) 547 548 ///////////////// 549 // Platform 550 551 // User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_AVX 552 553 #define GLM_ARCH_PURE 0x0000 554 #define GLM_ARCH_SSE2 0x0001 555 #define GLM_ARCH_SSE3 0x0002// | GLM_ARCH_SSE2 556 #define GLM_ARCH_AVX 0x0008// | GLM_ARCH_SSE3 | GLM_ARCH_SSE2 557 #define GLM_ARCH_AVX2 0x0010// | GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2 558 559 #if(defined(GLM_FORCE_PURE)) 560 # define GLM_ARCH GLM_ARCH_PURE 561 #elif(defined(GLM_FORCE_AVX2)) 562 # define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2) 563 #elif(defined(GLM_FORCE_AVX)) 564 # define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2) 565 #elif(defined(GLM_FORCE_SSE3)) 566 # define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2) 567 #elif(defined(GLM_FORCE_SSE2)) 568 # define GLM_ARCH (GLM_ARCH_SSE2) 569 #elif(GLM_COMPILER & GLM_COMPILER_VC) 570 # if _M_IX86_FP == 2 && defined(__AVX__) 571 # define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2) 572 # elif _M_IX86_FP == 2 573 # define GLM_ARCH (GLM_ARCH_SSE2) 574 # else 575 # define GLM_ARCH (GLM_ARCH_PURE) 576 # endif 577 #elif((GLM_PLATFORM & GLM_PLATFORM_APPLE) && (GLM_COMPILER & GLM_COMPILER_GCC)) 578 # define GLM_ARCH GLM_ARCH_PURE 579 #elif(((GLM_COMPILER & GLM_COMPILER_GCC) && (defined(__i386__) || defined(__x86_64__))) || (GLM_COMPILER & GLM_COMPILER_LLVM_GCC)) 580 # if defined(__AVX2__) 581 # define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2) 582 # elif defined(__AVX__) 583 # define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2) 584 # elif defined(__SSE3__) 585 # define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2) 586 # elif defined(__SSE2__) 587 # define GLM_ARCH (GLM_ARCH_SSE2) 588 # else 589 # define GLM_ARCH (GLM_ARCH_PURE) 590 # endif 591 #else 592 # define GLM_ARCH GLM_ARCH_PURE 593 #endif 594 595 // With MinGW-W64, including intrinsic headers before intrin.h will produce some errors. The problem is 596 // that windows.h (and maybe other headers) will silently include intrin.h, which of course causes problems. 597 // To fix, we just explicitly include intrin.h here. 598 #if defined(__MINGW32__) && (GLM_ARCH != GLM_ARCH_PURE) 599 # include <intrin.h> 600 #endif 601 602 //#if(GLM_ARCH != GLM_ARCH_PURE) 603 #if(GLM_ARCH & GLM_ARCH_AVX2) 604 # include <immintrin.h> 605 #endif//GLM_ARCH 606 #if(GLM_ARCH & GLM_ARCH_AVX) 607 # include <immintrin.h> 608 #endif//GLM_ARCH 609 #if(GLM_ARCH & GLM_ARCH_SSE4) 610 # include <smmintrin.h> 611 #endif//GLM_ARCH 612 #if(GLM_ARCH & GLM_ARCH_SSE3) 613 # include <pmmintrin.h> 614 #endif//GLM_ARCH 615 #if(GLM_ARCH & GLM_ARCH_SSE2) 616 # include <emmintrin.h> 617 # if(GLM_COMPILER == GLM_COMPILER_VC8) // VC8 is missing some intrinsics, workaround _mm_cvtss_f32(__m128 A)618 inline float _mm_cvtss_f32(__m128 A) { return A.m128_f32[0]; } _mm_castpd_ps(__m128d PD)619 inline __m128 _mm_castpd_ps(__m128d PD) { union { __m128 ps; __m128d pd; } c; c.pd = PD; return c.ps; } _mm_castps_pd(__m128 PS)620 inline __m128d _mm_castps_pd(__m128 PS) { union { __m128 ps; __m128d pd; } c; c.ps = PS; return c.pd; } _mm_castps_si128(__m128 PS)621 inline __m128i _mm_castps_si128(__m128 PS) { union { __m128 ps; __m128i pi; } c; c.ps = PS; return c.pi; } _mm_castsi128_ps(__m128i PI)622 inline __m128 _mm_castsi128_ps(__m128i PI) { union { __m128 ps; __m128i pi; } c; c.pi = PI; return c.ps; } 623 # endif 624 #endif//GLM_ARCH 625 //#endif//(GLM_ARCH != GLM_ARCH_PURE) 626 627 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED)) 628 # define GLM_MESSAGE_ARCH_DISPLAYED 629 # if(GLM_ARCH == GLM_ARCH_PURE) 630 # pragma message("GLM: Platform independent code") 631 # elif(GLM_ARCH & GLM_ARCH_SSE2) 632 # pragma message("GLM: SSE2 instruction set") 633 # elif(GLM_ARCH & GLM_ARCH_SSE3) 634 # pragma message("GLM: SSE3 instruction set") 635 # elif(GLM_ARCH & GLM_ARCH_SSE4) 636 # pragma message("GLM: SSE4 instruction set") 637 # elif(GLM_ARCH & GLM_ARCH_AVX) 638 # pragma message("GLM: AVX instruction set") 639 # elif(GLM_ARCH & GLM_ARCH_AVX2) 640 # pragma message("GLM: AVX2 instruction set") 641 # endif//GLM_ARCH 642 # pragma message("GLM: #define GLM_FORCE_PURE to avoid using platform specific instruction sets") 643 #endif//GLM_MESSAGE 644 645 /////////////////////////////////////////////////////////////////////////////////////////////////// 646 // Radians 647 648 //#define GLM_FORCE_RADIANS 649 650 /////////////////////////////////////////////////////////////////////////////////////////////////// 651 // Static assert 652 653 #if GLM_HAS_STATIC_ASSERT 654 # define GLM_STATIC_ASSERT(x, message) static_assert(x, message) 655 #elif(defined(BOOST_STATIC_ASSERT)) 656 # define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x) 657 #elif(GLM_COMPILER & GLM_COMPILER_VC) 658 # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1] 659 #else 660 # define GLM_STATIC_ASSERT(x, message) 661 # define GLM_STATIC_ASSERT_NULL 662 #endif//GLM_LANG 663 664 /////////////////////////////////////////////////////////////////////////////////////////////////// 665 // Qualifiers 666 667 // User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA 668 669 #if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA)) 670 # define GLM_CUDA_FUNC_DEF __device__ __host__ 671 # define GLM_CUDA_FUNC_DECL __device__ __host__ 672 #else 673 # define GLM_CUDA_FUNC_DEF 674 # define GLM_CUDA_FUNC_DECL 675 #endif 676 677 #if GLM_COMPILER & GLM_COMPILER_GCC 678 # define GLM_VAR_USED __attribute__ ((unused)) 679 #else 680 # define GLM_VAR_USED 681 #endif 682 683 #if(defined(GLM_FORCE_INLINE)) 684 # if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC8)) 685 # define GLM_INLINE __forceinline 686 # elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC34)) 687 # define GLM_INLINE __attribute__((always_inline)) inline 688 # elif(GLM_COMPILER & GLM_COMPILER_CLANG) 689 # define GLM_INLINE __attribute__((always_inline)) 690 # else 691 # define GLM_INLINE inline 692 # endif//GLM_COMPILER 693 #else 694 # define GLM_INLINE inline 695 #endif//defined(GLM_FORCE_INLINE) 696 697 #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL 698 #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE 699 700 /////////////////////////////////////////////////////////////////////////////////////////////////// 701 // Swizzle operators 702 703 // User defines: GLM_SWIZZLE 704 705 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)) 706 # define GLM_MESSAGE_SWIZZLE_DISPLAYED 707 # if defined(GLM_SWIZZLE) 708 # pragma message("GLM: Swizzling operators enabled") 709 # else 710 # pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators") 711 # endif 712 #endif//GLM_MESSAGE 713 714 /////////////////////////////////////////////////////////////////////////////////////////////////// 715 // Length type 716 717 // User defines: GLM_FORCE_SIZE_T_LENGTH 718 719 namespace glm 720 { 721 #if defined(GLM_FORCE_SIZE_T_LENGTH) 722 typedef std::size_t length_t; 723 #else 724 typedef int length_t; 725 #endif 726 }//namespace glm 727 728 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH)) 729 # define GLM_MESSAGE_FORCE_SIZE_T_LENGTH 730 # if defined(GLM_FORCE_SIZE_T_LENGTH) 731 # pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t") 732 # else 733 # pragma message("GLM: .length() returns glm::length_t, a typedef of int following the GLSL specification") 734 # pragma message("GLM: #define GLM_FORCE_SIZE_T_LENGTH for .length() to return a std::size_t") 735 # endif 736 #endif//GLM_MESSAGE 737 738 /////////////////////////////////////////////////////////////////////////////////////////////////// 739 // Qualifiers 740 741 #if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC8)) 742 # define GLM_DEPRECATED __declspec(deprecated) 743 # define GLM_ALIGN(x) __declspec(align(x)) 744 # define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct 745 # define GLM_RESTRICT __declspec(restrict) 746 # define GLM_RESTRICT_VAR __restrict 747 #elif(GLM_COMPILER & GLM_COMPILER_INTEL) 748 # define GLM_DEPRECATED 749 # define GLM_ALIGN(x) __declspec(align(x)) 750 # define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct 751 # define GLM_RESTRICT 752 # define GLM_RESTRICT_VAR __restrict 753 #elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) 754 # define GLM_DEPRECATED __attribute__((__deprecated__)) 755 # define GLM_ALIGN(x) __attribute__((aligned(x))) 756 # define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x))) 757 # define GLM_RESTRICT __restrict__ 758 # define GLM_RESTRICT_VAR __restrict__ 759 #else 760 # define GLM_DEPRECATED 761 # define GLM_ALIGN 762 # define GLM_ALIGNED_STRUCT(x) 763 # define GLM_RESTRICT 764 # define GLM_RESTRICT_VAR 765 #endif//GLM_COMPILER 766 767 #if GLM_HAS_CONSTEXPR 768 # define GLM_CONSTEXPR constexpr 769 #else 770 # define GLM_CONSTEXPR 771 #endif 772 773 #endif//GLM_SETUP_INCLUDED 774