glm-0.9.9-a2/0000700000175000001440000000000013173131001011466 5ustar guususersglm-0.9.9-a2/readme.md0000600000175000001440000011260413173131001013253 0ustar guususers![glm](/doc/manual/logo-mini.png) [OpenGL Mathematics](http://glm.g-truc.net/) (*GLM*) is a header only C++ mathematics library for graphics software based on the [OpenGL Shading Language (GLSL) specifications](https://www.opengl.org/registry/doc/GLSLangSpec.4.50.diff.pdf). *GLM* provides classes and functions designed and implemented with the same naming conventions and functionality than *GLSL* so that anyone who knows *GLSL*, can use *GLM* as well in C++. This project isn't limited to *GLSL* features. An extension system, based on the *GLSL* extension conventions, provides extended capabilities: matrix transformations, quaternions, data packing, random numbers, noise, etc... This library works perfectly with *[OpenGL](https://www.opengl.org)* but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (raytracing / rasterisation), image processing, physic simulations and any development context that requires a simple and convenient mathematics library. *GLM* is written in C++98 but can take advantage of C++11 when supported by the compiler. It is a platform independent library with no dependence and it officially supports the following compilers: - [Apple Clang 6.0](https://developer.apple.com/library/mac/documentation/CompilerTools/Conceptual/LLVMCompilerOverview/index.html) and higher - [GCC](http://gcc.gnu.org/) 4.7 and higher - [Intel C++ Composer](https://software.intel.com/en-us/intel-compilers) XE 2013 and higher - [LLVM](http://llvm.org/) 3.4 and higher - [Visual C++](http://www.visualstudio.com/) 2013 and higher - [CUDA](https://developer.nvidia.com/about-cuda) 7.0 and higher (experimental) - Any C++11 compiler For more information about *GLM*, please have a look at the [manual](manual.md) and the [API reference documentation](http://glm.g-truc.net/0.9.8/api/index.html). The source code and the documentation are licensed under both the [Happy Bunny License (Modified MIT) or the MIT License](manual.md#section0). Thanks for contributing to the project by [submitting issues](https://github.com/g-truc/glm/issues) for bug reports and feature requests. Any feedback is welcome at [glm@g-truc.net](mailto://glm@g-truc.net). ```cpp #include // glm::vec3 #include // glm::vec4 #include // glm::mat4 #include // glm::translate, glm::rotate, glm::scale, glm::perspective #include // glm::pi glm::mat4 camera(float Translate, glm::vec2 const& Rotate) { glm::mat4 Projection = glm::perspective(glm::pi() * 0.25f, 4.0f / 3.0f, 0.1f, 100.f); glm::mat4 View = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate)); View = glm::rotate(View, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f)); View = glm::rotate(View, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f)); return Projection * View * Model; } ``` ## [Lastest release](https://github.com/g-truc/glm/releases/latest) ## Project Health | Service | System | Compiler | Status | | ------- | ------ | -------- | ------ | | [Travis CI](https://travis-ci.org/g-truc/glm)| MacOSX, Linux 64 bits | Clang 3.4, Clang 3.6, Clang 4.0, GCC 4.9, GCC 7.0 | [![Travis CI](https://travis-ci.org/g-truc/glm.svg?branch=master)](https://travis-ci.org/g-truc/glm) | [AppVeyor](https://ci.appveyor.com/project/Groovounet/glm)| Windows 32 and 64 | Visual Studio 2013, Visual Studio 2015, Visual Studio 2017 | [![AppVeyor](https://ci.appveyor.com/api/projects/status/32r7s2skrgm9ubva?svg=true)](https://ci.appveyor.com/project/Groovounet/glm) ## Release notes ### [GLM 0.9.9.0](https://github.com/g-truc/glm/releases/latest) - 2017-XX-XX #### Features: - Added RGBM encoding in GTC_packing #420 - Added GTX_color_encoding extension - Added GTX_vec_swizzle, faster compile time swizzling then swizzle operator #558 - Added GTX_exterior_product with a vec2 cross implementation #621 - Added GTX_matrix_factorisation to factor matrices in various forms #654 - Added [GLM_ENABLE_EXPERIMENTAL](manual.md#section7_4) to enable experimental features. - Added packing functions for integer vectors #639 - Added conan packaging configuration #643 #641 - Added quatLookAt to GTX_quaternion #659 - Added fmin, fmax and fclamp to GTX_extended_min_max #372 - Added EXT_vector_relational: extend equal and notEqual to take an epsilon argument - Added EXT_vector_relational: openBounded and closeBounded - Added EXT_vec1: *vec1 types - Added GTX_texture: levels function - Added spearate functions to use both nagative one and zero near clip plans #680 - Added GLM_FORCE_SINGLE_ONLY to use GLM on platforms that don't support double #627 #### Improvements: - No more default initialization of vector, matrix and quaternion types - Added lowp variant of GTC_color_space convertLinearToSRGB #419 - Replaced the manual by a markdown version #458 - Improved API documentation #668 - Optimized GTC_packing implementation - Optimized GTC_noise functions - Optimized GTC_color_space HSV to RGB conversions - Optimised GTX_color_space_YCoCg YCoCgR conversions - Optimized GTX_matrix_interpolation axisAngle function - Added FAQ 12: Windows headers cause build errors... #557 - Removed GCC shadow warnings #595 - Added error for including of different versions of GLM #619 - Added GLM_FORCE_IGNORE_VERSION to ignore error caused by including different version of GLM #619 - Reduced warnings when using very strict compilation flags #646 - length() member functions are constexpr #657 - Added support of -Weverything with Clang #646 - Improved exponential funtion test coverage - Enabled warnings as error with Clang unit tests #### Fixes: - Removed doxygen references to GTC_half_float which was removed in 0.9.4 - Fixed glm::decompose #448 - Fixed intersectRayTriangle #6 - Fixed dual quaternion != operator #629 - Fixed usused variable warning in GTX_spline #618 - Fixed references to GLM_FORCE_RADIANS which was removed #642 - Fixed glm::fastInverseSqrt to use fast inverse square #640 - Fixed axisAngle NaN #638 - Fixed integer pow from GTX_integer with null exponent #658 - Fixed quat normalize build error #656 - Fixed Visual C++ 2017.2 warning regarding __has_feature definision #655 - Fixed documentation warnings - Fixed GLM_HAS_OPENMP when OpenMP is not enabled - Fixed Better follow GLSL min and max specification #372 - Fixed quaternion constructor from two vectors special cases #469 - Fixed glm::to_string on quaternions wrong components order #681 #### Deprecation: - Requires Visual Studio 2013, GCC 4.7, Clang 3.4, Cuda 7, ICC 2013 or a C++11 compiler - Removed GLM_GTX_simd_vec4 extension - Removed GLM_GTX_simd_mat4 extension - Removed GLM_GTX_simd_quat extension - Removed GLM_SWIZZLE, use GLM_FORCE_SWIZZLE instead - Removed GLM_MESSAGES, use GLM_FORCE_MESSAGES instead - Removed GLM_DEPTH_ZERO_TO_ONE, use GLM_FORCE_DEPTH_ZERO_TO_ONE instead - Removed GLM_LEFT_HANDED, use GLM_FORCE_LEFT_HANDED instead - Removed GLM_FORCE_NO_CTOR_INIT - Removed glm::uninitialize --- ### [GLM 0.9.8.5](https://github.com/g-truc/glm/releases/tag/0.9.8.5) - 2017-08-16 #### Features: - Added Conan package support #647 #### Fixes: - Fixed Clang version detection from source #608 - Fixed packF3x9_E1x5 exponent packing #614 - Fixed build error min and max specializations with integer #616 - Fixed simd_mat4 build error #652 --- ### [GLM 0.9.8.4](https://github.com/g-truc/glm/releases/tag/0.9.8.4) - 2017-01-22 #### Fixes: - Fixed GTC_packing test failing on GCC x86 due to denorms #212 #577 - Fixed POPCNT optimization build in Clang #512 - Fixed intersectRayPlane returns true in parallel case #578 - Fixed GCC 6.2 compiler warnings #580 - Fixed GTX_matrix_decompose decompose #582 #448 - Fixed GCC 4.5 and older build #566 - Fixed Visual C++ internal error when declaring a global vec type with siwzzle expression enabled #594 - Fixed GLM_FORCE_CXX11 with Clang and libstlc++ which wasn't using C++11 STL features. #604 --- ### [GLM 0.9.8.3](https://github.com/g-truc/glm/releases/tag/0.9.8.3) - 2016-11-12 #### Improvements: - Broader support of GLM_FORCE_UNRESTRICTED_GENTYPE #378 #### Fixes: - Fixed Android build error with C++11 compiler but C++98 STL #284 #564 - Fixed GTX_transform2 shear* functions #403 - Fixed interaction between GLM_FORCE_UNRESTRICTED_GENTYPE and ortho function #568 - Fixed bitCount with AVX on 32 bit builds #567 - Fixed CMake find_package with version specification #572 #573 --- ### [GLM 0.9.8.2](https://github.com/g-truc/glm/releases/tag/0.9.8.2) - 2016-11-01 #### Improvements: - Added Visual C++ 15 detection - Added Clang 4.0 detection - Added warning messages when using GLM_FORCE_CXX** but the compiler is known to not fully support the requested C++ version #555 - Refactored GLM_COMPILER_VC values - Made quat, vec, mat type component length() static #565 #### Fixes: - Fixed Visual C++ constexpr build error #555, #556 --- ### [GLM 0.9.8.1](https://github.com/g-truc/glm/releases/tag/0.9.8.1) - 2016-09-25 #### Improvements: - Optimized quaternion log function #554 #### Fixes: - Fixed GCC warning filtering, replaced -pedantic by -Wpedantic - Fixed SIMD faceforward bug. #549 - Fixed GCC 4.8 with C++11 compilation option #550 - Fixed Visual Studio aligned type W4 warning #548 - Fixed packing/unpacking function fixed for 5_6_5 and 5_5_5_1 #552 --- ### [GLM 0.9.8.0](https://github.com/g-truc/glm/releases/tag/0.9.8.0) - 2016-09-11 #### Features: - Added right and left handed projection and clip control support #447 #415 #119 - Added compNormalize and compScale functions to GTX_component_wise - Added packF3x9_E1x5 and unpackF3x9_E1x5 to GTC_packing for RGB9E5 #416 - Added (un)packHalf to GTC_packing - Added (un)packUnorm and (un)packSnorm to GTC_packing - Added 16bit pack and unpack to GTC_packing - Added 8bit pack and unpack to GTC_packing - Added missing bvec* && and || operators - Added iround and uround to GTC_integer, fast round on positive values - Added raw SIMD API - Added 'aligned' qualifiers - Added GTC_type_aligned with aligned *vec* types - Added GTC_functions extension - Added quaternion version of isnan and isinf #521 - Added lowestBitValue to GTX_bit #536 - Added GLM_FORCE_UNRESTRICTED_GENTYPE allowing non basic genType #543 #### Improvements: - Improved SIMD and swizzle operators interactions with GCC and Clang #474 - Improved GTC_random linearRand documentation - Improved GTC_reciprocal documentation - Improved GLM_FORCE_EXPLICIT_CTOR coverage #481 - Improved OpenMP support detection for Clang, GCC, ICC and VC - Improved GTX_wrap for SIMD friendliness - Added constexpr for *vec*, *mat*, *quat* and *dual_quat* types #493 - Added NEON instruction set detection - Added MIPS CPUs detection - Added PowerPC CPUs detection - Use Cuda built-in function for abs function implementation with Cuda compiler - Factorized GLM_COMPILER_LLVM and GLM_COMPILER_APPLE_CLANG into GLM_COMPILER_CLANG - No more warnings for use of long long - Added more information to build messages #### Fixes: - Fixed GTX_extended_min_max filename typo #386 - Fixed intersectRayTriangle to not do any unintentional backface culling - Fixed long long warnings when using C++98 on GCC and Clang #482 - Fixed sign with signed integer function on non-x86 architecture - Fixed strict aliasing warnings #473 - Fixed missing vec1 overload to length2 and distance2 functions #431 - Fixed GLM test '/fp:fast' and '/Za' command-line options are incompatible - Fixed quaterion to mat3 cast function mat3_cast from GTC_quaternion #542 - Fixed GTX_io for Cuda #547 #546 #### Deprecation: - Removed GLM_FORCE_SIZE_FUNC define - Deprecated GLM_GTX_simd_vec4 extension - Deprecated GLM_GTX_simd_mat4 extension - Deprecated GLM_GTX_simd_quat extension - Deprecated GLM_SWIZZLE, use GLM_FORCE_SWIZZLE instead - Deprecated GLM_MESSAGES, use GLM_FORCE_MESSAGES instead --- ### [GLM 0.9.7.6](https://github.com/g-truc/glm/releases/tag/0.9.7.6) - 2016-07-16 #### Improvements: - Added pkg-config file #509 - Updated list of compiler versions detected - Improved C++ 11 STL detection #523 #### Fixes: - Fixed STL for C++11 detection on ICC #510 - Fixed missing vec1 overload to length2 and distance2 functions #431 - Fixed long long warnings when using C++98 on GCC and Clang #482 - Fixed scalar reciprocal functions (GTC_reciprocal) #520 --- ### [GLM 0.9.7.5](https://github.com/g-truc/glm/releases/tag/0.9.7.5) - 2016-05-24 #### Improvements: - Added Visual C++ Clang toolset detection #### Fixes: - Fixed uaddCarry warning #497 - Fixed roundPowerOfTwo and floorPowerOfTwo #503 - Fixed Visual C++ SIMD instruction set automatic detection in 64 bits - Fixed to_string when used with GLM_FORCE_INLINE #506 - Fixed GLM_FORCE_INLINE with binary vec4 operators - Fixed GTX_extended_min_max filename typo #386 - Fixed intersectRayTriangle to not do any unintentional backface culling --- ### [GLM 0.9.7.4](https://github.com/g-truc/glm/releases/tag/0.9.7.4) - 2016-03-19 #### Fixes: - Fixed asinh and atanh warning with C++98 STL #484 - Fixed polar coordinates function latitude #485 - Fixed outerProduct defintions and operator signatures for mat2x4 and vec4 #475 - Fixed eulerAngles precision error, returns NaN #451 - Fixed undefined reference errors #489 - Fixed missing GLM_PLATFORM_CYGWIN declaration #495 - Fixed various undefined reference errors #490 --- ### [GLM 0.9.7.3](https://github.com/g-truc/glm/releases/tag/0.9.7.3) - 2016-02-21 #### Improvements: - Added AVX512 detection #### Fixes: - Fixed CMake policy warning - Fixed GCC 6.0 detection #477 - Fixed Clang build on Windows #479 - Fixed 64 bits constants warnings on GCC #463 --- ### [GLM 0.9.7.2](https://github.com/g-truc/glm/releases/tag/0.9.7.2) - 2016-01-03 #### Fixes: - Fixed GTC_round floorMultiple/ceilMultiple #412 - Fixed GTC_packing unpackUnorm3x10_1x2 #414 - Fixed GTC_matrix_inverse affineInverse #192 - Fixed ICC on Linux build errors #449 - Fixed ldexp and frexp compilation errors - Fixed "Declaration shadows a field" warning #468 - Fixed 'GLM_COMPILER_VC2005 is not defined' warning #468 - Fixed various 'X is not defined' warnings #468 - Fixed missing unary + operator #435 - Fixed Cygwin build errors when using C++11 #405 --- ### [GLM 0.9.7.1](https://github.com/g-truc/glm/releases/tag/0.9.7.1) - 2015-09-07 #### Improvements: - Improved constexpr for constant functions coverage #198 - Added to_string for quat and dual_quat in GTX_string_cast #375 - Improved overall execution time of unit tests #396 #### Fixes: - Fixed strict alignment warnings #235 #370 - Fixed link errors on compilers not supported default function #377 - Fixed compilation warnings in vec4 - Fixed non-identity quaternions for equal vectors #234 - Fixed excessive GTX_fast_trigonometry execution time #396 - Fixed Visual Studio 2015 'hides class member' warnings #394 - Fixed builtin bitscan never being used #392 - Removed unused func_noise.* files #398 --- ### [GLM 0.9.7.0](https://github.com/g-truc/glm/releases/tag/0.9.7.0) - 2015-08-02 #### Features: - Added GTC_color_space: convertLinearToSRGB and convertSRGBToLinear functions - Added 'fmod' overload to GTX_common with tests #308 - Left handed perspective and lookAt functions #314 - Added functions eulerAngleXYZ and extractEulerAngleXYZ #311 - Added to perform std::hash on GLM types #320 #367 - Added for texcoord wrapping - Added static components and precision members to all vector and quat types #350 - Added .gitignore #349 - Added support of defaulted functions to GLM types, to use them in unions #366 #### Improvements: - Changed usage of __has_include to support Intel compiler #307 - Specialized integer implementation of YCoCg-R #310 - Don't show status message in 'FindGLM' if 'QUIET' option is set. #317 - Added master branch continuous integration service on Linux 64 #332 - Clarified manual regarding angle unit in GLM, added FAQ 11 #326 - Updated list of compiler versions #### Fixes: - Fixed default precision for quat and dual_quat type #312 - Fixed (u)int64 MSB/LSB handling on BE archs #306 - Fixed multi-line comment warning in g++. #315 - Fixed specifier removal by 'std::make_pair<>' #333 - Fixed perspective fovy argument documentation #327 - Removed -m64 causing build issues on Linux 32 #331 - Fixed isfinite with C++98 compilers #343 - Fixed Intel compiler build error on Linux #354 - Fixed use of libstdc++ with Clang #351 - Fixed quaternion pow #346 - Fixed decompose warnings #373 - Fixed matrix conversions #371 #### Deprecation: - Removed integer specification for 'mod' in GTC_integer #308 - Removed GTX_multiple, replaced by GTC_round --- ### [GLM 0.9.6.3](https://github.com/g-truc/glm/releases/tag/0.9.6.3) - 2015-02-15 - Fixed Android doesn't have C++ 11 STL #284 --- ### [GLM 0.9.6.2](https://github.com/g-truc/glm/releases/tag/0.9.6.2) - 2015-02-15 #### Features: - Added display of GLM version with other GLM_MESSAGES - Added ARM instruction set detection #### Improvements: - Removed assert for perspective with zFar < zNear #298 - Added Visual Studio natvis support for vec1, quat and dualqual types - Cleaned up C++11 feature detections - Clarify GLM licensing #### Fixes: - Fixed faceforward build #289 - Fixed conflict with Xlib #define True 1 #293 - Fixed decompose function VS2010 templating issues #294 - Fixed mat4x3 = mat2x3 * mat4x2 operator #297 - Fixed warnings in F2x11_1x10 packing function in GTC_packing #295 - Fixed Visual Studio natvis support for vec4 #288 - Fixed GTC_packing *pack*norm*x* build and added tests #292 - Disabled GTX_scalar_multiplication for GCC, failing to build tests #242 - Fixed Visual C++ 2015 constexpr errors: Disabled only partial support - Fixed functions not inlined with Clang #302 - Fixed memory corruption (undefined behaviour) #303 --- ### [GLM 0.9.6.1](https://github.com/g-truc/glm/releases/tag/0.9.6.1) - 2014-12-10 #### Features: - Added GLM_LANG_CXX14_FLAG and GLM_LANG_CXX1Z_FLAG language feature flags - Added C++14 detection #### Improvements: - Clean up GLM_MESSAGES compilation log to report only detected capabilities #### Fixes: - Fixed scalar uaddCarry build error with Cuda #276 - Fixed C++11 explicit conversion operators detection #282 - Fixed missing explicit conversion when using integer log2 with *vec1 types - Fixed 64 bits integer GTX_string_cast to_string on VC 32 bit compiler - Fixed Android build issue, STL C++11 is not supported by the NDK #284 - Fixed unsupported _BitScanForward64 and _BitScanReverse64 in VC10 - Fixed Visual C++ 32 bit build #283 - Fixed GLM_FORCE_SIZE_FUNC pragma message - Fixed C++98 only build - Fixed conflict between GTX_compatibility and GTC_quaternion #286 - Fixed C++ language restriction using GLM_FORCE_CXX** --- ### [GLM 0.9.6.0](https://github.com/g-truc/glm/releases/tag/0.9.6.0) - 2014-11-30 #### Features: - Exposed template vector and matrix types in 'glm' namespace #239, #244 - Added GTX_scalar_multiplication for C++ 11 compiler only #242 - Added GTX_range for C++ 11 compiler only #240 - Added closestPointOnLine function for tvec2 to GTX_closest_point #238 - Added GTC_vec1 extension, *vec1 support to *vec* types - Updated GTX_associated_min_max with vec1 support - Added support of precision and integers to linearRand #230 - Added Integer types support to GTX_string_cast #249 - Added vec3 slerp #237 - Added GTX_common with isdenomal #223 - Added GLM_FORCE_SIZE_FUNC to replace .length() by .size() #245 - Added GLM_FORCE_NO_CTOR_INIT - Added 'uninitialize' to explicitly not initialize a GLM type - Added GTC_bitfield extension, promoted GTX_bit - Added GTC_integer extension, promoted GTX_bit and GTX_integer - Added GTC_round extension, promoted GTX_bit - Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269 - Added GTX_type_aligned for aligned vector, matrix and quaternion types #### Improvements: - Rely on C++11 to implement isinf and isnan - Removed GLM_FORCE_CUDA, Cuda is implicitly detected - Separated Apple Clang and LLVM compiler detection - Used pragma once - Undetected C++ compiler automatically compile with GLM_FORCE_CXX98 and GLM_FORCE_PURE - Added not function (from GLSL specification) on VC12 - Optimized bitfieldReverse and bitCount functions - Optimized findLSB and findMSB functions. - Optimized matrix-vector multiple performance with Cuda #257, #258 - Reduced integer type redifinitions #233 - Rewrited of GTX_fast_trigonometry #264 #265 - Made types trivially copyable #263 - Removed in GLM tests - Used std features within GLM without redeclaring - Optimized cot function #272 - Optimized sign function #272 - Added explicit cast from quat to mat3 and mat4 #275 #### Fixes: - Fixed std::nextafter not supported with C++11 on Android #217 - Fixed missing value_type for dual quaternion - Fixed return type of dual quaternion length - Fixed infinite loop in isfinite function with GCC #221 - Fixed Visual Studio 14 compiler warnings - Fixed implicit conversion from another tvec2 type to another tvec2 #241 - Fixed lack of consistency of quat and dualquat constructors - Fixed uaddCarray #253 - Fixed float comparison warnings #270 #### Deprecation: - Requires Visual Studio 2010, GCC 4.2, Apple Clang 4.0, LLVM 3.0, Cuda 4, ICC 2013 or a C++98 compiler - Removed degrees for function parameters - Removed GLM_FORCE_RADIANS, active by default - Removed VC 2005 / 8 and 2008 / 9 support - Removed GCC 3.4 to 4.3 support - Removed LLVM GCC support - Removed LLVM 2.6 to 3.1 support - Removed CUDA 3.0 to 3.2 support --- ### [GLM 0.9.5.4 - 2014-06-21](https://github.com/g-truc/glm/releases/tag/0.9.5.4) - Fixed non-utf8 character #196 - Added FindGLM install for CMake #189 - Fixed GTX_color_space - saturation #195 - Fixed glm::isinf and glm::isnan for with Android NDK 9d #191 - Fixed builtin GLM_ARCH_SSE4 #204 - Optimized Quaternion vector rotation #205 - Fixed missing doxygen @endcond tag #211 - Fixed instruction set detection with Clang #158 - Fixed orientate3 function #207 - Fixed lerp when cosTheta is close to 1 in quaternion slerp #210 - Added GTX_io for io with #144 - Fixed fastDistance ambiguity #215 - Fixed tweakedInfinitePerspective #208 and added user-defined epsilon to tweakedInfinitePerspective - Fixed std::copy and std::vector with GLM types #214 - Fixed strict aliasing issues #212, #152 - Fixed std::nextafter not supported with C++11 on Android #213 - Fixed corner cases in exp and log functions for quaternions #199 --- ### GLM 0.9.5.3 - 2014-04-02 - Added instruction set auto detection with Visual C++ using _M_IX86_FP - /arch compiler argument - Fixed GTX_raw_data code dependency - Fixed GCC instruction set detection - Added GLM_GTX_matrix_transform_2d extension (#178, #176) - Fixed CUDA issues (#169, #168, #183, #182) - Added support for all extensions but GTX_string_cast to CUDA - Fixed strict aliasing warnings in GCC 4.8.1 / Android NDK 9c (#152) - Fixed missing bitfieldInterleave definisions - Fixed usubBorrow (#171) - Fixed eulerAngle*** not consistent for right-handed coordinate system (#173) - Added full tests for eulerAngle*** functions (#173) - Added workaround for a CUDA compiler bug (#186, #185) --- ### GLM 0.9.5.2 - 2014-02-08 - Fixed initializer list ambiguity (#159, #160) - Fixed warnings with the Android NDK 9c - Fixed non power of two matrix products - Fixed mix function link error - Fixed SSE code included in GLM tests on "pure" platforms - Fixed undefined reference to fastInverseSqrt (#161) - Fixed GLM_FORCE_RADIANS with build error (#165) - Fix dot product clamp range for vector angle functions. (#163) - Tentative fix for strict aliasing warning in GCC 4.8.1 / Android NDK 9c (#152) - Fixed GLM_GTC_constants description brief (#162) --- ### GLM 0.9.5.1 - 2014-01-11 - Fixed angle and orientedAngle that sometimes return NaN values (#145) - Deprecated degrees for function parameters and display a message - Added possible static_cast conversion of GLM types (#72) - Fixed error 'inverse' is not a member of 'glm' from glm::unProject (#146) - Fixed mismatch between some declarations and definitions - Fixed inverse link error when using namespace glm; (#147) - Optimized matrix inverse and division code (#149) - Added intersectRayPlane function (#153) - Fixed outerProduct return type (#155) --- ### GLM 0.9.5.0 - 2013-12-25 - Added forward declarations (glm/fwd.hpp) for faster compilations - Added per feature headers - Minimized GLM internal dependencies - Improved Intel Compiler detection - Added bitfieldInterleave and _mm_bit_interleave_si128 functions - Added GTX_scalar_relational - Added GTX_dual_quaternion - Added rotation function to GTX_quaternion (#22) - Added precision variation of each type - Added quaternion comparison functions - Fixed GTX_multiple for negative value - Removed GTX_ocl_type extension - Fixed post increment and decrement operators - Fixed perspective with zNear == 0 (#71) - Removed l-value swizzle operators - Cleaned up compiler detection code for unsupported compilers - Replaced C cast by C++ casts - Fixed .length() that should return a int and not a size_t - Added GLM_FORCE_SIZE_T_LENGTH and glm::length_t - Removed unnecessary conversions - Optimized packing and unpacking functions - Removed the normalization of the up argument of lookAt function (#114) - Added low precision specializations of inversesqrt - Fixed ldexp and frexp implementations - Increased assert coverage - Increased static_assert coverage - Replaced GLM traits by STL traits when possible - Allowed including individual core feature - Increased unit tests completness - Added creating of a quaternion from two vectors - Added C++11 initializer lists - Fixed umulExtended and imulExtended implementations for vector types (#76) - Fixed CUDA coverage for GTC extensions - Added GTX_io extension - Improved GLM messages enabled when defining GLM_MESSAGES - Hidden matrix _inverse function implementation detail into private section --- ### [GLM 0.9.4.6](https://github.com/g-truc/glm/releases/tag/0.9.4.6) - 2013-09-20 - Fixed detection to select the last known compiler if newer version #106 - Fixed is_int and is_uint code duplication with GCC and C++11 #107 - Fixed test suite build while using Clang in C++11 mode - Added c++1y mode support in CMake test suite - Removed ms extension mode to CMake when no using Visual C++ - Added pedantic mode to CMake test suite for Clang and GCC - Added use of GCC frontend on Unix for ICC and Visual C++ fronted on Windows for ICC - Added compilation errors for unsupported compiler versions - Fixed glm::orientation with GLM_FORCE_RADIANS defined #112 - Fixed const ref issue on assignment operator taking a scalar parameter #116 - Fixed glm::eulerAngleY implementation #117 --- ### GLM 0.9.4.5 - 2013-08-12 - Fixed CUDA support - Fixed inclusion of intrinsics in "pure" mode #92 - Fixed language detection on GCC when the C++0x mode isn't enabled #95 - Fixed issue #97: register is deprecated in C++11 - Fixed issue #96: CUDA issues - Added Windows CE detection #92 - Added missing value_ptr for quaternions #99 --- ### GLM 0.9.4.4 - 2013-05-29 - Fixed slerp when costheta is close to 1 #65 - Fixed mat4x2 value_type constructor #70 - Fixed glm.natvis for Visual C++ 12 #82 - Added assert in inversesqrt to detect division by zero #61 - Fixed missing swizzle operators #86 - Fixed CUDA warnings #86 - Fixed GLM natvis for VC11 #82 - Fixed GLM_GTX_multiple with negative values #79 - Fixed glm::perspective when zNear is zero #71 --- ### GLM 0.9.4.3 - 2013-03-20 - Detected qualifier for Clang - Fixed C++11 mode for GCC, couldn't be enabled without MS extensions - Fixed squad, intermediate and exp quaternion functions - Fixed GTX_polar_coordinates euclidean function, takes a vec2 instead of a vec3 - Clarify the license applying on the manual - Added a docx copy of the manual - Fixed GLM_GTX_matrix_interpolation - Fixed isnan and isinf on Android with Clang - Autodetected C++ version using __cplusplus value - Fixed mix for bool and bvec* third parameter --- ### GLM 0.9.4.2 - 2013-02-14 - Fixed compAdd from GTX_component_wise - Fixed SIMD support for Intel compiler on Windows - Fixed isnan and isinf for CUDA compiler - Fixed GLM_FORCE_RADIANS on glm::perspective - Fixed GCC warnings - Fixed packDouble2x32 on Xcode - Fixed mix for vec4 SSE implementation - Fixed 0x2013 dash character in comments that cause issue in Windows Japanese mode - Fixed documentation warnings - Fixed CUDA warnings --- ### GLM 0.9.4.1 - 2012-12-22 - Improved half support: -0.0 case and implicit conversions - Fixed Intel Composer Compiler support on Linux - Fixed interaction between quaternion and euler angles - Fixed GTC_constants build - Fixed GTX_multiple - Fixed quat slerp using mix function when cosTheta close to 1 - Improved fvec4SIMD and fmat4x4SIMD implementations - Fixed assert messages - Added slerp and lerp quaternion functions and tests --- ### GLM 0.9.4.0 - 2012-11-18 - Added Intel Composer Compiler support - Promoted GTC_espilon extension - Promoted GTC_ulp extension - Removed GLM website from the source repository - Added GLM_FORCE_RADIANS so that all functions takes radians for arguments - Fixed detection of Clang and LLVM GCC on MacOS X - Added debugger visualizers for Visual C++ 2012 - Requires Visual Studio 2005, GCC 4.2, Clang 2.6, Cuda 3, ICC 2013 or a C++98 compiler --- ### [GLM 0.9.3.4](https://github.com/g-truc/glm/releases/tag/0.9.3.4) - 2012-06-30 - Added SSE4 and AVX2 detection. - Removed VIRTREV_xstream and the incompatibility generated with GCC - Fixed C++11 compiler option for GCC - Removed MS language extension option for GCC (not fonctionnal) - Fixed bitfieldExtract for vector types - Fixed warnings - Fixed SSE includes --- ### GLM 0.9.3.3 - 2012-05-10 - Fixed isinf and isnan - Improved compatibility with Intel compiler - Added CMake test build options: SIMD, C++11, fast math and MS land ext - Fixed SIMD mat4 test on GCC - Fixed perspectiveFov implementation - Fixed matrixCompMult for none-square matrices - Fixed namespace issue on stream operators - Fixed various warnings - Added VC11 support --- ### GLM 0.9.3.2 - 2012-03-15 - Fixed doxygen documentation - Fixed Clang version detection - Fixed simd mat4 /= operator --- ### GLM 0.9.3.1 - 2012-01-25 - Fixed platform detection - Fixed warnings - Removed detail code from Doxygen doc --- ### GLM 0.9.3.0 - 2012-01-09 - Added CPP Check project - Fixed conflict with Windows headers - Fixed isinf implementation - Fixed Boost conflict - Fixed warnings --- ### GLM 0.9.3.B - 2011-12-12 - Added support for Chrone Native Client - Added epsilon constant - Removed value_size function from vector types - Fixed roundEven on GCC - Improved API documentation - Fixed modf implementation - Fixed step function accuracy - Fixed outerProduct --- ### GLM 0.9.3.A - 2011-11-11 - Improved doxygen documentation - Added new swizzle operators for C++11 compilers - Added new swizzle operators declared as functions - Added GLSL 4.20 length for vector and matrix types - Promoted GLM_GTC_noise extension: simplex, perlin, periodic noise functions - Promoted GLM_GTC_random extension: linear, gaussian and various random number generation distribution - Added GLM_GTX_constants: provides useful constants - Added extension versioning - Removed many unused namespaces - Fixed half based type contructors - Added GLSL core noise functions --- ### [GLM 0.9.2.7](https://github.com/g-truc/glm/releases/tag/0.9.2.7) - 2011-10-24 - Added more swizzling constructors - Added missing none-squared matrix products --- ### [GLM 0.9.2.6](https://github.com/g-truc/glm/releases/tag/0.9.2.6) - 2011-10-01 - Fixed half based type build on old GCC - Fixed /W4 warnings on Visual C++ - Fixed some missing l-value swizzle operators --- ### GLM 0.9.2.5 - 2011-09-20 - Fixed floatBitToXint functions - Fixed pack and unpack functions - Fixed round functions --- ### GLM 0.9.2.4 - 2011-09-03 - Fixed extensions bugs --- ### GLM 0.9.2.3 - 2011-06-08 - Fixed build issues --- ### GLM 0.9.2.2 - 2011-06-02 - Expend matrix constructors flexibility - Improved quaternion implementation - Fixed many warnings across platforms and compilers --- ### GLM 0.9.2.1 - 2011-05-24 - Automatically detect CUDA support - Improved compiler detection - Fixed errors and warnings in VC with C++ extensions disabled - Fixed and tested GLM_GTX_vector_angle - Fixed and tested GLM_GTX_rotate_vector --- ### GLM 0.9.2.0 - 2011-05-09 - Added CUDA support - Added CTest test suite - Added GLM_GTX_ulp extension - Added GLM_GTX_noise extension - Added GLM_GTX_matrix_interpolation extension - Updated quaternion slerp interpolation --- ### [GLM 0.9.1.3](https://github.com/g-truc/glm/releases/tag/0.9.1.3) - 2011-05-07 - Fixed bugs --- ### GLM 0.9.1.2 - 2011-04-15 - Fixed bugs --- ### GLM 0.9.1.1 - 2011-03-17 - Fixed bugs --- ### GLM 0.9.1.0 - 2011-03-03 - Fixed bugs --- ### GLM 0.9.1.B - 2011-02-13 - Updated API documentation - Improved SIMD implementation - Fixed Linux build --- ### [GLM 0.9.0.8](https://github.com/g-truc/glm/releases/tag/0.9.0.8) - 2011-02-13 - Added quaternion product operator. - Clarify that GLM is a header only library. --- ### GLM 0.9.1.A - 2011-01-31 - Added SIMD support - Added new swizzle functions - Improved static assert error message with C++0x static_assert - New setup system - Reduced branching - Fixed trunc implementation --- ### [GLM 0.9.0.7](https://github.com/g-truc/glm/releases/tag/0.9.0.7) - 2011-01-30 - Added GLSL 4.10 packing functions - Added == and != operators for every types. --- ### GLM 0.9.0.6 - 2010-12-21 - Many matrices bugs fixed --- ### GLM 0.9.0.5 - 2010-11-01 - Improved Clang support - Fixed bugs --- ### GLM 0.9.0.4 - 2010-10-04 - Added autoexp for GLM - Fixed bugs --- ### GLM 0.9.0.3 - 2010-08-26 - Fixed non-squared matrix operators --- ### GLM 0.9.0.2 - 2010-07-08 - Added GLM_GTX_int_10_10_10_2 - Fixed bugs --- ### GLM 0.9.0.1 - 2010-06-21 - Fixed extensions errors --- ### GLM 0.9.0.0 - 2010-05-25 - Objective-C support - Fixed warnings - Updated documentation --- ### GLM 0.9.B.2 - 2010-04-30 - Git transition - Removed experimental code from releases - Fixed bugs --- ### GLM 0.9.B.1 - 2010-04-03 - Based on GLSL 4.00 specification - Added the new core functions - Added some implicit conversion support --- ### GLM 0.9.A.2 - 2010-02-20 - Improved some possible errors messages - Improved declarations and definitions match --- ### GLM 0.9.A.1 - 2010-02-09 - Removed deprecated features - Internal redesign --- ### GLM 0.8.4.4 final - 2010-01-25 - Fixed warnings --- ### GLM 0.8.4.3 final - 2009-11-16 - Fixed Half float arithmetic - Fixed setup defines --- ### GLM 0.8.4.2 final - 2009-10-19 - Fixed Half float adds --- ### GLM 0.8.4.1 final - 2009-10-05 - Updated documentation - Fixed MacOS X build --- ### GLM 0.8.4.0 final - 2009-09-16 - Added GCC 4.4 and VC2010 support - Added matrix optimizations --- ### GLM 0.8.3.5 final - 2009-08-11 - Fixed bugs --- ### GLM 0.8.3.4 final - 2009-08-10 - Updated GLM according GLSL 1.5 spec - Fixed bugs --- ### GLM 0.8.3.3 final - 2009-06-25 - Fixed bugs --- ### GLM 0.8.3.2 final - 2009-06-04 - Added GLM_GTC_quaternion - Added GLM_GTC_type_precision --- ### GLM 0.8.3.1 final - 2009-05-21 - Fixed old extension system. --- ### GLM 0.8.3.0 final - 2009-05-06 - Added stable extensions. - Added new extension system. --- ### GLM 0.8.2.3 final - 2009-04-01 - Fixed bugs. --- ### GLM 0.8.2.2 final - 2009-02-24 - Fixed bugs. --- ### GLM 0.8.2.1 final - 2009-02-13 - Fixed bugs. --- ### GLM 0.8.2 final - 2009-01-21 - Fixed bugs. --- ### GLM 0.8.1 final - 2008-10-30 - Fixed bugs. --- ### GLM 0.8.0 final - 2008-10-23 - New method to use extension. --- ### GLM 0.8.0 beta3 - 2008-10-10 - Added CMake support for GLM tests. --- ### GLM 0.8.0 beta2 - 2008-10-04 - Improved half scalars and vectors support. --- ### GLM 0.8.0 beta1 - 2008-09-26 - Improved GLSL conformance - Added GLSL 1.30 support - Improved API documentation --- ### GLM 0.7.6 final - 2008-08-08 - Improved C++ standard comformance - Added Static assert for types checking --- ### GLM 0.7.5 final - 2008-07-05 - Added build message system with Visual Studio - Pedantic build with GCC --- ### GLM 0.7.4 final - 2008-06-01 - Added external dependencies system. --- ### GLM 0.7.3 final - 2008-05-24 - Fixed bugs - Added new extension group --- ### GLM 0.7.2 final - 2008-04-27 - Updated documentation - Added preprocessor options --- ### GLM 0.7.1 final - 2008-03-24 - Disabled half on GCC - Fixed extensions --- ### GLM 0.7.0 final - 2008-03-22 - Changed to MIT license - Added new documentation --- ### GLM 0.6.4 - 2007-12-10 - Fixed swizzle operators --- ### GLM 0.6.3 - 2007-11-05 - Fixed type data accesses - Fixed 3DSMax sdk conflict --- ### GLM 0.6.2 - 2007-10-08 - Fixed extension --- ### GLM 0.6.1 - 2007-10-07 - Fixed a namespace error - Added extensions --- ### GLM 0.6.0 : 2007-09-16 - Added new extension namespace mecanium - Added Automatic compiler detection --- ### GLM 0.5.1 - 2007-02-19 - Fixed swizzle operators --- ### GLM 0.5.0 - 2007-01-06 - Upgrated to GLSL 1.2 - Added swizzle operators - Added setup settings --- ### GLM 0.4.1 - 2006-05-22 - Added OpenGL examples --- ### GLM 0.4.0 - 2006-05-17 - Added missing operators to vec* and mat* - Added first GLSL 1.2 features - Fixed windows.h before glm.h when windows.h required --- ### GLM 0.3.2 - 2006-04-21 - Fixed texcoord components access. - Fixed mat4 and imat4 division operators. --- ### GLM 0.3.1 - 2006-03-28 - Added GCC 4.0 support under MacOS X. - Added GCC 4.0 and 4.1 support under Linux. - Added code optimisations. --- ### GLM 0.3 - 2006-02-19 - Improved GLSL type conversion and construction compliance. - Added experimental extensions. - Added Doxygen Documentation. - Added code optimisations. - Fixed bugs. --- ### GLM 0.2 - 2005-05-05 - Improve adaptative from GLSL. - Add experimental extensions based on OpenGL extension process. - Fixe bugs. --- ### GLM 0.1 - 2005-02-21 - Add vec2, vec3, vec4 GLSL types - Add ivec2, ivec3, ivec4 GLSL types - Add bvec2, bvec3, bvec4 GLSL types - Add mat2, mat3, mat4 GLSL types - Add almost all functions glm-0.9.9-a2/test/0000700000175000001440000000000013173131001012445 5ustar guususersglm-0.9.9-a2/test/gtx/0000700000175000001440000000000013173131001013247 5ustar guususersglm-0.9.9-a2/test/gtx/gtx_type_aligned.cpp0000600000175000001440000000425713173131001017313 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include int test_decl() { int Error(0); { struct S1 { glm::aligned_vec4 B; }; struct S2 { glm::vec4 B; }; printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast(sizeof(S1)), static_cast(sizeof(S2))); Error += sizeof(S1) >= sizeof(S2) ? 0 : 1; } { struct S1 { bool A; glm::vec3 B; }; struct S2 { bool A; glm::aligned_vec3 B; }; printf("vec3 - Aligned: %d, unaligned: %d\n", static_cast(sizeof(S1)), static_cast(sizeof(S2))); Error += sizeof(S1) <= sizeof(S2) ? 0 : 1; } { struct S1 { bool A; glm::aligned_vec4 B; }; struct S2 { bool A; glm::vec4 B; }; printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast(sizeof(S1)), static_cast(sizeof(S2))); Error += sizeof(S1) >= sizeof(S2) ? 0 : 1; } { struct S1 { bool A; glm::aligned_dvec4 B; }; struct S2 { bool A; glm::dvec4 B; }; printf("dvec4 - Aligned: %d, unaligned: %d\n", static_cast(sizeof(S1)), static_cast(sizeof(S2))); Error += sizeof(S1) >= sizeof(S2) ? 0 : 1; } return Error; } template void print(genType const& Mat0) { printf("mat4(\n"); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast(Mat0[0][0]), static_cast(Mat0[0][1]), static_cast(Mat0[0][2]), static_cast(Mat0[0][3])); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast(Mat0[1][0]), static_cast(Mat0[1][1]), static_cast(Mat0[1][2]), static_cast(Mat0[1][3])); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast(Mat0[2][0]), static_cast(Mat0[2][1]), static_cast(Mat0[2][2]), static_cast(Mat0[2][3])); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", static_cast(Mat0[3][0]), static_cast(Mat0[3][1]), static_cast(Mat0[3][2]), static_cast(Mat0[3][3])); } int perf_mul() { int Error = 0; glm::mat4 A(1.0f); glm::mat4 B(1.0f); glm::mat4 C = A * B; print(C); return Error; } int main() { int Error(0); Error += test_decl(); Error += perf_mul(); return Error; } glm-0.9.9-a2/test/gtx/gtx_polar_coordinates.cpp0000600000175000001440000000017013173131001020344 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_euler_angle.cpp0000600000175000001440000002716113173131001017130 0ustar guususers// Code sample from Filippo Ramaciotti #define GLM_ENABLE_EXPERIMENTAL #include #include #include #include #include namespace test_eulerAngleX { int test() { int Error = 0; float const Angle(glm::pi() * 0.5f); glm::vec3 const X(1.0f, 0.0f, 0.0f); glm::vec4 const Y(0.0f, 1.0f, 0.0f, 1.0f); glm::vec4 const Y1 = glm::rotate(glm::mat4(1.0f), Angle, X) * Y; glm::vec4 const Y2 = glm::eulerAngleX(Angle) * Y; glm::vec4 const Y3 = glm::eulerAngleXY(Angle, 0.0f) * Y; glm::vec4 const Y4 = glm::eulerAngleYX(0.0f, Angle) * Y; glm::vec4 const Y5 = glm::eulerAngleXZ(Angle, 0.0f) * Y; glm::vec4 const Y6 = glm::eulerAngleZX(0.0f, Angle) * Y; glm::vec4 const Y7 = glm::eulerAngleYXZ(0.0f, Angle, 0.0f) * Y; Error += glm::all(glm::epsilonEqual(Y1, Y2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Y1, Y3, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Y1, Y4, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Y1, Y5, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Y1, Y6, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Y1, Y7, 0.00001f)) ? 0 : 1; glm::vec4 const Z(0.0f, 0.0f, 1.0f, 1.0f); glm::vec4 const Z1 = glm::rotate(glm::mat4(1.0f), Angle, X) * Z; glm::vec4 const Z2 = glm::eulerAngleX(Angle) * Z; glm::vec4 const Z3 = glm::eulerAngleXY(Angle, 0.0f) * Z; glm::vec4 const Z4 = glm::eulerAngleYX(0.0f, Angle) * Z; glm::vec4 const Z5 = glm::eulerAngleXZ(Angle, 0.0f) * Z; glm::vec4 const Z6 = glm::eulerAngleZX(0.0f, Angle) * Z; glm::vec4 const Z7 = glm::eulerAngleYXZ(0.0f, Angle, 0.0f) * Z; Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleX namespace test_eulerAngleY { int test() { int Error = 0; float const Angle(glm::pi() * 0.5f); glm::vec3 const Y(0.0f, 1.0f, 0.0f); glm::vec4 const X(1.0f, 0.0f, 0.0f, 1.0f); glm::vec4 const X1 = glm::rotate(glm::mat4(1.0f), Angle, Y) * X; glm::vec4 const X2 = glm::eulerAngleY(Angle) * X; glm::vec4 const X3 = glm::eulerAngleYX(Angle, 0.0f) * X; glm::vec4 const X4 = glm::eulerAngleXY(0.0f, Angle) * X; glm::vec4 const X5 = glm::eulerAngleYZ(Angle, 0.0f) * X; glm::vec4 const X6 = glm::eulerAngleZY(0.0f, Angle) * X; glm::vec4 const X7 = glm::eulerAngleYXZ(Angle, 0.0f, 0.0f) * X; Error += glm::all(glm::epsilonEqual(X1, X2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X3, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X4, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X5, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X6, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X7, 0.00001f)) ? 0 : 1; glm::vec4 const Z(0.0f, 0.0f, 1.0f, 1.0f); glm::vec4 const Z1 = glm::eulerAngleY(Angle) * Z; glm::vec4 const Z2 = glm::rotate(glm::mat4(1.0f), Angle, Y) * Z; glm::vec4 const Z3 = glm::eulerAngleYX(Angle, 0.0f) * Z; glm::vec4 const Z4 = glm::eulerAngleXY(0.0f, Angle) * Z; glm::vec4 const Z5 = glm::eulerAngleYZ(Angle, 0.0f) * Z; glm::vec4 const Z6 = glm::eulerAngleZY(0.0f, Angle) * Z; glm::vec4 const Z7 = glm::eulerAngleYXZ(Angle, 0.0f, 0.0f) * Z; Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleY namespace test_eulerAngleZ { int test() { int Error = 0; float const Angle(glm::pi() * 0.5f); glm::vec3 const Z(0.0f, 0.0f, 1.0f); glm::vec4 const X(1.0f, 0.0f, 0.0f, 1.0f); glm::vec4 const X1 = glm::rotate(glm::mat4(1.0f), Angle, Z) * X; glm::vec4 const X2 = glm::eulerAngleZ(Angle) * X; glm::vec4 const X3 = glm::eulerAngleZX(Angle, 0.0f) * X; glm::vec4 const X4 = glm::eulerAngleXZ(0.0f, Angle) * X; glm::vec4 const X5 = glm::eulerAngleZY(Angle, 0.0f) * X; glm::vec4 const X6 = glm::eulerAngleYZ(0.0f, Angle) * X; glm::vec4 const X7 = glm::eulerAngleYXZ(0.0f, 0.0f, Angle) * X; Error += glm::all(glm::epsilonEqual(X1, X2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X3, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X4, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X5, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X6, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(X1, X7, 0.00001f)) ? 0 : 1; glm::vec4 const Y(1.0f, 0.0f, 0.0f, 1.0f); glm::vec4 const Z1 = glm::rotate(glm::mat4(1.0f), Angle, Z) * Y; glm::vec4 const Z2 = glm::eulerAngleZ(Angle) * Y; glm::vec4 const Z3 = glm::eulerAngleZX(Angle, 0.0f) * Y; glm::vec4 const Z4 = glm::eulerAngleXZ(0.0f, Angle) * Y; glm::vec4 const Z5 = glm::eulerAngleZY(Angle, 0.0f) * Y; glm::vec4 const Z6 = glm::eulerAngleYZ(0.0f, Angle) * Y; glm::vec4 const Z7 = glm::eulerAngleYXZ(0.0f, 0.0f, Angle) * Y; Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleZ namespace test_eulerAngleXY { int test() { int Error = 0; glm::vec4 const V(1.0f); float const AngleX(glm::pi() * 0.5f); float const AngleY(glm::pi() * 0.25f); glm::vec3 const axisX(1.0f, 0.0f, 0.0f); glm::vec3 const axisY(0.0f, 1.0f, 0.0f); glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleX, axisX) * glm::rotate(glm::mat4(1.0f), AngleY, axisY)) * V; glm::vec4 const V2 = glm::eulerAngleXY(AngleX, AngleY) * V; glm::vec4 const V3 = glm::eulerAngleX(AngleX) * glm::eulerAngleY(AngleY) * V; Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleXY namespace test_eulerAngleYX { int test() { int Error = 0; glm::vec4 const V(1.0f); float const AngleX(glm::pi() * 0.5f); float const AngleY(glm::pi() * 0.25f); glm::vec3 const axisX(1.0f, 0.0f, 0.0f); glm::vec3 const axisY(0.0f, 1.0f, 0.0f); glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleY, axisY) * glm::rotate(glm::mat4(1.0f), AngleX, axisX)) * V; glm::vec4 const V2 = glm::eulerAngleYX(AngleY, AngleX) * V; glm::vec4 const V3 = glm::eulerAngleY(AngleY) * glm::eulerAngleX(AngleX) * V; Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleYX namespace test_eulerAngleXZ { int test() { int Error = 0; glm::vec4 const V(1.0f); float const AngleX(glm::pi() * 0.5f); float const AngleZ(glm::pi() * 0.25f); glm::vec3 const axisX(1.0f, 0.0f, 0.0f); glm::vec3 const axisZ(0.0f, 0.0f, 1.0f); glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleX, axisX) * glm::rotate(glm::mat4(1.0f), AngleZ, axisZ)) * V; glm::vec4 const V2 = glm::eulerAngleXZ(AngleX, AngleZ) * V; glm::vec4 const V3 = glm::eulerAngleX(AngleX) * glm::eulerAngleZ(AngleZ) * V; Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleXZ namespace test_eulerAngleZX { int test() { int Error = 0; glm::vec4 const V(1.0f); float const AngleX(glm::pi() * 0.5f); float const AngleZ(glm::pi() * 0.25f); glm::vec3 const axisX(1.0f, 0.0f, 0.0f); glm::vec3 const axisZ(0.0f, 0.0f, 1.0f); glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleZ, axisZ) * glm::rotate(glm::mat4(1.0f), AngleX, axisX)) * V; glm::vec4 const V2 = glm::eulerAngleZX(AngleZ, AngleX) * V; glm::vec4 const V3 = glm::eulerAngleZ(AngleZ) * glm::eulerAngleX(AngleX) * V; Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleZX namespace test_eulerAngleYZ { int test() { int Error = 0; glm::vec4 const V(1.0f); float const AngleY(glm::pi() * 0.5f); float const AngleZ(glm::pi() * 0.25f); glm::vec3 const axisX(1.0f, 0.0f, 0.0f); glm::vec3 const axisY(0.0f, 1.0f, 0.0f); glm::vec3 const axisZ(0.0f, 0.0f, 1.0f); glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleY, axisY) * glm::rotate(glm::mat4(1.0f), AngleZ, axisZ)) * V; glm::vec4 const V2 = glm::eulerAngleYZ(AngleY, AngleZ) * V; glm::vec4 const V3 = glm::eulerAngleY(AngleY) * glm::eulerAngleZ(AngleZ) * V; Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleYZ namespace test_eulerAngleZY { int test() { int Error = 0; glm::vec4 const V(1.0f); float const AngleY(glm::pi() * 0.5f); float const AngleZ(glm::pi() * 0.25f); glm::vec3 const axisX(1.0f, 0.0f, 0.0f); glm::vec3 const axisY(0.0f, 1.0f, 0.0f); glm::vec3 const axisZ(0.0f, 0.0f, 1.0f); glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleZ, axisZ) * glm::rotate(glm::mat4(1.0f), AngleY, axisY)) * V; glm::vec4 const V2 = glm::eulerAngleZY(AngleZ, AngleY) * V; glm::vec4 const V3 = glm::eulerAngleZ(AngleZ) * glm::eulerAngleY(AngleY) * V; Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1; return Error; } }//namespace test_eulerAngleZY namespace test_eulerAngleYXZ { int test() { glm::f32 first = 1.046f; glm::f32 second = 0.52f; glm::f32 third = -0.785f; glm::fmat4 rotationEuler = glm::eulerAngleYXZ(first, second, third); glm::fmat4 rotationInvertedY = glm::eulerAngleY(-1.f*first) * glm::eulerAngleX(second) * glm::eulerAngleZ(third); glm::fmat4 rotationDumb = glm::fmat4(); rotationDumb = glm::rotate(rotationDumb, first, glm::fvec3(0,1,0)); rotationDumb = glm::rotate(rotationDumb, second, glm::fvec3(1,0,0)); rotationDumb = glm::rotate(rotationDumb, third, glm::fvec3(0,0,1)); std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler)).c_str()); std::printf("%s\n", glm::to_string(glm::fmat3(rotationDumb)).c_str()); std::printf("%s\n", glm::to_string(glm::fmat3(rotationInvertedY)).c_str()); std::printf("\nRESIDUAL\n"); std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler-(rotationDumb))).c_str()); std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler-(rotationInvertedY))).c_str()); return 0; } }//namespace eulerAngleYXZ int main() { int Error = 0; Error += test_eulerAngleX::test(); Error += test_eulerAngleY::test(); Error += test_eulerAngleZ::test(); Error += test_eulerAngleXY::test(); Error += test_eulerAngleYX::test(); Error += test_eulerAngleXZ::test(); Error += test_eulerAngleZX::test(); Error += test_eulerAngleYZ::test(); Error += test_eulerAngleZY::test(); Error += test_eulerAngleYXZ::test(); return Error; } glm-0.9.9-a2/test/gtx/gtx_color_encoding.cpp0000600000175000001440000000254613173131001017632 0ustar guususers#include #include #include #include namespace srgb { int test() { int Error(0); glm::vec3 const ColorSourceRGB(1.0, 0.5, 0.0); /* { glm::vec3 const ColorSRGB = glm::convertLinearSRGBToD65XYZ(ColorSourceRGB); glm::vec3 const ColorRGB = glm::convertD65XYZToLinearSRGB(ColorSRGB); Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1; } */ { glm::vec3 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGB, 2.8f); glm::vec3 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f); Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1; } glm::vec4 const ColorSourceRGBA(1.0, 0.5, 0.0, 1.0); { glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA); glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB); Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1; } { glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA, 2.8f); glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f); Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1; } return Error; } }//namespace srgb int main() { int Error(0); Error += srgb::test(); return Error; } glm-0.9.9-a2/test/gtx/gtx_extended_min_max.cpp0000600000175000001440000000470013173131001020150 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include // This file has divisions by zero to test isnan #if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(disable : 4723) #endif namespace fmin_ { static int test() { int Error = 0; float Zero_f = 0.0f; glm::vec1 A0 = glm::fmin(glm::vec1(1), glm::vec1(Zero_f / 0.0f)); Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon()) ? 0 : 1; glm::vec1 A1 = glm::fmin(glm::vec1(Zero_f / 0.0f), glm::vec1(1)); Error += glm::epsilonEqual(A1.x, 1.0f, glm::epsilon()) ? 0 : 1; glm::vec2 B0 = glm::fmin(glm::vec2(1), glm::vec2(1)); glm::vec2 B1 = glm::fmin(glm::vec2(1), 1.0f); bool B2 = glm::all(glm::equal(B0, B1)); Error += B2 ? 0 : 1; glm::vec3 C0 = glm::fmin(glm::vec3(1), glm::vec3(1)); glm::vec3 C1 = glm::fmin(glm::vec3(1), 1.0f); bool C2 = glm::all(glm::equal(C0, C1)); Error += C2 ? 0 : 1; glm::vec4 D0 = glm::fmin(glm::vec4(1), glm::vec4(1)); glm::vec4 D1 = glm::fmin(glm::vec4(1), 1.0f); bool D2 = glm::all(glm::equal(D0, D1)); Error += D2 ? 0 : 1; return Error; } }//namespace fmin_ namespace fmax_ { static int test() { int Error = 0; float Zero_f = 0.0f; glm::vec1 A0 = glm::fmax(glm::vec1(1), glm::vec1(Zero_f / 0.0f)); Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon()) ? 0 : 1; glm::vec1 A1 = glm::fmax(glm::vec1(Zero_f / 0.0f), glm::vec1(1)); Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon()) ? 0 : 1; glm::vec2 B0 = glm::fmax(glm::vec2(1), glm::vec2(1)); glm::vec2 B1 = glm::fmax(glm::vec2(1), 1.0f); bool B2 = glm::all(glm::equal(B0, B1)); Error += B2 ? 0 : 1; glm::vec3 C0 = glm::fmax(glm::vec3(1), glm::vec3(1)); glm::vec3 C1 = glm::fmax(glm::vec3(1), 1.0f); bool C2 = glm::all(glm::equal(C0, C1)); Error += C2 ? 0 : 1; glm::vec4 D0 = glm::fmax(glm::vec4(1), glm::vec4(1)); glm::vec4 D1 = glm::fmax(glm::vec4(1), 1.0f); bool D2 = glm::all(glm::equal(D0, D1)); Error += D2 ? 0 : 1; return Error; } }//namespace fmax_ namespace fclamp_ { static int test() { int Error = 0; float Zero_f = 0.0f; glm::vec1 A0 = glm::fclamp(glm::vec1(1), glm::vec1(Zero_f / 0.0f), glm::vec1(2.0f)); Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon()) ? 0 : 1; return Error; } }//namespace fclamp_ int main() { int Error = 0; Error += fmin_::test(); Error += fmax_::test(); Error += fclamp_::test(); return Error; } glm-0.9.9-a2/test/gtx/gtx.cpp0000600000175000001440000000010713173131001014555 0ustar guususers#include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/gtx/gtx_fast_exponential.cpp0000600000175000001440000000016713173131001020206 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_scalar_multiplication.cpp0000600000175000001440000000141113173131001021216 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #if GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC) #include int main() { int Error(0); glm::vec3 v(0.5, 3.1, -9.1); Error += glm::all(glm::equal(v, 1.0 * v)) ? 0 : 1; Error += glm::all(glm::equal(v, 1 * v)) ? 0 : 1; Error += glm::all(glm::equal(v, 1u * v)) ? 0 : 1; glm::mat3 m(1, 2, 3, 4, 5, 6, 7, 8, 9); glm::vec3 w = 0.5f * m * v; Error += glm::all(glm::equal((m*v)/2, w)) ? 0 : 1; Error += glm::all(glm::equal(m*(v/2), w)) ? 0 : 1; Error += glm::all(glm::equal((m/2)*v, w)) ? 0 : 1; Error += glm::all(glm::equal((0.5*m)*v, w)) ? 0 : 1; Error += glm::all(glm::equal(0.5*(m*v), w)) ? 0 : 1; return Error; } #else int main() { return 0; } #endif glm-0.9.9-a2/test/gtx/gtx_optimum_pow.cpp0000600000175000001440000000016213173131001017215 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_matrix_transform_2d.cpp0000600000175000001440000000017213173131001020623 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_matrix_query.cpp0000600000175000001440000000172013173131001017370 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int test_isNull() { int Error(0); bool TestA = glm::isNull(glm::mat4(0), 0.00001f); Error += TestA ? 0 : 1; return Error; } int test_isIdentity() { int Error(0); { bool TestA = glm::isIdentity(glm::mat2(1), 0.00001f); Error += TestA ? 0 : 1; } { bool TestA = glm::isIdentity(glm::mat3(1), 0.00001f); Error += TestA ? 0 : 1; } { bool TestA = glm::isIdentity(glm::mat4(1), 0.00001f); Error += TestA ? 0 : 1; } return Error; } int test_isNormalized() { int Error(0); bool TestA = glm::isNormalized(glm::mat4(1), 0.00001f); Error += TestA ? 0 : 1; return Error; } int test_isOrthogonal() { int Error(0); bool TestA = glm::isOrthogonal(glm::mat4(1), 0.00001f); Error += TestA ? 0 : 1; return Error; } int main() { int Error(0); Error += test_isNull(); Error += test_isIdentity(); Error += test_isNormalized(); Error += test_isOrthogonal(); return Error; } glm-0.9.9-a2/test/gtx/gtx_matrix_factorisation.cpp0000600000175000001440000000610113173131001021066 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include template int test_qr(glm::mat m) { int Error = 0; T const epsilon = static_cast(1e-10); glm::mat<(C < R ? C : R), R, T, Q> q(-999); glm::mat r(-999); glm::qr_decompose(m, q, r); //Test if q*r really equals the input matrix glm::mat tm = q*r; glm::mat err = tm - m; for (glm::length_t i = 0; i < C; i++) for (glm::length_t j = 0; j < R; j++) Error += glm::abs(err[i][j]) > epsilon ? 1 : 0; //Test if the columns of q are orthonormal for (glm::length_t i = 0; i < (C < R ? C : R); i++) { Error += (length(q[i]) - 1) > epsilon ? 1 : 0; for (glm::length_t j = 0; j epsilon ? 1 : 0; } //Test if the matrix r is upper triangular for (glm::length_t i = 0; i < C; i++) for (glm::length_t j = i + 1; j < (C < R ? C : R); j++) Error += glm::epsilonEqual(r[i][j], static_cast(0), glm::epsilon()) ? 0 : 1; return Error; } template int test_rq(glm::mat m) { int Error = 0; T const epsilon = static_cast(1e-10); glm::mat q(-999); glm::mat<(C < R ? C : R), R, T, Q> r(-999); glm::rq_decompose(m, r, q); //Test if q*r really equals the input matrix glm::mat tm = r*q; glm::mat err = tm - m; for (glm::length_t i = 0; i < C; i++) for (glm::length_t j = 0; j < R; j++) Error += glm::abs(err[i][j]) > epsilon ? 1 : 0; //Test if the rows of q are orthonormal glm::mat<(C < R ? C : R), C, T, Q> tq = transpose(q); for (glm::length_t i = 0; i < (C < R ? C : R); i++) { Error += (length(tq[i]) - 1) > epsilon ? 1 : 0; for (glm::length_t j = 0; j epsilon ? 1 : 0; } //Test if the matrix r is upper triangular for (glm::length_t i = 0; i < (C < R ? C : R); i++) for (glm::length_t j = R - (C < R ? C : R) + i + 1; j < R; j++) Error += glm::epsilonEqual(r[i][j], static_cast(0), glm::epsilon()) ? 0 : 1; return Error; } int main() { int Error = 0; //Test QR square Error += test_qr(glm::dmat3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0)) ? 1 : 0; //Test RQ square Error += test_rq(glm::dmat3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0)) ? 1 : 0; //Test QR triangular 1 Error += test_qr(glm::dmat3x4(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0; //Test QR triangular 2 Error += test_qr(glm::dmat4x3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0; //Test RQ triangular 1 : Fails at the triangular test Error += test_rq(glm::dmat3x4(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0; //Test QR triangular 2 Error += test_rq(glm::dmat4x3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0; return Error; } glm-0.9.9-a2/test/gtx/gtx_gradient_paint.cpp0000600000175000001440000000107313173131001017630 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int test_radialGradient() { int Error = 0; float Gradient = glm::radialGradient(glm::vec2(0), 1.0f, glm::vec2(1), glm::vec2(0.5)); Error += Gradient != 0.0f ? 0 : 1; return Error; } int test_linearGradient() { int Error = 0; float Gradient = glm::linearGradient(glm::vec2(0), glm::vec2(1), glm::vec2(0.5)); Error += Gradient != 0.0f ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_radialGradient(); Error += test_linearGradient(); return Error; } glm-0.9.9-a2/test/gtx/gtx_orthonormalize.cpp0000600000175000001440000000016513173131001017715 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_wrap.cpp0000600000175000001440000001264013173131001015613 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include namespace clamp { int test() { int Error(0); float A = glm::clamp(0.5f); Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1; float B = glm::clamp(0.0f); Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1; float C = glm::clamp(1.0f); Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1; float D = glm::clamp(-0.5f); Error += glm::epsilonEqual(D, 0.0f, 0.00001f) ? 0 : 1; float E = glm::clamp(1.5f); Error += glm::epsilonEqual(E, 1.0f, 0.00001f) ? 0 : 1; glm::vec2 K = glm::clamp(glm::vec2(0.5f)); Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1; glm::vec3 L = glm::clamp(glm::vec3(0.5f)); Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1; glm::vec4 M = glm::clamp(glm::vec4(0.5f)); Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1; glm::vec1 N = glm::clamp(glm::vec1(0.5f)); Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1; return Error; } }//namespace clamp namespace repeat { int test() { int Error(0); float A = glm::repeat(0.5f); Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1; float B = glm::repeat(0.0f); Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1; float C = glm::repeat(1.0f); Error += glm::epsilonEqual(C, 0.0f, 0.00001f) ? 0 : 1; float D = glm::repeat(-0.5f); Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1; float E = glm::repeat(1.5f); Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1; float F = glm::repeat(0.9f); Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1; glm::vec2 K = glm::repeat(glm::vec2(0.5f)); Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1; glm::vec3 L = glm::repeat(glm::vec3(0.5f)); Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1; glm::vec4 M = glm::repeat(glm::vec4(0.5f)); Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1; glm::vec1 N = glm::repeat(glm::vec1(0.5f)); Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1; return Error; } }//namespace repeat namespace mirrorClamp { int test() { int Error(0); float A = glm::mirrorClamp(0.5f); Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1; float B = glm::mirrorClamp(0.0f); Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1; float C = glm::mirrorClamp(1.1f); Error += glm::epsilonEqual(C, 0.1f, 0.00001f) ? 0 : 1; float D = glm::mirrorClamp(-0.5f); Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1; float E = glm::mirrorClamp(1.5f); Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1; float F = glm::mirrorClamp(0.9f); Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1; float G = glm::mirrorClamp(3.1f); Error += glm::epsilonEqual(G, 0.1f, 0.00001f) ? 0 : 1; float H = glm::mirrorClamp(-3.1f); Error += glm::epsilonEqual(H, 0.1f, 0.00001f) ? 0 : 1; float I = glm::mirrorClamp(-0.9f); Error += glm::epsilonEqual(I, 0.9f, 0.00001f) ? 0 : 1; glm::vec2 K = glm::mirrorClamp(glm::vec2(0.5f)); Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1; glm::vec3 L = glm::mirrorClamp(glm::vec3(0.5f)); Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1; glm::vec4 M = glm::mirrorClamp(glm::vec4(0.5f)); Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1; glm::vec1 N = glm::mirrorClamp(glm::vec1(0.5f)); Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1; return Error; } }//namespace mirrorClamp namespace mirrorRepeat { int test() { int Error(0); float A = glm::mirrorRepeat(0.5f); Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1; float B = glm::mirrorRepeat(0.0f); Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1; float C = glm::mirrorRepeat(1.0f); Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1; float D = glm::mirrorRepeat(-0.5f); Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1; float E = glm::mirrorRepeat(1.5f); Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1; float F = glm::mirrorRepeat(0.9f); Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1; float G = glm::mirrorRepeat(3.0f); Error += glm::epsilonEqual(G, 1.0f, 0.00001f) ? 0 : 1; float H = glm::mirrorRepeat(-3.0f); Error += glm::epsilonEqual(H, 1.0f, 0.00001f) ? 0 : 1; float I = glm::mirrorRepeat(-1.0f); Error += glm::epsilonEqual(I, 1.0f, 0.00001f) ? 0 : 1; glm::vec2 K = glm::mirrorRepeat(glm::vec2(0.5f)); Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1; glm::vec3 L = glm::mirrorRepeat(glm::vec3(0.5f)); Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1; glm::vec4 M = glm::mirrorRepeat(glm::vec4(0.5f)); Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1; glm::vec1 N = glm::mirrorRepeat(glm::vec1(0.5f)); Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1; return Error; } }//namespace mirrorRepeat int main() { int Error(0); Error += clamp::test(); Error += repeat::test(); Error += mirrorClamp::test(); Error += mirrorRepeat::test(); return Error; } glm-0.9.9-a2/test/gtx/gtx_normal.cpp0000600000175000001440000000015513173131001016130 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_mixed_product.cpp0000600000175000001440000000121013173131001017477 0ustar guususers/////////////////////////////////////////////////////////////////////////////////////////////////// // OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /////////////////////////////////////////////////////////////////////////////////////////////////// // Created : 2013-10-25 // Updated : 2013-10-25 // Licence : This source is under MIT licence // File : test/gtx/associated_min_max.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// #include #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_io.cpp0000600000175000001440000001565713173131001015264 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include #include namespace { template std::basic_ostream& operator<<(std::basic_ostream& os, glm::qualifier const& a) { typename std::basic_ostream::sentry const cerberus(os); if (cerberus) { switch (a) { case glm::highp: os << "uhi"; break; case glm::mediump: os << "umd"; break; case glm::lowp: os << "ulo"; break; # if GLM_HAS_ALIGNED_TYPE case glm::aligned_highp: os << "ahi"; break; case glm::aligned_mediump: os << "amd"; break; case glm::aligned_lowp: os << "alo"; break; # endif } } return os; } template std::basic_string type_name(std::basic_ostream&, T const&) { std::basic_ostringstream ostr; if (typeid(T) == typeid(glm::tquat)) { ostr << "quat"; } else if (typeid(T) == typeid(glm::vec<2, U,P>)) { ostr << "vec2"; } else if (typeid(T) == typeid(glm::vec<3, U,P>)) { ostr << "vec3"; } else if (typeid(T) == typeid(glm::vec<4, U,P>)) { ostr << "vec4"; } else if (typeid(T) == typeid(glm::mat<2, 2, U,P>)) { ostr << "mat2x2"; } else if (typeid(T) == typeid(glm::mat<2, 3, U,P>)) { ostr << "mat2x3"; } else if (typeid(T) == typeid(glm::mat<2, 4, U,P>)) { ostr << "mat2x4"; } else if (typeid(T) == typeid(glm::mat<3, 2, U,P>)) { ostr << "mat3x2"; } else if (typeid(T) == typeid(glm::mat<3, 3, U,P>)) { ostr << "mat3x3"; } else if (typeid(T) == typeid(glm::mat<3, 4, U,P>)) { ostr << "mat3x4"; } else if (typeid(T) == typeid(glm::mat<4, 2, U,P>)) { ostr << "mat4x2"; } else if (typeid(T) == typeid(glm::mat<4, 3, U,P>)) { ostr << "mat4x3"; } else if (typeid(T) == typeid(glm::mat<4, 4, U,P>)) { ostr << "mat4x4"; } else { ostr << "unknown"; } ostr << '<' << typeid(U).name() << ',' << P << '>'; return ostr.str(); } } // namespace { template int test_io_quat(OS& os) { os << '\n' << typeid(OS).name() << '\n'; glm::tquat const q(1, 0, 0, 0); { glm::io::basic_format_saver const iofs(os); os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2) << type_name(os, q) << ": " << q << '\n'; } { glm::io::basic_format_saver const iofs(os); os << glm::io::unformatted << type_name(os, q) << ": " << q << '\n'; } return 0; } template int test_io_vec(OS& os) { os << '\n' << typeid(OS).name() << '\n'; glm::vec<2, T,P> const v2(0, 1); glm::vec<3, T,P> const v3(2, 3, 4); glm::vec<4, T,P> const v4(5, 6, 7, 8); os << type_name(os, v2) << ": " << v2 << '\n' << type_name(os, v3) << ": " << v3 << '\n' << type_name(os, v4) << ": " << v4 << '\n'; glm::io::basic_format_saver const iofs(os); os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2) << type_name(os, v2) << ": " << v2 << '\n' << type_name(os, v3) << ": " << v3 << '\n' << type_name(os, v4) << ": " << v4 << '\n'; return 0; } template int test_io_mat(OS& os, glm::io::order_type otype) { os << '\n' << typeid(OS).name() << '\n'; glm::vec<2, T,P> const v2_1( 0, 1); glm::vec<2, T,P> const v2_2( 2, 3); glm::vec<2, T,P> const v2_3( 4, 5); glm::vec<2, T,P> const v2_4( 6, 7); glm::vec<3, T,P> const v3_1( 8, 9, 10); glm::vec<3, T,P> const v3_2(11, 12, 13); glm::vec<3, T,P> const v3_3(14, 15, 16); glm::vec<3, T,P> const v3_4(17, 18, 19); glm::vec<4, T,P> const v4_1(20, 21, 22, 23); glm::vec<4, T,P> const v4_2(24, 25, 26, 27); glm::vec<4, T,P> const v4_3(28, 29, 30, 31); glm::vec<4, T,P> const v4_4(32, 33, 34, 35); glm::io::basic_format_saver const iofs(os); os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2) << glm::io::order(otype) << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 2, T,P>(v2_1, v2_2) << '\n' << "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 3, T,P>(v3_1, v3_2) << '\n' << "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 4, T,P>(v4_1, v4_2) << '\n' << "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 2, T,P>(v2_1, v2_2, v2_3) << '\n' << "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 3, T,P>(v3_1, v3_2, v3_3) << '\n' << "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 4, T,P>(v4_1, v4_2, v4_3) << '\n' << "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 2, T,P>(v2_1, v2_2, v2_3, v2_4) << '\n' << "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 3, T,P>(v3_1, v3_2, v3_3, v3_4) << '\n' << "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 4, T,P>(v4_1, v4_2, v4_3, v4_4) << '\n'; os << glm::io::unformatted << glm::io::order(otype) << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 2, T,P>(v2_1, v2_2) << '\n' << "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 3, T,P>(v3_1, v3_2) << '\n' << "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 4, T,P>(v4_1, v4_2) << '\n' << "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 2, T,P>(v2_1, v2_2, v2_3) << '\n' << "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 3, T,P>(v3_1, v3_2, v3_3) << '\n' << "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 4, T,P>(v4_1, v4_2, v4_3) << '\n' << "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 2, T,P>(v2_1, v2_2, v2_3, v2_4) << '\n' << "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 3, T,P>(v3_1, v3_2, v3_3, v3_4) << '\n' << "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 4, T,P>(v4_1, v4_2, v4_3, v4_4) << '\n'; return 0; } int main() { int Error(0); Error += test_io_quat(std::cout); Error += test_io_quat(std::wcout); Error += test_io_quat(std::cout); Error += test_io_quat(std::wcout); Error += test_io_quat(std::cout); Error += test_io_quat(std::wcout); Error += test_io_vec(std::cout); Error += test_io_vec(std::wcout); Error += test_io_vec(std::cout); Error += test_io_vec(std::wcout); Error += test_io_vec(std::cout); Error += test_io_vec(std::wcout); Error += test_io_mat(std::cout, glm::io::column_major); Error += test_io_mat(std::wcout, glm::io::column_major); Error += test_io_mat(std::cout, glm::io::row_major); Error += test_io_mat(std::wcout, glm::io::row_major); return Error; } glm-0.9.9-a2/test/gtx/gtx_string_cast.cpp0000600000175000001440000000712513173131001017164 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include int test_string_cast_vector() { int Error = 0; { glm::vec2 A1(1, 2); std::string A2 = glm::to_string(A1); Error += A2 != std::string("vec2(1.000000, 2.000000)") ? 1 : 0; glm::vec3 B1(1, 2, 3); std::string B2 = glm::to_string(B1); Error += B2 != std::string("vec3(1.000000, 2.000000, 3.000000)") ? 1 : 0; glm::vec4 C1(1, 2, 3, 4); std::string C2 = glm::to_string(C1); Error += C2 != std::string("vec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0; glm::dvec2 J1(1, 2); std::string J2 = glm::to_string(J1); Error += J2 != std::string("dvec2(1.000000, 2.000000)") ? 1 : 0; glm::dvec3 K1(1, 2, 3); std::string K2 = glm::to_string(K1); Error += K2 != std::string("dvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0; glm::dvec4 L1(1, 2, 3, 4); std::string L2 = glm::to_string(L1); Error += L2 != std::string("dvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0; } { glm::bvec2 M1(false, true); std::string M2 = glm::to_string(M1); Error += M2 != std::string("bvec2(false, true)") ? 1 : 0; glm::bvec3 O1(false, true, false); std::string O2 = glm::to_string(O1); Error += O2 != std::string("bvec3(false, true, false)") ? 1 : 0; glm::bvec4 P1(false, true, false, true); std::string P2 = glm::to_string(P1); Error += P2 != std::string("bvec4(false, true, false, true)") ? 1 : 0; } { glm::ivec2 D1(1, 2); std::string D2 = glm::to_string(D1); Error += D2 != std::string("ivec2(1, 2)") ? 1 : 0; glm::ivec3 E1(1, 2, 3); std::string E2 = glm::to_string(E1); Error += E2 != std::string("ivec3(1, 2, 3)") ? 1 : 0; glm::ivec4 F1(1, 2, 3, 4); std::string F2 = glm::to_string(F1); Error += F2 != std::string("ivec4(1, 2, 3, 4)") ? 1 : 0; } { glm::i8vec2 D1(1, 2); std::string D2 = glm::to_string(D1); Error += D2 != std::string("i8vec2(1, 2)") ? 1 : 0; glm::i8vec3 E1(1, 2, 3); std::string E2 = glm::to_string(E1); Error += E2 != std::string("i8vec3(1, 2, 3)") ? 1 : 0; glm::i8vec4 F1(1, 2, 3, 4); std::string F2 = glm::to_string(F1); Error += F2 != std::string("i8vec4(1, 2, 3, 4)") ? 1 : 0; } { glm::i16vec2 D1(1, 2); std::string D2 = glm::to_string(D1); Error += D2 != std::string("i16vec2(1, 2)") ? 1 : 0; glm::i16vec3 E1(1, 2, 3); std::string E2 = glm::to_string(E1); Error += E2 != std::string("i16vec3(1, 2, 3)") ? 1 : 0; glm::i16vec4 F1(1, 2, 3, 4); std::string F2 = glm::to_string(F1); Error += F2 != std::string("i16vec4(1, 2, 3, 4)") ? 1 : 0; } { glm::i64vec2 D1(1, 2); std::string D2 = glm::to_string(D1); Error += D2 != std::string("i64vec2(1, 2)") ? 1 : 0; glm::i64vec3 E1(1, 2, 3); std::string E2 = glm::to_string(E1); Error += E2 != std::string("i64vec3(1, 2, 3)") ? 1 : 0; glm::i64vec4 F1(1, 2, 3, 4); std::string F2 = glm::to_string(F1); Error += F2 != std::string("i64vec4(1, 2, 3, 4)") ? 1 : 0; } return Error; } int test_string_cast_matrix() { int Error = 0; glm::mat2x2 A1(1.000000, 2.000000, 3.000000, 4.000000); std::string A2 = glm::to_string(A1); Error += A2 != std::string("mat2x2((1.000000, 2.000000), (3.000000, 4.000000))") ? 1 : 0; return Error; } int test_string_cast_quaternion() { int Error = 0; glm::quat Q0 = glm::quat(1.0f, 2.0f, 3.0f, 4.0f); std::string S0 = glm::to_string(Q0); Error += S0 != std::string("quat(1.000000, {2.000000, 3.000000, 4.000000})") ? 1 : 0; return Error; } int main() { int Error = 0; Error += test_string_cast_vector(); Error += test_string_cast_matrix(); Error += test_string_cast_quaternion(); return Error; } glm-0.9.9-a2/test/gtx/gtx_extend.cpp0000600000175000001440000000015513173131001016127 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_matrix_major_storage.cpp0000600000175000001440000000017313173131001021060 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_type_trait.cpp0000600000175000001440000000021613173131001017022 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/gtx/gtx_common.cpp0000600000175000001440000000570113173131001016132 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include #include namespace fmod_ { template GLM_FUNC_QUALIFIER genType modTrunc(genType a, genType b) { return a - b * glm::trunc(a / b); } int test() { int Error(0); { float A0(3.0); float B0(2.0f); float C0 = glm::fmod(A0, B0); Error += glm::abs(C0 - 1.0f) < 0.00001f ? 0 : 1; glm::vec4 A1(3.0); float B1(2.0f); glm::vec4 C1 = glm::fmod(A1, B1); Error += glm::all(glm::epsilonEqual(C1, glm::vec4(1.0f), 0.00001f)) ? 0 : 1; glm::vec4 A2(3.0); glm::vec4 B2(2.0f); glm::vec4 C2 = glm::fmod(A2, B2); Error += glm::all(glm::epsilonEqual(C2, glm::vec4(1.0f), 0.00001f)) ? 0 : 1; glm::ivec4 A3(3); int B3(2); glm::ivec4 C3 = glm::fmod(A3, B3); Error += glm::all(glm::equal(C3, glm::ivec4(1))) ? 0 : 1; glm::ivec4 A4(3); glm::ivec4 B4(2); glm::ivec4 C4 = glm::fmod(A4, B4); Error += glm::all(glm::equal(C4, glm::ivec4(1))) ? 0 : 1; } { float A0(22.0); float B0(-10.0f); float C0 = glm::fmod(A0, B0); Error += glm::abs(C0 - 2.0f) < 0.00001f ? 0 : 1; glm::vec4 A1(22.0); float B1(-10.0f); glm::vec4 C1 = glm::fmod(A1, B1); Error += glm::all(glm::epsilonEqual(C1, glm::vec4(2.0f), 0.00001f)) ? 0 : 1; glm::vec4 A2(22.0); glm::vec4 B2(-10.0f); glm::vec4 C2 = glm::fmod(A2, B2); Error += glm::all(glm::epsilonEqual(C2, glm::vec4(2.0f), 0.00001f)) ? 0 : 1; glm::ivec4 A3(22); int B3(-10); glm::ivec4 C3 = glm::fmod(A3, B3); Error += glm::all(glm::equal(C3, glm::ivec4(2))) ? 0 : 1; glm::ivec4 A4(22); glm::ivec4 B4(-10); glm::ivec4 C4 = glm::fmod(A4, B4); Error += glm::all(glm::equal(C4, glm::ivec4(2))) ? 0 : 1; } // http://stackoverflow.com/questions/7610631/glsl-mod-vs-hlsl-fmod { for (float y = -10.0f; y < 10.0f; y += 0.1f) for (float x = -10.0f; x < 10.0f; x += 0.1f) { float const A(std::fmod(x, y)); //float const B(std::remainder(x, y)); float const C(glm::fmod(x, y)); float const D(modTrunc(x, y)); //Error += glm::epsilonEqual(A, B, 0.0001f) ? 0 : 1; //assert(!Error); Error += glm::epsilonEqual(A, C, 0.0001f) ? 0 : 1; assert(!Error); Error += glm::epsilonEqual(A, D, 0.00001f) ? 0 : 1; assert(!Error); } } return Error; } }//namespace fmod_ int test_isdenormal() { int Error = 0; bool A = glm::isdenormal(1.0f); Error += !A ? 0 : 1; glm::bvec1 B = glm::isdenormal(glm::vec1(1.0f)); Error += !glm::any(B) ? 0 : 1; glm::bvec2 C = glm::isdenormal(glm::vec2(1.0f)); Error += !glm::any(C) ? 0 : 1; glm::bvec3 D = glm::isdenormal(glm::vec3(1.0f)); Error += !glm::any(D) ? 0 : 1; glm::bvec4 E = glm::isdenormal(glm::vec4(1.0f)); Error += !glm::any(E) ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_isdenormal(); Error += ::fmod_::test(); return Error; } glm-0.9.9-a2/test/gtx/gtx_norm.cpp0000600000175000001440000000015313173131001015611 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_texture.cpp0000600000175000001440000000045313173131001016341 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include int test_levels() { int Error = 0; int const Levels = glm::levels(glm::ivec2(3, 2)); Error += Levels == 2 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_levels(); return Error; } glm-0.9.9-a2/test/gtx/gtx_color_space_YCoCg.cpp0000600000175000001440000000017013173131001020152 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_functions.cpp0000600000175000001440000000114613173131001016651 0ustar guususers#include #include int test_gauss_1d() { int Error = 0; std::vector Result(20); for(std::size_t i = 0, n = Result.size(); i < n; ++i) Result[i] = glm::gauss(static_cast(i) * 0.1f, 0.0f, 1.0f); return Error; } int test_gauss_2d() { int Error = 0; std::vector Result(20); for(std::size_t i = 0, n = Result.size(); i < n; ++i) Result[i] = glm::gauss(glm::vec2(static_cast(i)) * 0.1f, glm::vec2(0.0f), glm::vec2(1.0f)); return Error; } int main() { int Error = 0; Error += test_gauss_1d(); Error += test_gauss_2d(); return Error; } glm-0.9.9-a2/test/gtx/gtx_simd_mat4.cpp0000600000175000001440000002146213173131001016525 0ustar guususers/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @file test/gtx/gtx_simd_mat4.cpp /// @date 2010-09-16 / 2014-11-25 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #include #include #include #include #include #include #include #include #include #if(GLM_ARCH != GLM_ARCH_PURE) std::vector test_detA(std::vector const & Data) { std::vector Test(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Test.size() - 1; ++i) Test[i] = glm::determinant(Data[i]); std::clock_t TimeEnd = clock(); printf("Det A: %ld\n", TimeEnd - TimeStart); return Test; } std::vector test_detB(std::vector const & Data) { std::vector Test(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Test.size() - 1; ++i) { _mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0); glm::simdMat4 m(Data[i]); glm::simdVec4 d(glm::detail::sse_slow_det_ps((__m128 const * const)&m)); glm::vec4 v;//(d); Test[i] = v.x; } std::clock_t TimeEnd = clock(); printf("Det B: %ld\n", TimeEnd - TimeStart); return Test; } std::vector test_detC(std::vector const & Data) { std::vector Test(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Test.size() - 1; ++i) { _mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0); glm::simdMat4 m(Data[i]); glm::simdVec4 d(glm::detail::sse_det_ps((__m128 const * const)&m)); glm::vec4 v;//(d); Test[i] = v.x; } std::clock_t TimeEnd = clock(); printf("Det C: %ld\n", TimeEnd - TimeStart); return Test; } std::vector test_detD(std::vector const & Data) { std::vector Test(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Test.size() - 1; ++i) { _mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0); glm::simdMat4 m(Data[i]); glm::simdVec4 d(glm::detail::sse_detd_ps((__m128 const * const)&m)); glm::vec4 v;//(d); Test[i] = v.x; } std::clock_t TimeEnd = clock(); printf("Det D: %ld\n", TimeEnd - TimeStart); return Test; } void test_invA(std::vector const & Data, std::vector & Out) { //std::vector Test(Data.size()); Out.resize(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Out.size() - 1; ++i) { Out[i] = glm::inverse(Data[i]); } std::clock_t TimeEnd = clock(); printf("Inv A: %ld\n", TimeEnd - TimeStart); } void test_invC(std::vector const & Data, std::vector & Out) { //std::vector Test(Data.size()); Out.resize(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Out.size() - 1; ++i) { _mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0); glm::simdMat4 m(Data[i]); glm::simdMat4 o; glm::detail::sse_inverse_fast_ps((__m128 const * const)&m, (__m128 *)&o); Out[i] = *(glm::mat4*)&o; } std::clock_t TimeEnd = clock(); printf("Inv C: %ld\n", TimeEnd - TimeStart); } void test_invD(std::vector const & Data, std::vector & Out) { //std::vector Test(Data.size()); Out.resize(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Out.size() - 1; ++i) { _mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0); glm::simdMat4 m(Data[i]); glm::simdMat4 o; glm::detail::sse_inverse_ps((__m128 const * const)&m, (__m128 *)&o); Out[i] = *(glm::mat4*)&o; } std::clock_t TimeEnd = clock(); printf("Inv D: %ld\n", TimeEnd - TimeStart); } void test_mulA(std::vector const & Data, std::vector & Out) { //std::vector Test(Data.size()); Out.resize(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Out.size() - 1; ++i) { Out[i] = Data[i] * Data[i]; } std::clock_t TimeEnd = clock(); printf("Mul A: %ld\n", TimeEnd - TimeStart); } void test_mulD(std::vector const & Data, std::vector & Out) { //std::vector Test(Data.size()); Out.resize(Data.size()); std::clock_t TimeStart = clock(); for(std::size_t i = 0; i < Out.size() - 1; ++i) { _mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0); glm::simdMat4 m(Data[i]); glm::simdMat4 o; glm::detail::sse_mul_ps((__m128 const * const)&m, (__m128 const * const)&m, (__m128*)&o); Out[i] = *(glm::mat4*)&o; } std::clock_t TimeEnd = clock(); printf("Mul D: %ld\n", TimeEnd - TimeStart); } int test_compute_glm() { return 0; } int test_compute_gtx() { std::vector Output(1000000); std::clock_t TimeStart = clock(); for(std::size_t k = 0; k < Output.size(); ++k) { float i = float(k) / 1000.f + 0.001f; glm::vec3 A = glm::normalize(glm::vec3(i)); glm::vec3 B = glm::cross(A, glm::normalize(glm::vec3(1, 1, 2))); glm::mat4 C = glm::rotate(glm::mat4(1.0f), i, B); glm::mat4 D = glm::scale(C, glm::vec3(0.8f, 1.0f, 1.2f)); glm::mat4 E = glm::translate(D, glm::vec3(1.4f, 1.2f, 1.1f)); glm::mat4 F = glm::perspective(i, 1.5f, 0.1f, 1000.f); glm::mat4 G = glm::inverse(F * E); glm::vec3 H = glm::unProject(glm::vec3(i), G, F, E[3]); glm::vec3 I = glm::any(glm::isnan(glm::project(H, G, F, E[3]))) ? glm::vec3(2) : glm::vec3(1); glm::mat4 J = glm::lookAt(glm::normalize(glm::max(B, glm::vec3(0.001f))), H, I); glm::mat4 K = glm::transpose(J); glm::quat L = glm::normalize(glm::quat_cast(K)); glm::vec4 M = L * glm::smoothstep(K[3], J[3], glm::vec4(i)); glm::mat4 N = glm::mat4(glm::normalize(glm::max(M, glm::vec4(0.001f))), K[3], J[3], glm::vec4(i)); glm::mat4 O = N * glm::inverse(N); glm::vec4 P = O * glm::reflect(N[3], glm::vec4(A, 1.0f)); glm::vec4 Q = glm::vec4(glm::dot(M, P)); glm::vec4 R = glm::quat(Q.w, glm::vec3(Q)) * P; Output[k] = R; } std::clock_t TimeEnd = clock(); printf("test_compute_gtx: %ld\n", TimeEnd - TimeStart); return 0; } int main() { int Error = 0; std::vector Data(64 * 64 * 1); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = glm::mat4( glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f))), glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f))), glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f))), glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f)))); { std::vector TestInvA; test_invA(Data, TestInvA); } { std::vector TestInvC; test_invC(Data, TestInvC); } { std::vector TestInvD; test_invD(Data, TestInvD); } { std::vector TestA; test_mulA(Data, TestA); } { std::vector TestD; test_mulD(Data, TestD); } { std::vector TestDetA = test_detA(Data); std::vector TestDetB = test_detB(Data); std::vector TestDetD = test_detD(Data); std::vector TestDetC = test_detC(Data); for(std::size_t i = 0; i < TestDetA.size(); ++i) if(TestDetA[i] != TestDetB[i] && TestDetC[i] != TestDetB[i] && TestDetC[i] != TestDetD[i]) return 1; } // shuffle test glm::simdVec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::simdVec4 B(5.0f, 6.0f, 7.0f, 8.0f); //__m128 C = _mm_shuffle_ps(A.Data, B.Data, _MM_SHUFFLE(1, 0, 1, 0)); Error += test_compute_glm(); Error += test_compute_gtx(); float Det = glm::determinant(glm::simdMat4(1.0)); Error += Det == 1.0f ? 0 : 1; glm::simdMat4 D = glm::matrixCompMult(glm::simdMat4(1.0), glm::simdMat4(1.0)); return Error; } #else int main() { int Error = 0; return Error; } #endif//(GLM_ARCH != GLM_ARCH_PURE) glm-0.9.9-a2/test/gtx/gtx_dual_quaternion.cpp0000600000175000001440000001445013173131001020035 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include #include #if GLM_HAS_TRIVIAL_QUERIES # include #endif int myrand() { static int holdrand = 1; return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff); } float myfrand() // returns values from -1 to 1 inclusive { return float(double(myrand()) / double( 0x7ffff )) * 2.0f - 1.0f; } int test_dquat_type() { glm::dvec3 vA; glm::dquat dqA, dqB; glm::ddualquat C(dqA, dqB); glm::ddualquat B(dqA); glm::ddualquat D(dqA, vA); return 0; } int test_scalars() { float const Epsilon = 0.0001f; int Error(0); glm::quat src_q1 = glm::quat(1.0f,2.0f,3.0f,4.0f); glm::quat src_q2 = glm::quat(5.0f,6.0f,7.0f,8.0f); glm::dualquat src1(src_q1,src_q2); { glm::dualquat dst1 = src1 * 2.0f; glm::dualquat dst2 = 2.0f * src1; glm::dualquat dst3 = src1; dst3 *= 2.0f; glm::dualquat dstCmp(src_q1 * 2.0f,src_q2 * 2.0f); Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(dst3.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst3.dual,dstCmp.dual, Epsilon)) ? 0 : 1; } { glm::dualquat dst1 = src1 / 2.0f; glm::dualquat dst2 = src1; dst2 /= 2.0f; glm::dualquat dstCmp(src_q1 / 2.0f,src_q2 / 2.0f); Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1; } return Error; } int test_inverse() { int Error(0); float const Epsilon = 0.0001f; glm::dualquat dqid = glm::dual_quat_identity(); glm::mat4x4 mid(1.0f); for (int j = 0; j < 100; ++j) { glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f); glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f); glm::mat4x4 m = glm::translate(mid, vt) * rot; glm::quat qr = glm::quat_cast(m); glm::dualquat dq(qr); glm::dualquat invdq = glm::inverse(dq); glm::dualquat r1 = invdq * dq; glm::dualquat r2 = dq * invdq; Error += glm::all(glm::epsilonEqual(r1.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r1.dual, dqid.dual, Epsilon)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(r2.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r2.dual, dqid.dual, Epsilon)) ? 0 : 1; // testing commutative property glm::dualquat r ( glm::quat( myfrand() * glm::pi() * 2.0f, myfrand(), myfrand(), myfrand() ), glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f) ); glm::dualquat riq = (r * invdq) * dq; glm::dualquat rqi = (r * dq) * invdq; Error += glm::all(glm::epsilonEqual(riq.real, rqi.real, Epsilon)) && glm::all(glm::epsilonEqual(riq.dual, rqi.dual, Epsilon)) ? 0 : 1; } return Error; } int test_mul() { int Error(0); float const Epsilon = 0.0001f; glm::mat4x4 mid(1.0f); for (int j = 0; j < 100; ++j) { // generate random rotations and translations and compare transformed by matrix and dualquats random points glm::vec3 vt1 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f); glm::vec3 vt2 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f); glm::mat4x4 rot1 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f); glm::mat4x4 rot2 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f); glm::mat4x4 m1 = glm::translate(mid, vt1) * rot1; glm::mat4x4 m2 = glm::translate(mid, vt2) * rot2; glm::mat4x4 m3 = m2 * m1; glm::mat4x4 m4 = m1 * m2; glm::quat qrot1 = glm::quat_cast(rot1); glm::quat qrot2 = glm::quat_cast(rot2); glm::dualquat dq1 = glm::dualquat(qrot1,vt1); glm::dualquat dq2 = glm::dualquat(qrot2,vt2); glm::dualquat dq3 = dq2 * dq1; glm::dualquat dq4 = dq1 * dq2; for (int i = 0; i < 100; ++i) { glm::vec4 src_pt = glm::vec4(myfrand() * 4.0f, myfrand() * 5.0f, myfrand() * 3.0f,1.0f); // test both multiplication orders glm::vec4 dst_pt_m3 = m3 * src_pt; glm::vec4 dst_pt_dq3 = dq3 * src_pt; glm::vec4 dst_pt_m3_i = glm::inverse(m3) * src_pt; glm::vec4 dst_pt_dq3_i = src_pt * dq3; glm::vec4 dst_pt_m4 = m4 * src_pt; glm::vec4 dst_pt_dq4 = dq4 * src_pt; glm::vec4 dst_pt_m4_i = glm::inverse(m4) * src_pt; glm::vec4 dst_pt_dq4_i = src_pt * dq4; Error += glm::all(glm::epsilonEqual(dst_pt_m3, dst_pt_dq3, Epsilon)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(dst_pt_m4, dst_pt_dq4, Epsilon)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(dst_pt_m3_i, dst_pt_dq3_i, Epsilon)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(dst_pt_m4_i, dst_pt_dq4_i, Epsilon)) ? 0 : 1; } } return Error; } int test_dual_quat_ctr() { int Error(0); # if GLM_HAS_TRIVIAL_QUERIES // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; # endif return Error; } int test_size() { int Error = 0; Error += 32 == sizeof(glm::dualquat) ? 0 : 1; Error += 64 == sizeof(glm::ddualquat) ? 0 : 1; Error += glm::dualquat().length() == 2 ? 0 : 1; Error += glm::ddualquat().length() == 2 ? 0 : 1; Error += glm::dualquat::length() == 2 ? 0 : 1; Error += glm::ddualquat::length() == 2 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_dual_quat_ctr(); Error += test_dquat_type(); Error += test_scalars(); Error += test_inverse(); Error += test_mul(); Error += test_size(); return Error; } glm-0.9.9-a2/test/gtx/gtx_vector_angle.cpp0000600000175000001440000000373413173131001017316 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include int test_angle() { int Error = 0; float AngleA = glm::angle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1))); Error += glm::epsilonEqual(AngleA, glm::pi() * 0.25f, 0.01f) ? 0 : 1; float AngleB = glm::angle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0))); Error += glm::epsilonEqual(AngleB, glm::pi() * 0.25f, 0.01f) ? 0 : 1; float AngleC = glm::angle(glm::vec4(1, 0, 0, 0), glm::normalize(glm::vec4(1, 1, 0, 0))); Error += glm::epsilonEqual(AngleC, glm::pi() * 0.25f, 0.01f) ? 0 : 1; return Error; } int test_orientedAngle_vec2() { int Error = 0; float AngleA = glm::orientedAngle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1))); Error += glm::epsilonEqual(AngleA, glm::pi() * 0.25f, 0.01f) ? 0 : 1; float AngleB = glm::orientedAngle(glm::vec2(0, 1), glm::normalize(glm::vec2(1, 1))); Error += glm::epsilonEqual(AngleB, -glm::pi() * 0.25f, 0.01f) ? 0 : 1; float AngleC = glm::orientedAngle(glm::normalize(glm::vec2(1, 1)), glm::vec2(0, 1)); Error += glm::epsilonEqual(AngleC, glm::pi() * 0.25f, 0.01f) ? 0 : 1; return Error; } int test_orientedAngle_vec3() { int Error = 0; float AngleA = glm::orientedAngle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1)); Error += glm::epsilonEqual(AngleA, glm::pi() * 0.25f, 0.01f) ? 0 : 1; float AngleB = glm::orientedAngle(glm::vec3(0, 1, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1)); Error += glm::epsilonEqual(AngleB, -glm::pi() * 0.25f, 0.01f) ? 0 : 1; float AngleC = glm::orientedAngle(glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1)); Error += glm::epsilonEqual(AngleC, glm::pi() * 0.25f, 0.01f) ? 0 : 1; return Error; } int main() { int Error(0); Error += test_angle(); Error += test_orientedAngle_vec2(); Error += test_orientedAngle_vec3(); return Error; } glm-0.9.9-a2/test/gtx/gtx_handed_coordinate_space.cpp0000600000175000001440000000017613173131001021450 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_compatibility.cpp0000600000175000001440000000100413173131001017503 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); Error += glm::isfinite(1.0f) ? 0 : 1; Error += glm::isfinite(1.0) ? 0 : 1; Error += glm::isfinite(-1.0f) ? 0 : 1; Error += glm::isfinite(-1.0) ? 0 : 1; Error += glm::all(glm::isfinite(glm::vec4(1.0f))) ? 0 : 1; Error += glm::all(glm::isfinite(glm::dvec4(1.0))) ? 0 : 1; Error += glm::all(glm::isfinite(glm::vec4(-1.0f))) ? 0 : 1; Error += glm::all(glm::isfinite(glm::dvec4(-1.0))) ? 0 : 1; return Error; } glm-0.9.9-a2/test/gtx/gtx_scalar_relational.cpp0000600000175000001440000001035013173131001020315 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include int test_lessThan() { int Error(0); Error += glm::lessThan(0, 1) ? 0 : 1; Error += glm::lessThan(1, 0) ? 1 : 0; Error += glm::lessThan(0, 0) ? 1 : 0; Error += glm::lessThan(1, 1) ? 1 : 0; Error += glm::lessThan(0.0f, 1.0f) ? 0 : 1; Error += glm::lessThan(1.0f, 0.0f) ? 1 : 0; Error += glm::lessThan(0.0f, 0.0f) ? 1 : 0; Error += glm::lessThan(1.0f, 1.0f) ? 1 : 0; Error += glm::lessThan(0.0, 1.0) ? 0 : 1; Error += glm::lessThan(1.0, 0.0) ? 1 : 0; Error += glm::lessThan(0.0, 0.0) ? 1 : 0; Error += glm::lessThan(1.0, 1.0) ? 1 : 0; return Error; } int test_lessThanEqual() { int Error(0); Error += glm::lessThanEqual(0, 1) ? 0 : 1; Error += glm::lessThanEqual(1, 0) ? 1 : 0; Error += glm::lessThanEqual(0, 0) ? 0 : 1; Error += glm::lessThanEqual(1, 1) ? 0 : 1; Error += glm::lessThanEqual(0.0f, 1.0f) ? 0 : 1; Error += glm::lessThanEqual(1.0f, 0.0f) ? 1 : 0; Error += glm::lessThanEqual(0.0f, 0.0f) ? 0 : 1; Error += glm::lessThanEqual(1.0f, 1.0f) ? 0 : 1; Error += glm::lessThanEqual(0.0, 1.0) ? 0 : 1; Error += glm::lessThanEqual(1.0, 0.0) ? 1 : 0; Error += glm::lessThanEqual(0.0, 0.0) ? 0 : 1; Error += glm::lessThanEqual(1.0, 1.0) ? 0 : 1; return Error; } int test_greaterThan() { int Error(0); Error += glm::greaterThan(0, 1) ? 1 : 0; Error += glm::greaterThan(1, 0) ? 0 : 1; Error += glm::greaterThan(0, 0) ? 1 : 0; Error += glm::greaterThan(1, 1) ? 1 : 0; Error += glm::greaterThan(0.0f, 1.0f) ? 1 : 0; Error += glm::greaterThan(1.0f, 0.0f) ? 0 : 1; Error += glm::greaterThan(0.0f, 0.0f) ? 1 : 0; Error += glm::greaterThan(1.0f, 1.0f) ? 1 : 0; Error += glm::greaterThan(0.0, 1.0) ? 1 : 0; Error += glm::greaterThan(1.0, 0.0) ? 0 : 1; Error += glm::greaterThan(0.0, 0.0) ? 1 : 0; Error += glm::greaterThan(1.0, 1.0) ? 1 : 0; return Error; } int test_greaterThanEqual() { int Error(0); Error += glm::greaterThanEqual(0, 1) ? 1 : 0; Error += glm::greaterThanEqual(1, 0) ? 0 : 1; Error += glm::greaterThanEqual(0, 0) ? 0 : 1; Error += glm::greaterThanEqual(1, 1) ? 0 : 1; Error += glm::greaterThanEqual(0.0f, 1.0f) ? 1 : 0; Error += glm::greaterThanEqual(1.0f, 0.0f) ? 0 : 1; Error += glm::greaterThanEqual(0.0f, 0.0f) ? 0 : 1; Error += glm::greaterThanEqual(1.0f, 1.0f) ? 0 : 1; Error += glm::greaterThanEqual(0.0, 1.0) ? 1 : 0; Error += glm::greaterThanEqual(1.0, 0.0) ? 0 : 1; Error += glm::greaterThanEqual(0.0, 0.0) ? 0 : 1; Error += glm::greaterThanEqual(1.0, 1.0) ? 0 : 1; return Error; } int test_equal() { int Error(0); Error += glm::equal(0, 1) ? 1 : 0; Error += glm::equal(1, 0) ? 1 : 0; Error += glm::equal(0, 0) ? 0 : 1; Error += glm::equal(1, 1) ? 0 : 1; Error += glm::equal(0.0f, 1.0f) ? 1 : 0; Error += glm::equal(1.0f, 0.0f) ? 1 : 0; Error += glm::equal(0.0f, 0.0f) ? 0 : 1; Error += glm::equal(1.0f, 1.0f) ? 0 : 1; Error += glm::equal(0.0, 1.0) ? 1 : 0; Error += glm::equal(1.0, 0.0) ? 1 : 0; Error += glm::equal(0.0, 0.0) ? 0 : 1; Error += glm::equal(1.0, 1.0) ? 0 : 1; return Error; } int test_notEqual() { int Error(0); Error += glm::notEqual(0, 1) ? 0 : 1; Error += glm::notEqual(1, 0) ? 0 : 1; Error += glm::notEqual(0, 0) ? 1 : 0; Error += glm::notEqual(1, 1) ? 1 : 0; Error += glm::notEqual(0.0f, 1.0f) ? 0 : 1; Error += glm::notEqual(1.0f, 0.0f) ? 0 : 1; Error += glm::notEqual(0.0f, 0.0f) ? 1 : 0; Error += glm::notEqual(1.0f, 1.0f) ? 1 : 0; Error += glm::notEqual(0.0, 1.0) ? 0 : 1; Error += glm::notEqual(1.0, 0.0) ? 0 : 1; Error += glm::notEqual(0.0, 0.0) ? 1 : 0; Error += glm::notEqual(1.0, 1.0) ? 1 : 0; return Error; } int test_any() { int Error(0); Error += glm::any(true) ? 0 : 1; Error += glm::any(false) ? 1 : 0; return Error; } int test_all() { int Error(0); Error += glm::all(true) ? 0 : 1; Error += glm::all(false) ? 1 : 0; return Error; } int test_not() { int Error(0); Error += glm::not_(true) ? 1 : 0; Error += glm::not_(false) ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_lessThan(); Error += test_lessThanEqual(); Error += test_greaterThan(); Error += test_greaterThanEqual(); Error += test_equal(); Error += test_notEqual(); Error += test_any(); Error += test_all(); Error += test_not(); return Error; } glm-0.9.9-a2/test/gtx/gtx_intersect.cpp0000600000175000001440000000146713173131001016647 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include int test_intersectRayTriangle() { int Error = 0; glm::vec3 const Orig(0, 0, 2); glm::vec3 const Dir(0, 0, -1); glm::vec3 const Vert0(0, 0, 0); glm::vec3 const Vert1(-1, -1, 0); glm::vec3 const Vert2(1, -1, 0); glm::vec2 BaryPosition(0); float Distance = 0; bool const Result = glm::intersectRayTriangle(Orig, Dir, Vert0, Vert1, Vert2, BaryPosition, Distance); Error += glm::all(glm::epsilonEqual(BaryPosition, glm::vec2(0), std::numeric_limits::epsilon())) ? 0 : 1; Error += glm::abs(Distance - 2.f) <= std::numeric_limits::epsilon() ? 0 : 1; Error += Result ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_intersectRayTriangle(); return Error; } glm-0.9.9-a2/test/gtx/gtx_color_space.cpp0000600000175000001440000000042513173131001017131 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int test_saturation() { int Error(0); glm::vec4 Color = glm::saturation(1.0f, glm::vec4(1.0, 0.5, 0.0, 1.0)); return Error; } int main() { int Error(0); Error += test_saturation(); return Error; } glm-0.9.9-a2/test/gtx/gtx_range.cpp0000600000175000001440000000207113173131001015733 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #if GLM_HAS_RANGE_FOR #include int test_vec() { int Error = 0; { glm::ivec3 const v(1, 2, 3); int count = 0; glm::ivec3 Result(0); for(int x : v) { Result[count] = x; count++; } Error += count == 3 ? 0 : 1; Error += v == Result ? 0 : 1; } { glm::ivec3 v(1, 2, 3); for(int& x : v) x = 0; Error += glm::all(glm::equal(v, glm::ivec3(0))) ? 0 : 1; } return Error; } int test_mat() { int Error = 0; { glm::mat4x3 m(1.0f); int count = 0; float Sum = 0.0f; for(float x : m) { count++; Sum += x; } Error += count == 12 ? 0 : 1; Error += glm::epsilonEqual(Sum, 3.0f, 0.001f) ? 0 : 1; } { glm::mat4x3 m(1.0f); for (float& x : m) { x = 0; } glm::vec4 v(1, 1, 1, 1); Error += glm::all(glm::equal(m*v, glm::vec3(0, 0, 0))) ? 0 : 1; } return Error; } int main() { int Error = 0; Error += test_vec(); Error += test_mat(); return Error; } #else int main() { return 0; } #endif//GLM_HAS_RANGE_FOR glm-0.9.9-a2/test/gtx/gtx_vector_query.cpp0000600000175000001440000000247213173131001017373 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include int test_areCollinear() { int Error(0); { bool TestA = glm::areCollinear(glm::vec2(-1), glm::vec2(1), 0.00001f); Error += TestA ? 0 : 1; } { bool TestA = glm::areCollinear(glm::vec3(-1), glm::vec3(1), 0.00001f); Error += TestA ? 0 : 1; } { bool TestA = glm::areCollinear(glm::vec4(-1), glm::vec4(1), 0.00001f); Error += TestA ? 0 : 1; } return Error; } int test_areOrthogonal() { int Error(0); bool TestA = glm::areOrthogonal(glm::vec2(1, 0), glm::vec2(0, 1), 0.00001f); Error += TestA ? 0 : 1; return Error; } int test_isNormalized() { int Error(0); bool TestA = glm::isNormalized(glm::vec4(1, 0, 0, 0), 0.00001f); Error += TestA ? 0 : 1; return Error; } int test_isNull() { int Error(0); bool TestA = glm::isNull(glm::vec4(0), 0.00001f); Error += TestA ? 0 : 1; return Error; } int test_areOrthonormal() { int Error(0); bool TestA = glm::areOrthonormal(glm::vec2(1, 0), glm::vec2(0, 1), 0.00001f); Error += TestA ? 0 : 1; return Error; } int main() { int Error(0); Error += test_areCollinear(); Error += test_areOrthogonal(); Error += test_isNormalized(); Error += test_isNull(); Error += test_areOrthonormal(); return Error; } glm-0.9.9-a2/test/gtx/gtx_quaternion.cpp0000600000175000001440000000560513173131001017032 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include #include #include #include int test_quat_fastMix() { int Error = 0; glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1)); glm::quat B = glm::angleAxis(glm::pi() * 0.5f, glm::vec3(0, 0, 1)); glm::quat C = glm::fastMix(A, B, 0.5f); glm::quat D = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(0, 0, 1)); Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1; return Error; } int test_quat_shortMix() { int Error(0); glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1)); glm::quat B = glm::angleAxis(glm::pi() * 0.5f, glm::vec3(0, 0, 1)); glm::quat C = glm::shortMix(A, B, 0.5f); glm::quat D = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(0, 0, 1)); Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1; return Error; } int test_orientation() { int Error = 0; { glm::quat q(1.0f, 0.0f, 0.0f, 1.0f); float p = glm::roll(q); Error += glm::epsilonEqual(p, glm::pi() * 0.5f, 0.0001f) ? 0 : 1; } { glm::quat q(1.0f, 0.0f, 0.0f, 1.0f); float p = glm::pitch(q); Error += glm::epsilonEqual(p, 0.f, 0.0001f) ? 0 : 1; } { glm::quat q(1.0f, 0.0f, 0.0f, 1.0f); float p = glm::yaw(q); Error += glm::epsilonEqual(p, 0.f, 0.0001f) ? 0 : 1; } return Error; } int test_rotation() { int Error(0); glm::vec3 v(1, 0, 0); glm::vec3 u(0, 1, 0); glm::quat Rotation = glm::rotation(v, u); float Angle = glm::angle(Rotation); Error += glm::abs(Angle - glm::pi() * 0.5f) < glm::epsilon() ? 0 : 1; return Error; } int test_log() { int Error(0); glm::quat q; glm::quat p = glm::log(q); glm::quat r = glm::exp(p); return Error; } int test_quat_lookAt() { int Error(0); glm::vec3 eye(0.0f); glm::vec3 center(1.1f, -2.0f, 3.1416f); glm::vec3 up(-0.17f, 7.23f, -1.744f); glm::quat test_quat = glm::quatLookAt(glm::normalize(center - eye), up); glm::quat test_mat = glm::conjugate(glm::quat_cast(glm::lookAt(eye, center, up))); Error += static_cast(glm::abs(glm::length(test_quat) - 1.0f) > glm::epsilon()); Error += static_cast(glm::min(glm::length(test_quat + (-test_mat)), glm::length(test_quat + test_mat)) > glm::epsilon()); return Error; } int main() { int Error = 0; Error += test_log(); Error += test_rotation(); Error += test_orientation(); Error += test_quat_fastMix(); Error += test_quat_shortMix(); Error += test_quat_lookAt(); return Error; } glm-0.9.9-a2/test/gtx/gtx_exterior_product.cpp0000600000175000001440000000042213173131001020236 0ustar guususers#include #include #include int main() { int Error = 0; float const f = glm::cross(glm::vec2(1.0f, 1.0f), glm::vec2(1.0f, 1.0f)); Error += glm::epsilonEqual(f, 0.0f, 0.001f) ? 0 : 1; return Error; } glm-0.9.9-a2/test/gtx/gtx_simd_vec4.cpp0000600000175000001440000000473413173131001016524 0ustar guususers/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @file test/gtx/gtx_simd_vec4.cpp /// @date 2010-09-16 / 2014-11-25 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #include #include #include #if(GLM_ARCH != GLM_ARCH_PURE) int main() { glm::simdVec4 A1(0.0f, 0.1f, 0.2f, 0.3f); glm::simdVec4 B1(0.4f, 0.5f, 0.6f, 0.7f); glm::simdVec4 C1 = A1 + B1; glm::simdVec4 D1 = A1.swizzle(); glm::simdVec4 E1(glm::vec4(1.0f)); glm::vec4 F1 = glm::vec4_cast(E1); //glm::vec4 G1(E1); //printf("A1(%2.3f, %2.3f, %2.3f, %2.3f)\n", A1.x, A1.y, A1.z, A1.w); //printf("B1(%2.3f, %2.3f, %2.3f, %2.3f)\n", B1.x, B1.y, B1.z, B1.w); //printf("C1(%2.3f, %2.3f, %2.3f, %2.3f)\n", C1.x, C1.y, C1.z, C1.w); //printf("D1(%2.3f, %2.3f, %2.3f, %2.3f)\n", D1.x, D1.y, D1.z, D1.w); __m128 value = _mm_set1_ps(0.0f); __m128 data = _mm_cmpeq_ps(value, value); __m128 add0 = _mm_add_ps(data, data); glm::simdVec4 GNI(add0); return 0; } #else int main() { int Error = 0; return Error; } #endif//(GLM_ARCH != GLM_ARCH_PURE) glm-0.9.9-a2/test/gtx/gtx_matrix_operation.cpp0000600000175000001440000000016713173131001020227 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_rotate_normalized_axis.cpp0000600000175000001440000000017513173131001021410 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_perpendicular.cpp0000600000175000001440000000016413173131001017475 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_associated_min_max.cpp0000600000175000001440000000023713173131001020470 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_matrix_interpolation.cpp0000600000175000001440000000211413173131001021110 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include int test_axisAngle() { int Error = 0; glm::mat4 m1(-0.9946f, 0.0f, -0.104531f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.104531f, 0.0f, -0.9946f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); glm::mat4 m2(-0.992624f, 0.0f, -0.121874f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.121874f, 0.0f, -0.992624f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); glm::mat4 const m1rot = glm::extractMatrixRotation(m1); glm::mat4 const dltRotation = m2 * glm::transpose(m1rot); glm::vec3 dltAxis(0.0f); float dltAngle = 0.0f; glm::axisAngle(dltRotation, dltAxis, dltAngle); std::cout << "dltAngle: (" << dltAxis.x << ", " << dltAxis.y << ", " << dltAxis.z << "), dltAngle: " << dltAngle << std::endl; glm::fquat q = glm::quat_cast(dltRotation); std::cout << "q: (" << q.x << ", " << q.y << ", " << q.z << ", " << q.w << ")" << std::endl; float yaw = glm::yaw(q); std::cout << "Yaw: " << yaw << std::endl; return Error; } int main() { int Error = 0; Error += test_axisAngle(); return Error; } glm-0.9.9-a2/test/gtx/gtx_int_10_10_10_2.cpp0000600000175000001440000000121013173131001016744 0ustar guususers/////////////////////////////////////////////////////////////////////////////////////////////////// // OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /////////////////////////////////////////////////////////////////////////////////////////////////// // Created : 2013-10-25 // Updated : 2013-10-25 // Licence : This source is under MIT licence // File : test/gtx/associated_min_max.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// #include #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_closest_point.cpp0000600000175000001440000000016413173131001017525 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_fast_square_root.cpp0000600000175000001440000000320413173131001020216 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include int test_fastInverseSqrt() { int Error(0); Error += glm::epsilonEqual(glm::fastInverseSqrt(1.0f), 1.0f, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(glm::fastInverseSqrt(1.0), 1.0, 0.01) ? 0 : 1; Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::vec2(1.0f)), glm::vec2(1.0f), 0.01f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::dvec3(1.0)), glm::dvec3(1.0), 0.01)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::dvec4(1.0)), glm::dvec4(1.0), 0.01)) ? 0 : 1; return 0; } int test_fastDistance() { int Error(0); glm::mediump_f32 A = glm::fastDistance(glm::mediump_f32(0.0f), glm::mediump_f32(1.0f)); glm::mediump_f32 B = glm::fastDistance(glm::mediump_f32vec2(0.0f), glm::mediump_f32vec2(1.0f, 0.0f)); glm::mediump_f32 C = glm::fastDistance(glm::mediump_f32vec3(0.0f), glm::mediump_f32vec3(1.0f, 0.0f, 0.0f)); glm::mediump_f32 D = glm::fastDistance(glm::mediump_f32vec4(0.0f), glm::mediump_f32vec4(1.0f, 0.0f, 0.0f, 0.0f)); Error += glm::epsilonEqual(A, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1; Error += glm::epsilonEqual(B, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1; Error += glm::epsilonEqual(C, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1; Error += glm::epsilonEqual(D, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1; return Error; } int main() { int Error(0); Error += test_fastInverseSqrt(); Error += test_fastDistance(); return Error; } glm-0.9.9-a2/test/gtx/gtx_component_wise.cpp0000600000175000001440000000574113173131001017677 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include #include namespace compNormalize { int run() { int Error(0); { glm::vec4 const A = glm::compNormalize(glm::u8vec4(0, 127, 128, 255)); Error += glm::epsilonEqual(A.x, 0.0f, glm::epsilon()) ? 0 : 1; Error += A.y < 0.5f ? 0 : 1; Error += A.z > 0.5f ? 0 : 1; Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon()) ? 0 : 1; } { glm::vec4 const A = glm::compNormalize(glm::i8vec4(-128, -1, 0, 127)); Error += glm::epsilonEqual(A.x,-1.0f, glm::epsilon()) ? 0 : 1; Error += A.y < 0.0f ? 0 : 1; Error += A.z > 0.0f ? 0 : 1; Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon()) ? 0 : 1; } { glm::vec4 const A = glm::compNormalize(glm::u16vec4( std::numeric_limits::min(), (std::numeric_limits::max() >> 1) + 0, (std::numeric_limits::max() >> 1) + 1, std::numeric_limits::max())); Error += glm::epsilonEqual(A.x, 0.0f, glm::epsilon()) ? 0 : 1; Error += A.y < 0.5f ? 0 : 1; Error += A.z > 0.5f ? 0 : 1; Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon()) ? 0 : 1; } { glm::vec4 const A = glm::compNormalize(glm::i16vec4( std::numeric_limits::min(), static_cast(-1), static_cast(0), std::numeric_limits::max())); Error += glm::epsilonEqual(A.x,-1.0f, glm::epsilon()) ? 0 : 1; Error += A.y < 0.0f ? 0 : 1; Error += A.z > 0.0f ? 0 : 1; Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon()) ? 0 : 1; } return Error; } }//namespace compNormalize namespace compScale { int run() { int Error(0); { glm::u8vec4 const A = glm::compScale(glm::vec4(0.0f, 0.2f, 0.5f, 1.0f)); Error += A.x == std::numeric_limits::min() ? 0 : 1; Error += A.y < (std::numeric_limits::max() >> 2) ? 0 : 1; Error += A.z == 127 ? 0 : 1; Error += A.w == 255 ? 0 : 1; } { glm::i8vec4 const A = glm::compScale(glm::vec4(0.0f,-1.0f, 0.5f, 1.0f)); Error += A.x == 0 ? 0 : 1; Error += A.y == -128 ? 0 : 1; Error += A.z == 63 ? 0 : 1; Error += A.w == 127 ? 0 : 1; } { glm::u16vec4 const A = glm::compScale(glm::vec4(0.0f, 0.2f, 0.5f, 1.0f)); Error += A.x == std::numeric_limits::min() ? 0 : 1; Error += A.y < (std::numeric_limits::max() >> 2) ? 0 : 1; Error += A.z == 32767 ? 0 : 1; Error += A.w == 65535 ? 0 : 1; } { glm::i16vec4 const A = glm::compScale(glm::vec4(0.0f,-1.0f, 0.5f, 1.0f)); Error += A.x == 0 ? 0 : 1; Error += A.y == -32768 ? 0 : 1; Error += A.z == 16383 ? 0 : 1; Error += A.w == 32767 ? 0 : 1; } return Error; } }// compScale int main() { int Error(0); Error += compNormalize::run(); Error += compScale::run(); return Error; } glm-0.9.9-a2/test/gtx/gtx_projection.cpp0000600000175000001440000000016113173131001017011 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_integer.cpp0000600000175000001440000000366313173131001016304 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include /* int test_floor_log2() { int Error = 0; for(std::size_t i = 1; i < 1000000; ++i) { glm::uint A = glm::floor_log2(glm::uint(i)); glm::uint B = glm::uint(glm::floor(glm::log2(double(i)))); // Will fail with float, lack of accuracy Error += A == B ? 0 : 1; assert(!Error); } return Error; } */ int test_log2() { int Error = 0; for(std::size_t i = 1; i < 24; ++i) { glm::uint A = glm::log2(glm::uint(1 << i)); glm::uint B = glm::uint(glm::log2(double(1 << i))); //Error += glm::equalEpsilon(double(A), B, 1.0) ? 0 : 1; Error += glm::abs(double(A) - B) <= 24 ? 0 : 1; assert(!Error); printf("Log2(%d) error A=%d, B=%d\n", 1 << i, A, B); } printf("log2 error=%d\n", Error); return Error; } int test_nlz() { int Error = 0; for(glm::uint i = 1; i < glm::uint(33); ++i) Error += glm::nlz(i) == glm::uint(31u) - glm::findMSB(i) ? 0 : 1; //printf("%d, %d\n", glm::nlz(i), 31u - glm::findMSB(i)); return Error; } int test_pow_uint() { int Error = 0; glm::uint const p0 = glm::pow(2u, 0u); Error += p0 == 1u ? 0 : 1; glm::uint const p1 = glm::pow(2u, 1u); Error += p1 == 2u ? 0 : 1; glm::uint const p2 = glm::pow(2u, 2u); Error += p2 == 4u ? 0 : 1; return Error; } int test_pow_int() { int Error = 0; int const p0 = glm::pow(2, 0u); Error += p0 == 1 ? 0 : 1; int const p1 = glm::pow(2, 1u); Error += p1 == 2 ? 0 : 1; int const p2 = glm::pow(2, 2u); Error += p2 == 4 ? 0 : 1; int const p0n = glm::pow(-2, 0u); Error += p0n == -1 ? 0 : 1; int const p1n = glm::pow(-2, 1u); Error += p1n == -2 ? 0 : 1; int const p2n = glm::pow(-2, 2u); Error += p2n == 4 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_nlz(); // Error += test_floor_log2(); Error += test_log2(); Error += test_pow_uint(); Error += test_pow_int(); return Error; } glm-0.9.9-a2/test/gtx/gtx_fast_trigonometry.cpp0000600000175000001440000004206513173131001020425 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include #include #include #include #include #include #include #include #include namespace fastCos { int perf(bool NextFloat) { const float begin = -glm::pi(); const float end = glm::pi(); float result = 0.f; const std::clock_t timestamp1 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::fastCos(i); const std::clock_t timestamp2 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::cos(i); const std::clock_t timestamp3 = std::clock(); const std::clock_t time_fast = timestamp2 - timestamp1; const std::clock_t time_default = timestamp3 - timestamp2; std::printf("fastCos Time %d clocks\n", static_cast(time_fast)); std::printf("cos Time %d clocks\n", static_cast(time_default)); return time_fast <= time_default ? 0 : 1; } }//namespace fastCos namespace fastSin { /* float sin(float x) { float temp; temp = (x + M_PI) / ((2 * M_PI) - M_PI); return limited_sin((x + M_PI) - ((2 * M_PI) - M_PI) * temp)); } */ int perf(bool NextFloat) { const float begin = -glm::pi(); const float end = glm::pi(); float result = 0.f; const std::clock_t timestamp1 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::fastSin(i); const std::clock_t timestamp2 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::sin(i); const std::clock_t timestamp3 = std::clock(); const std::clock_t time_fast = timestamp2 - timestamp1; const std::clock_t time_default = timestamp3 - timestamp2; std::printf("fastSin Time %d clocks\n", static_cast(time_fast)); std::printf("sin Time %d clocks\n", static_cast(time_default)); return time_fast <= time_default ? 0 : 1; } }//namespace fastSin namespace fastTan { int perf(bool NextFloat) { const float begin = -glm::pi(); const float end = glm::pi(); float result = 0.f; const std::clock_t timestamp1 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::fastTan(i); const std::clock_t timestamp2 = std::clock(); for (float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::tan(i); const std::clock_t timestamp3 = std::clock(); const std::clock_t time_fast = timestamp2 - timestamp1; const std::clock_t time_default = timestamp3 - timestamp2; std::printf("fastTan Time %d clocks\n", static_cast(time_fast)); std::printf("tan Time %d clocks\n", static_cast(time_default)); return time_fast <= time_default ? 0 : 1; } }//namespace fastTan namespace fastAcos { int perf(bool NextFloat) { const float begin = -glm::pi(); const float end = glm::pi(); float result = 0.f; const std::clock_t timestamp1 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::fastAcos(i); const std::clock_t timestamp2 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::acos(i); const std::clock_t timestamp3 = std::clock(); const std::clock_t time_fast = timestamp2 - timestamp1; const std::clock_t time_default = timestamp3 - timestamp2; std::printf("fastAcos Time %d clocks\n", static_cast(time_fast)); std::printf("acos Time %d clocks\n", static_cast(time_default)); return time_fast <= time_default ? 0 : 1; } }//namespace fastAcos namespace fastAsin { int perf(bool NextFloat) { const float begin = -glm::pi(); const float end = glm::pi(); float result = 0.f; const std::clock_t timestamp1 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::fastAsin(i); const std::clock_t timestamp2 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::asin(i); const std::clock_t timestamp3 = std::clock(); const std::clock_t time_fast = timestamp2 - timestamp1; const std::clock_t time_default = timestamp3 - timestamp2; std::printf("fastAsin Time %d clocks\n", static_cast(time_fast)); std::printf("asin Time %d clocks\n", static_cast(time_default)); return time_fast <= time_default ? 0 : 1; } }//namespace fastAsin namespace fastAtan { int perf(bool NextFloat) { const float begin = -glm::pi(); const float end = glm::pi(); float result = 0.f; const std::clock_t timestamp1 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::fastAtan(i); const std::clock_t timestamp2 = std::clock(); for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f) result = glm::atan(i); const std::clock_t timestamp3 = std::clock(); const std::clock_t time_fast = timestamp2 - timestamp1; const std::clock_t time_default = timestamp3 - timestamp2; std::printf("fastAtan Time %d clocks\n", static_cast(time_fast)); std::printf("atan Time %d clocks\n", static_cast(time_default)); return time_fast <= time_default ? 0 : 1; } }//namespace fastAtan namespace taylorCos { using glm::qualifier; using glm::length_t; glm::vec4 const AngleShift(0.0f, glm::half_pi(), glm::pi(), glm::three_over_two_pi()); template GLM_FUNC_QUALIFIER glm::vec taylorSeriesNewCos(glm::vec const& x) { glm::vec const Powed2(x * x); glm::vec const Powed4(Powed2 * Powed2); glm::vec const Powed6(Powed4 * Powed2); glm::vec const Powed8(Powed4 * Powed4); return static_cast(1) - Powed2 * static_cast(0.5) + Powed4 * static_cast(0.04166666666666666666666666666667) - Powed6 * static_cast(0.00138888888888888888888888888889) + Powed8 * static_cast(2.4801587301587301587301587301587e-5); } template GLM_FUNC_QUALIFIER glm::vec taylorSeriesNewCos6(glm::vec const& x) { glm::vec const Powed2(x * x); glm::vec const Powed4(Powed2 * Powed2); glm::vec const Powed6(Powed4 * Powed2); return static_cast(1) - Powed2 * static_cast(0.5) + Powed4 * static_cast(0.04166666666666666666666666666667) - Powed6 * static_cast(0.00138888888888888888888888888889); } template GLM_FUNC_QUALIFIER glm::vec fastAbs(glm::vec x) { int* Pointer = reinterpret_cast(&x[0]); Pointer[0] &= 0x7fffffff; Pointer[1] &= 0x7fffffff; Pointer[2] &= 0x7fffffff; Pointer[3] &= 0x7fffffff; return x; } template GLM_FUNC_QUALIFIER glm::vec fastCosNew(glm::vec const& x) { glm::vec const Angle0_PI(fastAbs(fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); return taylorSeriesNewCos6(x); /* vec const FirstQuarterPi(lessThanEqual(Angle0_PI, vec(glm::half_pi()))); vec const RevertAngle(mix(vec(glm::pi()), vec(0), FirstQuarterPi)); vec const ReturnSign(mix(vec(-1), vec(1), FirstQuarterPi)); vec const SectionAngle(RevertAngle - Angle0_PI); return ReturnSign * taylorSeriesNewCos(SectionAngle); */ } int perf_fastCosNew(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = fastCosNew(AngleShift + glm::vec4(Begin + Steps * i)); std::clock_t const TimeStampEnd = std::clock(); std::printf("fastCosNew %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1; return Error; } template GLM_FUNC_QUALIFIER glm::vec deterministic_fmod(glm::vec const& x, T y) { return x - y * trunc(x / y); } template GLM_FUNC_QUALIFIER glm::vec fastCosDeterminisctic(glm::vec const& x) { glm::vec const Angle0_PI(abs(deterministic_fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); glm::vec const FirstQuarterPi(lessThanEqual(Angle0_PI, glm::vec(glm::half_pi()))); glm::vec const RevertAngle(mix(glm::vec(glm::pi()), glm::vec(0), FirstQuarterPi)); glm::vec const ReturnSign(mix(glm::vec(-1), glm::vec(1), FirstQuarterPi)); glm::vec const SectionAngle(RevertAngle - Angle0_PI); return ReturnSign * taylorSeriesNewCos(SectionAngle); } int perf_fastCosDeterminisctic(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = taylorCos::fastCosDeterminisctic(AngleShift + glm::vec4(Begin + Steps * i)); std::clock_t const TimeStampEnd = std::clock(); std::printf("fastCosDeterminisctic %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1; return Error; } template GLM_FUNC_QUALIFIER glm::vec taylorSeriesRefCos(glm::vec const& x) { return static_cast(1) - (x * x) / glm::factorial(static_cast(2)) + (x * x * x * x) / glm::factorial(static_cast(4)) - (x * x * x * x * x * x) / glm::factorial(static_cast(6)) + (x * x * x * x * x * x * x * x) / glm::factorial(static_cast(8)); } template GLM_FUNC_QUALIFIER glm::vec fastRefCos(glm::vec const& x) { glm::vec const Angle0_PI(glm::abs(fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); // return taylorSeriesRefCos(Angle0_PI); glm::vec const FirstQuarterPi(lessThanEqual(Angle0_PI, glm::vec(glm::half_pi()))); glm::vec const RevertAngle(mix(glm::vec(glm::pi()), glm::vec(0), FirstQuarterPi)); glm::vec const ReturnSign(mix(glm::vec(-1), glm::vec(1), FirstQuarterPi)); glm::vec const SectionAngle(RevertAngle - Angle0_PI); return ReturnSign * taylorSeriesRefCos(SectionAngle); } int perf_fastCosRef(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = taylorCos::fastRefCos(AngleShift + glm::vec4(Begin + Steps * i)); std::clock_t const TimeStampEnd = std::clock(); std::printf("fastCosRef %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1; return Error; } int perf_fastCosOld(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = glm::fastCos(AngleShift + glm::vec4(Begin + Steps * i)); std::clock_t const TimeStampEnd = std::clock(); std::printf("fastCosOld %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1; return Error; } int perf_cos(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = glm::cos(AngleShift + glm::vec4(Begin + Steps * i)); std::clock_t const TimeStampEnd = std::clock(); std::printf("cos %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1; return Error; } int perf(std::size_t const Samples) { int Error = 0; float const Begin = -glm::pi(); float const End = glm::pi(); Error += perf_cos(Begin, End, Samples); Error += perf_fastCosOld(Begin, End, Samples); Error += perf_fastCosRef(Begin, End, Samples); //Error += perf_fastCosNew(Begin, End, Samples); Error += perf_fastCosDeterminisctic(Begin, End, Samples); return Error; } int test() { int Error = 0; //for(float Angle = -4.0f * glm::pi(); Angle < 4.0f * glm::pi(); Angle += 0.1f) //for(float Angle = -720.0f; Angle < 720.0f; Angle += 0.1f) for(float Angle = 0.0f; Angle < 180.0f; Angle += 0.1f) { float const modAngle = std::fmod(glm::abs(Angle), 360.f); assert(modAngle >= 0.0f && modAngle <= 360.f); float const radAngle = glm::radians(modAngle); float const Cos0 = std::cos(radAngle); float const Cos1 = taylorCos::fastRefCos(glm::fvec1(radAngle)).x; Error += glm::abs(Cos1 - Cos0) < 0.1f ? 0 : 1; //float const Cos2 = taylorCos::fastCosNew(glm::fvec1(radAngle)).x; //Error += glm::abs(Cos2 - Cos0) < 0.1f ? 0 : 1; assert(!Error); } return Error; } }//namespace taylorCos namespace taylor2 { glm::vec4 const AngleShift(0.0f, glm::pi() * 0.5f, glm::pi() * 1.0f, glm::pi() * 1.5f); float taylorCosA(float x) { return 1.f - (x * x) * (1.f / 2.f) + (x * x * x * x) * (1.f / 24.f) - (x * x * x * x * x * x) * (1.f / 720.f) + (x * x * x * x * x * x * x * x) * (1.f / 40320.f); } float taylorCosB(float x) { return 1.f - (x * x) * (1.f / 2.f) + (x * x * x * x) * (1.f / 24.f) - (x * x * x * x * x * x) * (1.f / 720.f) + (x * x * x * x * x * x * x * x) * (1.f / 40320.f); } float taylorCosC(float x) { return 1.f - (x * x) * (1.f / 2.f) + ((x * x) * (x * x)) * (1.f / 24.f) - (((x * x) * (x * x)) * (x * x)) * (1.f / 720.f) + (((x * x) * (x * x)) * ((x * x) * (x * x))) * (1.f / 40320.f); } int perf_taylorCosA(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = taylorCosA(AngleShift.x + Begin + Steps * i); std::clock_t const TimeStampEnd = std::clock(); std::printf("taylorCosA %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i] >= -1.0f && Results[i] <= 1.0f ? 0 : 1; return Error; } int perf_taylorCosB(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = taylorCosB(AngleShift.x + Begin + Steps * i); std::clock_t const TimeStampEnd = std::clock(); std::printf("taylorCosB %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i] >= -1.0f && Results[i] <= 1.0f ? 0 : 1; return Error; } int perf_taylorCosC(float Begin, float End, std::size_t Samples) { std::vector Results; Results.resize(Samples); float Steps = (End - Begin) / Samples; std::clock_t const TimeStampBegin = std::clock(); for(std::size_t i = 0; i < Samples; ++i) Results[i] = taylorCosC(AngleShift.x + Begin + Steps * i); std::clock_t const TimeStampEnd = std::clock(); std::printf("taylorCosC %ld clocks\n", TimeStampEnd - TimeStampBegin); int Error = 0; for(std::size_t i = 0; i < Samples; ++i) Error += Results[i] >= -1.0f && Results[i] <= 1.0f ? 0 : 1; return Error; } int perf(std::size_t Samples) { int Error = 0; float const Begin = -glm::pi(); float const End = glm::pi(); Error += perf_taylorCosA(Begin, End, Samples); Error += perf_taylorCosB(Begin, End, Samples); Error += perf_taylorCosC(Begin, End, Samples); return Error; } }//namespace taylor2 int main() { int Error(0); Error += ::taylor2::perf(1000); Error += ::taylorCos::test(); Error += ::taylorCos::perf(1000); # ifdef NDEBUG ::fastCos::perf(false); ::fastSin::perf(false); ::fastTan::perf(false); ::fastAcos::perf(false); ::fastAsin::perf(false); ::fastAtan::perf(false); # endif//NDEBUG return Error; } glm-0.9.9-a2/test/gtx/CMakeLists.txt0000600000175000001440000000371613173131001016020 0ustar guususersglmCreateTestGTC(gtx) glmCreateTestGTC(gtx_associated_min_max) glmCreateTestGTC(gtx_closest_point) glmCreateTestGTC(gtx_color_encoding) glmCreateTestGTC(gtx_color_space_YCoCg) glmCreateTestGTC(gtx_color_space) glmCreateTestGTC(gtx_common) glmCreateTestGTC(gtx_compatibility) glmCreateTestGTC(gtx_component_wise) glmCreateTestGTC(gtx_euler_angle) glmCreateTestGTC(gtx_extend) glmCreateTestGTC(gtx_extended_min_max) glmCreateTestGTC(gtx_exterior_product) glmCreateTestGTC(gtx_fast_exponential) glmCreateTestGTC(gtx_fast_square_root) glmCreateTestGTC(gtx_fast_trigonometry) glmCreateTestGTC(gtx_functions) glmCreateTestGTC(gtx_gradient_paint) glmCreateTestGTC(gtx_handed_coordinate_space) glmCreateTestGTC(gtx_integer) glmCreateTestGTC(gtx_intersect) glmCreateTestGTC(gtx_io) glmCreateTestGTC(gtx_log_base) glmCreateTestGTC(gtx_matrix_cross_product) glmCreateTestGTC(gtx_matrix_decompose) glmCreateTestGTC(gtx_matrix_factorisation) glmCreateTestGTC(gtx_matrix_interpolation) glmCreateTestGTC(gtx_matrix_major_storage) glmCreateTestGTC(gtx_matrix_operation) glmCreateTestGTC(gtx_matrix_query) glmCreateTestGTC(gtx_matrix_transform_2d) glmCreateTestGTC(gtx_norm) glmCreateTestGTC(gtx_normal) glmCreateTestGTC(gtx_normalize_dot) glmCreateTestGTC(gtx_number_precision) glmCreateTestGTC(gtx_orthonormalize) glmCreateTestGTC(gtx_optimum_pow) glmCreateTestGTC(gtx_perpendicular) glmCreateTestGTC(gtx_polar_coordinates) glmCreateTestGTC(gtx_projection) glmCreateTestGTC(gtx_quaternion) glmCreateTestGTC(gtx_dual_quaternion) glmCreateTestGTC(gtx_range) glmCreateTestGTC(gtx_rotate_normalized_axis) glmCreateTestGTC(gtx_rotate_vector) glmCreateTestGTC(gtx_scalar_multiplication) glmCreateTestGTC(gtx_scalar_relational) glmCreateTestGTC(gtx_spline) glmCreateTestGTC(gtx_string_cast) glmCreateTestGTC(gtx_texture) glmCreateTestGTC(gtx_type_aligned) glmCreateTestGTC(gtx_type_trait) glmCreateTestGTC(gtx_vec_swizzle) glmCreateTestGTC(gtx_vector_angle) glmCreateTestGTC(gtx_vector_query) glmCreateTestGTC(gtx_wrap) glm-0.9.9-a2/test/gtx/gtx_random.cpp0000600000175000001440000000541613173131001016125 0ustar guususers/////////////////////////////////////////////////////////////////////////////////////////////////// // OpenGL Mathematics Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) /////////////////////////////////////////////////////////////////////////////////////////////////// // Created : 2011-05-31 // Updated : 2011-05-31 // Licence : This source is under MIT licence // File : test/gtx/random.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// #include #include #include #include int test_signedRand1() { int Error = 0; { float ResultFloat = 0.0f; double ResultDouble = 0.0f; for(std::size_t i = 0; i < 100000; ++i) { ResultFloat += glm::signedRand1(); ResultDouble += glm::signedRand1(); } Error += glm::equalEpsilon(ResultFloat, 0.0f, 0.0001f); Error += glm::equalEpsilon(ResultDouble, 0.0, 0.0001); } return Error; } int test_normalizedRand2() { int Error = 0; { std::size_t Max = 100000; float ResultFloat = 0.0f; double ResultDouble = 0.0f; for(std::size_t i = 0; i < Max; ++i) { ResultFloat += glm::length(glm::normalizedRand2()); ResultDouble += glm::length(glm::normalizedRand2()); } Error += glm::equalEpsilon(ResultFloat, float(Max), 0.000001f) ? 0 : 1; Error += glm::equalEpsilon(ResultDouble, double(Max), 0.000001) ? 0 : 1; assert(!Error); } return Error; } int test_normalizedRand3() { int Error = 0; { std::size_t Max = 100000; float ResultFloatA = 0.0f; float ResultFloatB = 0.0f; float ResultFloatC = 0.0f; double ResultDoubleA = 0.0f; double ResultDoubleB = 0.0f; double ResultDoubleC = 0.0f; for(std::size_t i = 0; i < Max; ++i) { ResultFloatA += glm::length(glm::normalizedRand3()); ResultDoubleA += glm::length(glm::normalizedRand3()); ResultFloatB += glm::length(glm::normalizedRand3(2.0f, 2.0f)); ResultDoubleB += glm::length(glm::normalizedRand3(2.0, 2.0)); ResultFloatC += glm::length(glm::normalizedRand3(1.0f, 3.0f)); ResultDoubleC += glm::length(glm::normalizedRand3(1.0, 3.0)); } Error += glm::equalEpsilon(ResultFloatA, float(Max), 0.0001f) ? 0 : 1; Error += glm::equalEpsilon(ResultDoubleA, double(Max), 0.0001) ? 0 : 1; Error += glm::equalEpsilon(ResultFloatB, float(Max * 2), 0.0001f) ? 0 : 1; Error += glm::equalEpsilon(ResultDoubleB, double(Max * 2), 0.0001) ? 0 : 1; Error += (ResultFloatC >= float(Max) && ResultFloatC <= float(Max * 3)) ? 0 : 1; Error += (ResultDoubleC >= double(Max) && ResultDoubleC <= double(Max * 3)) ? 0 : 1; } return Error; } int main() { int Error = 0; Error += test_signedRand1(); Error += test_normalizedRand2(); Error += test_normalizedRand3(); return Error; } glm-0.9.9-a2/test/gtx/gtx_matrix_cross_product.cpp0000600000175000001440000000017313173131001021115 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_number_precision.cpp0000600000175000001440000000016713173131001020206 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_matrix_decompose.cpp0000600000175000001440000000051613173131001020203 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); glm::mat4 Matrix(1); glm::vec3 Scale; glm::quat Orientation; glm::vec3 Translation; glm::vec3 Skew(1); glm::vec4 Perspective(1); glm::decompose(Matrix, Scale, Orientation, Translation, Skew, Perspective); return Error; } glm-0.9.9-a2/test/gtx/gtx_vec_swizzle.cpp0000600000175000001440000000016513173131001017205 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/gtx/gtx_spline.cpp0000600000175000001440000000405313173131001016133 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include namespace catmullRom { int test() { int Error(0); glm::vec2 Result2 = glm::catmullRom( glm::vec2(0.0f, 0.0f), glm::vec2(1.0f, 0.0f), glm::vec2(1.0f, 1.0f), glm::vec2(0.0f, 1.0f), 0.5f); glm::vec3 Result3 = glm::catmullRom( glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), 0.5f); glm::vec4 Result4 = glm::catmullRom( glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::vec4(1.0f, 0.0f, 0.0f, 1.0f), glm::vec4(1.0f, 1.0f, 0.0f, 1.0f), glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f); return Error; } }//catmullRom namespace hermite { int test() { int Error(0); glm::vec2 Result2 = glm::hermite( glm::vec2(0.0f, 0.0f), glm::vec2(1.0f, 0.0f), glm::vec2(1.0f, 1.0f), glm::vec2(0.0f, 1.0f), 0.5f); glm::vec3 Result3 = glm::hermite( glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), 0.5f); glm::vec4 Result4 = glm::hermite( glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::vec4(1.0f, 0.0f, 0.0f, 1.0f), glm::vec4(1.0f, 1.0f, 0.0f, 1.0f), glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f); return Error; } }//catmullRom namespace cubic { int test() { int Error(0); glm::vec2 Result2 = glm::cubic( glm::vec2(0.0f, 0.0f), glm::vec2(1.0f, 0.0f), glm::vec2(1.0f, 1.0f), glm::vec2(0.0f, 1.0f), 0.5f); glm::vec3 Result3 = glm::cubic( glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), 0.5f); glm::vec4 Result = glm::cubic( glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::vec4(1.0f, 0.0f, 0.0f, 1.0f), glm::vec4(1.0f, 1.0f, 0.0f, 1.0f), glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f); return Error; } }//catmullRom int main() { int Error(0); Error += catmullRom::test(); Error += hermite::test(); Error += cubic::test(); return Error; } glm-0.9.9-a2/test/gtx/gtx_rotate_vector.cpp0000600000175000001440000000356213173131001017525 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include int test_rotate() { int Error = 0; glm::vec2 A = glm::rotate(glm::vec2(1, 0), glm::pi() * 0.5f); glm::vec3 B = glm::rotate(glm::vec3(1, 0, 0), glm::pi() * 0.5f, glm::vec3(0, 0, 1)); glm::vec4 C = glm::rotate(glm::vec4(1, 0, 0, 1), glm::pi() * 0.5f, glm::vec3(0, 0, 1)); glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi() * 0.5f); glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi() * 0.5f); glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi() * 0.5f); glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi() * 0.5f); glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi() * 0.5f); glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi() * 0.5f); glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1)); return Error; } int test_rotateX() { int Error = 0; glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi() * 0.5f); glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi() * 0.5f); return Error; } int test_rotateY() { int Error = 0; glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi() * 0.5f); glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi() * 0.5f); return Error; } int test_rotateZ() { int Error = 0; glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi() * 0.5f); glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi() * 0.5f); return Error; } int test_orientation() { int Error = 0; glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1)); return Error; } int main() { int Error = 0; Error += test_rotate(); Error += test_rotateX(); Error += test_rotateY(); Error += test_rotateZ(); Error += test_orientation(); return Error; } glm-0.9.9-a2/test/gtx/gtx_normalize_dot.cpp0000600000175000001440000000016413173131001017506 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_extented_min_max.cpp0000600000175000001440000000323013173131001020165 0ustar guususers/////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// /// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Restrictions: /// By making use of the Software for military purposes, you choose to make /// a Bunny unhappy. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// /// @file test/gtx/gtx_extented_min_max.cpp /// @date 2013-10-25 / 2014-11-25 /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// #include int main() { int Error(0); return Error; } glm-0.9.9-a2/test/gtx/gtx_log_base.cpp0000600000175000001440000000230113173131001016406 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include #include namespace test_log { int run() { int Error = 0; { float A = glm::log(10.f, 2.0f); float B = glm::log2(10.f); Error += glm::epsilonEqual(A, B, 0.00001f) ? 0 : 1; } { glm::vec1 A = glm::log(glm::vec1(10.f), glm::vec1(2.0f)); glm::vec1 B = glm::log2(glm::vec1(10.f)); Error += glm::all(glm::epsilonEqual(A, B, glm::vec1(0.00001f))) ? 0 : 1; } { glm::vec2 A = glm::log(glm::vec2(10.f), glm::vec2(2.0f)); glm::vec2 B = glm::log2(glm::vec2(10.f)); Error += glm::all(glm::epsilonEqual(A, B, glm::vec2(0.00001f))) ? 0 : 1; } { glm::vec3 A = glm::log(glm::vec3(10.f), glm::vec3(2.0f)); glm::vec3 B = glm::log2(glm::vec3(10.f)); Error += glm::all(glm::epsilonEqual(A, B, glm::vec3(0.00001f))) ? 0 : 1; } { glm::vec4 A = glm::log(glm::vec4(10.f), glm::vec4(2.0f)); glm::vec4 B = glm::log2(glm::vec4(10.f)); Error += glm::all(glm::epsilonEqual(A, B, glm::vec4(0.00001f))) ? 0 : 1; } return Error; } }//namespace test_log int main() { int Error(0); Error += test_log::run(); return Error; } glm-0.9.9-a2/test/gtc/0000700000175000001440000000000013173131001013222 5ustar guususersglm-0.9.9-a2/test/gtc/gtc_constants.cpp0000600000175000001440000000067713173131001016613 0ustar guususers#include int test_epsilon() { int Error = 0; { float Test = glm::epsilon(); Error += Test > 0.0f ? 0 : 1; } { double Test = glm::epsilon(); Error += Test > 0.0 ? 0 : 1; } return Error; } int main() { int Error(0); //float MinHalf = 0.0f; //while (glm::half(MinHalf) == glm::half(0.0f)) // MinHalf += std::numeric_limits::epsilon(); Error += test_epsilon(); return Error; } glm-0.9.9-a2/test/gtc/gtc_random.cpp0000600000175000001440000002306113173131001016047 0ustar guususers#include #include #if GLM_LANG & GLM_LANG_CXX0X_FLAG # include #endif std::size_t const TestSamples = 10000; int test_linearRand() { int Error = 0; glm::int32 const Min = 16; glm::int32 const Max = 32; { glm::u8vec2 AMin(std::numeric_limits::max()); glm::u8vec2 AMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::u8vec2 A = glm::linearRand(glm::u8vec2(Min), glm::u8vec2(Max)); AMin = glm::min(AMin, A); AMax = glm::max(AMax, A); if(!glm::all(glm::lessThanEqual(A, glm::u8vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(A, glm::u8vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(AMin, glm::u8vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(AMax, glm::u8vec2(Max))) ? 0 : 1; assert(!Error); } glm::u16vec2 BMin(std::numeric_limits::max()); glm::u16vec2 BMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::u16vec2 B = glm::linearRand(glm::u16vec2(Min), glm::u16vec2(Max)); BMin = glm::min(BMin, B); BMax = glm::max(BMax, B); if(!glm::all(glm::lessThanEqual(B, glm::u16vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(B, glm::u16vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(BMin, glm::u16vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(BMax, glm::u16vec2(Max))) ? 0 : 1; assert(!Error); } glm::u32vec2 CMin(std::numeric_limits::max()); glm::u32vec2 CMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::u32vec2 C = glm::linearRand(glm::u32vec2(Min), glm::u32vec2(Max)); CMin = glm::min(CMin, C); CMax = glm::max(CMax, C); if(!glm::all(glm::lessThanEqual(C, glm::u32vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(C, glm::u32vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(CMin, glm::u32vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(CMax, glm::u32vec2(Max))) ? 0 : 1; assert(!Error); } glm::u64vec2 DMin(std::numeric_limits::max()); glm::u64vec2 DMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::u64vec2 D = glm::linearRand(glm::u64vec2(Min), glm::u64vec2(Max)); DMin = glm::min(DMin, D); DMax = glm::max(DMax, D); if(!glm::all(glm::lessThanEqual(D, glm::u64vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(D, glm::u64vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(DMin, glm::u64vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(DMax, glm::u64vec2(Max))) ? 0 : 1; assert(!Error); } } { glm::i8vec2 AMin(std::numeric_limits::max()); glm::i8vec2 AMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::i8vec2 A = glm::linearRand(glm::i8vec2(Min), glm::i8vec2(Max)); AMin = glm::min(AMin, A); AMax = glm::max(AMax, A); if(!glm::all(glm::lessThanEqual(A, glm::i8vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(A, glm::i8vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(AMin, glm::i8vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(AMax, glm::i8vec2(Max))) ? 0 : 1; assert(!Error); } glm::i16vec2 BMin(std::numeric_limits::max()); glm::i16vec2 BMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::i16vec2 B = glm::linearRand(glm::i16vec2(Min), glm::i16vec2(Max)); BMin = glm::min(BMin, B); BMax = glm::max(BMax, B); if(!glm::all(glm::lessThanEqual(B, glm::i16vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(B, glm::i16vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(BMin, glm::i16vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(BMax, glm::i16vec2(Max))) ? 0 : 1; assert(!Error); } glm::i32vec2 CMin(std::numeric_limits::max()); glm::i32vec2 CMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::i32vec2 C = glm::linearRand(glm::i32vec2(Min), glm::i32vec2(Max)); CMin = glm::min(CMin, C); CMax = glm::max(CMax, C); if(!glm::all(glm::lessThanEqual(C, glm::i32vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(C, glm::i32vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(CMin, glm::i32vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(CMax, glm::i32vec2(Max))) ? 0 : 1; assert(!Error); } glm::i64vec2 DMin(std::numeric_limits::max()); glm::i64vec2 DMax(std::numeric_limits::min()); { for(std::size_t i = 0; i < TestSamples; ++i) { glm::i64vec2 D = glm::linearRand(glm::i64vec2(Min), glm::i64vec2(Max)); DMin = glm::min(DMin, D); DMax = glm::max(DMax, D); if(!glm::all(glm::lessThanEqual(D, glm::i64vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(D, glm::i64vec2(Min)))) ++Error; assert(!Error); } Error += glm::all(glm::equal(DMin, glm::i64vec2(Min))) ? 0 : 1; Error += glm::all(glm::equal(DMax, glm::i64vec2(Max))) ? 0 : 1; assert(!Error); } } for(std::size_t i = 0; i < TestSamples; ++i) { glm::f32vec2 const A(glm::linearRand(glm::f32vec2(static_cast(Min)), glm::f32vec2(static_cast(Max)))); if(!glm::all(glm::lessThanEqual(A, glm::f32vec2(static_cast(Max))))) ++Error; if(!glm::all(glm::greaterThanEqual(A, glm::f32vec2(static_cast(Min))))) ++Error; glm::f64vec2 const B(glm::linearRand(glm::f64vec2(Min), glm::f64vec2(Max))); if(!glm::all(glm::lessThanEqual(B, glm::f64vec2(Max)))) ++Error; if(!glm::all(glm::greaterThanEqual(B, glm::f64vec2(Min)))) ++Error; assert(!Error); } { float ResultFloat = 0.0f; double ResultDouble = 0.0; for(std::size_t i = 0; i < TestSamples; ++i) { ResultFloat += glm::linearRand(-1.0f, 1.0f); ResultDouble += glm::linearRand(-1.0, 1.0); } Error += glm::epsilonEqual(ResultFloat, 0.0f, 0.0001f); Error += glm::epsilonEqual(ResultDouble, 0.0, 0.0001); assert(!Error); } return Error; } int test_circularRand() { int Error = 0; { std::size_t Max = TestSamples; float ResultFloat = 0.0f; double ResultDouble = 0.0; double Radius = 2.0; for(std::size_t i = 0; i < Max; ++i) { ResultFloat += glm::length(glm::circularRand(1.0f)); ResultDouble += glm::length(glm::circularRand(Radius)); } Error += glm::epsilonEqual(ResultFloat, float(Max), 0.01f) ? 0 : 1; Error += glm::epsilonEqual(ResultDouble, double(Max) * double(Radius), 0.01) ? 0 : 1; assert(!Error); } return Error; } int test_sphericalRand() { int Error = 0; { std::size_t Max = TestSamples; float ResultFloatA = 0.0f; float ResultFloatB = 0.0f; float ResultFloatC = 0.0f; double ResultDoubleA = 0.0; double ResultDoubleB = 0.0; double ResultDoubleC = 0.0; for(std::size_t i = 0; i < Max; ++i) { ResultFloatA += glm::length(glm::sphericalRand(1.0f)); ResultDoubleA += glm::length(glm::sphericalRand(1.0)); ResultFloatB += glm::length(glm::sphericalRand(2.0f)); ResultDoubleB += glm::length(glm::sphericalRand(2.0)); ResultFloatC += glm::length(glm::sphericalRand(3.0f)); ResultDoubleC += glm::length(glm::sphericalRand(3.0)); } Error += glm::epsilonEqual(ResultFloatA, float(Max), 0.01f) ? 0 : 1; Error += glm::epsilonEqual(ResultDoubleA, double(Max), 0.0001) ? 0 : 1; Error += glm::epsilonEqual(ResultFloatB, float(Max * 2), 0.01f) ? 0 : 1; Error += glm::epsilonEqual(ResultDoubleB, double(Max * 2), 0.0001) ? 0 : 1; Error += glm::epsilonEqual(ResultFloatC, float(Max * 3), 0.01f) ? 0 : 1; Error += glm::epsilonEqual(ResultDoubleC, double(Max * 3), 0.01) ? 0 : 1; assert(!Error); } return Error; } int test_diskRand() { int Error = 0; { float ResultFloat = 0.0f; double ResultDouble = 0.0; for(std::size_t i = 0; i < TestSamples; ++i) { ResultFloat += glm::length(glm::diskRand(2.0f)); ResultDouble += glm::length(glm::diskRand(2.0)); } Error += ResultFloat < float(TestSamples) * 2.f ? 0 : 1; Error += ResultDouble < double(TestSamples) * 2.0 ? 0 : 1; assert(!Error); } return Error; } int test_ballRand() { int Error = 0; { float ResultFloat = 0.0f; double ResultDouble = 0.0; for(std::size_t i = 0; i < TestSamples; ++i) { ResultFloat += glm::length(glm::ballRand(2.0f)); ResultDouble += glm::length(glm::ballRand(2.0)); } Error += ResultFloat < float(TestSamples) * 2.f ? 0 : 1; Error += ResultDouble < double(TestSamples) * 2.0 ? 0 : 1; assert(!Error); } return Error; } /* #if(GLM_LANG & GLM_LANG_CXX0X_FLAG) int test_grid() { int Error = 0; typedef std::array colors; typedef std::array grid; grid Grid; colors Colors; grid GridBest; colors ColorsBest; while(true) { for(std::size_t i = 0; i < Grid.size(); ++i) Grid[i] = int(glm::linearRand(0.0, 8.0 * 8.0 * 8.0 - 1.0) / 64.0); for(std::size_t i = 0; i < Grid.size(); ++i) ++Colors[Grid[i]]; bool Exit = true; for(std::size_t i = 0; i < Colors.size(); ++i) { if(Colors[i] == 8) continue; Exit = false; break; } if(Exit == true) break; } return Error; } #endif */ int main() { int Error = 0; Error += test_linearRand(); Error += test_circularRand(); Error += test_sphericalRand(); Error += test_diskRand(); Error += test_ballRand(); /* #if(GLM_LANG & GLM_LANG_CXX0X_FLAG) Error += test_grid(); #endif */ return Error; } glm-0.9.9-a2/test/gtc/gtc_packing.cpp0000600000175000001440000004432713173131001016213 0ustar guususers#include #include #include #include #include void print_bits(float const& s) { union { float f; unsigned int i; } uif; uif.f = s; printf("f32: "); for(std::size_t j = sizeof(s) * 8; j > 0; --j) { if(j == 23 || j == 31) printf(" "); printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0); } } void print_10bits(glm::uint const& s) { printf("10b: "); for(std::size_t j = 10; j > 0; --j) { if(j == 5) printf(" "); printf("%d", (s & (1 << (j - 1))) ? 1 : 0); } } void print_11bits(glm::uint const& s) { printf("11b: "); for(std::size_t j = 11; j > 0; --j) { if(j == 6) printf(" "); printf("%d", (s & (1 << (j - 1))) ? 1 : 0); } } void print_value(float const& s) { printf("%2.5f, ", static_cast(s)); print_bits(s); printf(", "); // print_11bits(detail::floatTo11bit(s)); // printf(", "); // print_10bits(detail::floatTo10bit(s)); printf("\n"); } int test_Half1x16() { int Error = 0; std::vector Tests; Tests.push_back(0.0f); Tests.push_back(1.0f); Tests.push_back(-1.0f); Tests.push_back(2.0f); Tests.push_back(-2.0f); Tests.push_back(1.9f); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint16 p0 = glm::packHalf1x16(Tests[i]); float v0 = glm::unpackHalf1x16(p0); glm::uint16 p1 = glm::packHalf1x16(v0); float v1 = glm::unpackHalf1x16(p1); Error += glm::epsilonEqual(v0, v1, glm::epsilon()) ? 0 : 1; } return Error; } int test_Half4x16() { int Error = 0; std::vector Tests; Tests.push_back(glm::vec4(1.0f)); Tests.push_back(glm::vec4(0.0f)); Tests.push_back(glm::vec4(2.0f)); Tests.push_back(glm::vec4(0.1f)); Tests.push_back(glm::vec4(0.5f)); Tests.push_back(glm::vec4(-0.9f)); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint64 p0 = glm::packHalf4x16(Tests[i]); glm::vec4 v0 = glm::unpackHalf4x16(p0); glm::uint64 p1 = glm::packHalf4x16(v0); glm::vec4 v1 = glm::unpackHalf4x16(p1); glm::u16vec4 p2 = glm::packHalf(v0); glm::vec4 v2 = glm::unpackHalf(p2); Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; Error += glm::all(glm::equal(v0, v2)) ? 0 : 1; } return Error; } int test_I3x10_1x2() { int Error = 0; std::vector Tests; Tests.push_back(glm::ivec4(0)); Tests.push_back(glm::ivec4(1)); Tests.push_back(glm::ivec4(-1)); Tests.push_back(glm::ivec4(2)); Tests.push_back(glm::ivec4(-2)); Tests.push_back(glm::ivec4(3)); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint32 p0 = glm::packI3x10_1x2(Tests[i]); glm::ivec4 v0 = glm::unpackI3x10_1x2(p0); glm::uint32 p1 = glm::packI3x10_1x2(v0); glm::ivec4 v1 = glm::unpackI3x10_1x2(p1); Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; } return Error; } int test_U3x10_1x2() { int Error = 0; std::vector Tests; Tests.push_back(glm::uvec4(0)); Tests.push_back(glm::uvec4(1)); Tests.push_back(glm::uvec4(2)); Tests.push_back(glm::uvec4(3)); Tests.push_back(glm::uvec4(4)); Tests.push_back(glm::uvec4(5)); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint32 p0 = glm::packU3x10_1x2(Tests[i]); glm::uvec4 v0 = glm::unpackU3x10_1x2(p0); glm::uint32 p1 = glm::packU3x10_1x2(v0); glm::uvec4 v1 = glm::unpackU3x10_1x2(p1); Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; } glm::u8vec4 const v0(0xff, 0x77, 0x0, 0x33); glm::uint32 const p0 = *reinterpret_cast(&v0[0]); glm::uint32 const r0 = 0x330077ff; Error += p0 == r0 ? 0 : 1; glm::uvec4 const v1(0xff, 0x77, 0x0, 0x33); glm::uint32 const p1 = glm::packU3x10_1x2(v1); glm::uint32 const r1 = 0xc001dcff; Error += p1 == r1 ? 0 : 1; return Error; } int test_Snorm3x10_1x2() { int Error = 0; std::vector Tests; Tests.push_back(glm::vec4(1.0f)); Tests.push_back(glm::vec4(0.0f)); Tests.push_back(glm::vec4(2.0f)); Tests.push_back(glm::vec4(0.1f)); Tests.push_back(glm::vec4(0.5f)); Tests.push_back(glm::vec4(0.9f)); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]); glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0); glm::uint32 p1 = glm::packSnorm3x10_1x2(v0); glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p1); Error += glm::all(glm::epsilonEqual(v0, v1, 0.01f)) ? 0 : 1; } return Error; } int test_Unorm3x10_1x2() { int Error = 0; std::vector Tests; Tests.push_back(glm::vec4(1.0f)); Tests.push_back(glm::vec4(0.0f)); Tests.push_back(glm::vec4(2.0f)); Tests.push_back(glm::vec4(0.1f)); Tests.push_back(glm::vec4(0.5f)); Tests.push_back(glm::vec4(0.9f)); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint32 p0 = glm::packUnorm3x10_1x2(Tests[i]); glm::vec4 v0 = glm::unpackUnorm3x10_1x2(p0); glm::uint32 p1 = glm::packUnorm3x10_1x2(v0); glm::vec4 v1 = glm::unpackUnorm3x10_1x2(p1); Error += glm::all(glm::epsilonEqual(v0, v1, 0.001f)) ? 0 : 1; } return Error; } int test_F2x11_1x10() { int Error = 0; std::vector Tests; Tests.push_back(glm::vec3(1.0f)); Tests.push_back(glm::vec3(0.0f)); Tests.push_back(glm::vec3(2.0f)); Tests.push_back(glm::vec3(0.1f)); Tests.push_back(glm::vec3(0.5f)); Tests.push_back(glm::vec3(0.9f)); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint32 p0 = glm::packF2x11_1x10(Tests[i]); glm::vec3 v0 = glm::unpackF2x11_1x10(p0); glm::uint32 p1 = glm::packF2x11_1x10(v0); glm::vec3 v1 = glm::unpackF2x11_1x10(p1); Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; } return Error; } int test_F3x9_E1x5() { int Error = 0; std::vector Tests; Tests.push_back(glm::vec3(1.0f)); Tests.push_back(glm::vec3(0.0f)); Tests.push_back(glm::vec3(2.0f)); Tests.push_back(glm::vec3(0.1f)); Tests.push_back(glm::vec3(0.5f)); Tests.push_back(glm::vec3(0.9f)); for(std::size_t i = 0; i < Tests.size(); ++i) { glm::uint32 p0 = glm::packF3x9_E1x5(Tests[i]); glm::vec3 v0 = glm::unpackF3x9_E1x5(p0); glm::uint32 p1 = glm::packF3x9_E1x5(v0); glm::vec3 v1 = glm::unpackF3x9_E1x5(p1); Error += glm::all(glm::epsilonEqual(v0, v1, 0.01f)) ? 0 : 1; } return Error; } int test_RGBM() { int Error = 0; for(std::size_t i = 0; i < 1024; ++i) { glm::vec3 const Color(static_cast(i)); glm::vec4 const RGBM = glm::packRGBM(Color); glm::vec3 const Result= glm::unpackRGBM(RGBM); Error += glm::all(glm::epsilonEqual(Color, Result, 0.01f)) ? 0 : 1; } return Error; } int test_packUnorm1x16() { int Error = 0; std::vector A; A.push_back(glm::vec1(1.0f)); A.push_back(glm::vec1(0.5f)); A.push_back(glm::vec1(0.1f)); A.push_back(glm::vec1(0.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec1 B(A[i]); glm::uint16 C = glm::packUnorm1x16(B.x); glm::vec1 D(glm::unpackUnorm1x16(C)); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm1x16() { int Error = 0; std::vector A; A.push_back(glm::vec1( 1.0f)); A.push_back(glm::vec1( 0.0f)); A.push_back(glm::vec1(-0.5f)); A.push_back(glm::vec1(-0.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec1 B(A[i]); glm::uint16 C = glm::packSnorm1x16(B.x); glm::vec1 D(glm::unpackSnorm1x16(C)); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1; } return Error; } int test_packUnorm2x16() { int Error = 0; std::vector A; A.push_back(glm::vec2(1.0f, 0.0f)); A.push_back(glm::vec2(0.5f, 0.7f)); A.push_back(glm::vec2(0.1f, 0.2f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint32 C = glm::packUnorm2x16(B); glm::vec2 D = glm::unpackUnorm2x16(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm2x16() { int Error = 0; std::vector A; A.push_back(glm::vec2( 1.0f, 0.0f)); A.push_back(glm::vec2(-0.5f,-0.7f)); A.push_back(glm::vec2(-0.1f, 0.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint32 C = glm::packSnorm2x16(B); glm::vec2 D = glm::unpackSnorm2x16(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm4x16() { int Error = 0; std::vector A; A.push_back(glm::vec4(1.0f)); A.push_back(glm::vec4(0.5f)); A.push_back(glm::vec4(0.1f)); A.push_back(glm::vec4(0.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint64 C = glm::packUnorm4x16(B); glm::vec4 D(glm::unpackUnorm4x16(C)); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm4x16() { int Error = 0; std::vector A; A.push_back(glm::vec4( 1.0f, 0.0f, -0.5f, 0.5f)); A.push_back(glm::vec4(-0.3f,-0.7f, 0.3f, 0.7f)); A.push_back(glm::vec4(-0.1f, 0.1f, -0.2f, 0.2f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint64 C = glm::packSnorm4x16(B); glm::vec4 D(glm::unpackSnorm4x16(C)); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm1x8() { int Error = 0; std::vector A; A.push_back(glm::vec1(1.0f)); A.push_back(glm::vec1(0.5f)); A.push_back(glm::vec1(0.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec1 B(A[i]); glm::uint8 C = glm::packUnorm1x8(B.x); glm::vec1 D(glm::unpackUnorm1x8(C)); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm1x8() { int Error = 0; std::vector A; A.push_back(glm::vec1( 1.0f)); A.push_back(glm::vec1(-0.7f)); A.push_back(glm::vec1(-1.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec1 B(A[i]); glm::uint8 C = glm::packSnorm1x8(B.x); glm::vec1 D(glm::unpackSnorm1x8(C)); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1; } return Error; } int test_packUnorm2x8() { int Error = 0; std::vector A; A.push_back(glm::vec2(1.0f, 0.7f)); A.push_back(glm::vec2(0.5f, 0.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint16 C = glm::packUnorm2x8(B); glm::vec2 D = glm::unpackUnorm2x8(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm2x8() { int Error = 0; std::vector A; A.push_back(glm::vec2( 1.0f, 0.0f)); A.push_back(glm::vec2(-0.7f,-0.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint16 C = glm::packSnorm2x8(B); glm::vec2 D = glm::unpackSnorm2x8(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1; } return Error; } int test_packUnorm4x8() { int Error = 0; std::vector A; A.push_back(glm::vec4(1.0f, 0.7f, 0.3f, 0.0f)); A.push_back(glm::vec4(0.5f, 0.1f, 0.2f, 0.3f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint32 C = glm::packUnorm4x8(B); glm::vec4 D = glm::unpackUnorm4x8(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm4x8() { int Error = 0; std::vector A; A.push_back(glm::vec4( 1.0f, 0.0f,-0.5f,-1.0f)); A.push_back(glm::vec4(-0.7f,-0.1f, 0.1f, 0.7f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint32 C = glm::packSnorm4x8(B); glm::vec4 D = glm::unpackSnorm4x8(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm() { int Error = 0; std::vector A; A.push_back(glm::vec2(1.0f, 0.7f)); A.push_back(glm::vec2(0.5f, 0.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::u16vec2 C = glm::packUnorm(B); glm::vec2 D = glm::unpackUnorm(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm() { int Error = 0; std::vector A; A.push_back(glm::vec2( 1.0f, 0.0f)); A.push_back(glm::vec2(-0.5f,-0.7f)); A.push_back(glm::vec2(-0.1f, 0.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::i16vec2 C = glm::packSnorm(B); glm::vec2 D = glm::unpackSnorm(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm2x4() { int Error = 0; std::vector A; A.push_back(glm::vec2(1.0f, 0.7f)); A.push_back(glm::vec2(0.5f, 0.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint8 C = glm::packUnorm2x4(B); glm::vec2 D = glm::unpackUnorm2x4(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm4x4() { int Error = 0; std::vector A; A.push_back(glm::vec4(1.0f, 0.7f, 0.5f, 0.0f)); A.push_back(glm::vec4(0.5f, 0.1f, 0.0f, 1.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint16 C = glm::packUnorm4x4(B); glm::vec4 D = glm::unpackUnorm4x4(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm3x5_1x1() { int Error = 0; std::vector A; A.push_back(glm::vec4(1.0f, 0.7f, 0.5f, 0.0f)); A.push_back(glm::vec4(0.5f, 0.1f, 0.0f, 1.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint16 C = glm::packUnorm3x5_1x1(B); glm::vec4 D = glm::unpackUnorm3x5_1x1(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm1x5_1x6_1x5() { int Error = 0; std::vector A; A.push_back(glm::vec3(1.0f, 0.7f, 0.5f)); A.push_back(glm::vec3(0.5f, 0.1f, 0.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec3 B(A[i]); glm::uint16 C = glm::packUnorm1x5_1x6_1x5(B); glm::vec3 D = glm::unpackUnorm1x5_1x6_1x5(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm2x3_1x2() { int Error = 0; std::vector A; A.push_back(glm::vec3(1.0f, 0.7f, 0.5f)); A.push_back(glm::vec3(0.5f, 0.1f, 0.0f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec3 B(A[i]); glm::uint8 C = glm::packUnorm2x3_1x2(B); glm::vec3 D = glm::unpackUnorm2x3_1x2(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 3.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUint2x8() { int Error = 0; glm::u8vec2 const Source(1, 2); glm::uint16 const Packed = glm::packUint2x8(Source); Error += Packed != 0 ? 0 : 1; glm::u8vec2 const Unpacked = glm::unpackUint2x8(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packUint4x8() { int Error = 0; glm::u8vec4 const Source(1, 2, 3, 4); glm::uint32 const Packed = glm::packUint4x8(Source); Error += Packed != 0 ? 0 : 1; glm::u8vec4 const Unpacked = glm::unpackUint4x8(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packUint2x16() { int Error = 0; glm::u16vec2 const Source(1, 2); glm::uint32 const Packed = glm::packUint2x16(Source); Error += Packed != 0 ? 0 : 1; glm::u16vec2 const Unpacked = glm::unpackUint2x16(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packUint4x16() { int Error = 0; glm::u16vec4 const Source(1, 2, 3, 4); glm::uint64 const Packed = glm::packUint4x16(Source); Error += Packed != 0 ? 0 : 1; glm::u16vec4 const Unpacked = glm::unpackUint4x16(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packUint2x32() { int Error = 0; glm::u32vec2 const Source(1, 2); glm::uint64 const Packed = glm::packUint2x32(Source); Error += Packed != 0 ? 0 : 1; glm::u32vec2 const Unpacked = glm::unpackUint2x32(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packInt2x8() { int Error = 0; glm::i8vec2 const Source(1, 2); glm::int16 const Packed = glm::packInt2x8(Source); Error += Packed != 0 ? 0 : 1; glm::i8vec2 const Unpacked = glm::unpackInt2x8(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packInt4x8() { int Error = 0; glm::i8vec4 const Source(1, 2, 3, 4); glm::int32 const Packed = glm::packInt4x8(Source); Error += Packed != 0 ? 0 : 1; glm::i8vec4 const Unpacked = glm::unpackInt4x8(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packInt2x16() { int Error = 0; glm::i16vec2 const Source(1, 2); glm::int32 const Packed = glm::packInt2x16(Source); Error += Packed != 0 ? 0 : 1; glm::i16vec2 const Unpacked = glm::unpackInt2x16(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packInt4x16() { int Error = 0; glm::i16vec4 const Source(1, 2, 3, 4); glm::int64 const Packed = glm::packInt4x16(Source); Error += Packed != 0 ? 0 : 1; glm::i16vec4 const Unpacked = glm::unpackInt4x16(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int test_packInt2x32() { int Error = 0; glm::i32vec2 const Source(1, 2); glm::int64 const Packed = glm::packInt2x32(Source); Error += Packed != 0 ? 0 : 1; glm::i32vec2 const Unpacked = glm::unpackInt2x32(Packed); Error += Source == Unpacked ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_packUnorm(); Error += test_packSnorm(); Error += test_packSnorm1x16(); Error += test_packSnorm2x16(); Error += test_packSnorm4x16(); Error += test_packSnorm1x8(); Error += test_packSnorm2x8(); Error += test_packSnorm4x8(); Error += test_packUnorm1x16(); Error += test_packUnorm2x16(); Error += test_packUnorm4x16(); Error += test_packUnorm1x8(); Error += test_packUnorm2x8(); Error += test_packUnorm4x8(); Error += test_packUnorm2x4(); Error += test_packUnorm4x4(); Error += test_packUnorm3x5_1x1(); Error += test_packUnorm1x5_1x6_1x5(); Error += test_packUnorm2x3_1x2(); Error += test_packUint2x8(); Error += test_packUint4x8(); Error += test_packUint2x16(); Error += test_packUint4x16(); Error += test_packUint2x32(); Error += test_packInt2x8(); Error += test_packInt4x8(); Error += test_packInt2x16(); Error += test_packInt4x16(); Error += test_packInt2x32(); Error += test_F2x11_1x10(); Error += test_F3x9_E1x5(); Error += test_RGBM(); Error += test_Unorm3x10_1x2(); Error += test_Snorm3x10_1x2(); Error += test_I3x10_1x2(); Error += test_U3x10_1x2(); Error += test_Half1x16(); Error += test_Half4x16(); return Error; } glm-0.9.9-a2/test/gtc/gtc_matrix_transform.cpp0000600000175000001440000000167113173131001020171 0ustar guususers#include #include int test_perspective() { int Error = 0; glm::mat4 Projection = glm::perspective(glm::pi() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f); return Error; } int test_pick() { int Error = 0; glm::mat4 Pick = glm::pickMatrix(glm::vec2(1, 2), glm::vec2(3, 4), glm::ivec4(0, 0, 320, 240)); return Error; } int test_tweakedInfinitePerspective() { int Error = 0; glm::mat4 ProjectionA = glm::tweakedInfinitePerspective(45.f, 640.f/480.f, 1.0f); glm::mat4 ProjectionB = glm::tweakedInfinitePerspective(45.f, 640.f/480.f, 1.0f, 0.001f); return Error; } int test_translate() { int Error = 0; glm::lowp_vec3 v(1.0); glm::lowp_mat4 m(0); glm::lowp_mat4 t = glm::translate(m, v); return Error; } int main() { int Error = 0; Error += test_translate(); Error += test_tweakedInfinitePerspective(); Error += test_pick(); Error += test_perspective(); return Error; } glm-0.9.9-a2/test/gtc/gtc_color_space.cpp0000600000175000001440000000342613173131001017063 0ustar guususers#include #include #include namespace srgb { int test() { int Error(0); glm::vec3 const ColorSourceRGB(1.0, 0.5, 0.0); { glm::vec3 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGB); glm::vec3 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB); Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1; } { glm::vec3 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGB, 2.8f); glm::vec3 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f); Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1; } glm::vec4 const ColorSourceRGBA(1.0, 0.5, 0.0, 1.0); { glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA); glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB); Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1; } { glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA, 2.8f); glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f); Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1; } return Error; } }//namespace srgb namespace srgb_lowp { int test() { int Error(0); for(float Color = 0.0f; Color < 1.0f; Color += 0.01f) { glm::highp_vec3 const HighpSRGB = glm::convertLinearToSRGB(glm::highp_vec3(Color)); glm::lowp_vec3 const LowpSRGB = glm::convertLinearToSRGB(glm::lowp_vec3(Color)); Error += glm::all(glm::epsilonEqual(glm::abs(HighpSRGB - glm::highp_vec3(LowpSRGB)), glm::highp_vec3(0), 0.1f)) ? 0 : 1; } return Error; } }//namespace srgb_lowp int main() { int Error(0); Error += srgb::test(); Error += srgb_lowp::test(); return Error; } glm-0.9.9-a2/test/gtc/gtc_user_defined_types.cpp0000600000175000001440000000136113173131001020446 0ustar guususers/////////////////////////////////////////////////////////////////////////////////////////////////// // OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net) /////////////////////////////////////////////////////////////////////////////////////////////////// // Created : 2010-09-16 // Updated : 2011-05-27 // Licence : This source is under MIT licence // File : test/gtc/type_ptr.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// #define GLM_FORCE_RADIANS #include int test_make_pointer_vec() { int Error = 0; glm::func(); //func(); return Error; } int main() { int Error = 0; Error += test_make_pointer_vec(); return Error; } glm-0.9.9-a2/test/gtc/gtc_matrix_integer.cpp0000600000175000001440000000012613173131001017605 0ustar guususers#include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/gtc/gtc_epsilon.cpp0000600000175000001440000000346713173131001016250 0ustar guususers#include #include #include int test_defined() { glm::epsilonEqual(glm::vec2(), glm::vec2(), glm::vec2()); glm::epsilonEqual(glm::vec3(), glm::vec3(), glm::vec3()); glm::epsilonEqual(glm::vec4(), glm::vec4(), glm::vec4()); glm::epsilonNotEqual(glm::vec2(), glm::vec2(), glm::vec2()); glm::epsilonNotEqual(glm::vec3(), glm::vec3(), glm::vec3()); glm::epsilonNotEqual(glm::vec4(), glm::vec4(), glm::vec4()); glm::epsilonEqual(glm::vec2(), glm::vec2(), 0.0f); glm::epsilonEqual(glm::vec3(), glm::vec3(), 0.0f); glm::epsilonEqual(glm::vec4(), glm::vec4(), 0.0f); glm::epsilonEqual(glm::quat(), glm::quat(), 0.0f); glm::epsilonNotEqual(glm::vec2(), glm::vec2(), 0.0f); glm::epsilonNotEqual(glm::vec3(), glm::vec3(), 0.0f); glm::epsilonNotEqual(glm::vec4(), glm::vec4(), 0.0f); glm::epsilonNotEqual(glm::quat(), glm::quat(), 0.0f); return 0; } template int test_equal() { int Error(0); { T A = glm::epsilon(); T B = glm::epsilon(); Error += glm::epsilonEqual(A, B, glm::epsilon() * T(2)) ? 0 : 1; } { T A(0); T B = static_cast(0) + glm::epsilon(); Error += glm::epsilonEqual(A, B, glm::epsilon() * T(2)) ? 0 : 1; } { T A(0); T B = static_cast(0) - glm::epsilon(); Error += glm::epsilonEqual(A, B, glm::epsilon() * T(2)) ? 0 : 1; } { T A = static_cast(0) + glm::epsilon(); T B = static_cast(0); Error += glm::epsilonEqual(A, B, glm::epsilon() * T(2)) ? 0 : 1; } { T A = static_cast(0) - glm::epsilon(); T B = static_cast(0); Error += glm::epsilonEqual(A, B, glm::epsilon() * T(2)) ? 0 : 1; } return Error; } int main() { int Error(0); Error += test_defined(); Error += test_equal(); Error += test_equal(); return Error; } glm-0.9.9-a2/test/gtc/gtc_type_aligned.cpp0000600000175000001440000000627113173131001017237 0ustar guususers#define GLM_FORCE_MESSAGES #include #if GLM_HAS_ALIGNED_TYPE #include GLM_STATIC_ASSERT(glm::detail::is_aligned::value, "aligned_lowp is not aligned"); GLM_STATIC_ASSERT(glm::detail::is_aligned::value, "aligned_mediump is not aligned"); GLM_STATIC_ASSERT(glm::detail::is_aligned::value, "aligned_highp is not aligned"); GLM_STATIC_ASSERT(!glm::detail::is_aligned::value, "packed_highp is aligned"); GLM_STATIC_ASSERT(!glm::detail::is_aligned::value, "packed_mediump is aligned"); GLM_STATIC_ASSERT(!glm::detail::is_aligned::value, "packed_lowp is aligned"); struct my_vec4_packed { glm::uint32 a; glm::vec4 b; }; GLM_STATIC_ASSERT(sizeof(my_vec4_packed) == sizeof(glm::uint32) + sizeof(glm::vec4), "glm::vec4 packed is not correct"); struct my_vec4_aligned { glm::uint32 a; glm::aligned_vec4 b; }; GLM_STATIC_ASSERT(sizeof(my_vec4_aligned) == sizeof(glm::aligned_vec4) * 2, "glm::vec4 aligned is not correct"); struct my_dvec4_packed { glm::uint64 a; glm::dvec4 b; }; GLM_STATIC_ASSERT(sizeof(my_dvec4_packed) == sizeof(glm::uint64) + sizeof(glm::dvec4), "glm::dvec4 packed is not correct"); struct my_dvec4_aligned { glm::uint64 a; glm::aligned_dvec4 b; }; //GLM_STATIC_ASSERT(sizeof(my_dvec4_aligned) == sizeof(glm::aligned_dvec4) * 2, "glm::dvec4 aligned is not correct"); struct my_ivec4_packed { glm::uint32 a; glm::ivec4 b; }; GLM_STATIC_ASSERT(sizeof(my_ivec4_packed) == sizeof(glm::uint32) + sizeof(glm::ivec4), "glm::ivec4 packed is not correct"); struct my_ivec4_aligned { glm::uint32 a; glm::aligned_ivec4 b; }; GLM_STATIC_ASSERT(sizeof(my_ivec4_aligned) == sizeof(glm::aligned_ivec4) * 2, "glm::ivec4 aligned is not correct"); struct my_u8vec4_packed { glm::uint32 a; glm::u8vec4 b; }; GLM_STATIC_ASSERT(sizeof(my_u8vec4_packed) == sizeof(glm::uint32) + sizeof(glm::u8vec4), "glm::u8vec4 packed is not correct"); static int test_copy() { int Error = 0; { glm::aligned_ivec4 const a(1, 2, 3, 4); glm::ivec4 const u(a); Error += a.x == u.x ? 0 : 1; Error += a.y == u.y ? 0 : 1; Error += a.z == u.z ? 0 : 1; Error += a.w == u.w ? 0 : 1; } { my_ivec4_aligned a; a.b = glm::ivec4(1, 2, 3, 4); my_ivec4_packed u; u.b = a.b; Error += a.b.x == u.b.x ? 0 : 1; Error += a.b.y == u.b.y ? 0 : 1; Error += a.b.z == u.b.z ? 0 : 1; Error += a.b.w == u.b.w ? 0 : 1; } return Error; } static int test_ctor() { int Error = 0; # if GLM_HAS_CONSTEXPR && GLM_ARCH == GLM_ARCH_PURE { constexpr glm::aligned_ivec4 v(1); Error += v.x == 1 ? 0 : 1; Error += v.y == 1 ? 0 : 1; Error += v.z == 1 ? 0 : 1; Error += v.w == 1 ? 0 : 1; } { constexpr glm::packed_ivec4 v(1); Error += v.x == 1 ? 0 : 1; Error += v.y == 1 ? 0 : 1; Error += v.z == 1 ? 0 : 1; Error += v.w == 1 ? 0 : 1; } { constexpr glm::ivec4 v(1); Error += v.x == 1 ? 0 : 1; Error += v.y == 1 ? 0 : 1; Error += v.z == 1 ? 0 : 1; Error += v.w == 1 ? 0 : 1; } # endif return Error; } int main() { int Error = 0; Error += test_ctor(); Error += test_copy(); return Error; } #else int main() { return 0; } #endif//GLM_HAS_ALIGNED_TYPE glm-0.9.9-a2/test/gtc/gtc_noise.cpp0000600000175000001440000000262013173131001015702 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #include #include #include int test_simplex() { int Error = 0; glm::u8vec4 const PixelSimplex2D(glm::byte(glm::abs(glm::simplex(glm::vec2(0.f, 0.f))) * 255.f)); glm::u8vec4 const PixelSimplex3D(glm::byte(glm::abs(glm::simplex(glm::vec3(0.f, 0.f, 0.f))) * 255.f)); glm::u8vec4 const PixelSimplex4D(glm::byte(glm::abs(glm::simplex(glm::vec4(0.f, 0.f, 0.f, 0.f))) * 255.f)); return Error; } int test_perlin() { int Error = 0; glm::u8vec4 const PixelPerlin2D(glm::byte(glm::abs(glm::perlin(glm::vec2(0.f, 0.f))) * 255.f)); glm::u8vec4 const PixelPerlin3D(glm::byte(glm::abs(glm::perlin(glm::vec3(0.f, 0.f, 0.f))) * 255.f)); glm::u8vec4 const PixelPerlin4D(glm::byte(glm::abs(glm::perlin(glm::vec4(0.f, 0.f, 0.f, 0.f))) * 255.f)); return Error; } int test_perlin_pedioric() { int Error = 0; glm::u8vec4 const PixelPeriodic2D(glm::byte(glm::abs(glm::perlin(glm::vec2(0.f, 0.f), glm::vec2(2.0f))) * 255.f)); glm::u8vec4 const PixelPeriodic3D(glm::byte(glm::abs(glm::perlin(glm::vec3(0.f, 0.f, 0.f), glm::vec3(2.0f))) * 255.f)); glm::u8vec4 const PixelPeriodic4D(glm::byte(glm::abs(glm::perlin(glm::vec4(0.f, 0.f, 0.f, 0.f), glm::vec4(2.0f))) * 255.f)); return Error; } int main() { int Error = 0; Error += test_simplex(); Error += test_perlin(); Error += test_perlin_pedioric(); return Error; } glm-0.9.9-a2/test/gtc/gtc_matrix_inverse.cpp0000600000175000001440000000202613173131001017624 0ustar guususers#include #include int test_affine() { int Error = 0; { glm::mat3 const M( 2.f, 0.f, 0.f, 0.f, 2.f, 0.f, 0.f, 0.f, 1.f); glm::mat3 const A = glm::affineInverse(M); glm::mat3 const I = glm::inverse(M); glm::mat3 const R = glm::affineInverse(A); for(glm::length_t i = 0; i < A.length(); ++i) { Error += glm::all(glm::epsilonEqual(M[i], R[i], 0.01f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A[i], I[i], 0.01f)) ? 0 : 1; } } { glm::mat4 const M( 2.f, 0.f, 0.f, 0.f, 0.f, 2.f, 0.f, 0.f, 0.f, 0.f, 2.f, 0.f, 0.f, 0.f, 0.f, 1.f); glm::mat4 const A = glm::affineInverse(M); glm::mat4 const I = glm::inverse(M); glm::mat4 const R = glm::affineInverse(A); for(glm::length_t i = 0; i < A.length(); ++i) { Error += glm::all(glm::epsilonEqual(M[i], R[i], 0.01f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A[i], I[i], 0.01f)) ? 0 : 1; } } return Error; } int main() { int Error = 0; Error += test_affine(); return Error; } glm-0.9.9-a2/test/gtc/gtc_type_precision.cpp0000600000175000001440000006552713173131001017640 0ustar guususers#include #include #include #if GLM_HAS_OPENMP # include #endif static int test_scalar_size() { int Error = 0; Error += sizeof(glm::int8) != 1; Error += sizeof(glm::int16) != 2; Error += sizeof(glm::int32) != 4; Error += sizeof(glm::int64) != 8; Error += sizeof(glm::uint8) != 1; Error += sizeof(glm::uint16) != 2; Error += sizeof(glm::uint32) != 4; Error += sizeof(glm::uint64) != 8; Error += sizeof(glm::float32) != 4; Error += sizeof(glm::float64) != 8; Error += sizeof(glm::lowp_int8) != 1; Error += sizeof(glm::lowp_int16) != 2; Error += sizeof(glm::lowp_int32) != 4; Error += sizeof(glm::lowp_int64) != 8; Error += sizeof(glm::lowp_uint8) != 1; Error += sizeof(glm::lowp_uint16) != 2; Error += sizeof(glm::lowp_uint32) != 4; Error += sizeof(glm::lowp_uint64) != 8; Error += sizeof(glm::lowp_float32) != 4; Error += sizeof(glm::lowp_float64) != 8; Error += sizeof(glm::mediump_int8) != 1; Error += sizeof(glm::mediump_int16) != 2; Error += sizeof(glm::mediump_int32) != 4; Error += sizeof(glm::mediump_int64) != 8; Error += sizeof(glm::mediump_uint8) != 1; Error += sizeof(glm::mediump_uint16) != 2; Error += sizeof(glm::mediump_uint32) != 4; Error += sizeof(glm::mediump_uint64) != 8; Error += sizeof(glm::mediump_float32) != 4; Error += sizeof(glm::mediump_float64) != 8; Error += sizeof(glm::highp_int8) != 1; Error += sizeof(glm::highp_int16) != 2; Error += sizeof(glm::highp_int32) != 4; Error += sizeof(glm::highp_int64) != 8; Error += sizeof(glm::highp_uint8) != 1; Error += sizeof(glm::highp_uint16) != 2; Error += sizeof(glm::highp_uint32) != 4; Error += sizeof(glm::highp_uint64) != 8; Error += sizeof(glm::highp_float32) != 4; Error += sizeof(glm::highp_float64) != 8; return Error; } static int test_fvec_size() { int Error = 0; Error += sizeof(glm::f32vec2) != 8; Error += sizeof(glm::f32vec3) != 12; Error += sizeof(glm::f32vec4) != 16; Error += sizeof(glm::f64vec2) != 16; Error += sizeof(glm::f64vec3) != 24; Error += sizeof(glm::f64vec4) != 32; Error += sizeof(glm::lowp_f32vec2) != 8; Error += sizeof(glm::lowp_f32vec3) != 12; Error += sizeof(glm::lowp_f32vec4) != 16; Error += sizeof(glm::lowp_f64vec2) != 16; Error += sizeof(glm::lowp_f64vec3) != 24; Error += sizeof(glm::lowp_f64vec4) != 32; Error += sizeof(glm::mediump_f32vec2) != 8; Error += sizeof(glm::mediump_f32vec3) != 12; Error += sizeof(glm::mediump_f32vec4) != 16; Error += sizeof(glm::mediump_f64vec2) != 16; Error += sizeof(glm::mediump_f64vec3) != 24; Error += sizeof(glm::mediump_f64vec4) != 32; Error += sizeof(glm::highp_f32vec2) != 8; Error += sizeof(glm::highp_f32vec3) != 12; Error += sizeof(glm::highp_f32vec4) != 16; Error += sizeof(glm::highp_f64vec2) != 16; Error += sizeof(glm::highp_f64vec3) != 24; Error += sizeof(glm::highp_f64vec4) != 32; return Error; } static int test_fvec_precision() { int Error = 0; /* { glm::f32vec2 v1; glm::lowp_f32vec2 v2((glm::f32vec2(v1))); glm::mediump_f32vec2 v3((glm::f32vec2(v1))); glm::highp_f32vec2 v4((glm::f32vec2(v1))); Error += glm::all(glm::equal(v1, v2)) ? 0 : 1; Error += glm::all(glm::equal(v1, v3)) ? 0 : 1; Error += glm::all(glm::equal(v1, v4)) ? 0 : 1; } */ { glm::f32vec2 v1(1.f); glm::lowp_f32vec2 v2(v1); glm::mediump_f32vec2 v3(v1); glm::highp_f32vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::f32vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f32vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f32vec2(v4))) ? 0 : 1; } { glm::f32vec3 v1(1.f); glm::lowp_f32vec3 v2(v1); glm::mediump_f32vec3 v3(v1); glm::highp_f32vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::f32vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f32vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f32vec3(v4))) ? 0 : 1; } { glm::f32vec4 v1(1.f); glm::lowp_f32vec4 v2(v1); glm::mediump_f32vec4 v3(v1); glm::highp_f32vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::f32vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f32vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f32vec4(v4))) ? 0 : 1; } return Error; } static int test_dvec_precision() { int Error = 0; { glm::f64vec2 v1(1.0); glm::lowp_f64vec2 v2(v1); glm::mediump_f64vec2 v3(v1); glm::highp_f64vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::f64vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f64vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f64vec2(v4))) ? 0 : 1; } { glm::f64vec3 v1(1.0); glm::lowp_f64vec3 v2(v1); glm::mediump_f64vec3 v3(v1); glm::highp_f64vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::f64vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f64vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f64vec3(v4))) ? 0 : 1; } { glm::f64vec4 v1(1.0); glm::lowp_f64vec4 v2(v1); glm::mediump_f64vec4 v3(v1); glm::highp_f64vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::f64vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f64vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::f64vec4(v4))) ? 0 : 1; } return Error; } static int test_ivec_size() { int Error = 0; Error += sizeof(glm::i8vec2) != 2; Error += sizeof(glm::i8vec3) != 3; Error += sizeof(glm::i8vec4) != 4; Error += sizeof(glm::i16vec2) != 4; Error += sizeof(glm::i16vec3) != 6; Error += sizeof(glm::i16vec4) != 8; Error += sizeof(glm::i32vec2) != 8; Error += sizeof(glm::i32vec3) != 12; Error += sizeof(glm::i32vec4) != 16; Error += sizeof(glm::i64vec2) != 16; Error += sizeof(glm::i64vec3) != 24; Error += sizeof(glm::i64vec4) != 32; Error += sizeof(glm::lowp_i8vec2) != 2; Error += sizeof(glm::lowp_i8vec3) != 3; Error += sizeof(glm::lowp_i8vec4) != 4; Error += sizeof(glm::lowp_i16vec2) != 4; Error += sizeof(glm::lowp_i16vec3) != 6; Error += sizeof(glm::lowp_i16vec4) != 8; Error += sizeof(glm::lowp_i32vec2) != 8; Error += sizeof(glm::lowp_i32vec3) != 12; Error += sizeof(glm::lowp_i32vec4) != 16; Error += sizeof(glm::lowp_i64vec2) != 16; Error += sizeof(glm::lowp_i64vec3) != 24; Error += sizeof(glm::lowp_i64vec4) != 32; Error += sizeof(glm::mediump_i8vec2) != 2; Error += sizeof(glm::mediump_i8vec3) != 3; Error += sizeof(glm::mediump_i8vec4) != 4; Error += sizeof(glm::mediump_i16vec2) != 4; Error += sizeof(glm::mediump_i16vec3) != 6; Error += sizeof(glm::mediump_i16vec4) != 8; Error += sizeof(glm::mediump_i32vec2) != 8; Error += sizeof(glm::mediump_i32vec3) != 12; Error += sizeof(glm::mediump_i32vec4) != 16; Error += sizeof(glm::mediump_i64vec2) != 16; Error += sizeof(glm::mediump_i64vec3) != 24; Error += sizeof(glm::mediump_i64vec4) != 32; Error += sizeof(glm::highp_i8vec2) != 2; Error += sizeof(glm::highp_i8vec3) != 3; Error += sizeof(glm::highp_i8vec4) != 4; Error += sizeof(glm::highp_i16vec2) != 4; Error += sizeof(glm::highp_i16vec3) != 6; Error += sizeof(glm::highp_i16vec4) != 8; Error += sizeof(glm::highp_i32vec2) != 8; Error += sizeof(glm::highp_i32vec3) != 12; Error += sizeof(glm::highp_i32vec4) != 16; Error += sizeof(glm::highp_i64vec2) != 16; Error += sizeof(glm::highp_i64vec3) != 24; Error += sizeof(glm::highp_i64vec4) != 32; return Error; } static int test_ivec_precision() { int Error = 0; { glm::i8vec2 v1(0); glm::lowp_i8vec2 v2(v1); glm::mediump_i8vec2 v3(v1); glm::highp_i8vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::i8vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i8vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i8vec2(v4))) ? 0 : 1; } { glm::i8vec3 v1(0); glm::lowp_i8vec3 v2(v1); glm::mediump_i8vec3 v3(v1); glm::highp_i8vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::i8vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i8vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i8vec3(v4))) ? 0 : 1; } { glm::i8vec4 v1(0); glm::lowp_i8vec4 v2(v1); glm::mediump_i8vec4 v3(v1); glm::highp_i8vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::i8vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i8vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i8vec4(v4))) ? 0 : 1; } { glm::i16vec2 v1(0); glm::lowp_i16vec2 v2(v1); glm::mediump_i16vec2 v3(v1); glm::highp_i16vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::i16vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i16vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i16vec2(v4))) ? 0 : 1; } { glm::i16vec3 v1(0); glm::lowp_i16vec3 v2(v1); glm::mediump_i16vec3 v3(v1); glm::highp_i16vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::i16vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i16vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i16vec3(v4))) ? 0 : 1; } { glm::i16vec4 v1(0); glm::lowp_i16vec4 v2(v1); glm::mediump_i16vec4 v3(v1); glm::highp_i16vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::i16vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i16vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i16vec4(v4))) ? 0 : 1; } { glm::i32vec2 v1(0); glm::lowp_i32vec2 v2(v1); glm::mediump_i32vec2 v3(v1); glm::highp_i32vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::i32vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i32vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i32vec2(v4))) ? 0 : 1; } { glm::i32vec3 v1(0); glm::lowp_i32vec3 v2(v1); glm::mediump_i32vec3 v3(v1); glm::highp_i32vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::i32vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i32vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i32vec3(v4))) ? 0 : 1; } { glm::i32vec4 v1(0); glm::lowp_i32vec4 v2(v1); glm::mediump_i32vec4 v3(v1); glm::highp_i32vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::i32vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i32vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i32vec4(v4))) ? 0 : 1; } { glm::i64vec2 v1(0); glm::lowp_i64vec2 v2(v1); glm::mediump_i64vec2 v3(v1); glm::highp_i64vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::i64vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i64vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i64vec2(v4))) ? 0 : 1; } { glm::i64vec3 v1(0); glm::lowp_i64vec3 v2(v1); glm::mediump_i64vec3 v3(v1); glm::highp_i64vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::i64vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i64vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i64vec3(v4))) ? 0 : 1; } { glm::i64vec4 v1(0); glm::lowp_i64vec4 v2(v1); glm::mediump_i64vec4 v3(v1); glm::highp_i64vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::i64vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i64vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::i64vec4(v4))) ? 0 : 1; } return Error; } static int test_uvec_size() { int Error = 0; Error += sizeof(glm::u8vec2) != 2; Error += sizeof(glm::u8vec3) != 3; Error += sizeof(glm::u8vec4) != 4; Error += sizeof(glm::u16vec2) != 4; Error += sizeof(glm::u16vec3) != 6; Error += sizeof(glm::u16vec4) != 8; Error += sizeof(glm::u32vec2) != 8; Error += sizeof(glm::u32vec3) != 12; Error += sizeof(glm::u32vec4) != 16; Error += sizeof(glm::u64vec2) != 16; Error += sizeof(glm::u64vec3) != 24; Error += sizeof(glm::u64vec4) != 32; Error += sizeof(glm::lowp_u8vec2) != 2; Error += sizeof(glm::lowp_u8vec3) != 3; Error += sizeof(glm::lowp_u8vec4) != 4; Error += sizeof(glm::lowp_u16vec2) != 4; Error += sizeof(glm::lowp_u16vec3) != 6; Error += sizeof(glm::lowp_u16vec4) != 8; Error += sizeof(glm::lowp_u32vec2) != 8; Error += sizeof(glm::lowp_u32vec3) != 12; Error += sizeof(glm::lowp_u32vec4) != 16; Error += sizeof(glm::lowp_u64vec2) != 16; Error += sizeof(glm::lowp_u64vec3) != 24; Error += sizeof(glm::lowp_u64vec4) != 32; Error += sizeof(glm::mediump_u8vec2) != 2; Error += sizeof(glm::mediump_u8vec3) != 3; Error += sizeof(glm::mediump_u8vec4) != 4; Error += sizeof(glm::mediump_u16vec2) != 4; Error += sizeof(glm::mediump_u16vec3) != 6; Error += sizeof(glm::mediump_u16vec4) != 8; Error += sizeof(glm::mediump_u32vec2) != 8; Error += sizeof(glm::mediump_u32vec3) != 12; Error += sizeof(glm::mediump_u32vec4) != 16; Error += sizeof(glm::mediump_u64vec2) != 16; Error += sizeof(glm::mediump_u64vec3) != 24; Error += sizeof(glm::mediump_u64vec4) != 32; Error += sizeof(glm::highp_u8vec2) != 2; Error += sizeof(glm::highp_u8vec3) != 3; Error += sizeof(glm::highp_u8vec4) != 4; Error += sizeof(glm::highp_u16vec2) != 4; Error += sizeof(glm::highp_u16vec3) != 6; Error += sizeof(glm::highp_u16vec4) != 8; Error += sizeof(glm::highp_u32vec2) != 8; Error += sizeof(glm::highp_u32vec3) != 12; Error += sizeof(glm::highp_u32vec4) != 16; Error += sizeof(glm::highp_u64vec2) != 16; Error += sizeof(glm::highp_u64vec3) != 24; Error += sizeof(glm::highp_u64vec4) != 32; return Error; } static int test_uvec_precision() { int Error = 0; { glm::u8vec2 v1(0); glm::lowp_u8vec2 v2(v1); glm::mediump_u8vec2 v3(v1); glm::highp_u8vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::u8vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u8vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u8vec2(v4))) ? 0 : 1; } { glm::u8vec3 v1(0); glm::lowp_u8vec3 v2(v1); glm::mediump_u8vec3 v3(v1); glm::highp_u8vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::u8vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u8vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u8vec3(v4))) ? 0 : 1; } { glm::u8vec4 v1(0); glm::lowp_u8vec4 v2(v1); glm::mediump_u8vec4 v3(v1); glm::highp_u8vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::u8vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u8vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u8vec4(v4))) ? 0 : 1; } { glm::u16vec2 v1(0); glm::lowp_u16vec2 v2(v1); glm::mediump_u16vec2 v3(v1); glm::highp_u16vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::u16vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u16vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u16vec2(v4))) ? 0 : 1; } { glm::u16vec3 v1(0); glm::lowp_u16vec3 v2(v1); glm::mediump_u16vec3 v3(v1); glm::highp_u16vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::u16vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u16vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u16vec3(v4))) ? 0 : 1; } { glm::u16vec4 v1(0); glm::lowp_u16vec4 v2(v1); glm::mediump_u16vec4 v3(v1); glm::highp_u16vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::u16vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u16vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u16vec4(v4))) ? 0 : 1; } { glm::u32vec2 v1(0); glm::lowp_u32vec2 v2(v1); glm::mediump_u32vec2 v3(v1); glm::highp_u32vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::u32vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u32vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u32vec2(v4))) ? 0 : 1; } { glm::u32vec3 v1(0); glm::lowp_u32vec3 v2(v1); glm::mediump_u32vec3 v3(v1); glm::highp_u32vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::u32vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u32vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u32vec3(v4))) ? 0 : 1; } { glm::u32vec4 v1(0); glm::lowp_u32vec4 v2(v1); glm::mediump_u32vec4 v3(v1); glm::highp_u32vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::u32vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u32vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u32vec4(v4))) ? 0 : 1; } { glm::u64vec2 v1(0); glm::lowp_u64vec2 v2(v1); glm::mediump_u64vec2 v3(v1); glm::highp_u64vec2 v4(v1); Error += glm::all(glm::equal(v1, glm::u64vec2(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u64vec2(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u64vec2(v4))) ? 0 : 1; } { glm::u64vec3 v1(0); glm::lowp_u64vec3 v2(v1); glm::mediump_u64vec3 v3(v1); glm::highp_u64vec3 v4(v1); Error += glm::all(glm::equal(v1, glm::u64vec3(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u64vec3(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u64vec3(v4))) ? 0 : 1; } { glm::u64vec4 v1(0); glm::lowp_u64vec4 v2(v1); glm::mediump_u64vec4 v3(v1); glm::highp_u64vec4 v4(v1); Error += glm::all(glm::equal(v1, glm::u64vec4(v2))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u64vec4(v3))) ? 0 : 1; Error += glm::all(glm::equal(v1, glm::u64vec4(v4))) ? 0 : 1; } return Error; } static int test_fmat_size() { int Error = 0; Error += sizeof(glm::mat2) != 16; Error += sizeof(glm::mat3) != 36; Error += sizeof(glm::mat4) != 64; Error += sizeof(glm::mat2x2) != 16; Error += sizeof(glm::mat2x3) != 24; Error += sizeof(glm::mat2x4) != 32; Error += sizeof(glm::mat3x2) != 24; Error += sizeof(glm::mat3x3) != 36; Error += sizeof(glm::mat3x4) != 48; Error += sizeof(glm::mat4x2) != 32; Error += sizeof(glm::mat4x3) != 48; Error += sizeof(glm::mat4x4) != 64; Error += sizeof(glm::fmat2) != 16; Error += sizeof(glm::fmat3) != 36; Error += sizeof(glm::fmat4) != 64; Error += sizeof(glm::fmat2x2) != 16; Error += sizeof(glm::fmat2x3) != 24; Error += sizeof(glm::fmat2x4) != 32; Error += sizeof(glm::fmat3x2) != 24; Error += sizeof(glm::fmat3x3) != 36; Error += sizeof(glm::fmat3x4) != 48; Error += sizeof(glm::fmat4x2) != 32; Error += sizeof(glm::fmat4x3) != 48; Error += sizeof(glm::fmat4x4) != 64; Error += sizeof(glm::f32mat2) != 16; Error += sizeof(glm::f32mat3) != 36; Error += sizeof(glm::f32mat4) != 64; Error += sizeof(glm::f32mat2x2) != 16; Error += sizeof(glm::f32mat2x3) != 24; Error += sizeof(glm::f32mat2x4) != 32; Error += sizeof(glm::f32mat3x2) != 24; Error += sizeof(glm::f32mat3x3) != 36; Error += sizeof(glm::f32mat3x4) != 48; Error += sizeof(glm::f32mat4x2) != 32; Error += sizeof(glm::f32mat4x3) != 48; Error += sizeof(glm::f32mat4x4) != 64; Error += sizeof(glm::lowp_mat2) != 16; Error += sizeof(glm::lowp_mat3) != 36; Error += sizeof(glm::lowp_mat4) != 64; Error += sizeof(glm::lowp_mat2x2) != 16; Error += sizeof(glm::lowp_mat2x3) != 24; Error += sizeof(glm::lowp_mat2x4) != 32; Error += sizeof(glm::lowp_mat3x2) != 24; Error += sizeof(glm::lowp_mat3x3) != 36; Error += sizeof(glm::lowp_mat3x4) != 48; Error += sizeof(glm::lowp_mat4x2) != 32; Error += sizeof(glm::lowp_mat4x3) != 48; Error += sizeof(glm::lowp_mat4x4) != 64; Error += sizeof(glm::lowp_fmat2) != 16; Error += sizeof(glm::lowp_fmat3) != 36; Error += sizeof(glm::lowp_fmat4) != 64; Error += sizeof(glm::lowp_fmat2x2) != 16; Error += sizeof(glm::lowp_fmat2x3) != 24; Error += sizeof(glm::lowp_fmat2x4) != 32; Error += sizeof(glm::lowp_fmat3x2) != 24; Error += sizeof(glm::lowp_fmat3x3) != 36; Error += sizeof(glm::lowp_fmat3x4) != 48; Error += sizeof(glm::lowp_fmat4x2) != 32; Error += sizeof(glm::lowp_fmat4x3) != 48; Error += sizeof(glm::lowp_fmat4x4) != 64; Error += sizeof(glm::lowp_f32mat2) != 16; Error += sizeof(glm::lowp_f32mat3) != 36; Error += sizeof(glm::lowp_f32mat4) != 64; Error += sizeof(glm::lowp_f32mat2x2) != 16; Error += sizeof(glm::lowp_f32mat2x3) != 24; Error += sizeof(glm::lowp_f32mat2x4) != 32; Error += sizeof(glm::lowp_f32mat3x2) != 24; Error += sizeof(glm::lowp_f32mat3x3) != 36; Error += sizeof(glm::lowp_f32mat3x4) != 48; Error += sizeof(glm::lowp_f32mat4x2) != 32; Error += sizeof(glm::lowp_f32mat4x3) != 48; Error += sizeof(glm::lowp_f32mat4x4) != 64; Error += sizeof(glm::mediump_mat2) != 16; Error += sizeof(glm::mediump_mat3) != 36; Error += sizeof(glm::mediump_mat4) != 64; Error += sizeof(glm::mediump_mat2x2) != 16; Error += sizeof(glm::mediump_mat2x3) != 24; Error += sizeof(glm::mediump_mat2x4) != 32; Error += sizeof(glm::mediump_mat3x2) != 24; Error += sizeof(glm::mediump_mat3x3) != 36; Error += sizeof(glm::mediump_mat3x4) != 48; Error += sizeof(glm::mediump_mat4x2) != 32; Error += sizeof(glm::mediump_mat4x3) != 48; Error += sizeof(glm::mediump_mat4x4) != 64; Error += sizeof(glm::mediump_fmat2) != 16; Error += sizeof(glm::mediump_fmat3) != 36; Error += sizeof(glm::mediump_fmat4) != 64; Error += sizeof(glm::mediump_fmat2x2) != 16; Error += sizeof(glm::mediump_fmat2x3) != 24; Error += sizeof(glm::mediump_fmat2x4) != 32; Error += sizeof(glm::mediump_fmat3x2) != 24; Error += sizeof(glm::mediump_fmat3x3) != 36; Error += sizeof(glm::mediump_fmat3x4) != 48; Error += sizeof(glm::mediump_fmat4x2) != 32; Error += sizeof(glm::mediump_fmat4x3) != 48; Error += sizeof(glm::mediump_fmat4x4) != 64; Error += sizeof(glm::mediump_f32mat2) != 16; Error += sizeof(glm::mediump_f32mat3) != 36; Error += sizeof(glm::mediump_f32mat4) != 64; Error += sizeof(glm::mediump_f32mat2x2) != 16; Error += sizeof(glm::mediump_f32mat2x3) != 24; Error += sizeof(glm::mediump_f32mat2x4) != 32; Error += sizeof(glm::mediump_f32mat3x2) != 24; Error += sizeof(glm::mediump_f32mat3x3) != 36; Error += sizeof(glm::mediump_f32mat3x4) != 48; Error += sizeof(glm::mediump_f32mat4x2) != 32; Error += sizeof(glm::mediump_f32mat4x3) != 48; Error += sizeof(glm::mediump_f32mat4x4) != 64; Error += sizeof(glm::highp_mat2) != 16; Error += sizeof(glm::highp_mat3) != 36; Error += sizeof(glm::highp_mat4) != 64; Error += sizeof(glm::highp_mat2x2) != 16; Error += sizeof(glm::highp_mat2x3) != 24; Error += sizeof(glm::highp_mat2x4) != 32; Error += sizeof(glm::highp_mat3x2) != 24; Error += sizeof(glm::highp_mat3x3) != 36; Error += sizeof(glm::highp_mat3x4) != 48; Error += sizeof(glm::highp_mat4x2) != 32; Error += sizeof(glm::highp_mat4x3) != 48; Error += sizeof(glm::highp_mat4x4) != 64; Error += sizeof(glm::highp_fmat2) != 16; Error += sizeof(glm::highp_fmat3) != 36; Error += sizeof(glm::highp_fmat4) != 64; Error += sizeof(glm::highp_fmat2x2) != 16; Error += sizeof(glm::highp_fmat2x3) != 24; Error += sizeof(glm::highp_fmat2x4) != 32; Error += sizeof(glm::highp_fmat3x2) != 24; Error += sizeof(glm::highp_fmat3x3) != 36; Error += sizeof(glm::highp_fmat3x4) != 48; Error += sizeof(glm::highp_fmat4x2) != 32; Error += sizeof(glm::highp_fmat4x3) != 48; Error += sizeof(glm::highp_fmat4x4) != 64; Error += sizeof(glm::highp_f32mat2) != 16; Error += sizeof(glm::highp_f32mat3) != 36; Error += sizeof(glm::highp_f32mat4) != 64; Error += sizeof(glm::highp_f32mat2x2) != 16; Error += sizeof(glm::highp_f32mat2x3) != 24; Error += sizeof(glm::highp_f32mat2x4) != 32; Error += sizeof(glm::highp_f32mat3x2) != 24; Error += sizeof(glm::highp_f32mat3x3) != 36; Error += sizeof(glm::highp_f32mat3x4) != 48; Error += sizeof(glm::highp_f32mat4x2) != 32; Error += sizeof(glm::highp_f32mat4x3) != 48; Error += sizeof(glm::highp_f32mat4x4) != 64; return Error; } static int test_dmat_size() { int Error = 0; Error += sizeof(glm::f64mat2) != 32; Error += sizeof(glm::f64mat3) != 72; Error += sizeof(glm::f64mat4) != 128; Error += sizeof(glm::f64mat2x2) != 32; Error += sizeof(glm::f64mat2x3) != 48; Error += sizeof(glm::f64mat2x4) != 64; Error += sizeof(glm::f64mat3x2) != 48; Error += sizeof(glm::f64mat3x3) != 72; Error += sizeof(glm::f64mat3x4) != 96; Error += sizeof(glm::f64mat4x2) != 64; Error += sizeof(glm::f64mat4x3) != 96; Error += sizeof(glm::f64mat4x4) != 128; Error += sizeof(glm::lowp_f64mat2) != 32; Error += sizeof(glm::lowp_f64mat3) != 72; Error += sizeof(glm::lowp_f64mat4) != 128; Error += sizeof(glm::lowp_f64mat2x2) != 32; Error += sizeof(glm::lowp_f64mat2x3) != 48; Error += sizeof(glm::lowp_f64mat2x4) != 64; Error += sizeof(glm::lowp_f64mat3x2) != 48; Error += sizeof(glm::lowp_f64mat3x3) != 72; Error += sizeof(glm::lowp_f64mat3x4) != 96; Error += sizeof(glm::lowp_f64mat4x2) != 64; Error += sizeof(glm::lowp_f64mat4x3) != 96; Error += sizeof(glm::lowp_f64mat4x4) != 128; Error += sizeof(glm::mediump_f64mat2) != 32; Error += sizeof(glm::mediump_f64mat3) != 72; Error += sizeof(glm::mediump_f64mat4) != 128; Error += sizeof(glm::mediump_f64mat2x2) != 32; Error += sizeof(glm::mediump_f64mat2x3) != 48; Error += sizeof(glm::mediump_f64mat2x4) != 64; Error += sizeof(glm::mediump_f64mat3x2) != 48; Error += sizeof(glm::mediump_f64mat3x3) != 72; Error += sizeof(glm::mediump_f64mat3x4) != 96; Error += sizeof(glm::mediump_f64mat4x2) != 64; Error += sizeof(glm::mediump_f64mat4x3) != 96; Error += sizeof(glm::mediump_f64mat4x4) != 128; Error += sizeof(glm::highp_f64mat2) != 32; Error += sizeof(glm::highp_f64mat3) != 72; Error += sizeof(glm::highp_f64mat4) != 128; Error += sizeof(glm::highp_f64mat2x2) != 32; Error += sizeof(glm::highp_f64mat2x3) != 48; Error += sizeof(glm::highp_f64mat2x4) != 64; Error += sizeof(glm::highp_f64mat3x2) != 48; Error += sizeof(glm::highp_f64mat3x3) != 72; Error += sizeof(glm::highp_f64mat3x4) != 96; Error += sizeof(glm::highp_f64mat4x2) != 64; Error += sizeof(glm::highp_f64mat4x3) != 96; Error += sizeof(glm::highp_f64mat4x4) != 128; return Error; } static int test_quat_size() { int Error = 0; Error += sizeof(glm::f32quat) != 16; Error += sizeof(glm::f64quat) != 32; Error += sizeof(glm::lowp_f32quat) != 16; Error += sizeof(glm::lowp_f64quat) != 32; Error += sizeof(glm::mediump_f32quat) != 16; Error += sizeof(glm::mediump_f64quat) != 32; Error += sizeof(glm::highp_f32quat) != 16; Error += sizeof(glm::highp_f64quat) != 32; return Error; } static int test_quat_precision() { int Error = 0; { glm::f32quat q1(0.f, glm::vec3(0.f, 0.f, 1.f)); glm::lowp_f32quat qA(q1); glm::mediump_f32quat qB(q1); glm::highp_f32quat qC(q1); glm::f32quat q2(qA); glm::f32quat q3(qB); glm::f32quat q4(qC); Error += glm::all(glm::equal(q1, q2)) ? 0 : 1; Error += glm::all(glm::equal(q1, q3)) ? 0 : 1; Error += glm::all(glm::equal(q1, q4)) ? 0 : 1; } return Error; } static int test_fvec_conversion() { int Error(0); { glm::highp_vec4 a = glm::vec4(1, 2, 3, 4); glm::mediump_vec4 b = glm::vec4(1, 2, 3, 4); glm::lowp_vec4 c = b; glm::mediump_vec4 d = c; glm::lowp_ivec4 e = glm::ivec4(d); glm::lowp_ivec3 f = glm::ivec3(e); Error += glm::all(glm::equal(b, d)) ? 0 : 1; } return Error; } #if GLM_HAS_OPENMP static int test_openmp() { std::vector VectorA(1000); std::vector VectorB(1000); std::vector VectorC(1000); for (std::size_t i = 0; i < VectorA.size(); ++i) { VectorA[i] = glm::u8vec3(1, 1, 1); VectorB[i] = glm::u8vec3(1, 1, 1); } #pragma omp parallel for default(none) shared(VectorA, VectorB, VectorC) for (int i = 0; i < static_cast(VectorC.size()); ++i) { VectorC[i] = VectorA[i] + VectorB[i]; } return 0; } #endif//GLM_HAS_OPENMP int main() { int Error = 0; Error += test_scalar_size(); Error += test_fvec_size(); Error += test_fvec_precision(); Error += test_fvec_conversion(); Error += test_dvec_precision(); Error += test_uvec_size(); Error += test_uvec_precision(); Error += test_ivec_size(); Error += test_ivec_precision(); Error += test_fmat_size(); Error += test_dmat_size(); Error += test_quat_size(); Error += test_quat_precision(); # if GLM_HAS_OPENMP Error += test_openmp(); # endif// return Error; } glm-0.9.9-a2/test/gtc/gtc_round.cpp0000600000175000001440000002165213173131001015722 0ustar guususers#include #include #include #include #include #include #include namespace isPowerOfTwo { template struct type { genType Value; bool Return; }; int test_int16() { type const Data[] = { {0x0001, true}, {0x0002, true}, {0x0004, true}, {0x0080, true}, {0x0000, true}, {0x0003, false} }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { bool Result = glm::isPowerOfTwo(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int test_uint16() { type const Data[] = { {0x0001, true}, {0x0002, true}, {0x0004, true}, {0x0000, true}, {0x0000, true}, {0x0003, false} }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { bool Result = glm::isPowerOfTwo(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int test_int32() { type const Data[] = { {0x00000001, true}, {0x00000002, true}, {0x00000004, true}, {0x0000000f, false}, {0x00000000, true}, {0x00000003, false} }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { bool Result = glm::isPowerOfTwo(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::bvec1 Result = glm::isPowerOfTwo(glm::ivec1(Data[i].Value)); Error += glm::all(glm::equal(glm::bvec1(Data[i].Return), Result)) ? 0 : 1; } for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::bvec2 Result = glm::isPowerOfTwo(glm::ivec2(Data[i].Value)); Error += glm::all(glm::equal(glm::bvec2(Data[i].Return), Result)) ? 0 : 1; } for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::bvec3 Result = glm::isPowerOfTwo(glm::ivec3(Data[i].Value)); Error += glm::all(glm::equal(glm::bvec3(Data[i].Return), Result)) ? 0 : 1; } for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::bvec4 Result = glm::isPowerOfTwo(glm::ivec4(Data[i].Value)); Error += glm::all(glm::equal(glm::bvec4(Data[i].Return), Result)) ? 0 : 1; } return Error; } int test_uint32() { type const Data[] = { {0x00000001, true}, {0x00000002, true}, {0x00000004, true}, {0x80000000, true}, {0x00000000, true}, {0x00000003, false} }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { bool Result = glm::isPowerOfTwo(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int test() { int Error(0); Error += test_int16(); Error += test_uint16(); Error += test_int32(); Error += test_uint32(); return Error; } }//isPowerOfTwo namespace ceilPowerOfTwo_advanced { template GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value) { genIUType tmp = Value; genIUType result = genIUType(0); while(tmp) { result = (tmp & (~tmp + 1)); // grab lowest bit tmp &= ~result; // clear lowest bit } return result; } template GLM_FUNC_QUALIFIER genType ceilPowerOfTwo_loop(genType value) { return glm::isPowerOfTwo(value) ? value : highestBitValue(value) << 1; } template struct type { genType Value; genType Return; }; int test_int32() { type const Data[] = { {0x0000ffff, 0x00010000}, {-3, -4}, {-8, -8}, {0x00000001, 0x00000001}, {0x00000002, 0x00000002}, {0x00000004, 0x00000004}, {0x00000007, 0x00000008}, {0x0000fff0, 0x00010000}, {0x0000f000, 0x00010000}, {0x08000000, 0x08000000}, {0x00000000, 0x00000000}, {0x00000003, 0x00000004} }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::int32 Result = glm::ceilPowerOfTwo(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int test_uint32() { type const Data[] = { {0x00000001, 0x00000001}, {0x00000002, 0x00000002}, {0x00000004, 0x00000004}, {0x00000007, 0x00000008}, {0x0000ffff, 0x00010000}, {0x0000fff0, 0x00010000}, {0x0000f000, 0x00010000}, {0x80000000, 0x80000000}, {0x00000000, 0x00000000}, {0x00000003, 0x00000004} }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::uint32 Result = glm::ceilPowerOfTwo(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int perf() { int Error(0); std::vector v; v.resize(100000000); std::clock_t Timestramp0 = std::clock(); for(glm::uint32 i = 0, n = static_cast(v.size()); i < n; ++i) v[i] = ceilPowerOfTwo_loop(i); std::clock_t Timestramp1 = std::clock(); for(glm::uint32 i = 0, n = static_cast(v.size()); i < n; ++i) v[i] = glm::ceilPowerOfTwo(i); std::clock_t Timestramp2 = std::clock(); std::printf("ceilPowerOfTwo_loop: %d clocks\n", static_cast(Timestramp1 - Timestramp0)); std::printf("glm::ceilPowerOfTwo: %d clocks\n", static_cast(Timestramp2 - Timestramp1)); return Error; } int test() { int Error(0); Error += test_int32(); Error += test_uint32(); return Error; } }//namespace ceilPowerOfTwo_advanced namespace roundPowerOfTwo { int test() { int Error = 0; glm::uint32 const A = glm::roundPowerOfTwo(7u); Error += A == 8u ? 0 : 1; glm::uint32 const B = glm::roundPowerOfTwo(15u); Error += B == 16u ? 0 : 1; glm::uint32 const C = glm::roundPowerOfTwo(31u); Error += C == 32u ? 0 : 1; glm::uint32 const D = glm::roundPowerOfTwo(9u); Error += D == 8u ? 0 : 1; glm::uint32 const E = glm::roundPowerOfTwo(17u); Error += E == 16u ? 0 : 1; glm::uint32 const F = glm::roundPowerOfTwo(33u); Error += F == 32u ? 0 : 1; return Error; } }//namespace roundPowerOfTwo namespace floorPowerOfTwo { int test() { int Error = 0; glm::uint32 const A = glm::floorPowerOfTwo(7u); Error += A == 4u ? 0 : 1; glm::uint32 const B = glm::floorPowerOfTwo(15u); Error += B == 8u ? 0 : 1; glm::uint32 const C = glm::floorPowerOfTwo(31u); Error += C == 16u ? 0 : 1; return Error; } }//namespace floorPowerOfTwo namespace ceilPowerOfTwo { int test() { int Error = 0; glm::uint32 const A = glm::ceilPowerOfTwo(7u); Error += A == 8u ? 0 : 1; glm::uint32 const B = glm::ceilPowerOfTwo(15u); Error += B == 16u ? 0 : 1; glm::uint32 const C = glm::ceilPowerOfTwo(31u); Error += C == 32u ? 0 : 1; return Error; } }//namespace ceilPowerOfTwo namespace floorMultiple { template struct type { genType Source; genType Multiple; genType Return; genType Epsilon; }; int test_float() { type const Data[] = { {3.4, 0.3, 3.3, 0.0001}, {-1.4, 0.3, -1.5, 0.0001}, }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::float64 Result = glm::floorMultiple(Data[i].Source, Data[i].Multiple); Error += glm::epsilonEqual(Data[i].Return, Result, Data[i].Epsilon) ? 0 : 1; } return Error; } int test() { int Error(0); Error += test_float(); return Error; } }//namespace floorMultiple namespace ceilMultiple { template struct type { genType Source; genType Multiple; genType Return; genType Epsilon; }; int test_float() { type const Data[] = { {3.4, 0.3, 3.6, 0.0001}, {-1.4, 0.3, -1.2, 0.0001}, }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::float64 Result = glm::ceilMultiple(Data[i].Source, Data[i].Multiple); Error += glm::epsilonEqual(Data[i].Return, Result, Data[i].Epsilon) ? 0 : 1; } return Error; } int test_int() { type const Data[] = { {3, 4, 4, 0}, {7, 4, 8, 0}, {5, 4, 8, 0}, {1, 4, 4, 0}, {1, 3, 3, 0}, {4, 3, 6, 0}, {4, 1, 4, 0}, {1, 1, 1, 0}, {7, 1, 7, 0}, }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { int Result = glm::ceilMultiple(Data[i].Source, Data[i].Multiple); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int test() { int Error(0); Error += test_int(); Error += test_float(); return Error; } }//namespace ceilMultiple int main() { int Error(0); Error += isPowerOfTwo::test(); Error += floorPowerOfTwo::test(); Error += roundPowerOfTwo::test(); Error += ceilPowerOfTwo::test(); Error += ceilPowerOfTwo_advanced::test(); # ifdef NDEBUG Error += ceilPowerOfTwo_advanced::perf(); # endif//NDEBUG Error += floorMultiple::test(); Error += ceilMultiple::test(); return Error; } glm-0.9.9-a2/test/gtc/gtc_matrix_access.cpp0000600000175000001440000002146713173131001017424 0ustar guususers#include #include #include #include #include #include #include #include #include #include int test_mat2x2_row_set() { int Error = 0; glm::mat2x2 m(1); m = glm::row(m, 0, glm::vec2( 0, 1)); m = glm::row(m, 1, glm::vec2( 4, 5)); Error += glm::row(m, 0) == glm::vec2( 0, 1) ? 0 : 1; Error += glm::row(m, 1) == glm::vec2( 4, 5) ? 0 : 1; return Error; } int test_mat2x2_col_set() { int Error = 0; glm::mat2x2 m(1); m = glm::column(m, 0, glm::vec2( 0, 1)); m = glm::column(m, 1, glm::vec2( 4, 5)); Error += glm::column(m, 0) == glm::vec2( 0, 1) ? 0 : 1; Error += glm::column(m, 1) == glm::vec2( 4, 5) ? 0 : 1; return Error; } int test_mat2x3_row_set() { int Error = 0; glm::mat2x3 m(1); m = glm::row(m, 0, glm::vec2( 0, 1)); m = glm::row(m, 1, glm::vec2( 4, 5)); m = glm::row(m, 2, glm::vec2( 8, 9)); Error += glm::row(m, 0) == glm::vec2( 0, 1) ? 0 : 1; Error += glm::row(m, 1) == glm::vec2( 4, 5) ? 0 : 1; Error += glm::row(m, 2) == glm::vec2( 8, 9) ? 0 : 1; return Error; } int test_mat2x3_col_set() { int Error = 0; glm::mat2x3 m(1); m = glm::column(m, 0, glm::vec3( 0, 1, 2)); m = glm::column(m, 1, glm::vec3( 4, 5, 6)); Error += glm::column(m, 0) == glm::vec3( 0, 1, 2) ? 0 : 1; Error += glm::column(m, 1) == glm::vec3( 4, 5, 6) ? 0 : 1; return Error; } int test_mat2x4_row_set() { int Error = 0; glm::mat2x4 m(1); m = glm::row(m, 0, glm::vec2( 0, 1)); m = glm::row(m, 1, glm::vec2( 4, 5)); m = glm::row(m, 2, glm::vec2( 8, 9)); m = glm::row(m, 3, glm::vec2(12, 13)); Error += glm::row(m, 0) == glm::vec2( 0, 1) ? 0 : 1; Error += glm::row(m, 1) == glm::vec2( 4, 5) ? 0 : 1; Error += glm::row(m, 2) == glm::vec2( 8, 9) ? 0 : 1; Error += glm::row(m, 3) == glm::vec2(12, 13) ? 0 : 1; return Error; } int test_mat2x4_col_set() { int Error = 0; glm::mat2x4 m(1); m = glm::column(m, 0, glm::vec4( 0, 1, 2, 3)); m = glm::column(m, 1, glm::vec4( 4, 5, 6, 7)); Error += glm::column(m, 0) == glm::vec4( 0, 1, 2, 3) ? 0 : 1; Error += glm::column(m, 1) == glm::vec4( 4, 5, 6, 7) ? 0 : 1; return Error; } int test_mat3x2_row_set() { int Error = 0; glm::mat3x2 m(1); m = glm::row(m, 0, glm::vec3( 0, 1, 2)); m = glm::row(m, 1, glm::vec3( 4, 5, 6)); Error += glm::row(m, 0) == glm::vec3( 0, 1, 2) ? 0 : 1; Error += glm::row(m, 1) == glm::vec3( 4, 5, 6) ? 0 : 1; return Error; } int test_mat3x2_col_set() { int Error = 0; glm::mat3x2 m(1); m = glm::column(m, 0, glm::vec2( 0, 1)); m = glm::column(m, 1, glm::vec2( 4, 5)); m = glm::column(m, 2, glm::vec2( 8, 9)); Error += glm::column(m, 0) == glm::vec2( 0, 1) ? 0 : 1; Error += glm::column(m, 1) == glm::vec2( 4, 5) ? 0 : 1; Error += glm::column(m, 2) == glm::vec2( 8, 9) ? 0 : 1; return Error; } int test_mat3x3_row_set() { int Error = 0; glm::mat3x3 m(1); m = glm::row(m, 0, glm::vec3( 0, 1, 2)); m = glm::row(m, 1, glm::vec3( 4, 5, 6)); m = glm::row(m, 2, glm::vec3( 8, 9, 10)); Error += glm::row(m, 0) == glm::vec3( 0, 1, 2) ? 0 : 1; Error += glm::row(m, 1) == glm::vec3( 4, 5, 6) ? 0 : 1; Error += glm::row(m, 2) == glm::vec3( 8, 9, 10) ? 0 : 1; return Error; } int test_mat3x3_col_set() { int Error = 0; glm::mat3x3 m(1); m = glm::column(m, 0, glm::vec3( 0, 1, 2)); m = glm::column(m, 1, glm::vec3( 4, 5, 6)); m = glm::column(m, 2, glm::vec3( 8, 9, 10)); Error += glm::column(m, 0) == glm::vec3( 0, 1, 2) ? 0 : 1; Error += glm::column(m, 1) == glm::vec3( 4, 5, 6) ? 0 : 1; Error += glm::column(m, 2) == glm::vec3( 8, 9, 10) ? 0 : 1; return Error; } int test_mat3x4_row_set() { int Error = 0; glm::mat3x4 m(1); m = glm::row(m, 0, glm::vec3( 0, 1, 2)); m = glm::row(m, 1, glm::vec3( 4, 5, 6)); m = glm::row(m, 2, glm::vec3( 8, 9, 10)); m = glm::row(m, 3, glm::vec3(12, 13, 14)); Error += glm::row(m, 0) == glm::vec3( 0, 1, 2) ? 0 : 1; Error += glm::row(m, 1) == glm::vec3( 4, 5, 6) ? 0 : 1; Error += glm::row(m, 2) == glm::vec3( 8, 9, 10) ? 0 : 1; Error += glm::row(m, 3) == glm::vec3(12, 13, 14) ? 0 : 1; return Error; } int test_mat3x4_col_set() { int Error = 0; glm::mat3x4 m(1); m = glm::column(m, 0, glm::vec4( 0, 1, 2, 3)); m = glm::column(m, 1, glm::vec4( 4, 5, 6, 7)); m = glm::column(m, 2, glm::vec4( 8, 9, 10, 11)); Error += glm::column(m, 0) == glm::vec4( 0, 1, 2, 3) ? 0 : 1; Error += glm::column(m, 1) == glm::vec4( 4, 5, 6, 7) ? 0 : 1; Error += glm::column(m, 2) == glm::vec4( 8, 9, 10, 11) ? 0 : 1; return Error; } int test_mat4x2_row_set() { int Error = 0; glm::mat4x2 m(1); m = glm::row(m, 0, glm::vec4( 0, 1, 2, 3)); m = glm::row(m, 1, glm::vec4( 4, 5, 6, 7)); Error += glm::row(m, 0) == glm::vec4( 0, 1, 2, 3) ? 0 : 1; Error += glm::row(m, 1) == glm::vec4( 4, 5, 6, 7) ? 0 : 1; return Error; } int test_mat4x2_col_set() { int Error = 0; glm::mat4x2 m(1); m = glm::column(m, 0, glm::vec2( 0, 1)); m = glm::column(m, 1, glm::vec2( 4, 5)); m = glm::column(m, 2, glm::vec2( 8, 9)); m = glm::column(m, 3, glm::vec2(12, 13)); Error += glm::column(m, 0) == glm::vec2( 0, 1) ? 0 : 1; Error += glm::column(m, 1) == glm::vec2( 4, 5) ? 0 : 1; Error += glm::column(m, 2) == glm::vec2( 8, 9) ? 0 : 1; Error += glm::column(m, 3) == glm::vec2(12, 13) ? 0 : 1; return Error; } int test_mat4x3_row_set() { int Error = 0; glm::mat4x3 m(1); m = glm::row(m, 0, glm::vec4( 0, 1, 2, 3)); m = glm::row(m, 1, glm::vec4( 4, 5, 6, 7)); m = glm::row(m, 2, glm::vec4( 8, 9, 10, 11)); Error += glm::row(m, 0) == glm::vec4( 0, 1, 2, 3) ? 0 : 1; Error += glm::row(m, 1) == glm::vec4( 4, 5, 6, 7) ? 0 : 1; Error += glm::row(m, 2) == glm::vec4( 8, 9, 10, 11) ? 0 : 1; return Error; } int test_mat4x3_col_set() { int Error = 0; glm::mat4x3 m(1); m = glm::column(m, 0, glm::vec3( 0, 1, 2)); m = glm::column(m, 1, glm::vec3( 4, 5, 6)); m = glm::column(m, 2, glm::vec3( 8, 9, 10)); m = glm::column(m, 3, glm::vec3(12, 13, 14)); Error += glm::column(m, 0) == glm::vec3( 0, 1, 2) ? 0 : 1; Error += glm::column(m, 1) == glm::vec3( 4, 5, 6) ? 0 : 1; Error += glm::column(m, 2) == glm::vec3( 8, 9, 10) ? 0 : 1; Error += glm::column(m, 3) == glm::vec3(12, 13, 14) ? 0 : 1; return Error; } int test_mat4x4_row_set() { int Error = 0; glm::mat4 m(1); m = glm::row(m, 0, glm::vec4( 0, 1, 2, 3)); m = glm::row(m, 1, glm::vec4( 4, 5, 6, 7)); m = glm::row(m, 2, glm::vec4( 8, 9, 10, 11)); m = glm::row(m, 3, glm::vec4(12, 13, 14, 15)); Error += glm::row(m, 0) == glm::vec4( 0, 1, 2, 3) ? 0 : 1; Error += glm::row(m, 1) == glm::vec4( 4, 5, 6, 7) ? 0 : 1; Error += glm::row(m, 2) == glm::vec4( 8, 9, 10, 11) ? 0 : 1; Error += glm::row(m, 3) == glm::vec4(12, 13, 14, 15) ? 0 : 1; return Error; } int test_mat4x4_col_set() { int Error = 0; glm::mat4 m(1); m = glm::column(m, 0, glm::vec4( 0, 1, 2, 3)); m = glm::column(m, 1, glm::vec4( 4, 5, 6, 7)); m = glm::column(m, 2, glm::vec4( 8, 9, 10, 11)); m = glm::column(m, 3, glm::vec4(12, 13, 14, 15)); Error += glm::column(m, 0) == glm::vec4( 0, 1, 2, 3) ? 0 : 1; Error += glm::column(m, 1) == glm::vec4( 4, 5, 6, 7) ? 0 : 1; Error += glm::column(m, 2) == glm::vec4( 8, 9, 10, 11) ? 0 : 1; Error += glm::column(m, 3) == glm::vec4(12, 13, 14, 15) ? 0 : 1; return Error; } int test_mat4x4_row_get() { int Error = 0; glm::mat4 m(1); glm::vec4 A = glm::row(m, 0); Error += A == glm::vec4(1, 0, 0, 0) ? 0 : 1; glm::vec4 B = glm::row(m, 1); Error += B == glm::vec4(0, 1, 0, 0) ? 0 : 1; glm::vec4 C = glm::row(m, 2); Error += C == glm::vec4(0, 0, 1, 0) ? 0 : 1; glm::vec4 D = glm::row(m, 3); Error += D == glm::vec4(0, 0, 0, 1) ? 0 : 1; return Error; } int test_mat4x4_col_get() { int Error = 0; glm::mat4 m(1); glm::vec4 A = glm::column(m, 0); Error += A == glm::vec4(1, 0, 0, 0) ? 0 : 1; glm::vec4 B = glm::column(m, 1); Error += B == glm::vec4(0, 1, 0, 0) ? 0 : 1; glm::vec4 C = glm::column(m, 2); Error += C == glm::vec4(0, 0, 1, 0) ? 0 : 1; glm::vec4 D = glm::column(m, 3); Error += D == glm::vec4(0, 0, 0, 1) ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_mat2x2_row_set(); Error += test_mat2x2_col_set(); Error += test_mat2x3_row_set(); Error += test_mat2x3_col_set(); Error += test_mat2x4_row_set(); Error += test_mat2x4_col_set(); Error += test_mat3x2_row_set(); Error += test_mat3x2_col_set(); Error += test_mat3x3_row_set(); Error += test_mat3x3_col_set(); Error += test_mat3x4_row_set(); Error += test_mat3x4_col_set(); Error += test_mat4x2_row_set(); Error += test_mat4x2_col_set(); Error += test_mat4x3_row_set(); Error += test_mat4x3_col_set(); Error += test_mat4x4_row_set(); Error += test_mat4x4_col_set(); Error += test_mat4x4_row_get(); Error += test_mat4x4_col_get(); return Error; } glm-0.9.9-a2/test/gtc/gtc_bitfield.cpp0000600000175000001440000006412013173131001016352 0ustar guususers#include #include #include #include #include #include #include namespace mask { template struct type { genType Value; genType Return; }; inline int mask_zero(int Bits) { return ~((~0) << Bits); } inline int mask_mix(int Bits) { return Bits >= sizeof(int) * 8 ? 0xffffffff : (static_cast(1) << Bits) - static_cast(1); } inline int mask_half(int Bits) { // We do the shift in two steps because 1 << 32 on an int is undefined. int const Half = Bits >> 1; int const Fill = ~0; int const ShiftHaft = (Fill << Half); int const Rest = Bits - Half; int const Reversed = ShiftHaft << Rest; return ~Reversed; } inline int mask_loop(int Bits) { int Mask = 0; for(int Bit = 0; Bit < Bits; ++Bit) Mask |= (static_cast(1) << Bit); return Mask; } int perf() { int const Count = 100000000; std::clock_t Timestamp1 = std::clock(); { std::vector Mask; Mask.resize(Count); for(int i = 0; i < Count; ++i) Mask[i] = mask_mix(i % 32); } std::clock_t Timestamp2 = std::clock(); { std::vector Mask; Mask.resize(Count); for(int i = 0; i < Count; ++i) Mask[i] = mask_loop(i % 32); } std::clock_t Timestamp3 = std::clock(); { std::vector Mask; Mask.resize(Count); for(int i = 0; i < Count; ++i) Mask[i] = glm::mask(i % 32); } std::clock_t Timestamp4 = std::clock(); { std::vector Mask; Mask.resize(Count); for(int i = 0; i < Count; ++i) Mask[i] = mask_zero(i % 32); } std::clock_t Timestamp5 = std::clock(); { std::vector Mask; Mask.resize(Count); for(int i = 0; i < Count; ++i) Mask[i] = mask_half(i % 32); } std::clock_t Timestamp6 = std::clock(); std::clock_t TimeMix = Timestamp2 - Timestamp1; std::clock_t TimeLoop = Timestamp3 - Timestamp2; std::clock_t TimeDefault = Timestamp4 - Timestamp3; std::clock_t TimeZero = Timestamp5 - Timestamp4; std::clock_t TimeHalf = Timestamp6 - Timestamp5; printf("mask[mix]: %d\n", static_cast(TimeMix)); printf("mask[loop]: %d\n", static_cast(TimeLoop)); printf("mask[default]: %d\n", static_cast(TimeDefault)); printf("mask[zero]: %d\n", static_cast(TimeZero)); printf("mask[half]: %d\n", static_cast(TimeHalf)); return TimeDefault < TimeLoop ? 0 : 1; } int test_uint() { type const Data[] = { { 0, 0x00000000}, { 1, 0x00000001}, { 2, 0x00000003}, { 3, 0x00000007}, {31, 0x7fffffff}, {32, 0xffffffff} }; int Error = 0; /* mask_zero is sadly not a correct code for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = mask_zero(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } */ for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = mask_mix(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = mask_half(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = mask_loop(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = glm::mask(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int test_uvec4() { type const Data[] = { {glm::ivec4( 0), glm::ivec4(0x00000000)}, {glm::ivec4( 1), glm::ivec4(0x00000001)}, {glm::ivec4( 2), glm::ivec4(0x00000003)}, {glm::ivec4( 3), glm::ivec4(0x00000007)}, {glm::ivec4(31), glm::ivec4(0x7fffffff)}, {glm::ivec4(32), glm::ivec4(0xffffffff)} }; int Error(0); for(std::size_t i = 0, n = sizeof(Data) / sizeof(type); i < n; ++i) { glm::ivec4 Result = glm::mask(Data[i].Value); Error += glm::all(glm::equal(Data[i].Return, Result)) ? 0 : 1; } return Error; } int test() { int Error(0); Error += test_uint(); Error += test_uvec4(); return Error; } }//namespace mask namespace bitfieldInterleave3 { template inline RET refBitfieldInterleave(PARAM x, PARAM y, PARAM z) { RET Result = 0; for(RET i = 0; i < sizeof(PARAM) * 8; ++i) { Result |= ((RET(x) & (RET(1U) << i)) << ((i << 1) + 0)); Result |= ((RET(y) & (RET(1U) << i)) << ((i << 1) + 1)); Result |= ((RET(z) & (RET(1U) << i)) << ((i << 1) + 2)); } return Result; } int test() { int Error(0); glm::uint16 x_max = 1 << 11; glm::uint16 y_max = 1 << 11; glm::uint16 z_max = 1 << 11; for(glm::uint16 z = 0; z < z_max; z += 27) for(glm::uint16 y = 0; y < y_max; y += 27) for(glm::uint16 x = 0; x < x_max; x += 27) { glm::uint64 ResultA = refBitfieldInterleave(x, y, z); glm::uint64 ResultB = glm::bitfieldInterleave(x, y, z); Error += ResultA == ResultB ? 0 : 1; } return Error; } } namespace bitfieldInterleave4 { template inline RET loopBitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w) { RET const v[4] = {x, y, z, w}; RET Result = 0; for(RET i = 0; i < sizeof(PARAM) * 8; i++) { Result |= ((((v[0] >> i) & 1U)) << ((i << 2) + 0)); Result |= ((((v[1] >> i) & 1U)) << ((i << 2) + 1)); Result |= ((((v[2] >> i) & 1U)) << ((i << 2) + 2)); Result |= ((((v[3] >> i) & 1U)) << ((i << 2) + 3)); } return Result; } int test() { int Error(0); glm::uint16 x_max = 1 << 11; glm::uint16 y_max = 1 << 11; glm::uint16 z_max = 1 << 11; glm::uint16 w_max = 1 << 11; for(glm::uint16 w = 0; w < w_max; w += 27) for(glm::uint16 z = 0; z < z_max; z += 27) for(glm::uint16 y = 0; y < y_max; y += 27) for(glm::uint16 x = 0; x < x_max; x += 27) { glm::uint64 ResultA = loopBitfieldInterleave(x, y, z, w); glm::uint64 ResultB = glm::bitfieldInterleave(x, y, z, w); Error += ResultA == ResultB ? 0 : 1; } return Error; } } namespace bitfieldInterleave { inline glm::uint64 fastBitfieldInterleave(glm::uint32 x, glm::uint32 y) { glm::uint64 REG1; glm::uint64 REG2; REG1 = x; REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); REG2 = y; REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); return REG1 | (REG2 << 1); } inline glm::uint64 interleaveBitfieldInterleave(glm::uint32 x, glm::uint32 y) { glm::uint64 REG1; glm::uint64 REG2; REG1 = x; REG2 = y; REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); return REG1 | (REG2 << 1); } /* inline glm::uint64 loopBitfieldInterleave(glm::uint32 x, glm::uint32 y) { static glm::uint64 const Mask[5] = { 0x5555555555555555, 0x3333333333333333, 0x0F0F0F0F0F0F0F0F, 0x00FF00FF00FF00FF, 0x0000FFFF0000FFFF }; glm::uint64 REG1 = x; glm::uint64 REG2 = y; for(int i = 4; i >= 0; --i) { REG1 = ((REG1 << (1 << i)) | REG1) & Mask[i]; REG2 = ((REG2 << (1 << i)) | REG2) & Mask[i]; } return REG1 | (REG2 << 1); } */ #if GLM_ARCH & GLM_ARCH_SSE2_BIT inline glm::uint64 sseBitfieldInterleave(glm::uint32 x, glm::uint32 y) { __m128i const Array = _mm_set_epi32(0, y, 0, x); __m128i const Mask4 = _mm_set1_epi32(0x0000FFFF); __m128i const Mask3 = _mm_set1_epi32(0x00FF00FF); __m128i const Mask2 = _mm_set1_epi32(0x0F0F0F0F); __m128i const Mask1 = _mm_set1_epi32(0x33333333); __m128i const Mask0 = _mm_set1_epi32(0x55555555); __m128i Reg1; __m128i Reg2; // REG1 = x; // REG2 = y; Reg1 = _mm_load_si128(&Array); //REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); //REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); Reg2 = _mm_slli_si128(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask4); //REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); //REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); Reg2 = _mm_slli_si128(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask3); //REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); //REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); Reg2 = _mm_slli_epi32(Reg1, 4); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask2); //REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); //REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); Reg2 = _mm_slli_epi32(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask1); //REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); //REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); Reg2 = _mm_slli_epi32(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask0); //return REG1 | (REG2 << 1); Reg2 = _mm_slli_epi32(Reg1, 1); Reg2 = _mm_srli_si128(Reg2, 8); Reg1 = _mm_or_si128(Reg1, Reg2); __m128i Result; _mm_store_si128(&Result, Reg1); return *reinterpret_cast(&Result); } inline glm::uint64 sseUnalignedBitfieldInterleave(glm::uint32 x, glm::uint32 y) { __m128i const Array = _mm_set_epi32(0, y, 0, x); __m128i const Mask4 = _mm_set1_epi32(0x0000FFFF); __m128i const Mask3 = _mm_set1_epi32(0x00FF00FF); __m128i const Mask2 = _mm_set1_epi32(0x0F0F0F0F); __m128i const Mask1 = _mm_set1_epi32(0x33333333); __m128i const Mask0 = _mm_set1_epi32(0x55555555); __m128i Reg1; __m128i Reg2; // REG1 = x; // REG2 = y; Reg1 = _mm_loadu_si128(&Array); //REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); //REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); Reg2 = _mm_slli_si128(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask4); //REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); //REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); Reg2 = _mm_slli_si128(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask3); //REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); //REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); Reg2 = _mm_slli_epi32(Reg1, 4); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask2); //REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); //REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); Reg2 = _mm_slli_epi32(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask1); //REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); //REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); Reg2 = _mm_slli_epi32(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask0); //return REG1 | (REG2 << 1); Reg2 = _mm_slli_epi32(Reg1, 1); Reg2 = _mm_srli_si128(Reg2, 8); Reg1 = _mm_or_si128(Reg1, Reg2); __m128i Result; _mm_store_si128(&Result, Reg1); return *reinterpret_cast(&Result); } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT int test() { int Error = 0; /* { for(glm::uint32 y = 0; y < (1 << 10); ++y) for(glm::uint32 x = 0; x < (1 << 10); ++x) { glm::uint64 A = glm::bitfieldInterleave(x, y); glm::uint64 B = fastBitfieldInterleave(x, y); //glm::uint64 C = loopBitfieldInterleave(x, y); glm::uint64 D = interleaveBitfieldInterleave(x, y); assert(A == B); //assert(A == C); assert(A == D); # if GLM_ARCH & GLM_ARCH_SSE2_BIT glm::uint64 E = sseBitfieldInterleave(x, y); glm::uint64 F = sseUnalignedBitfieldInterleave(x, y); assert(A == E); assert(A == F); __m128i G = glm_i128_interleave(_mm_set_epi32(0, y, 0, x)); glm::uint64 Result[2]; _mm_storeu_si128((__m128i*)Result, G); assert(A == Result[0]); # endif//GLM_ARCH & GLM_ARCH_SSE2_BIT } } */ { for(glm::uint8 y = 0; y < 127; ++y) for(glm::uint8 x = 0; x < 127; ++x) { glm::uint64 A(glm::bitfieldInterleave(glm::uint8(x), glm::uint8(y))); glm::uint64 B(glm::bitfieldInterleave(glm::uint16(x), glm::uint16(y))); glm::uint64 C(glm::bitfieldInterleave(glm::uint32(x), glm::uint32(y))); Error += A == B ? 0 : 1; Error += A == C ? 0 : 1; glm::int64 D(glm::bitfieldInterleave(glm::int8(x), glm::int8(y))); glm::int64 E(glm::bitfieldInterleave(glm::int16(x), glm::int16(y))); glm::int64 F(glm::bitfieldInterleave(glm::int32(x), glm::int32(y))); Error += D == E ? 0 : 1; Error += D == F ? 0 : 1; } } return Error; } int perf() { glm::uint32 x_max = 1 << 11; glm::uint32 y_max = 1 << 10; // ALU std::vector Data(x_max * y_max); std::vector Param(x_max * y_max); for(glm::uint32 i = 0; i < Param.size(); ++i) Param[i] = glm::u32vec2(i % x_max, i / y_max); { std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = glm::bitfieldInterleave(Param[i].x, Param[i].y); std::clock_t Time = std::clock() - LastTime; std::printf("glm::bitfieldInterleave Time %d clocks\n", static_cast(Time)); } { std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = fastBitfieldInterleave(Param[i].x, Param[i].y); std::clock_t Time = std::clock() - LastTime; std::printf("fastBitfieldInterleave Time %d clocks\n", static_cast(Time)); } /* { std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = loopBitfieldInterleave(Param[i].x, Param[i].y); std::clock_t Time = std::clock() - LastTime; std::printf("loopBitfieldInterleave Time %d clocks\n", static_cast(Time)); } */ { std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = interleaveBitfieldInterleave(Param[i].x, Param[i].y); std::clock_t Time = std::clock() - LastTime; std::printf("interleaveBitfieldInterleave Time %d clocks\n", static_cast(Time)); } # if GLM_ARCH & GLM_ARCH_SSE2_BIT { std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = sseBitfieldInterleave(Param[i].x, Param[i].y); std::clock_t Time = std::clock() - LastTime; std::printf("sseBitfieldInterleave Time %d clocks\n", static_cast(Time)); } { std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = sseUnalignedBitfieldInterleave(Param[i].x, Param[i].y); std::clock_t Time = std::clock() - LastTime; std::printf("sseUnalignedBitfieldInterleave Time %d clocks\n", static_cast(Time)); } # endif//GLM_ARCH & GLM_ARCH_SSE2_BIT { std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < Data.size(); ++i) Data[i] = glm::bitfieldInterleave(Param[i].x, Param[i].y, Param[i].x); std::clock_t Time = std::clock() - LastTime; std::printf("glm::detail::bitfieldInterleave Time %d clocks\n", static_cast(Time)); } # if(GLM_ARCH & GLM_ARCH_SSE2_BIT && !(GLM_COMPILER & GLM_COMPILER_GCC)) { // SIMD std::vector<__m128i> SimdData; SimdData.resize(static_cast(x_max * y_max)); std::vector<__m128i> SimdParam; SimdParam.resize(static_cast(x_max * y_max)); for(std::size_t i = 0; i < SimdParam.size(); ++i) SimdParam[i] = _mm_set_epi32(static_cast(i % static_cast(x_max)), 0, static_cast(i / static_cast(y_max)), 0); std::clock_t LastTime = std::clock(); for(std::size_t i = 0; i < SimdData.size(); ++i) SimdData[i] = glm_i128_interleave(SimdParam[i]); std::clock_t Time = std::clock() - LastTime; std::printf("_mm_bit_interleave_si128 Time %d clocks\n", static_cast(Time)); } # endif//GLM_ARCH & GLM_ARCH_SSE2_BIT return 0; } }//namespace bitfieldInterleave namespace bitfieldInterleave5 { GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave_u8vec2(glm::uint8 x, glm::uint8 y) { glm::uint32 Result = (glm::uint32(y) << 16) | glm::uint32(x); Result = ((Result << 4) | Result) & 0x0F0F0F0F; Result = ((Result << 2) | Result) & 0x33333333; Result = ((Result << 1) | Result) & 0x55555555; return static_cast((Result & 0x0000FFFF) | (Result >> 15)); } GLM_FUNC_QUALIFIER glm::u8vec2 bitfieldDeinterleave_u8vec2(glm::uint16 InterleavedBitfield) { glm::uint32 Result(InterleavedBitfield); Result = ((Result << 15) | Result) & 0x55555555; Result = ((Result >> 1) | Result) & 0x33333333; Result = ((Result >> 2) | Result) & 0x0F0F0F0F; Result = ((Result >> 4) | Result) & 0x00FF00FF; return glm::u8vec2(Result & 0x0000FFFF, Result >> 16); } GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave_u8vec4(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w) { glm::uint64 Result = (glm::uint64(w) << 48) | (glm::uint64(z) << 32) | (glm::uint64(y) << 16) | glm::uint64(x); Result = ((Result << 12) | Result) & 0x000F000F000F000Full; Result = ((Result << 6) | Result) & 0x0303030303030303ull; Result = ((Result << 3) | Result) & 0x1111111111111111ull; const glm::uint32 a = static_cast((Result & 0x000000000000FFFF) >> ( 0 - 0)); const glm::uint32 b = static_cast((Result & 0x00000000FFFF0000) >> (16 - 3)); const glm::uint32 c = static_cast((Result & 0x0000FFFF00000000) >> (32 - 6)); const glm::uint32 d = static_cast((Result & 0xFFFF000000000000) >> (48 - 12)); return a | b | c | d; } GLM_FUNC_QUALIFIER glm::u8vec4 bitfieldDeinterleave_u8vec4(glm::uint32 InterleavedBitfield) { glm::uint64 Result(InterleavedBitfield); Result = ((Result << 15) | Result) & 0x9249249249249249ull; Result = ((Result >> 1) | Result) & 0x30C30C30C30C30C3ull; Result = ((Result >> 2) | Result) & 0xF00F00F00F00F00Full; Result = ((Result >> 4) | Result) & 0x00FF0000FF0000FFull; return glm::u8vec4( (Result >> 0) & 0x000000000000FFFFull, (Result >> 16) & 0x00000000FFFF0000ull, (Result >> 32) & 0x0000FFFF00000000ull, (Result >> 48) & 0xFFFF000000000000ull); } GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave_u16vec2(glm::uint16 x, glm::uint16 y) { glm::uint64 Result = (glm::uint64(y) << 32) | glm::uint64(x); Result = ((Result << 8) | Result) & static_cast(0x00FF00FF00FF00FFull); Result = ((Result << 4) | Result) & static_cast(0x0F0F0F0F0F0F0F0Full); Result = ((Result << 2) | Result) & static_cast(0x3333333333333333ull); Result = ((Result << 1) | Result) & static_cast(0x5555555555555555ull); return static_cast((Result & 0x00000000FFFFFFFFull) | (Result >> 31)); } GLM_FUNC_QUALIFIER glm::u16vec2 bitfieldDeinterleave_u16vec2(glm::uint32 InterleavedBitfield) { glm::uint64 Result(InterleavedBitfield); Result = ((Result << 31) | Result) & 0x5555555555555555ull; Result = ((Result >> 1) | Result) & 0x3333333333333333ull; Result = ((Result >> 2) | Result) & 0x0F0F0F0F0F0F0F0Full; Result = ((Result >> 4) | Result) & 0x00FF00FF00FF00FFull; Result = ((Result >> 8) | Result) & 0x0000FFFF0000FFFFull; return glm::u16vec2(Result & 0x00000000FFFFFFFFull, Result >> 32); } int test() { int Error = 0; for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) { glm::uint16 A = bitfieldInterleave_u8vec2(glm::uint8(i), glm::uint8(j)); glm::uint16 B = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j)); Error += A == B ? 0 : 1; glm::u8vec2 C = bitfieldDeinterleave_u8vec2(A); Error += C.x == glm::uint8(i) ? 0 : 1; Error += C.y == glm::uint8(j) ? 0 : 1; } for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) { glm::uint32 A = bitfieldInterleave_u8vec4(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j)); glm::uint32 B = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j)); Error += A == B ? 0 : 1; /* glm::u8vec4 C = bitfieldDeinterleave_u8vec4(A); Error += C.x == glm::uint8(i) ? 0 : 1; Error += C.y == glm::uint8(j) ? 0 : 1; Error += C.z == glm::uint8(i) ? 0 : 1; Error += C.w == glm::uint8(j) ? 0 : 1; */ } for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) { glm::uint32 A = bitfieldInterleave_u16vec2(glm::uint16(i), glm::uint16(j)); glm::uint32 B = glm::bitfieldInterleave(glm::uint16(i), glm::uint16(j)); Error += A == B ? 0 : 1; } return Error; } int perf_old_u8vec2(std::vector& Result) { int Error = 0; const std::clock_t BeginTime = std::clock(); for(glm::size_t k = 0; k < 10000; ++k) for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Error += Result[j * 256 + i] == glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j)) ? 0 : 1; const std::clock_t EndTime = std::clock(); std::printf("glm::bitfieldInterleave Time %d clocks\n", static_cast(EndTime - BeginTime)); return Error; } int perf_new_u8vec2(std::vector& Result) { int Error = 0; const std::clock_t BeginTime = std::clock(); for(glm::size_t k = 0; k < 10000; ++k) for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Error += Result[j * 256 + i] == bitfieldInterleave_u8vec2(glm::uint8(i), glm::uint8(j)) ? 0 : 1; const std::clock_t EndTime = std::clock(); std::printf("bitfieldInterleave_u8vec2 Time %d clocks\n", static_cast(EndTime - BeginTime)); return Error; } int perf_old_u8vec4(std::vector& Result) { int Error = 0; const std::clock_t BeginTime = std::clock(); for(glm::size_t k = 0; k < 10000; ++k) for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Error += Result[j * 256 + i] == glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j)) ? 0 : 1; const std::clock_t EndTime = std::clock(); std::printf("glm::bitfieldInterleave Time %d clocks\n", static_cast(EndTime - BeginTime)); return Error; } int perf_new_u8vec4(std::vector& Result) { int Error = 0; const std::clock_t BeginTime = std::clock(); for(glm::size_t k = 0; k < 10000; ++k) for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Error += Result[j * 256 + i] == bitfieldInterleave_u8vec4(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j)) ? 0 : 1; const std::clock_t EndTime = std::clock(); std::printf("bitfieldInterleave_u8vec4 Time %d clocks\n", static_cast(EndTime - BeginTime)); return Error; } int perf_old_u16vec2(std::vector& Result) { int Error = 0; const std::clock_t BeginTime = std::clock(); for(glm::size_t k = 0; k < 10000; ++k) for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Error += Result[j * 256 + i] == glm::bitfieldInterleave(glm::uint16(i), glm::uint16(j)) ? 0 : 1; const std::clock_t EndTime = std::clock(); std::printf("glm::bitfieldInterleave Time %d clocks\n", static_cast(EndTime - BeginTime)); return Error; } int perf_new_u16vec2(std::vector& Result) { int Error = 0; const std::clock_t BeginTime = std::clock(); for(glm::size_t k = 0; k < 10000; ++k) for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Error += Result[j * 256 + i] == bitfieldInterleave_u16vec2(glm::uint16(i), glm::uint16(j)) ? 0 : 1; const std::clock_t EndTime = std::clock(); std::printf("bitfieldInterleave_u16vec2 Time %d clocks\n", static_cast(EndTime - BeginTime)); return Error; } int perf() { int Error = 0; std::printf("bitfieldInterleave perf: init\r"); std::vector Result_u8vec2(256 * 256, 0); for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Result_u8vec2[j * 256 + i] = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j)); Error += perf_old_u8vec2(Result_u8vec2); Error += perf_new_u8vec2(Result_u8vec2); std::vector Result_u8vec4(256 * 256, 0); for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Result_u8vec4[j * 256 + i] = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j)); Error += perf_old_u8vec4(Result_u8vec4); Error += perf_new_u8vec4(Result_u8vec4); std::vector Result_u16vec2(256 * 256, 0); for(glm::size_t j = 0; j < 256; ++j) for(glm::size_t i = 0; i < 256; ++i) Result_u16vec2[j * 256 + i] = glm::bitfieldInterleave(glm::uint16(i), glm::uint16(j)); Error += perf_old_u16vec2(Result_u16vec2); Error += perf_new_u16vec2(Result_u16vec2); std::printf("bitfieldInterleave perf: %d Errors\n", Error); return Error; } }//namespace bitfieldInterleave5 int main() { int Error = 0; /* Tests for a faster and to reserve bitfieldInterleave Error += ::bitfieldInterleave5::test(); Error += ::bitfieldInterleave5::perf(); */ Error += ::mask::test(); Error += ::bitfieldInterleave3::test(); Error += ::bitfieldInterleave4::test(); Error += ::bitfieldInterleave::test(); # ifdef NDEBUG Error += ::mask::perf(); Error += ::bitfieldInterleave::perf(); # endif//NDEBUG return Error; } glm-0.9.9-a2/test/gtc/gtc_integer.cpp0000600000175000001440000001227013173131001016224 0ustar guususers#define GLM_ENABLE_EXPERIMENTAL #define GLM_FORCE_INLINE #include #include #include #include #include #include #include #include #include #include #include #include #include namespace log2_ { int test() { int Error = 0; int A0 = static_cast(glm::log2(16.f)); glm::ivec1 B0(glm::log2(glm::vec1(16.f))); glm::ivec2 C0(glm::log2(glm::vec2(16.f))); glm::ivec3 D0(glm::log2(glm::vec3(16.f))); glm::ivec4 E0(glm::log2(glm::vec4(16.f))); int A1 = glm::log2(int(16)); glm::ivec1 B1 = glm::log2(glm::ivec1(16)); glm::ivec2 C1 = glm::log2(glm::ivec2(16)); glm::ivec3 D1 = glm::log2(glm::ivec3(16)); glm::ivec4 E1 = glm::log2(glm::ivec4(16)); Error += A0 == A1 ? 0 : 1; Error += glm::all(glm::equal(B0, B1)) ? 0 : 1; Error += glm::all(glm::equal(C0, C1)) ? 0 : 1; Error += glm::all(glm::equal(D0, D1)) ? 0 : 1; Error += glm::all(glm::equal(E0, E1)) ? 0 : 1; glm::uint64 A2 = glm::log2(glm::uint64(16)); glm::u64vec1 B2 = glm::log2(glm::u64vec1(16)); glm::u64vec2 C2 = glm::log2(glm::u64vec2(16)); glm::u64vec3 D2 = glm::log2(glm::u64vec3(16)); glm::u64vec4 E2 = glm::log2(glm::u64vec4(16)); Error += A2 == glm::uint64(4) ? 0 : 1; Error += glm::all(glm::equal(B2, glm::u64vec1(4))) ? 0 : 1; Error += glm::all(glm::equal(C2, glm::u64vec2(4))) ? 0 : 1; Error += glm::all(glm::equal(D2, glm::u64vec3(4))) ? 0 : 1; Error += glm::all(glm::equal(E2, glm::u64vec4(4))) ? 0 : 1; return Error; } int perf(std::size_t Count) { int Error = 0; { std::vector Result; Result.resize(Count); std::clock_t Begin = clock(); for(int i = 0; i < static_cast(Count); ++i) Result[i] = glm::log2(static_cast(i)); std::clock_t End = clock(); printf("glm::log2: %ld clocks\n", End - Begin); } { std::vector Result; Result.resize(Count); std::clock_t Begin = clock(); for(int i = 0; i < static_cast(Count); ++i) Result[i] = glm::log2(glm::ivec4(i)); std::clock_t End = clock(); printf("glm::log2: %ld clocks\n", End - Begin); } # if GLM_HAS_BITSCAN_WINDOWS { std::vector Result; Result.resize(Count); std::clock_t Begin = clock(); for(std::size_t i = 0; i < Count; ++i) { glm::vec<4, unsigned long, glm::defaultp> Tmp; _BitScanReverse(&Tmp.x, i); _BitScanReverse(&Tmp.y, i); _BitScanReverse(&Tmp.z, i); _BitScanReverse(&Tmp.w, i); Result[i] = glm::ivec4(Tmp); } std::clock_t End = clock(); printf("glm::log2 inlined: %ld clocks\n", End - Begin); } { std::vector > Result; Result.resize(Count); std::clock_t Begin = clock(); for(std::size_t i = 0; i < Count; ++i) { _BitScanReverse(&Result[i].x, i); _BitScanReverse(&Result[i].y, i); _BitScanReverse(&Result[i].z, i); _BitScanReverse(&Result[i].w, i); } std::clock_t End = clock(); printf("glm::log2 inlined no cast: %ld clocks\n", End - Begin); } { std::vector Result; Result.resize(Count); std::clock_t Begin = clock(); for(std::size_t i = 0; i < Count; ++i) { _BitScanReverse(reinterpret_cast(&Result[i].x), i); _BitScanReverse(reinterpret_cast(&Result[i].y), i); _BitScanReverse(reinterpret_cast(&Result[i].z), i); _BitScanReverse(reinterpret_cast(&Result[i].w), i); } std::clock_t End = clock(); printf("glm::log2 reinterpret: %ld clocks\n", End - Begin); } # endif//GLM_HAS_BITSCAN_WINDOWS { std::vector Result; Result.resize(Count); std::clock_t Begin = clock(); for(std::size_t i = 0; i < Count; ++i) Result[i] = glm::log2(static_cast(i)); std::clock_t End = clock(); printf("glm::log2: %ld clocks\n", End - Begin); } { std::vector Result; Result.resize(Count); std::clock_t Begin = clock(); for(int i = 0; i < static_cast(Count); ++i) Result[i] = glm::log2(glm::vec4(static_cast(i))); std::clock_t End = clock(); printf("glm::log2: %ld clocks\n", End - Begin); } return Error; } }//namespace log2_ namespace iround { int test() { int Error = 0; for(float f = 0.0f; f < 3.1f; f += 0.05f) { int RoundFast = static_cast(glm::iround(f)); int RoundSTD = static_cast(glm::round(f)); Error += RoundFast == RoundSTD ? 0 : 1; assert(!Error); } return Error; } }//namespace iround namespace uround { int test() { int Error = 0; for(float f = 0.0f; f < 3.1f; f += 0.05f) { int RoundFast = static_cast(glm::uround(f)); int RoundSTD = static_cast(glm::round(f)); Error += RoundFast == RoundSTD ? 0 : 1; assert(!Error); } return Error; } }//namespace uround int main() { int Error(0); Error += ::log2_::test(); Error += ::iround::test(); Error += ::uround::test(); # ifdef NDEBUG std::size_t const Samples(1000); Error += ::log2_::perf(Samples); # endif//NDEBUG return Error; } glm-0.9.9-a2/test/gtc/gtc_vec1.cpp0000600000175000001440000000011413173131001015417 0ustar guususers#include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/gtc/gtc_reciprocal.cpp0000600000175000001440000000011713173131001016707 0ustar guususers#include #include int main() { return 0; } glm-0.9.9-a2/test/gtc/gtc_ulp.cpp0000600000175000001440000000370513173131001015372 0ustar guususers#include #include #include int test_ulp_float_dist() { int Error = 0; float A = 1.0f; float B = glm::next_float(A); Error += !glm::epsilonEqual(A, B, glm::epsilon()) ? 0 : 1; float C = glm::prev_float(B); Error += glm::epsilonEqual(A, C, glm::epsilon()) ? 0 : 1; int D = glm::float_distance(A, B); Error += D == 1 ? 0 : 1; int E = glm::float_distance(A, C); Error += E == 0 ? 0 : 1; return Error; } int test_ulp_float_step() { int Error = 0; float A = 1.0f; for(int i = 10; i < 1000; i *= 10) { float B = glm::next_float(A, i); Error += !glm::epsilonEqual(A, B, glm::epsilon()) ? 0 : 1; float C = glm::prev_float(B, i); Error += glm::epsilonEqual(A, C, glm::epsilon()) ? 0 : 1; int D = glm::float_distance(A, B); Error += D == i ? 0 : 1; int E = glm::float_distance(A, C); Error += E == 0 ? 0 : 1; } return Error; } int test_ulp_double_dist() { int Error = 0; double A = 1.0; double B = glm::next_float(A); Error += !glm::epsilonEqual(A, B, glm::epsilon()) ? 0 : 1; double C = glm::prev_float(B); Error += glm::epsilonEqual(A, C, glm::epsilon()) ? 0 : 1; int D = glm::float_distance(A, B); Error += D == 1 ? 0 : 1; int E = glm::float_distance(A, C); Error += E == 0 ? 0 : 1; return Error; } int test_ulp_double_step() { int Error = 0; double A = 1.0; for(int i = 10; i < 1000; i *= 10) { double B = glm::next_float(A, i); Error += !glm::epsilonEqual(A, B, glm::epsilon()) ? 0 : 1; double C = glm::prev_float(B, i); Error += glm::epsilonEqual(A, C, glm::epsilon()) ? 0 : 1; int D = glm::float_distance(A, B); Error += D == i ? 0 : 1; int E = glm::float_distance(A, C); Error += E == 0 ? 0 : 1; } return Error; } int main() { int Error = 0; Error += test_ulp_float_dist(); Error += test_ulp_float_step(); Error += test_ulp_double_dist(); Error += test_ulp_double_step(); return Error; } glm-0.9.9-a2/test/gtc/CMakeLists.txt0000600000175000001440000000120313173131001015760 0ustar guususersglmCreateTestGTC(gtc_bitfield) glmCreateTestGTC(gtc_color_space) glmCreateTestGTC(gtc_constants) glmCreateTestGTC(gtc_epsilon) glmCreateTestGTC(gtc_integer) glmCreateTestGTC(gtc_matrix_access) glmCreateTestGTC(gtc_matrix_integer) glmCreateTestGTC(gtc_matrix_inverse) glmCreateTestGTC(gtc_matrix_transform) glmCreateTestGTC(gtc_noise) glmCreateTestGTC(gtc_packing) glmCreateTestGTC(gtc_quaternion) glmCreateTestGTC(gtc_random) glmCreateTestGTC(gtc_round) glmCreateTestGTC(gtc_reciprocal) glmCreateTestGTC(gtc_type_aligned) glmCreateTestGTC(gtc_type_precision) glmCreateTestGTC(gtc_type_ptr) glmCreateTestGTC(gtc_ulp) glmCreateTestGTC(gtc_vec1) glm-0.9.9-a2/test/gtc/gtc_quaternion.cpp0000600000175000001440000002261213173131001016755 0ustar guususers#include #include #include #include int test_quat_angle() { int Error = 0; { glm::quat Q = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(0, 0, 1)); glm::quat N = glm::normalize(Q); float L = glm::length(N); Error += glm::epsilonEqual(L, 1.0f, 0.01f) ? 0 : 1; float A = glm::angle(N); Error += glm::epsilonEqual(A, glm::pi() * 0.25f, 0.01f) ? 0 : 1; } { glm::quat Q = glm::angleAxis(glm::pi() * 0.25f, glm::normalize(glm::vec3(0, 1, 1))); glm::quat N = glm::normalize(Q); float L = glm::length(N); Error += glm::epsilonEqual(L, 1.0f, 0.01f) ? 0 : 1; float A = glm::angle(N); Error += glm::epsilonEqual(A, glm::pi() * 0.25f, 0.01f) ? 0 : 1; } { glm::quat Q = glm::angleAxis(glm::pi() * 0.25f, glm::normalize(glm::vec3(1, 2, 3))); glm::quat N = glm::normalize(Q); float L = glm::length(N); Error += glm::epsilonEqual(L, 1.0f, 0.01f) ? 0 : 1; float A = glm::angle(N); Error += glm::epsilonEqual(A, glm::pi() * 0.25f, 0.01f) ? 0 : 1; } return Error; } int test_quat_angleAxis() { int Error = 0; glm::quat A = glm::angleAxis(0.f, glm::vec3(0.f, 0.f, 1.f)); glm::quat B = glm::angleAxis(glm::pi() * 0.5f, glm::vec3(0, 0, 1)); glm::quat C = glm::mix(A, B, 0.5f); glm::quat D = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(0, 0, 1)); Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1; return Error; } int test_quat_mix() { int Error = 0; glm::quat A = glm::angleAxis(0.f, glm::vec3(0.f, 0.f, 1.f)); glm::quat B = glm::angleAxis(glm::pi() * 0.5f, glm::vec3(0, 0, 1)); glm::quat C = glm::mix(A, B, 0.5f); glm::quat D = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(0, 0, 1)); Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1; Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1; return Error; } int test_quat_precision() { int Error = 0; Error += sizeof(glm::lowp_quat) <= sizeof(glm::mediump_quat) ? 0 : 1; Error += sizeof(glm::mediump_quat) <= sizeof(glm::highp_quat) ? 0 : 1; return Error; } int test_quat_normalize() { int Error(0); { glm::quat Q = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(0, 0, 1)); glm::quat N = glm::normalize(Q); float L = glm::length(N); Error += glm::epsilonEqual(L, 1.0f, 0.000001f) ? 0 : 1; } { glm::quat Q = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(0, 0, 2)); glm::quat N = glm::normalize(Q); float L = glm::length(N); Error += glm::epsilonEqual(L, 1.0f, 0.000001f) ? 0 : 1; } { glm::quat Q = glm::angleAxis(glm::pi() * 0.25f, glm::vec3(1, 2, 3)); glm::quat N = glm::normalize(Q); float L = glm::length(N); Error += glm::epsilonEqual(L, 1.0f, 0.000001f) ? 0 : 1; } return Error; } int test_quat_euler() { int Error = 0; { glm::quat q(1.0f, 0.0f, 0.0f, 1.0f); float Roll = glm::roll(q); float Pitch = glm::pitch(q); float Yaw = glm::yaw(q); glm::vec3 Angles = glm::eulerAngles(q); Error += glm::all(glm::epsilonEqual(Angles, glm::vec3(Pitch, Yaw, Roll), 0.000001f)) ? 0 : 1; } { glm::dquat q(1.0, 0.0, 0.0, 1.0); double Roll = glm::roll(q); double Pitch = glm::pitch(q); double Yaw = glm::yaw(q); glm::dvec3 Angles = glm::eulerAngles(q); Error += glm::all(glm::epsilonEqual(Angles, glm::dvec3(Pitch, Yaw, Roll), 0.000001)) ? 0 : 1; } return Error; } int test_quat_slerp() { int Error = 0; float const Epsilon = 0.0001f;//glm::epsilon(); float sqrt2 = std::sqrt(2.0f)/2.0f; glm::quat id(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); glm::quat Y90rot(sqrt2, 0.0f, sqrt2, 0.0f); glm::quat Y180rot(0.0f, 0.0f, 1.0f, 0.0f); // Testing a == 0 // Must be id glm::quat id2 = glm::slerp(id, Y90rot, 0.0f); Error += glm::all(glm::epsilonEqual(id, id2, Epsilon)) ? 0 : 1; // Testing a == 1 // Must be 90 rotation on Y : 0 0.7 0 0.7 glm::quat Y90rot2 = glm::slerp(id, Y90rot, 1.0f); Error += glm::all(glm::epsilonEqual(Y90rot, Y90rot2, Epsilon)) ? 0 : 1; // Testing standard, easy case // Must be 45 rotation on Y : 0 0.38 0 0.92 glm::quat Y45rot1 = glm::slerp(id, Y90rot, 0.5f); // Testing reverse case // Must be 45 rotation on Y : 0 0.38 0 0.92 glm::quat Ym45rot2 = glm::slerp(Y90rot, id, 0.5f); // Testing against full circle around the sphere instead of shortest path // Must be 45 rotation on Y // certainly not a 135 rotation glm::quat Y45rot3 = glm::slerp(id , -Y90rot, 0.5f); float Y45angle3 = glm::angle(Y45rot3); Error += glm::epsilonEqual(Y45angle3, glm::pi() * 0.25f, Epsilon) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Ym45rot2, Y45rot3, Epsilon)) ? 0 : 1; // Same, but inverted // Must also be 45 rotation on Y : 0 0.38 0 0.92 // -0 -0.38 -0 -0.92 is ok too glm::quat Y45rot4 = glm::slerp(-Y90rot, id, 0.5f); Error += glm::all(glm::epsilonEqual(Ym45rot2, -Y45rot4, Epsilon)) ? 0 : 1; // Testing q1 = q2 // Must be 90 rotation on Y : 0 0.7 0 0.7 glm::quat Y90rot3 = glm::slerp(Y90rot, Y90rot, 0.5f); Error += glm::all(glm::epsilonEqual(Y90rot, Y90rot3, Epsilon)) ? 0 : 1; // Testing 180 rotation // Must be 90 rotation on almost any axis that is on the XZ plane glm::quat XZ90rot = glm::slerp(id, -Y90rot, 0.5f); float XZ90angle = glm::angle(XZ90rot); // Must be PI/4 = 0.78; Error += glm::epsilonEqual(XZ90angle, glm::pi() * 0.25f, Epsilon) ? 0 : 1; // Testing almost equal quaternions (this test should pass through the linear interpolation) // Must be 0 0.00X 0 0.99999 glm::quat almostid = glm::slerp(id, glm::angleAxis(0.1f, glm::vec3(0.0f, 1.0f, 0.0f)), 0.5f); // Testing quaternions with opposite sign { glm::quat a(-1, 0, 0, 0); glm::quat result = glm::slerp(a, id, 0.5f); Error += glm::epsilonEqual(glm::pow(glm::dot(id, result), 2.f), 1.f, 0.01f) ? 0 : 1; } return Error; } int test_quat_mul() { int Error(0); glm::quat temp1 = glm::normalize(glm::quat(1.0f, glm::vec3(0.0, 1.0, 0.0))); glm::quat temp2 = glm::normalize(glm::quat(0.5f, glm::vec3(1.0, 0.0, 0.0))); glm::vec3 transformed0 = (temp1 * glm::vec3(0.0, 1.0, 0.0) * glm::inverse(temp1)); glm::vec3 temp4 = temp2 * transformed0 * glm::inverse(temp2); glm::quat temp5 = glm::normalize(temp1 * temp2); glm::vec3 temp6 = temp5 * glm::vec3(0.0, 1.0, 0.0) * glm::inverse(temp5); glm::quat temp7(1.0f, glm::vec3(0.0, 1.0, 0.0)); temp7 *= temp5; temp7 *= glm::inverse(temp5); Error += temp7 != glm::quat(1.0f, glm::vec3(0.0, 1.0, 0.0)); return Error; } int test_quat_two_axis_ctr() { int Error = 0; glm::quat const q1(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0)); glm::vec3 const v1 = q1 * glm::vec3(1, 0, 0); Error += glm::all(glm::epsilonEqual(v1, glm::vec3(0, 1, 0), 0.0001f)) ? 0 : 1; glm::quat const q2 = q1 * q1; glm::vec3 const v2 = q2 * glm::vec3(1, 0, 0); Error += glm::all(glm::epsilonEqual(v2, glm::vec3(-1, 0, 0), 0.0001f)) ? 0 : 1; glm::quat const q3(glm::vec3(1, 0, 0), glm::vec3(-1, 0, 0)); glm::vec3 const v3 = q3 * glm::vec3(1, 0, 0); Error += glm::all(glm::epsilonEqual(v3, glm::vec3(-1, 0, 0), 0.0001f)) ? 0 : 1; glm::quat const q4(glm::vec3(0, 1, 0), glm::vec3(0, -1, 0)); glm::vec3 const v4 = q4 * glm::vec3(0, 1, 0); Error += glm::all(glm::epsilonEqual(v4, glm::vec3(0, -1, 0), 0.0001f)) ? 0 : 1; glm::quat const q5(glm::vec3(0, 0, 1), glm::vec3(0, 0, -1)); glm::vec3 const v5 = q5 * glm::vec3(0, 0, 1); Error += glm::all(glm::epsilonEqual(v5, glm::vec3(0, 0, -1), 0.0001f)) ? 0 : 1; return Error; } int test_quat_mul_vec() { int Error(0); glm::quat q = glm::angleAxis(glm::pi() * 0.5f, glm::vec3(0, 0, 1)); glm::vec3 v(1, 0, 0); glm::vec3 u(q * v); glm::vec3 w(u * q); Error += glm::all(glm::epsilonEqual(v, w, 0.01f)) ? 0 : 1; return Error; } int test_quat_ctr() { int Error(0); # if GLM_HAS_TRIVIAL_QUERIES // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; # endif # if GLM_HAS_INITIALIZER_LISTS { glm::quat A{0, 1, 2, 3}; std::vector B{ {0, 1, 2, 3}, {0, 1, 2, 3}}; } # endif//GLM_HAS_INITIALIZER_LISTS return Error; } int test_size() { int Error = 0; Error += 16 == sizeof(glm::quat) ? 0 : 1; Error += 32 == sizeof(glm::dquat) ? 0 : 1; Error += glm::quat().length() == 4 ? 0 : 1; Error += glm::dquat().length() == 4 ? 0 : 1; Error += glm::quat::length() == 4 ? 0 : 1; Error += glm::dquat::length() == 4 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_quat_ctr(); Error += test_quat_mul_vec(); Error += test_quat_two_axis_ctr(); Error += test_quat_mul(); Error += test_quat_precision(); Error += test_quat_angle(); Error += test_quat_angleAxis(); Error += test_quat_mix(); Error += test_quat_normalize(); Error += test_quat_euler(); Error += test_quat_slerp(); Error += test_size(); return Error; } glm-0.9.9-a2/test/gtc/gtc_type_ptr.cpp0000600000175000001440000001623613173131001016443 0ustar guususers#include #include int test_value_ptr_vec() { int Error = 0; { glm::vec2 v(1.0); float * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::vec3 v(1.0); float * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::vec4 v(1.0); float * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::dvec2 v(1.0); double * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::dvec3 v(1.0); double * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::dvec4 v(1.0); double * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } return Error; } int test_value_ptr_vec_const() { int Error = 0; { glm::vec2 const v(1.0); float const * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::vec3 const v(1.0); float const * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::vec4 const v(1.0); float const * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::dvec2 const v(1.0); double const * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::dvec3 const v(1.0); double const * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } { glm::dvec4 const v(1.0); double const * p = glm::value_ptr(v); Error += p == &v[0] ? 0 : 1; } return Error; } int test_value_ptr_mat() { int Error = 0; { glm::mat2x2 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat2x3 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat2x4 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat3x2 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat3x3 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat3x4 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat4x2 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat4x3 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat4x4 m(1.0); float * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } return Error; } int test_value_ptr_mat_const() { int Error = 0; { glm::mat2x2 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat2x3 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat2x4 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat3x2 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat3x3 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat3x4 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat4x2 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat4x3 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } { glm::mat4x4 const m(1.0); float const * p = glm::value_ptr(m); Error += p == &m[0][0] ? 0 : 1; } return Error; } int test_make_pointer_mat() { int Error = 0; float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; double ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; glm::mat2x2 Mat2x2A = glm::make_mat2x2(ArrayA); glm::mat2x3 Mat2x3A = glm::make_mat2x3(ArrayA); glm::mat2x4 Mat2x4A = glm::make_mat2x4(ArrayA); glm::mat3x2 Mat3x2A = glm::make_mat3x2(ArrayA); glm::mat3x3 Mat3x3A = glm::make_mat3x3(ArrayA); glm::mat3x4 Mat3x4A = glm::make_mat3x4(ArrayA); glm::mat4x2 Mat4x2A = glm::make_mat4x2(ArrayA); glm::mat4x3 Mat4x3A = glm::make_mat4x3(ArrayA); glm::mat4x4 Mat4x4A = glm::make_mat4x4(ArrayA); glm::dmat2x2 Mat2x2B = glm::make_mat2x2(ArrayB); glm::dmat2x3 Mat2x3B = glm::make_mat2x3(ArrayB); glm::dmat2x4 Mat2x4B = glm::make_mat2x4(ArrayB); glm::dmat3x2 Mat3x2B = glm::make_mat3x2(ArrayB); glm::dmat3x3 Mat3x3B = glm::make_mat3x3(ArrayB); glm::dmat3x4 Mat3x4B = glm::make_mat3x4(ArrayB); glm::dmat4x2 Mat4x2B = glm::make_mat4x2(ArrayB); glm::dmat4x3 Mat4x3B = glm::make_mat4x3(ArrayB); glm::dmat4x4 Mat4x4B = glm::make_mat4x4(ArrayB); return Error; } int test_make_pointer_vec() { int Error = 0; float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; int ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; bool ArrayC[] = {true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false}; glm::vec2 Vec2A = glm::make_vec2(ArrayA); glm::vec3 Vec3A = glm::make_vec3(ArrayA); glm::vec4 Vec4A = glm::make_vec4(ArrayA); glm::ivec2 Vec2B = glm::make_vec2(ArrayB); glm::ivec3 Vec3B = glm::make_vec3(ArrayB); glm::ivec4 Vec4B = glm::make_vec4(ArrayB); glm::bvec2 Vec2C = glm::make_vec2(ArrayC); glm::bvec3 Vec3C = glm::make_vec3(ArrayC); glm::bvec4 Vec4C = glm::make_vec4(ArrayC); return Error; } int test_make_vec1() { int Error = 0; glm::ivec1 const v1 = glm::make_vec1(glm::ivec1(2)); Error += v1 == glm::ivec1(2) ? 0 : 1; glm::ivec1 const v2 = glm::make_vec1(glm::ivec2(2)); Error += v2 == glm::ivec1(2) ? 0 : 1; glm::ivec1 const v3 = glm::make_vec1(glm::ivec3(2)); Error += v3 == glm::ivec1(2) ? 0 : 1; glm::ivec1 const v4 = glm::make_vec1(glm::ivec4(2)); Error += v3 == glm::ivec1(2) ? 0 : 1; return Error; } int test_make_vec2() { int Error = 0; glm::ivec2 const v1 = glm::make_vec2(glm::ivec1(2)); Error += v1 == glm::ivec2(2, 0) ? 0 : 1; glm::ivec2 const v2 = glm::make_vec2(glm::ivec2(2)); Error += v2 == glm::ivec2(2, 2) ? 0 : 1; glm::ivec2 const v3 = glm::make_vec2(glm::ivec3(2)); Error += v3 == glm::ivec2(2, 2) ? 0 : 1; glm::ivec2 const v4 = glm::make_vec2(glm::ivec4(2)); Error += v3 == glm::ivec2(2, 2) ? 0 : 1; return Error; } int test_make_vec3() { int Error = 0; glm::ivec3 const v1 = glm::make_vec3(glm::ivec1(2)); Error += v1 == glm::ivec3(2, 0, 0) ? 0 : 1; glm::ivec3 const v2 = glm::make_vec3(glm::ivec2(2)); Error += v2 == glm::ivec3(2, 2, 0) ? 0 : 1; glm::ivec3 const v3 = glm::make_vec3(glm::ivec3(2)); Error += v3 == glm::ivec3(2, 2, 2) ? 0 : 1; glm::ivec3 const v4 = glm::make_vec3(glm::ivec4(2)); Error += v3 == glm::ivec3(2, 2, 2) ? 0 : 1; return Error; } int test_make_vec4() { int Error = 0; glm::ivec4 const v1 = glm::make_vec4(glm::ivec1(2)); Error += v1 == glm::ivec4(2, 0, 0, 1) ? 0 : 1; glm::ivec4 const v2 = glm::make_vec4(glm::ivec2(2)); Error += v2 == glm::ivec4(2, 2, 0, 1) ? 0 : 1; glm::ivec4 const v3 = glm::make_vec4(glm::ivec3(2)); Error += v3 == glm::ivec4(2, 2, 2, 1) ? 0 : 1; glm::ivec4 const v4 = glm::make_vec4(glm::ivec4(2)); Error += v4 == glm::ivec4(2, 2, 2, 2) ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_make_vec1(); Error += test_make_vec2(); Error += test_make_vec3(); Error += test_make_vec4(); Error += test_make_pointer_vec(); Error += test_make_pointer_mat(); Error += test_value_ptr_vec(); Error += test_value_ptr_vec_const(); Error += test_value_ptr_mat(); Error += test_value_ptr_mat_const(); return Error; } glm-0.9.9-a2/test/glm.cppcheck0000600000175000001440000000021013173131001014721 0ustar guususers glm-0.9.9-a2/test/core/0000700000175000001440000000000013173131001013375 5ustar guususersglm-0.9.9-a2/test/core/core_type_int.cpp0000600000175000001440000000226313173131001016751 0ustar guususers#include static int test_int_size() { return sizeof(glm::int_t) != sizeof(glm::lowp_int) && sizeof(glm::int_t) != sizeof(glm::mediump_int) && sizeof(glm::int_t) != sizeof(glm::highp_int); } static int test_uint_size() { return sizeof(glm::uint_t) != sizeof(glm::lowp_uint) && sizeof(glm::uint_t) != sizeof(glm::mediump_uint) && sizeof(glm::uint_t) != sizeof(glm::highp_uint); } static int test_int_precision() { return ( sizeof(glm::lowp_int) <= sizeof(glm::mediump_int) && sizeof(glm::mediump_int) <= sizeof(glm::highp_int)) ? 0 : 1; } static int test_uint_precision() { return ( sizeof(glm::lowp_uint) <= sizeof(glm::mediump_uint) && sizeof(glm::mediump_uint) <= sizeof(glm::highp_uint)) ? 0 : 1; } static int test_bit_operator() { int Error = 0; glm::ivec4 const a(1); glm::ivec4 const b = ~a; Error += glm::all(glm::equal(b, glm::ivec4(-2))) ? 0 : 1; glm::int32 const c(1); glm::int32 const d = ~c; Error += d == -2 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_int_size(); Error += test_int_precision(); Error += test_uint_size(); Error += test_uint_precision(); Error += test_bit_operator(); return Error; } glm-0.9.9-a2/test/core/core_type_mat4x3.cpp0000600000175000001440000000512313173131001017275 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include static int test_operators() { glm::mat4x3 l(1.0f); glm::mat4x3 m(1.0f); glm::vec4 u(1.0f); glm::vec3 v(1.0f); float x = 1.0f; glm::vec3 a = m * u; glm::vec4 b = v * m; glm::mat4x3 n = x / m; glm::mat4x3 o = m / x; glm::mat4x3 p = x * m; glm::mat4x3 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_ctr() { int Error(0); #if(GLM_HAS_INITIALIZER_LISTS) glm::mat4x3 m0( glm::vec3(0, 1, 2), glm::vec3(3, 4, 5), glm::vec3(6, 7, 8), glm::vec3(9, 10, 11)); glm::mat4x3 m1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; glm::mat4x3 m2{ {0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} }; std::vector v2{ { { 0, 1, 2 }, { 4, 5, 6 }, { 8, 9, 10 }, { 12, 13, 14 } }, { { 0, 1, 2 }, { 4, 5, 6 }, { 8, 9, 10 }, { 12, 13, 14 } } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat4x3 B(A); glm::mat4x3 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::equal(B[i], Identity[i])) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 48 == sizeof(glm::mat4x3) ? 0 : 1; Error += 96 == sizeof(glm::dmat4x3) ? 0 : 1; Error += glm::mat4x3().length() == 4 ? 0 : 1; Error += glm::dmat4x3().length() == 4 ? 0 : 1; Error += glm::mat4x3::length() == 4 ? 0 : 1; Error += glm::dmat4x3::length() == 4 ? 0 : 1; return Error; } int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/core_func_integer_find_lsb.cpp0000600000175000001440000002640613173131001021433 0ustar guususers#include #include #include //To define "exit", req'd by XLC. #include int nlz(unsigned x) { int pop(unsigned x); x = x | (x >> 1); x = x | (x >> 2); x = x | (x >> 4); x = x | (x >> 8); x = x | (x >>16); return pop(~x); } int pop(unsigned x) { x = x - ((x >> 1) & 0x55555555); x = (x & 0x33333333) + ((x >> 2) & 0x33333333); x = (x + (x >> 4)) & 0x0F0F0F0F; x = x + (x << 8); x = x + (x << 16); return x >> 24; } int ntz1(unsigned x) { return 32 - nlz(~x & (x-1)); } int ntz2(unsigned x) { return pop(~x & (x - 1)); } int ntz3(unsigned x) { int n; if (x == 0) return(32); n = 1; if ((x & 0x0000FFFF) == 0) {n = n +16; x = x >>16;} if ((x & 0x000000FF) == 0) {n = n + 8; x = x >> 8;} if ((x & 0x0000000F) == 0) {n = n + 4; x = x >> 4;} if ((x & 0x00000003) == 0) {n = n + 2; x = x >> 2;} return n - (x & 1); } int ntz4(unsigned x) { unsigned y; int n; if (x == 0) return 32; n = 31; y = x <<16; if (y != 0) {n = n -16; x = y;} y = x << 8; if (y != 0) {n = n - 8; x = y;} y = x << 4; if (y != 0) {n = n - 4; x = y;} y = x << 2; if (y != 0) {n = n - 2; x = y;} y = x << 1; if (y != 0) {n = n - 1;} return n; } int ntz4a(unsigned x) { unsigned y; int n; if (x == 0) return 32; n = 31; y = x <<16; if (y != 0) {n = n -16; x = y;} y = x << 8; if (y != 0) {n = n - 8; x = y;} y = x << 4; if (y != 0) {n = n - 4; x = y;} y = x << 2; if (y != 0) {n = n - 2; x = y;} n = n - ((x << 1) >> 31); return n; } int ntz5(char x) { if (x & 15) { if (x & 3) { if (x & 1) return 0; else return 1; } else if (x & 4) return 2; else return 3; } else if (x & 0x30) { if (x & 0x10) return 4; else return 5; } else if (x & 0x40) return 6; else if (x) return 7; else return 8; } int ntz6(unsigned x) { int n; x = ~x & (x - 1); n = 0; // n = 32; while(x != 0) { // while (x != 0) { n = n + 1; // n = n - 1; x = x >> 1; // x = x + x; } // } return n; // return n; } int ntz6a(unsigned x) { int n = 32; while (x != 0) { n = n - 1; x = x + x; } return n; } /* Dean Gaudet's algorithm. To be most useful there must be a good way to evaluate the C "conditional expression" (a?b:c construction) without branching. The result of a?b:c is b if a is true (nonzero), and c if a is false (0). For example, a compare to zero op that sets a target GPR to 1 if the operand is 0, and to 0 if the operand is nonzero, will do it. With this instruction, the algorithm is entirely branch-free. But the most interesting thing about it is the high degree of parallelism. All six lines with conditional expressions can be executed in parallel (on a machine with sufficient computational units). Although the instruction count is 30 measured statically, it could execute in only 10 cycles on a machine with sufficient parallelism. The first two uses of y can instead be x, which would increase the useful parallelism on most machines (the assignments to y, bz, and b4 could then all run in parallel). */ int ntz7(unsigned x) { unsigned y, bz, b4, b3, b2, b1, b0; y = x & -x; // Isolate rightmost 1-bit. bz = y ? 0 : 1; // 1 if y = 0. b4 = (y & 0x0000FFFF) ? 0 : 16; b3 = (y & 0x00FF00FF) ? 0 : 8; b2 = (y & 0x0F0F0F0F) ? 0 : 4; b1 = (y & 0x33333333) ? 0 : 2; b0 = (y & 0x55555555) ? 0 : 1; return bz + b4 + b3 + b2 + b1 + b0; } // This file has divisions by zero to test isnan #if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(disable : 4800) #endif int ntz7_christophe(unsigned x) { unsigned y, bz, b4, b3, b2, b1, b0; y = x & -x; // Isolate rightmost 1-bit. bz = unsigned(!bool(y)); // 1 if y = 0. b4 = unsigned(!bool(y & 0x0000FFFF)) * 16; b3 = unsigned(!bool(y & 0x00FF00FF)) * 8; b2 = unsigned(!bool(y & 0x0F0F0F0F)) * 4; b1 = unsigned(!bool(y & 0x33333333)) * 2; b0 = unsigned(!bool(y & 0x55555555)) * 1; return bz + b4 + b3 + b2 + b1 + b0; } /* Below is David Seal's algorithm, found at http://www.ciphersbyritter.com/NEWS4/BITCT.HTM Table entries marked "u" are unused. 6 ops including a multiply, plus an indexed load. */ #define u 99 int ntz8(unsigned x) { static char table[64] = {32, 0, 1,12, 2, 6, u,13, 3, u, 7, u, u, u, u,14, 10, 4, u, u, 8, u, u,25, u, u, u, u, u,21,27,15, 31,11, 5, u, u, u, u, u, 9, u, u,24, u, u,20,26, 30, u, u, u, u,23, u,19, 29, u,22,18,28,17,16, u}; x = (x & -x)*0x0450FBAF; return table[x >> 26]; } /* Seal's algorithm with multiply expanded. 9 elementary ops plus an indexed load. */ int ntz8a(unsigned x) { static char table[64] = {32, 0, 1,12, 2, 6, u,13, 3, u, 7, u, u, u, u,14, 10, 4, u, u, 8, u, u,25, u, u, u, u, u,21,27,15, 31,11, 5, u, u, u, u, u, 9, u, u,24, u, u,20,26, 30, u, u, u, u,23, u,19, 29, u,22,18,28,17,16, u}; x = (x & -x); x = (x << 4) + x; // x = x*17. x = (x << 6) + x; // x = x*65. x = (x << 16) - x; // x = x*65535. return table[x >> 26]; } /* Reiser's algorithm. Three ops including a "remainder," plus an indexed load. */ int ntz9(unsigned x) { static char table[37] = {32, 0, 1, 26, 2, 23, 27, u, 3, 16, 24, 30, 28, 11, u, 13, 4, 7, 17, u, 25, 22, 31, 15, 29, 10, 12, 6, u, 21, 14, 9, 5, 20, 8, 19, 18}; x = (x & -x)%37; return table[x]; } /* Using a de Bruijn sequence. This is a table lookup with a 32-entry table. The de Bruijn sequence used here is 0000 0100 1101 0111 0110 0101 0001 1111, obtained from Danny Dube's October 3, 1997, posting in comp.compression.research. Thanks to Norbert Juffa for this reference. */ int ntz10(unsigned x) { static char table[32] = { 0, 1, 2,24, 3,19, 6,25, 22, 4,20,10,16, 7,12,26, 31,23,18, 5,21, 9,15,11, 30,17, 8,14,29,13,28,27}; if (x == 0) return 32; x = (x & -x)*0x04D7651F; return table[x >> 27]; } /* Norbert Juffa's code, answer to exercise 1 of Chapter 5 (2nd ed). */ #define SLOW_MUL int ntz11 (unsigned int n) { static unsigned char tab[32] = { 0, 1, 2, 24, 3, 19, 6, 25, 22, 4, 20, 10, 16, 7, 12, 26, 31, 23, 18, 5, 21, 9, 15, 11, 30, 17, 8, 14, 29, 13, 28, 27 }; unsigned int k; n = n & (-n); /* isolate lsb */ printf("n = %d\n", n); #if defined(SLOW_MUL) k = (n << 11) - n; k = (k << 2) + k; k = (k << 8) + n; k = (k << 5) - k; #else k = n * 0x4d7651f; #endif return n ? tab[k>>27] : 32; } int errors; void error(int x, int y) { errors = errors + 1; printf("Error for x = %08x, got %d\n", x, y); } int main() { # ifdef NDEBUG int i, m, n; static unsigned test[] = {0,32, 1,0, 2,1, 3,0, 4,2, 5,0, 6,1, 7,0, 8,3, 9,0, 16,4, 32,5, 64,6, 128,7, 255,0, 256,8, 512,9, 1024,10, 2048,11, 4096,12, 8192,13, 16384,14, 32768,15, 65536,16, 0x20000,17, 0x40000,18, 0x80000,19, 0x100000,20, 0x200000,21, 0x400000,22, 0x800000,23, 0x1000000,24, 0x2000000,25, 0x4000000,26, 0x8000000,27, 0x10000000,28, 0x20000000,29, 0x40000000,30, 0x80000000,31, 0xFFFFFFF0,4, 0x3000FF00,8, 0xC0000000,30, 0x60000000,29, 0x00011000, 12}; std::size_t const Count = 1000; n = sizeof(test)/4; std::clock_t TimestampBeg = 0; std::clock_t TimestampEnd = 0; TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz1(test[i]) != test[i+1]) error(test[i], ntz1(test[i]));} TimestampEnd = std::clock(); printf("ntz1: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz2(test[i]) != test[i+1]) error(test[i], ntz2(test[i]));} TimestampEnd = std::clock(); printf("ntz2: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz3(test[i]) != test[i+1]) error(test[i], ntz3(test[i]));} TimestampEnd = std::clock(); printf("ntz3: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz4(test[i]) != test[i+1]) error(test[i], ntz4(test[i]));} TimestampEnd = std::clock(); printf("ntz4: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz4a(test[i]) != test[i+1]) error(test[i], ntz4a(test[i]));} TimestampEnd = std::clock(); printf("ntz4a: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(i = 0; i < n; i += 2) { m = test[i+1]; if(m > 8) m = 8; if(ntz5(static_cast(test[i])) != m) error(test[i], ntz5(static_cast(test[i]))); } TimestampEnd = std::clock(); printf("ntz5: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz6(test[i]) != test[i+1]) error(test[i], ntz6(test[i]));} TimestampEnd = std::clock(); printf("ntz6: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz6a(test[i]) != test[i+1]) error(test[i], ntz6a(test[i]));} TimestampEnd = std::clock(); printf("ntz6a: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz7(test[i]) != test[i+1]) error(test[i], ntz7(test[i]));} TimestampEnd = std::clock(); printf("ntz7: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz7_christophe(test[i]) != test[i+1]) error(test[i], ntz7(test[i]));} TimestampEnd = std::clock(); printf("ntz7_christophe: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz8(test[i]) != test[i+1]) error(test[i], ntz8(test[i]));} TimestampEnd = std::clock(); printf("ntz8: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz8a(test[i]) != test[i+1]) error(test[i], ntz8a(test[i]));} TimestampEnd = std::clock(); printf("ntz8a: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz9(test[i]) != test[i+1]) error(test[i], ntz9(test[i]));} TimestampEnd = std::clock(); printf("ntz9: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (ntz10(test[i]) != test[i+1]) error(test[i], ntz10(test[i]));} TimestampEnd = std::clock(); printf("ntz10: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); if (errors == 0) printf("Passed all %d cases.\n", static_cast(sizeof(test)/8)); # endif//NDEBUG } glm-0.9.9-a2/test/core/core_type_aligned.cpp0000600000175000001440000001250013173131001017555 0ustar guususers#include int test_aligned() { int Error = 0; size_t size1_aligned = sizeof(glm::detail::storage::type); Error += size1_aligned == 1 ? 0 : 1; size_t size2_aligned = sizeof(glm::detail::storage::type); Error += size2_aligned == 2 ? 0 : 1; size_t size4_aligned = sizeof(glm::detail::storage::type); Error += size4_aligned == 4 ? 0 : 1; size_t size8_aligned = sizeof(glm::detail::storage::type); Error += size8_aligned == 8 ? 0 : 1; size_t size16_aligned = sizeof(glm::detail::storage::type); Error += size16_aligned == 16 ? 0 : 1; size_t size32_aligned = sizeof(glm::detail::storage::type); Error += size32_aligned == 32 ? 0 : 1; size_t size64_aligned = sizeof(glm::detail::storage::type); Error += size64_aligned == 64 ? 0 : 1; # if GLM_HAS_ALIGNOF size_t align1_aligned = alignof(glm::detail::storage::type); Error += align1_aligned == 1 ? 0 : 1; size_t align2_aligned = alignof(glm::detail::storage::type); Error += align2_aligned == 2 ? 0 : 1; size_t align4_aligned = alignof(glm::detail::storage::type); Error += align4_aligned == 4 ? 0 : 1; size_t align8_aligned = alignof(glm::detail::storage::type); Error += align8_aligned == 8 ? 0 : 1; size_t align16_aligned = alignof(glm::detail::storage::type); Error += align16_aligned == 16 ? 0 : 1; size_t align32_aligned = alignof(glm::detail::storage::type); Error += align32_aligned == 32 ? 0 : 1; size_t align64_aligned = alignof(glm::detail::storage::type); Error += align64_aligned == 64 ? 0 : 1; # elif GLM_COMPILER & GLM_COMPILER_GCC size_t align1_aligned = __alignof__(glm::detail::storage::type); Error += align1_aligned == 1 ? 0 : 1; size_t align2_aligned = __alignof__(glm::detail::storage::type); Error += align2_aligned == 2 ? 0 : 1; size_t align4_aligned = __alignof__(glm::detail::storage::type); Error += align4_aligned == 4 ? 0 : 1; size_t align8_aligned = __alignof__(glm::detail::storage::type); Error += align8_aligned == 8 ? 0 : 1; size_t align16_aligned = __alignof__(glm::detail::storage::type); Error += align16_aligned == 16 ? 0 : 1; size_t align32_aligned = __alignof__(glm::detail::storage::type); Error += align32_aligned == 32 ? 0 : 1; size_t align64_aligned = __alignof__(glm::detail::storage::type); Error += align64_aligned == 64 ? 0 : 1; # endif //GLM_HAS_ALIGNOF return Error; } int test_unaligned() { int Error = 0; size_t size1_unaligned = sizeof(glm::detail::storage::type); Error += size1_unaligned == 1 ? 0 : 1; size_t size2_unaligned = sizeof(glm::detail::storage::type); Error += size2_unaligned == 2 ? 0 : 1; size_t size4_unaligned = sizeof(glm::detail::storage::type); Error += size4_unaligned == 4 ? 0 : 1; size_t size8_unaligned = sizeof(glm::detail::storage::type); Error += size8_unaligned == 8 ? 0 : 1; size_t size16_unaligned = sizeof(glm::detail::storage::type); Error += size16_unaligned == 16 ? 0 : 1; size_t size32_unaligned = sizeof(glm::detail::storage::type); Error += size32_unaligned == 32 ? 0 : 1; size_t size64_unaligned = sizeof(glm::detail::storage::type); Error += size64_unaligned == 64 ? 0 : 1; # if GLM_HAS_ALIGNOF size_t align1_unaligned = alignof(glm::detail::storage::type); Error += align1_unaligned == 1 ? 0 : 1; size_t align2_unaligned = alignof(glm::detail::storage::type); Error += align2_unaligned == 1 ? 0 : 1; size_t align4_unaligned = alignof(glm::detail::storage::type); Error += align4_unaligned == 1 ? 0 : 1; size_t align8_unaligned = alignof(glm::detail::storage::type); Error += align8_unaligned == 1 ? 0 : 1; size_t align16_unaligned = alignof(glm::detail::storage::type); Error += align16_unaligned == 1 ? 0 : 1; size_t align32_unaligned = alignof(glm::detail::storage::type); Error += align32_unaligned == 1 ? 0 : 1; size_t align64_unaligned = alignof(glm::detail::storage::type); Error += align64_unaligned == 1 ? 0 : 1; # elif GLM_COMPILER & GLM_COMPILER_GCC size_t align1_unaligned = __alignof__(glm::detail::storage::type); Error += align1_unaligned == 1 ? 0 : 1; size_t align2_unaligned = __alignof__(glm::detail::storage::type); Error += align2_unaligned == 1 ? 0 : 1; size_t align4_unaligned = __alignof__(glm::detail::storage::type); Error += align4_unaligned == 1 ? 0 : 1; size_t align8_unaligned = __alignof__(glm::detail::storage::type); Error += align8_unaligned == 1 ? 0 : 1; size_t align16_unaligned = __alignof__(glm::detail::storage::type); Error += align16_unaligned == 1 ? 0 : 1; size_t align32_unaligned = __alignof__(glm::detail::storage::type); Error += align32_unaligned == 1 ? 0 : 1; size_t align64_unaligned = __alignof__(glm::detail::storage::type); Error += align64_unaligned == 1 ? 0 : 1; # endif //GLM_HAS_ALIGNOF return Error; } int main() { int Error = 0; Error += test_aligned(); Error += test_unaligned(); return Error; } glm-0.9.9-a2/test/core/core_func_integer_bit_count.cpp0000600000175000001440000001756713173131001021651 0ustar guususers// This has the programs for computing the number of 1-bits // in a word, or byte, etc. // Max line length is 57, to fit in hacker.book. #include #include //To define "exit", req'd by XLC. #include unsigned rotatel(unsigned x, int n) { if (static_cast(n) > 63) {printf("rotatel, n out of range.\n"); exit(1);} return (x << n) | (x >> (32 - n)); } int pop0(unsigned x) { x = (x & 0x55555555) + ((x >> 1) & 0x55555555); x = (x & 0x33333333) + ((x >> 2) & 0x33333333); x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F); x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF); x = (x & 0x0000FFFF) + ((x >>16) & 0x0000FFFF); return x; } int pop1(unsigned x) { x = x - ((x >> 1) & 0x55555555); x = (x & 0x33333333) + ((x >> 2) & 0x33333333); x = (x + (x >> 4)) & 0x0F0F0F0F; x = x + (x >> 8); x = x + (x >> 16); return x & 0x0000003F; } /* Note: an alternative to the last three executable lines above is: return x*0x01010101 >> 24; if your machine has a fast multiplier (suggested by Jari Kirma). */ int pop2(unsigned x) { unsigned n; n = (x >> 1) & 033333333333; // Count bits in x = x - n; // each 3-bit n = (n >> 1) & 033333333333; // field. x = x - n; x = (x + (x >> 3)) & 030707070707; // 6-bit sums. return x%63; // Add 6-bit sums. } /* An alternative to the "return" statement above is: return ((x * 0404040404) >> 26) + // Add 6-bit sums. (x >> 30); which runs faster on most machines (suggested by Norbert Juffa). */ int pop3(unsigned x) { unsigned n; n = (x >> 1) & 0x77777777; // Count bits in x = x - n; // each 4-bit n = (n >> 1) & 0x77777777; // field. x = x - n; n = (n >> 1) & 0x77777777; x = x - n; x = (x + (x >> 4)) & 0x0F0F0F0F; // Get byte sums. x = x*0x01010101; // Add the bytes. return x >> 24; } int pop4(unsigned x) { int n; n = 0; while (x != 0) { n = n + 1; x = x & (x - 1); } return n; } int pop5(unsigned x) { int i, sum; // Rotate and sum method // Shift right & subtract sum = x; // sum = x; for (i = 1; i <= 31; i++) { // while (x != 0) { x = rotatel(x, 1); // x = x >> 1; sum = sum + x; // sum = sum - x; } // } return -sum; // return sum; } int pop5a(unsigned x) { int sum; // Shift right & subtract sum = x; while (x != 0) { x = x >> 1; sum = sum - x; } return sum; } int pop6(unsigned x) { // Table lookup. static char table[256] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8}; return table[x & 0xFF] + table[(x >> 8) & 0xFF] + table[(x >> 16) & 0xFF] + table[(x >> 24)]; } // The following works only for 8-bit quantities. int pop7(unsigned x) { x = x*0x08040201; // Make 4 copies. x = x >> 3; // So next step hits proper bits. x = x & 0x11111111; // Every 4th bit. x = x*0x11111111; // Sum the digits (each 0 or 1). x = x >> 28; // Position the result. return x; } // The following works only for 7-bit quantities. int pop8(unsigned x) { x = x*0x02040810; // Make 4 copies, left-adjusted. x = x & 0x11111111; // Every 4th bit. x = x*0x11111111; // Sum the digits (each 0 or 1). x = x >> 28; // Position the result. return x; } // The following works only for 15-bit quantities. int pop9(unsigned x) { unsigned long long y; y = x * 0x0002000400080010ULL; y = y & 0x1111111111111111ULL; y = y * 0x1111111111111111ULL; y = y >> 60; return static_cast(y); } int errors; void error(int x, int y) { errors = errors + 1; printf("Error for x = %08x, got %08x\n", x, y); } int main() { # ifdef NDEBUG int i, n; static unsigned test[] = {0,0, 1,1, 2,1, 3,2, 4,1, 5,2, 6,2, 7,3, 8,1, 9,2, 10,2, 11,3, 12,2, 13,3, 14,3, 15,4, 16,1, 17,2, 0x3F,6, 0x40,1, 0x41,2, 0x7f,7, 0x80,1, 0x81,2, 0xfe,7, 0xff,8, 0x4000,1, 0x4001,2, 0x7000,3, 0x7fff,15, 0x55555555,16, 0xAAAAAAAA, 16, 0xFF000000,8, 0xC0C0C0C0,8, 0x0FFFFFF0,24, 0x80000000,1, 0xFFFFFFFF,32}; std::size_t const Count = 1000000; n = sizeof(test)/4; std::clock_t TimestampBeg = 0; std::clock_t TimestampEnd = 0; TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop0(test[i]) != test[i+1]) error(test[i], pop0(test[i]));} TimestampEnd = std::clock(); printf("pop0: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop1(test[i]) != test[i+1]) error(test[i], pop1(test[i]));} TimestampEnd = std::clock(); printf("pop1: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop2(test[i]) != test[i+1]) error(test[i], pop2(test[i]));} TimestampEnd = std::clock(); printf("pop2: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop3(test[i]) != test[i+1]) error(test[i], pop3(test[i]));} TimestampEnd = std::clock(); printf("pop3: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop4(test[i]) != test[i+1]) error(test[i], pop4(test[i]));} TimestampEnd = std::clock(); printf("pop4: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop5(test[i]) != test[i+1]) error(test[i], pop5(test[i]));} TimestampEnd = std::clock(); printf("pop5: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop5a(test[i]) != test[i+1]) error(test[i], pop5a(test[i]));} TimestampEnd = std::clock(); printf("pop5a: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (pop6(test[i]) != test[i+1]) error(test[i], pop6(test[i]));} TimestampEnd = std::clock(); printf("pop6: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if ((test[i] & 0xffffff00) == 0) if (pop7(test[i]) != test[i+1]) error(test[i], pop7(test[i]));} TimestampEnd = std::clock(); printf("pop7: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if ((test[i] & 0xffffff80) == 0) if (pop8(test[i]) != test[i+1]) error(test[i], pop8(test[i]));} TimestampEnd = std::clock(); printf("pop8: %ld clocks\n", TimestampEnd - TimestampBeg); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if ((test[i] & 0xffff8000) == 0) if (pop9(test[i]) != test[i+1]) error(test[i], pop9(test[i]));} TimestampEnd = std::clock(); printf("pop9: %ld clocks\n", TimestampEnd - TimestampBeg); if (errors == 0) printf("Passed all %d cases.\n", static_cast(sizeof(test)/8)); # endif//NDEBUG } glm-0.9.9-a2/test/core/core_setup_precision.cpp0000600000175000001440000000310013173131001020320 0ustar guususers#define GLM_FORCE_INLINE #define GLM_PRECISION_HIGHP_FLOAT #include #include static int test_mat() { int Error = 0; Error += sizeof(glm::mat2) == sizeof(glm::highp_mat2) ? 0 : 1; Error += sizeof(glm::mat3) == sizeof(glm::highp_mat3) ? 0 : 1; Error += sizeof(glm::mat4) == sizeof(glm::highp_mat4) ? 0 : 1; Error += sizeof(glm::mat2x2) == sizeof(glm::highp_mat2x2) ? 0 : 1; Error += sizeof(glm::mat2x3) == sizeof(glm::highp_mat2x3) ? 0 : 1; Error += sizeof(glm::mat2x4) == sizeof(glm::highp_mat2x4) ? 0 : 1; Error += sizeof(glm::mat3x2) == sizeof(glm::highp_mat3x2) ? 0 : 1; Error += sizeof(glm::mat3x3) == sizeof(glm::highp_mat3x3) ? 0 : 1; Error += sizeof(glm::mat3x4) == sizeof(glm::highp_mat3x4) ? 0 : 1; Error += sizeof(glm::mat4x2) == sizeof(glm::highp_mat4x2) ? 0 : 1; Error += sizeof(glm::mat4x3) == sizeof(glm::highp_mat4x3) ? 0 : 1; Error += sizeof(glm::mat4x4) == sizeof(glm::highp_mat4x4) ? 0 : 1; return Error; } static int test_vec() { int Error = 0; Error += sizeof(glm::vec2) == sizeof(glm::highp_vec2) ? 0 : 1; Error += sizeof(glm::vec3) == sizeof(glm::highp_vec3) ? 0 : 1; Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1; return Error; } static int test_dvec() { int Error = 0; Error += sizeof(glm::dvec2) == sizeof(glm::highp_dvec2) ? 0 : 1; Error += sizeof(glm::dvec3) == sizeof(glm::highp_dvec3) ? 0 : 1; Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_mat(); Error += test_vec(); Error += test_dvec(); return Error; } glm-0.9.9-a2/test/core/core_type_ctor.cpp0000600000175000001440000001354713173131001017135 0ustar guususers#include #include #include static int test_vec1_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::vec1 f; glm::ivec1 i; } A, B; A.f = glm::vec1(0); Error += glm::all(glm::equal(A.i, glm::ivec1(0))) ? 0 : 1; B.f = glm::vec1(1); Error += glm::all(glm::equal(B.i, glm::ivec1(1065353216))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_vec2_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::vec2 f; glm::ivec2 i; } A, B; A.f = glm::vec2(0); Error += glm::all(glm::equal(A.i, glm::ivec2(0))) ? 0 : 1; B.f = glm::vec2(1); Error += glm::all(glm::equal(B.i, glm::ivec2(1065353216))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_vec3_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::vec3 f; glm::ivec3 i; } A, B; A.f = glm::vec3(0); Error += glm::all(glm::equal(A.i, glm::ivec3(0))) ? 0 : 1; B.f = glm::vec3(1); Error += glm::all(glm::equal(B.i, glm::ivec3(1065353216))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_vec4_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::vec4 f; glm::ivec4 i; } A, B; A.f = glm::vec4(0); Error += glm::all(glm::equal(A.i, glm::ivec4(0))) ? 0 : 1; B.f = glm::vec4(1); Error += glm::all(glm::equal(B.i, glm::ivec4(1065353216))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat2x2_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat2x2 f; glm::mat2x2 i; } A, B; A.f = glm::mat2x2(0); Error += glm::all(glm::equal(A.i[0], glm::vec2(0))) ? 0 : 1; B.f = glm::mat2x2(1); Error += glm::all(glm::equal(B.i[0], glm::vec2(1, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat2x3_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat2x3 f; glm::mat2x3 i; } A, B; A.f = glm::mat2x3(0); Error += glm::all(glm::equal(A.i[0], glm::vec3(0))) ? 0 : 1; B.f = glm::mat2x3(1); Error += glm::all(glm::equal(B.i[0], glm::vec3(1, 0, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat2x4_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat2x4 f; glm::mat2x4 i; } A, B; A.f = glm::mat2x4(0); glm::vec4 const C(0, 0, 0, 0); Error += glm::all(glm::equal(A.i[0], C)) ? 0 : 1; B.f = glm::mat2x4(1); glm::vec4 const D(1, 0, 0, 0); Error += glm::all(glm::equal(B.i[0], D)) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat3x2_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat3x2 f; glm::mat3x2 i; } A, B; A.f = glm::mat3x2(0); Error += glm::all(glm::equal(A.i[0], glm::vec2(0))) ? 0 : 1; B.f = glm::mat3x2(1); Error += glm::all(glm::equal(B.i[0], glm::vec2(1, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat3x3_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat3x3 f; glm::mat3x3 i; } A, B; A.f = glm::mat3x3(0); Error += glm::all(glm::equal(A.i[0], glm::vec3(0))) ? 0 : 1; B.f = glm::mat3x3(1); Error += glm::all(glm::equal(B.i[0], glm::vec3(1, 0, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat3x4_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat3x4 f; glm::mat3x4 i; } A, B; A.f = glm::mat3x4(0); Error += glm::all(glm::equal(A.i[0], glm::vec4(0))) ? 0 : 1; B.f = glm::mat3x4(1); Error += glm::all(glm::equal(B.i[0], glm::vec4(1, 0, 0, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat4x2_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat4x2 f; glm::mat4x2 i; } A, B; A.f = glm::mat4x2(0); Error += glm::all(glm::equal(A.i[0], glm::vec2(0))) ? 0 : 1; B.f = glm::mat4x2(1); Error += glm::all(glm::equal(B.i[0], glm::vec2(1, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat4x3_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat4x3 f; glm::mat4x3 i; } A, B; A.f = glm::mat4x3(0); Error += glm::all(glm::equal(A.i[0], glm::vec3(0))) ? 0 : 1; B.f = glm::mat4x3(1); Error += glm::all(glm::equal(B.i[0], glm::vec3(1, 0, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_mat4x4_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::mat4 f; glm::mat4 i; } A, B; A.f = glm::mat4(0); Error += glm::all(glm::equal(A.i[0], glm::vec4(0))) ? 0 : 1; B.f = glm::mat4(1); Error += glm::all(glm::equal(B.i[0], glm::vec4(1, 0, 0, 0))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } static int test_quat_ctor() { int Error = 0; # if GLM_HAS_DEFAULTED_FUNCTIONS { union pack { glm::quat f; glm::quat i; } A, B; A.f = glm::quat(0, 0, 0, 0); Error += glm::all(glm::equal(A.i, glm::quat(0, 0, 0, 0))) ? 0 : 1; B.f = glm::quat(1, 1, 1, 1); Error += glm::all(glm::equal(B.i, glm::quat(1, 1, 1, 1))) ? 0 : 1; } # endif//GLM_HAS_DEFAULTED_FUNCTIONS return Error; } int main() { int Error = 0; Error += test_vec1_ctor(); Error += test_vec2_ctor(); Error += test_vec3_ctor(); Error += test_vec4_ctor(); Error += test_mat2x2_ctor(); Error += test_mat2x3_ctor(); Error += test_mat2x4_ctor(); Error += test_mat3x2_ctor(); Error += test_mat3x3_ctor(); Error += test_mat3x4_ctor(); Error += test_mat4x2_ctor(); Error += test_mat4x3_ctor(); Error += test_mat4x4_ctor(); Error += test_quat_ctor(); return Error; } glm-0.9.9-a2/test/core/core_type_mat2x3.cpp0000600000175000001440000000460513173131001017277 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include static int test_operators() { glm::mat2x3 l(1.0f); glm::mat2x3 m(1.0f); glm::vec2 u(1.0f); glm::vec3 v(1.0f); float x = 1.0f; glm::vec3 a = m * u; glm::vec2 b = v * m; glm::mat2x3 n = x / m; glm::mat2x3 o = m / x; glm::mat2x3 p = x * m; glm::mat2x3 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_ctr() { int Error(0); #if GLM_HAS_INITIALIZER_LISTS glm::mat2x3 m0( glm::vec3(0, 1, 2), glm::vec3(3, 4, 5)); glm::mat2x3 m1{0, 1, 2, 3, 4, 5}; glm::mat2x3 m2{ {0, 1, 2}, {3, 4, 5}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 4, 5} }; std::vector v2{ { { 0, 1, 2}, { 4, 5, 6} }, { { 0, 1, 2}, { 4, 5, 6} } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat2x3 B(A); glm::mat2x3 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::equal(B[i], Identity[i])) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 24 == sizeof(glm::mat2x3) ? 0 : 1; Error += 48 == sizeof(glm::dmat2x3) ? 0 : 1; Error += glm::mat2x3().length() == 2 ? 0 : 1; Error += glm::dmat2x3().length() == 2 ? 0 : 1; Error += glm::mat2x3::length() == 2 ? 0 : 1; Error += glm::dmat2x3::length() == 2 ? 0 : 1; return Error; } int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/core_func_vector_relational.cpp0000600000175000001440000000105713173131001021645 0ustar guususers#include #include #include #include #include static int test_not() { int Error(0); { glm::bvec1 v(false); Error += glm::all(glm::not_(v)) ? 0 : 1; } { glm::bvec2 v(false); Error += glm::all(glm::not_(v)) ? 0 : 1; } { glm::bvec3 v(false); Error += glm::all(glm::not_(v)) ? 0 : 1; } { glm::bvec4 v(false); Error += glm::all(glm::not_(v)) ? 0 : 1; } return Error; } int main() { int Error(0); Error += test_not(); return Error; } glm-0.9.9-a2/test/core/core_func_packing.cpp0000600000175000001440000000655613173131001017556 0ustar guususers#include #include #include #include #include int test_packUnorm2x16() { int Error = 0; std::vector A; A.push_back(glm::vec2(1.0f, 0.0f)); A.push_back(glm::vec2(0.5f, 0.7f)); A.push_back(glm::vec2(0.1f, 0.2f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint32 C = glm::packUnorm2x16(B); glm::vec2 D = glm::unpackUnorm2x16(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm2x16() { int Error = 0; std::vector A; A.push_back(glm::vec2( 1.0f, 0.0f)); A.push_back(glm::vec2(-0.5f,-0.7f)); A.push_back(glm::vec2(-0.1f, 0.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint32 C = glm::packSnorm2x16(B); glm::vec2 D = glm::unpackSnorm2x16(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1; assert(!Error); } return Error; } int test_packUnorm4x8() { int Error = 0; glm::uint32 Packed = glm::packUnorm4x8(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)); glm::u8vec4 Vec(255, 128, 0, 255); glm::uint32 & Ref = *reinterpret_cast(&Vec[0]); Error += Packed == Ref ? 0 : 1; std::vector A; A.push_back(glm::vec4(1.0f, 0.7f, 0.3f, 0.0f)); A.push_back(glm::vec4(0.5f, 0.1f, 0.2f, 0.3f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint32 C = glm::packUnorm4x8(B); glm::vec4 D = glm::unpackUnorm4x8(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packSnorm4x8() { int Error = 0; std::vector A; A.push_back(glm::vec4( 1.0f, 0.0f,-0.5f,-1.0f)); A.push_back(glm::vec4(-0.7f,-0.1f, 0.1f, 0.7f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec4 B(A[i]); glm::uint32 C = glm::packSnorm4x8(B); glm::vec4 D = glm::unpackSnorm4x8(C); Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packHalf2x16() { int Error = 0; /* std::vector A; A.push_back(glm::hvec2(glm::half( 1.0f), glm::half( 2.0f))); A.push_back(glm::hvec2(glm::half(-1.0f), glm::half(-2.0f))); A.push_back(glm::hvec2(glm::half(-1.1f), glm::half( 1.1f))); */ std::vector A; A.push_back(glm::vec2( 1.0f, 2.0f)); A.push_back(glm::vec2(-1.0f,-2.0f)); A.push_back(glm::vec2(-1.1f, 1.1f)); for(std::size_t i = 0; i < A.size(); ++i) { glm::vec2 B(A[i]); glm::uint C = glm::packHalf2x16(B); glm::vec2 D = glm::unpackHalf2x16(C); //Error += B == D ? 0 : 1; Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1; assert(!Error); } return Error; } int test_packDouble2x32() { int Error = 0; std::vector A; A.push_back(glm::uvec2( 1, 2)); A.push_back(glm::uvec2(-1,-2)); A.push_back(glm::uvec2(-1000, 1100)); for(std::size_t i = 0; i < A.size(); ++i) { glm::uvec2 B(A[i]); double C = glm::packDouble2x32(B); glm::uvec2 D = glm::unpackDouble2x32(C); Error += B == D ? 0 : 1; assert(!Error); } return Error; } int main() { int Error = 0; Error += test_packSnorm4x8(); Error += test_packUnorm4x8(); Error += test_packSnorm2x16(); Error += test_packUnorm2x16(); Error += test_packHalf2x16(); Error += test_packDouble2x32(); return Error; } glm-0.9.9-a2/test/core/core_type_mat4x4.cpp0000600000175000001440000002264513173131001017306 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include #include #include #include template void print(genType const& Mat0) { printf("mat4(\n"); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast(Mat0[0][0]), static_cast(Mat0[0][1]), static_cast(Mat0[0][2]), static_cast(Mat0[0][3])); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast(Mat0[1][0]), static_cast(Mat0[1][1]), static_cast(Mat0[1][2]), static_cast(Mat0[1][3])); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast(Mat0[2][0]), static_cast(Mat0[2][1]), static_cast(Mat0[2][2]), static_cast(Mat0[2][3])); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", static_cast(Mat0[3][0]), static_cast(Mat0[3][1]), static_cast(Mat0[3][2]), static_cast(Mat0[3][3])); } int test_inverse_mat4x4() { glm::mat4 Mat0( glm::vec4(0.6f, 0.2f, 0.3f, 0.4f), glm::vec4(0.2f, 0.7f, 0.5f, 0.3f), glm::vec4(0.3f, 0.5f, 0.7f, 0.2f), glm::vec4(0.4f, 0.3f, 0.2f, 0.6f)); glm::mat4 Inv0 = glm::inverse(Mat0); glm::mat4 Res0 = Mat0 * Inv0; print(Mat0); print(Inv0); print(Res0); return 0; } int test_inverse_dmat4x4() { glm::dmat4 Mat0( glm::dvec4(0.6f, 0.2f, 0.3f, 0.4f), glm::dvec4(0.2f, 0.7f, 0.5f, 0.3f), glm::dvec4(0.3f, 0.5f, 0.7f, 0.2f), glm::dvec4(0.4f, 0.3f, 0.2f, 0.6f)); glm::dmat4 Inv0 = glm::inverse(Mat0); glm::dmat4 Res0 = Mat0 * Inv0; print(Mat0); print(Inv0); print(Res0); return 0; } static bool test_operators() { glm::mat4x4 l(1.0f); glm::mat4x4 m(1.0f); glm::vec4 u(1.0f); glm::vec4 v(1.0f); float x = 1.0f; glm::vec4 a = m * u; glm::vec4 b = v * m; glm::mat4x4 n = x / m; glm::mat4x4 o = m / x; glm::mat4x4 p = x * m; glm::mat4x4 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_inverse() { int Error(0); { glm::mat4 const Matrix( glm::vec4(0.6f, 0.2f, 0.3f, 0.4f), glm::vec4(0.2f, 0.7f, 0.5f, 0.3f), glm::vec4(0.3f, 0.5f, 0.7f, 0.2f), glm::vec4(0.4f, 0.3f, 0.2f, 0.6f)); glm::mat4 const Inverse = glm::inverse(Matrix); glm::mat4 const Identity = Matrix * Inverse; print(Matrix); print(Inverse); print(Identity); Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec4(1.0f, 0.0f, 0.0f, 0.0f), glm::vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec4(0.0f, 1.0f, 0.0f, 0.0f), glm::vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[2], glm::vec4(0.0f, 0.0f, 1.0f, 0.0f), glm::vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[3], glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::vec4(0.01f))) ? 0 : 1; } { glm::highp_mat4 const Matrix( glm::highp_vec4(0.6f, 0.2f, 0.3f, 0.4f), glm::highp_vec4(0.2f, 0.7f, 0.5f, 0.3f), glm::highp_vec4(0.3f, 0.5f, 0.7f, 0.2f), glm::highp_vec4(0.4f, 0.3f, 0.2f, 0.6f)); glm::highp_mat4 const Inverse = glm::inverse(Matrix); glm::highp_mat4 const Identity = Matrix * Inverse; printf("highp_mat4 inverse\n"); print(Matrix); print(Inverse); print(Identity); Error += glm::all(glm::epsilonEqual(Identity[0], glm::highp_vec4(1.0f, 0.0f, 0.0f, 0.0f), glm::highp_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::highp_vec4(0.0f, 1.0f, 0.0f, 0.0f), glm::highp_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[2], glm::highp_vec4(0.0f, 0.0f, 1.0f, 0.0f), glm::highp_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[3], glm::highp_vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::highp_vec4(0.01f))) ? 0 : 1; } { glm::mediump_mat4 const Matrix( glm::mediump_vec4(0.6f, 0.2f, 0.3f, 0.4f), glm::mediump_vec4(0.2f, 0.7f, 0.5f, 0.3f), glm::mediump_vec4(0.3f, 0.5f, 0.7f, 0.2f), glm::mediump_vec4(0.4f, 0.3f, 0.2f, 0.6f)); glm::mediump_mat4 const Inverse = glm::inverse(Matrix); glm::mediump_mat4 const Identity = Matrix * Inverse; printf("mediump_mat4 inverse\n"); print(Matrix); print(Inverse); print(Identity); Error += glm::all(glm::epsilonEqual(Identity[0], glm::mediump_vec4(1.0f, 0.0f, 0.0f, 0.0f), glm::mediump_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::mediump_vec4(0.0f, 1.0f, 0.0f, 0.0f), glm::mediump_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[2], glm::mediump_vec4(0.0f, 0.0f, 1.0f, 0.0f), glm::mediump_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[3], glm::mediump_vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::mediump_vec4(0.01f))) ? 0 : 1; } { glm::lowp_mat4 const Matrix( glm::lowp_vec4(0.6f, 0.2f, 0.3f, 0.4f), glm::lowp_vec4(0.2f, 0.7f, 0.5f, 0.3f), glm::lowp_vec4(0.3f, 0.5f, 0.7f, 0.2f), glm::lowp_vec4(0.4f, 0.3f, 0.2f, 0.6f)); glm::lowp_mat4 const Inverse = glm::inverse(Matrix); glm::lowp_mat4 const Identity = Matrix * Inverse; printf("lowp_mat4 inverse\n"); print(Matrix); print(Inverse); print(Identity); Error += glm::all(glm::epsilonEqual(Identity[0], glm::lowp_vec4(1.0f, 0.0f, 0.0f, 0.0f), glm::lowp_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::lowp_vec4(0.0f, 1.0f, 0.0f, 0.0f), glm::lowp_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[2], glm::lowp_vec4(0.0f, 0.0f, 1.0f, 0.0f), glm::lowp_vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[3], glm::lowp_vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::lowp_vec4(0.01f))) ? 0 : 1; } { glm::mat4 const Matrix( glm::vec4(0.6f, 0.2f, 0.3f, 0.4f), glm::vec4(0.2f, 0.7f, 0.5f, 0.3f), glm::vec4(0.3f, 0.5f, 0.7f, 0.2f), glm::vec4(0.4f, 0.3f, 0.2f, 0.6f)); glm::mat4 const Identity = Matrix / Matrix; Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec4(1.0f, 0.0f, 0.0f, 0.0f), glm::vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec4(0.0f, 1.0f, 0.0f, 0.0f), glm::vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[2], glm::vec4(0.0f, 0.0f, 1.0f, 0.0f), glm::vec4(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[3], glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), glm::vec4(0.01f))) ? 0 : 1; } return Error; } int test_ctr() { int Error(0); #if GLM_HAS_TRIVIAL_QUERIES //Error += std::is_trivially_default_constructible::value ? 0 : 1; //Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; //Error += std::is_copy_constructible::value ? 0 : 1; //Error += std::has_trivial_copy_constructor::value ? 0 : 1; #endif #if(GLM_HAS_INITIALIZER_LISTS) glm::mat4 m0( glm::vec4(0, 1, 2, 3), glm::vec4(4, 5, 6, 7), glm::vec4(8, 9, 10, 11), glm::vec4(12, 13, 14, 15)); assert(sizeof(m0) == 4 * 4 * 4); glm::vec4 V{0, 1, 2, 3}; glm::mat4 m1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; glm::mat4 m2{ {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}, {12, 13, 14, 15}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector m3{ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}; std::vector v1{ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}; std::vector v2{ { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 }, { 12, 13, 14, 15 } }, { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 }, { 12, 13, 14, 15 } }}; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } int perf_mul() { int Error = 0; return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat4x4 B(A); glm::mat4x4 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::epsilonEqual(B[i], Identity[i], glm::epsilon())) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast struct repro { repro(){ this->matrix = new glm::mat4(); } ~repro(){delete this->matrix;} glm::mat4* matrix; }; int test_size() { int Error = 0; Error += 64 == sizeof(glm::mat4) ? 0 : 1; Error += 128 == sizeof(glm::dmat4) ? 0 : 1; Error += glm::mat4().length() == 4 ? 0 : 1; Error += glm::dmat4().length() == 4 ? 0 : 1; Error += glm::mat4::length() == 4 ? 0 : 1; Error += glm::dmat4::length() == 4 ? 0 : 1; return Error; } int main() { int Error = 0; repro Repro; Error += cast::test(); Error += test_ctr(); Error += test_inverse_dmat4x4(); Error += test_inverse_mat4x4(); Error += test_operators(); Error += test_inverse(); Error += test_size(); Error += perf_mul(); return Error; } glm-0.9.9-a2/test/core/core_type_mat3x4.cpp0000600000175000001440000000521713173131001017301 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include #include #include static bool test_operators() { glm::mat3x4 l(1.0f); glm::mat3x4 m(1.0f); glm::vec3 u(1.0f); glm::vec4 v(1.0f); float x = 1.0f; glm::vec4 a = m * u; glm::vec3 b = v * m; glm::mat3x4 n = x / m; glm::mat3x4 o = m / x; glm::mat3x4 p = x * m; glm::mat3x4 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_ctr() { int Error(0); #if(GLM_HAS_INITIALIZER_LISTS) glm::mat3x4 m0( glm::vec4(0, 1, 2, 3), glm::vec4(4, 5, 6, 7), glm::vec4(8, 9, 10, 11)); glm::mat3x4 m1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; glm::mat3x4 m2{ {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} }; std::vector v2{ { { 0, 1, 2, 3}, { 4, 5, 6, 7}, { 8, 9, 10, 11} }, { { 0, 1, 2, 3}, { 4, 5, 6, 7}, { 8, 9, 10, 11} } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat3x4 B(A); glm::mat3x4 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::epsilonEqual(B[i], Identity[i], glm::epsilon())) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 48 == sizeof(glm::mat3x4) ? 0 : 1; Error += 96 == sizeof(glm::dmat3x4) ? 0 : 1; Error += glm::mat3x4().length() == 3 ? 0 : 1; Error += glm::dmat3x4().length() == 3 ? 0 : 1; Error += glm::mat3x4::length() == 3 ? 0 : 1; Error += glm::dmat3x4::length() == 3 ? 0 : 1; return Error; } int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/core_type_vec4.cpp0000600000175000001440000003131613173131001017021 0ustar guususers#define GLM_FORCE_ALIGNED #define GLM_FORCE_SWIZZLE #include #include #include #include #include #include #include #include static glm::vec4 g1; static glm::vec4 g2(1); static glm::vec4 g3(1, 1, 1, 1); template struct mask { enum{value = Value}; }; enum comp { X, Y, Z, W }; //template //__m128 swizzle(glm::vec4 const& v) //{ // __m128 Src = _mm_set_ps(v.w, v.z, v.y, v.x); // return _mm_shuffle_ps(Src, Src, mask<(int(W) << 6) | (int(Z) << 4) | (int(Y) << 2) | (int(X) << 0)>::value); //} static int test_vec4_ctor() { int Error = 0; { glm::ivec4 A(1, 2, 3, 4); glm::ivec4 B(A); Error += glm::all(glm::equal(A, B)) ? 0 : 1; } # if GLM_HAS_TRIVIAL_QUERIES // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; # endif #if GLM_HAS_INITIALIZER_LISTS { glm::vec4 a{ 0, 1, 2, 3 }; std::vector v = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 0, 1}}; } { glm::dvec4 a{ 0, 1, 2, 3 }; std::vector v = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 0, 1}}; } #endif #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) { glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A.xyzw; glm::vec4 C(A.xyzw); glm::vec4 D(A.xyzw()); glm::vec4 E(A.x, A.yzw); glm::vec4 F(A.x, A.yzw()); glm::vec4 G(A.xyz, A.w); glm::vec4 H(A.xyz(), A.w); glm::vec4 I(A.xy, A.zw); glm::vec4 J(A.xy(), A.zw()); glm::vec4 K(A.x, A.y, A.zw); glm::vec4 L(A.x, A.yz, A.w); glm::vec4 M(A.xy, A.z, A.w); Error += glm::all(glm::equal(A, B)) ? 0 : 1; Error += glm::all(glm::equal(A, C)) ? 0 : 1; Error += glm::all(glm::equal(A, D)) ? 0 : 1; Error += glm::all(glm::equal(A, E)) ? 0 : 1; Error += glm::all(glm::equal(A, F)) ? 0 : 1; Error += glm::all(glm::equal(A, G)) ? 0 : 1; Error += glm::all(glm::equal(A, H)) ? 0 : 1; Error += glm::all(glm::equal(A, I)) ? 0 : 1; Error += glm::all(glm::equal(A, J)) ? 0 : 1; Error += glm::all(glm::equal(A, K)) ? 0 : 1; Error += glm::all(glm::equal(A, L)) ? 0 : 1; Error += glm::all(glm::equal(A, M)) ? 0 : 1; } #endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) # if GLM_HAS_CONSTEXPR && GLM_ARCH == GLM_ARCH_PURE && !(GLM_COMPILER & GLM_COMPILER_VC) // Visual Studio bug? { constexpr glm::ivec4 v(1); Error += v.x == 1 ? 0 : 1; Error += v.y == 1 ? 0 : 1; Error += v.z == 1 ? 0 : 1; Error += v.w == 1 ? 0 : 1; } # endif { glm::vec4 A(1); glm::vec4 B(1, 1, 1, 1); Error += A == B ? 0 : 1; } { std::vector Tests; Tests.push_back(glm::vec4(glm::vec2(1, 2), 3, 4)); Tests.push_back(glm::vec4(1, glm::vec2(2, 3), 4)); Tests.push_back(glm::vec4(1, 2, glm::vec2(3, 4))); Tests.push_back(glm::vec4(glm::vec3(1, 2, 3), 4)); Tests.push_back(glm::vec4(1, glm::vec3(2, 3, 4))); Tests.push_back(glm::vec4(glm::vec2(1, 2), glm::vec2(3, 4))); Tests.push_back(glm::vec4(1, 2, 3, 4)); Tests.push_back(glm::vec4(glm::vec4(1, 2, 3, 4))); for(std::size_t i = 0; i < Tests.size(); ++i) Error += Tests[i] == glm::vec4(1, 2, 3, 4) ? 0 : 1; } return Error; } static int test_bvec4_ctor() { int Error = 0; glm::bvec4 const A(true); glm::bvec4 const B(true); glm::bvec4 const C(false); glm::bvec4 const D = A && B; glm::bvec4 const E = A && C; glm::bvec4 const F = A || C; Error += D == glm::bvec4(true) ? 0 : 1; Error += E == glm::bvec4(false) ? 0 : 1; Error += F == glm::bvec4(true) ? 0 : 1; bool const G = A == C; bool const H = A != C; Error += !G ? 0 : 1; Error += H ? 0 : 1; return Error; } static int test_vec4_operators() { int Error = 0; { glm::vec4 A(1.0f); glm::vec4 B(1.0f); bool R = A != B; bool S = A == B; Error += (S && !R) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); glm::vec4 C = A + B; Error += C == glm::vec4(5, 7, 9, 11) ? 0 : 1; glm::vec4 D = B - A; Error += D == glm::vec4(3, 3, 3, 3) ? 0 : 1; glm::vec4 E = A * B; Error += E == glm::vec4(4, 10, 18, 28) ? 0 : 1; glm::vec4 F = B / A; Error += F == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1; glm::vec4 G = A + 1.0f; Error += G == glm::vec4(2, 3, 4, 5) ? 0 : 1; glm::vec4 H = B - 1.0f; Error += H == glm::vec4(3, 4, 5, 6) ? 0 : 1; glm::vec4 I = A * 2.0f; Error += I == glm::vec4(2, 4, 6, 8) ? 0 : 1; glm::vec4 J = B / 2.0f; Error += J == glm::vec4(2, 2.5, 3, 3.5) ? 0 : 1; glm::vec4 K = 1.0f + A; Error += K == glm::vec4(2, 3, 4, 5) ? 0 : 1; glm::vec4 L = 1.0f - B; Error += L == glm::vec4(-3, -4, -5, -6) ? 0 : 1; glm::vec4 M = 2.0f * A; Error += M == glm::vec4(2, 4, 6, 8) ? 0 : 1; glm::vec4 N = 2.0f / B; Error += N == glm::vec4(0.5, 2.0 / 5.0, 2.0 / 6.0, 2.0 / 7.0) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); A += B; Error += A == glm::vec4(5, 7, 9, 11) ? 0 : 1; A += 1.0f; Error += A == glm::vec4(6, 8, 10, 12) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); B -= A; Error += B == glm::vec4(3, 3, 3, 3) ? 0 : 1; B -= 1.0f; Error += B == glm::vec4(2, 2, 2, 2) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); A *= B; Error += A == glm::vec4(4, 10, 18, 28) ? 0 : 1; A *= 2.0f; Error += A == glm::vec4(8, 20, 36, 56) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); B /= A; Error += B == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1; B /= 2.0f; Error += B == glm::vec4(2, 1.25, 1, 7.0f / 4.0f / 2.0f) ? 0 : 1; } { glm::vec4 B(2.0f); B /= B.y; Error += B == glm::vec4(1.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = -A; Error += B == glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = --A; Error += B == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A--; Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1; Error += A == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = ++A; Error += B == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A++; Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1; Error += A == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1; } return Error; } static int test_vec4_equal() { int Error = 0; { glm::vec4 const A(1, 2, 3, 4); glm::vec4 const B(1, 2, 3, 4); Error += A == B ? 0 : 1; Error += A != B ? 1 : 0; } { glm::ivec4 const A(1, 2, 3, 4); glm::ivec4 const B(1, 2, 3, 4); Error += A == B ? 0 : 1; Error += A != B ? 1 : 0; } return Error; } static int test_vec4_size() { int Error = 0; Error += sizeof(glm::vec4) == sizeof(glm::lowp_vec4) ? 0 : 1; Error += sizeof(glm::vec4) == sizeof(glm::mediump_vec4) ? 0 : 1; Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1; Error += 16 == sizeof(glm::mediump_vec4) ? 0 : 1; Error += sizeof(glm::dvec4) == sizeof(glm::lowp_dvec4) ? 0 : 1; Error += sizeof(glm::dvec4) == sizeof(glm::mediump_dvec4) ? 0 : 1; Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1; Error += 32 == sizeof(glm::highp_dvec4) ? 0 : 1; Error += glm::vec4().length() == 4 ? 0 : 1; Error += glm::dvec4().length() == 4 ? 0 : 1; Error += glm::vec4::length() == 4 ? 0 : 1; Error += glm::dvec4::length() == 4 ? 0 : 1; # if GLM_HAS_CONSTEXPR_PARTIAL constexpr std::size_t Length = glm::vec4::length(); Error += Length == 4 ? 0 : 1; # endif return Error; } static int test_vec4_swizzle_partial() { int Error = 0; glm::vec4 A(1, 2, 3, 4); # if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE_RELAX) { glm::vec4 B(A.xy, A.zw); Error += A == B ? 0 : 1; } { glm::vec4 B(A.xy, 3.0f, 4.0f); Error += A == B ? 0 : 1; } { glm::vec4 B(1.0f, A.yz, 4.0f); Error += A == B ? 0 : 1; } { glm::vec4 B(1.0f, 2.0f, A.zw); Error += A == B ? 0 : 1; } { glm::vec4 B(A.xyz, 4.0f); Error += A == B ? 0 : 1; } { glm::vec4 B(1.0f, A.yzw); Error += A == B ? 0 : 1; } # endif return Error; } static int test_operator_increment() { int Error(0); glm::ivec4 v0(1); glm::ivec4 v1(v0); glm::ivec4 v2(v0); glm::ivec4 v3 = ++v1; glm::ivec4 v4 = v2++; Error += glm::all(glm::equal(v0, v4)) ? 0 : 1; Error += glm::all(glm::equal(v1, v2)) ? 0 : 1; Error += glm::all(glm::equal(v1, v3)) ? 0 : 1; int i0(1); int i1(i0); int i2(i0); int i3 = ++i1; int i4 = i2++; Error += i0 == i4 ? 0 : 1; Error += i1 == i2 ? 0 : 1; Error += i1 == i3 ? 0 : 1; return Error; } struct AoS { glm::vec4 A; glm::vec3 B; glm::vec3 C; glm::vec2 D; }; static int test_vec4_perf_AoS(std::size_t Size) { int Error(0); std::vector In; std::vector Out; In.resize(Size); Out.resize(Size); std::clock_t StartTime = std::clock(); for(std::size_t i = 0; i < In.size(); ++i) Out[i] = In[i]; std::clock_t EndTime = std::clock(); std::printf("AoS: %ld\n", EndTime - StartTime); return Error; } static int test_vec4_perf_SoA(std::size_t Size) { int Error(0); std::vector InA; std::vector InB; std::vector InC; std::vector InD; std::vector OutA; std::vector OutB; std::vector OutC; std::vector OutD; InA.resize(Size); InB.resize(Size); InC.resize(Size); InD.resize(Size); OutA.resize(Size); OutB.resize(Size); OutC.resize(Size); OutD.resize(Size); std::clock_t StartTime = std::clock(); for(std::size_t i = 0; i < InA.size(); ++i) { OutA[i] = InA[i]; OutB[i] = InB[i]; OutC[i] = InC[i]; OutD[i] = InD[i]; } std::clock_t EndTime = std::clock(); std::printf("SoA: %ld\n", EndTime - StartTime); return Error; } namespace heap { struct A { float f; }; struct B : public A { float g; glm::vec4 v; }; static int test() { int Error = 0; A* p = new B; p->f = 0.0f; delete p; Error += sizeof(B) == sizeof(glm::vec4) + sizeof(float) * 2 ? 0 : 1; return Error; } }//namespace heap static int test_vec4_simd() { int Error = 0; glm::vec4 const a(std::clock(), std::clock(), std::clock(), std::clock()); glm::vec4 const b(std::clock(), std::clock(), std::clock(), std::clock()); glm::vec4 const c(b * a); glm::vec4 const d(a + c); Error += glm::all(glm::greaterThanEqual(d, glm::vec4(0))) ? 0 : 1; return Error; } static int test_inheritance() { struct my_vec4 : public glm::vec4 { my_vec4() : glm::vec4(76.f, 75.f, 74.f, 73.f) , data(82) {} int data; }; int Error = 0; my_vec4 v; Error += v.data == 82 ? 0 : 1; Error += glm::epsilonEqual(v.x, 76.f, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(v.y, 75.f, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(v.z, 74.f, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(v.w, 73.f, glm::epsilon()) ? 0 : 1; return Error; } int main() { int Error = 0; /* { glm::ivec4 const a1(2); glm::ivec4 const b1 = a1 >> 1; __m128i const e1 = _mm_set1_epi32(2); __m128i const f1 = _mm_srli_epi32(e1, 1); glm::ivec4 const g1 = *reinterpret_cast(&f1); glm::ivec4 const a2(-2); glm::ivec4 const b2 = a2 >> 1; __m128i const e2 = _mm_set1_epi32(-1); __m128i const f2 = _mm_srli_epi32(e2, 1); glm::ivec4 const g2 = *reinterpret_cast(&f2); printf("GNI\n"); } { glm::uvec4 const a1(2); glm::uvec4 const b1 = a1 >> 1u; __m128i const e1 = _mm_set1_epi32(2); __m128i const f1 = _mm_srli_epi32(e1, 1); glm::uvec4 const g1 = *reinterpret_cast(&f1); glm::uvec4 const a2(-1); glm::uvec4 const b2 = a2 >> 1u; __m128i const e2 = _mm_set1_epi32(-1); __m128i const f2 = _mm_srli_epi32(e2, 1); glm::uvec4 const g2 = *reinterpret_cast(&f2); printf("GNI\n"); } */ # ifdef NDEBUG std::size_t const Size(1000000); # else std::size_t const Size(1); # endif//NDEBUG Error += test_vec4_perf_AoS(Size); Error += test_vec4_perf_SoA(Size); Error += test_vec4_ctor(); Error += test_bvec4_ctor(); Error += test_vec4_size(); Error += test_vec4_operators(); Error += test_vec4_equal(); Error += test_vec4_swizzle_partial(); Error += test_vec4_simd(); Error += test_operator_increment(); Error += heap::test(); Error += test_inheritance(); return Error; } glm-0.9.9-a2/test/core/core_type_length.cpp0000600000175000001440000000403713173131001017441 0ustar guususers#include static int test_length_mat_non_squared() { int Error = 0; Error += glm::mat2x3().length() == 2 ? 0 : 1; Error += glm::mat2x4().length() == 2 ? 0 : 1; Error += glm::mat3x2().length() == 3 ? 0 : 1; Error += glm::mat3x4().length() == 3 ? 0 : 1; Error += glm::mat4x2().length() == 4 ? 0 : 1; Error += glm::mat4x3().length() == 4 ? 0 : 1; Error += glm::dmat2x3().length() == 2 ? 0 : 1; Error += glm::dmat2x4().length() == 2 ? 0 : 1; Error += glm::dmat3x2().length() == 3 ? 0 : 1; Error += glm::dmat3x4().length() == 3 ? 0 : 1; Error += glm::dmat4x2().length() == 4 ? 0 : 1; Error += glm::dmat4x3().length() == 4 ? 0 : 1; return Error; } static int test_length_mat() { int Error = 0; Error += glm::mat2().length() == 2 ? 0 : 1; Error += glm::mat3().length() == 3 ? 0 : 1; Error += glm::mat4().length() == 4 ? 0 : 1; Error += glm::mat2x2().length() == 2 ? 0 : 1; Error += glm::mat3x3().length() == 3 ? 0 : 1; Error += glm::mat4x4().length() == 4 ? 0 : 1; Error += glm::dmat2().length() == 2 ? 0 : 1; Error += glm::dmat3().length() == 3 ? 0 : 1; Error += glm::dmat4().length() == 4 ? 0 : 1; Error += glm::dmat2x2().length() == 2 ? 0 : 1; Error += glm::dmat3x3().length() == 3 ? 0 : 1; Error += glm::dmat4x4().length() == 4 ? 0 : 1; return Error; } static int test_length_vec() { int Error = 0; Error += glm::vec2().length() == 2 ? 0 : 1; Error += glm::vec3().length() == 3 ? 0 : 1; Error += glm::vec4().length() == 4 ? 0 : 1; Error += glm::ivec2().length() == 2 ? 0 : 1; Error += glm::ivec3().length() == 3 ? 0 : 1; Error += glm::ivec4().length() == 4 ? 0 : 1; Error += glm::uvec2().length() == 2 ? 0 : 1; Error += glm::uvec3().length() == 3 ? 0 : 1; Error += glm::uvec4().length() == 4 ? 0 : 1; Error += glm::dvec2().length() == 2 ? 0 : 1; Error += glm::dvec3().length() == 3 ? 0 : 1; Error += glm::dvec4().length() == 4 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_length_vec(); Error += test_length_mat(); Error += test_length_mat_non_squared(); return Error; } glm-0.9.9-a2/test/core/core_func_noise.cpp0000600000175000001440000000006013173131001017237 0ustar guususersint main() { int Error = 0; return Error; } glm-0.9.9-a2/test/core/core_func_swizzle.cpp0000600000175000001440000000227413173131001017642 0ustar guususers#define GLM_FORCE_MESSAGES #define GLM_FORCE_SWIZZLE #include #if !GLM_HAS_ONLY_XYZW int test_ivec2_swizzle() { int Error = 0; glm::ivec2 A(1, 2); glm::ivec2 B = A.yx(); glm::ivec2 C = B.yx(); Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; return Error; } int test_ivec3_swizzle() { int Error = 0; glm::ivec3 A(1, 2, 3); glm::ivec3 B = A.zyx(); glm::ivec3 C = B.zyx(); Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; return Error; } int test_ivec4_swizzle() { int Error = 0; glm::ivec4 A(1, 2, 3, 4); glm::ivec4 B = A.wzyx(); glm::ivec4 C = B.wzyx(); Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; return Error; } int test_vec4_swizzle() { int Error = 0; glm::vec4 A(1, 2, 3, 4); glm::vec4 B = A.wzyx(); glm::vec4 C = B.wzyx(); Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; float f = glm::dot(C.wzyx(), C.xyzw()); Error += glm::abs(f - 20.f) < 0.01f ? 0 : 1; return Error; } #endif//!GLM_HAS_ONLY_XYZW int main() { int Error = 0; # if !GLM_HAS_ONLY_XYZW Error += test_ivec2_swizzle(); Error += test_ivec3_swizzle(); Error += test_ivec4_swizzle(); Error += test_vec4_swizzle(); # endif//!GLM_HAS_ONLY_XYZW return Error; } glm-0.9.9-a2/test/core/core_type_vec3.cpp0000600000175000001440000003243413173131001017022 0ustar guususers#define GLM_FORCE_SWIZZLE #include #include #include #include #include #include #include static glm::vec3 g1; static glm::vec3 g2(1); static glm::vec3 g3(1, 1, 1); int test_vec3_ctor() { int Error = 0; # if GLM_HAS_TRIVIAL_QUERIES // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; # endif #if (GLM_HAS_INITIALIZER_LISTS) { glm::vec3 a{ 0, 1, 2 }; std::vector v = { {0, 1, 2}, {4, 5, 6}, {8, 9, 0}}; } { glm::dvec3 a{ 0, 1, 2 }; std::vector v = { {0, 1, 2}, {4, 5, 6}, {8, 9, 0}}; } #endif #if(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)) { glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f); glm::vec3 B = A.xyz; glm::vec3 C(A.xyz); glm::vec3 D(A.xyz()); glm::vec3 E(A.x, A.yz); glm::vec3 F(A.x, A.yz()); glm::vec3 G(A.xy, A.z); glm::vec3 H(A.xy(), A.z); Error += glm::all(glm::equal(A, B)) ? 0 : 1; Error += glm::all(glm::equal(A, C)) ? 0 : 1; Error += glm::all(glm::equal(A, D)) ? 0 : 1; Error += glm::all(glm::equal(A, E)) ? 0 : 1; Error += glm::all(glm::equal(A, F)) ? 0 : 1; Error += glm::all(glm::equal(A, G)) ? 0 : 1; Error += glm::all(glm::equal(A, H)) ? 0 : 1; } #endif//(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)) { glm::vec3 A(1); glm::vec3 B(1, 1, 1); Error += A == B ? 0 : 1; } { std::vector Tests; Tests.push_back(glm::vec3(glm::vec2(1, 2), 3)); Tests.push_back(glm::vec3(1, glm::vec2(2, 3))); Tests.push_back(glm::vec3(1, 2, 3)); Tests.push_back(glm::vec3(glm::vec4(1, 2, 3, 4))); for(std::size_t i = 0; i < Tests.size(); ++i) Error += Tests[i] == glm::vec3(1, 2, 3) ? 0 : 1; } return Error; } float foo() { glm::vec3 bar = glm::vec3(0.0f, 1.0f, 1.0f); return glm::length(bar); } int test_vec3_operators() { int Error = 0; { glm::vec3 A(1.0f); glm::vec3 B(1.0f); bool R = A != B; bool S = A == B; Error += (S && !R) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B(4.0f, 5.0f, 6.0f); glm::vec3 C = A + B; Error += C == glm::vec3(5, 7, 9) ? 0 : 1; glm::vec3 D = B - A; Error += D == glm::vec3(3, 3, 3) ? 0 : 1; glm::vec3 E = A * B; Error += E == glm::vec3(4, 10, 18) ? 0 : 1; glm::vec3 F = B / A; Error += F == glm::vec3(4, 2.5, 2) ? 0 : 1; glm::vec3 G = A + 1.0f; Error += G == glm::vec3(2, 3, 4) ? 0 : 1; glm::vec3 H = B - 1.0f; Error += H == glm::vec3(3, 4, 5) ? 0 : 1; glm::vec3 I = A * 2.0f; Error += I == glm::vec3(2, 4, 6) ? 0 : 1; glm::vec3 J = B / 2.0f; Error += J == glm::vec3(2, 2.5, 3) ? 0 : 1; glm::vec3 K = 1.0f + A; Error += K == glm::vec3(2, 3, 4) ? 0 : 1; glm::vec3 L = 1.0f - B; Error += L == glm::vec3(-3, -4, -5) ? 0 : 1; glm::vec3 M = 2.0f * A; Error += M == glm::vec3(2, 4, 6) ? 0 : 1; glm::vec3 N = 2.0f / B; Error += N == glm::vec3(0.5, 2.0 / 5.0, 2.0 / 6.0) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B(4.0f, 5.0f, 6.0f); A += B; Error += A == glm::vec3(5, 7, 9) ? 0 : 1; A += 1.0f; Error += A == glm::vec3(6, 8, 10) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B(4.0f, 5.0f, 6.0f); B -= A; Error += B == glm::vec3(3, 3, 3) ? 0 : 1; B -= 1.0f; Error += B == glm::vec3(2, 2, 2) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B(4.0f, 5.0f, 6.0f); A *= B; Error += A == glm::vec3(4, 10, 18) ? 0 : 1; A *= 2.0f; Error += A == glm::vec3(8, 20, 36) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B(4.0f, 5.0f, 6.0f); B /= A; Error += B == glm::vec3(4, 2.5, 2) ? 0 : 1; B /= 2.0f; Error += B == glm::vec3(2, 1.25, 1) ? 0 : 1; } { glm::vec3 B(2.0f); B /= B.y; Error += B == glm::vec3(1.0f) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B = -A; Error += B == glm::vec3(-1.0f, -2.0f, -3.0f) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B = --A; Error += B == glm::vec3(0.0f, 1.0f, 2.0f) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B = A--; Error += B == glm::vec3(1.0f, 2.0f, 3.0f) ? 0 : 1; Error += A == glm::vec3(0.0f, 1.0f, 2.0f) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B = ++A; Error += B == glm::vec3(2.0f, 3.0f, 4.0f) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::vec3 B = A++; Error += B == glm::vec3(1.0f, 2.0f, 3.0f) ? 0 : 1; Error += A == glm::vec3(2.0f, 3.0f, 4.0f) ? 0 : 1; } return Error; } int test_vec3_size() { int Error = 0; Error += sizeof(glm::vec3) == sizeof(glm::lowp_vec3) ? 0 : 1; Error += sizeof(glm::vec3) == sizeof(glm::mediump_vec3) ? 0 : 1; Error += sizeof(glm::vec3) == sizeof(glm::highp_vec3) ? 0 : 1; Error += 12 == sizeof(glm::mediump_vec3) ? 0 : 1; Error += sizeof(glm::dvec3) == sizeof(glm::lowp_dvec3) ? 0 : 1; Error += sizeof(glm::dvec3) == sizeof(glm::mediump_dvec3) ? 0 : 1; Error += sizeof(glm::dvec3) == sizeof(glm::highp_dvec3) ? 0 : 1; Error += 24 == sizeof(glm::highp_dvec3) ? 0 : 1; Error += glm::vec3().length() == 3 ? 0 : 1; Error += glm::dvec3().length() == 3 ? 0 : 1; Error += glm::vec3::length() == 3 ? 0 : 1; Error += glm::dvec3::length() == 3 ? 0 : 1; # if GLM_HAS_CONSTEXPR_PARTIAL constexpr std::size_t Length = glm::vec3::length(); Error += Length == 3 ? 0 : 1; # endif return Error; } int test_vec3_swizzle3_2() { int Error = 0; # if(GLM_LANG & GLM_LANG_CXXMS_FLAG) glm::vec3 v(1, 2, 3); glm::vec2 u; // Can not assign a vec3 swizzle to a vec2 //u = v.xyz; //Illegal //u = v.rgb; //Illegal //u = v.stp; //Illegal u = v.xx; Error += (u.x == 1.0f && u.y == 1.0f) ? 0 : 1; u = v.xy; Error += (u.x == 1.0f && u.y == 2.0f) ? 0 : 1; u = v.xz; Error += (u.x == 1.0f && u.y == 3.0f) ? 0 : 1; u = v.yx; Error += (u.x == 2.0f && u.y == 1.0f) ? 0 : 1; u = v.yy; Error += (u.x == 2.0f && u.y == 2.0f) ? 0 : 1; u = v.yz; Error += (u.x == 2.0f && u.y == 3.0f) ? 0 : 1; u = v.zx; Error += (u.x == 3.0f && u.y == 1.0f) ? 0 : 1; u = v.zy; Error += (u.x == 3.0f && u.y == 2.0f) ? 0 : 1; u = v.zz; Error += (u.x == 3.0f && u.y == 3.0f) ? 0 : 1; u = v.rr; Error += (u.r == 1.0f && u.g == 1.0f) ? 0 : 1; u = v.rg; Error += (u.r == 1.0f && u.g == 2.0f) ? 0 : 1; u = v.rb; Error += (u.r == 1.0f && u.g == 3.0f) ? 0 : 1; u = v.gr; Error += (u.r == 2.0f && u.g == 1.0f) ? 0 : 1; u = v.gg; Error += (u.r == 2.0f && u.g == 2.0f) ? 0 : 1; u = v.gb; Error += (u.r == 2.0f && u.g == 3.0f) ? 0 : 1; u = v.br; Error += (u.r == 3.0f && u.g == 1.0f) ? 0 : 1; u = v.bg; Error += (u.r == 3.0f && u.g == 2.0f) ? 0 : 1; u = v.bb; Error += (u.r == 3.0f && u.g == 3.0f) ? 0 : 1; u = v.ss; Error += (u.s == 1.0f && u.t == 1.0f) ? 0 : 1; u = v.st; Error += (u.s == 1.0f && u.t == 2.0f) ? 0 : 1; u = v.sp; Error += (u.s == 1.0f && u.t == 3.0f) ? 0 : 1; u = v.ts; Error += (u.s == 2.0f && u.t == 1.0f) ? 0 : 1; u = v.tt; Error += (u.s == 2.0f && u.t == 2.0f) ? 0 : 1; u = v.tp; Error += (u.s == 2.0f && u.t == 3.0f) ? 0 : 1; u = v.ps; Error += (u.s == 3.0f && u.t == 1.0f) ? 0 : 1; u = v.pt; Error += (u.s == 3.0f && u.t == 2.0f) ? 0 : 1; u = v.pp; Error += (u.s == 3.0f && u.t == 3.0f) ? 0 : 1; // Mixed member aliases are not valid //u = v.rx; //Illegal //u = v.sy; //Illegal u = glm::vec2(1, 2); v = glm::vec3(1, 2, 3); //v.xx = u; //Illegal v.xy = u; Error += (v.x == 1.0f && v.y == 2.0f && v.z == 3.0f) ? 0 : 1; v.xz = u; Error += (v.x == 1.0f && v.y == 2.0f && v.z == 2.0f) ? 0 : 1; v.yx = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 2.0f) ? 0 : 1; //v.yy = u; //Illegal v.yz = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 2.0f) ? 0 : 1; v.zx = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 1.0f) ? 0 : 1; v.zy = u; Error += (v.x == 2.0f && v.y == 2.0f && v.z == 1.0f) ? 0 : 1; //v.zz = u; //Illegal # endif//GLM_LANG return Error; } int test_vec3_swizzle3_3() { int Error = 0; # if(GLM_LANG & GLM_LANG_CXXMS_FLAG) glm::vec3 v(1, 2, 3); glm::vec3 u; u = v; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; u = v.xyz; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; u = v.zyx; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u.zyx = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u = v.rgb; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; u = v.bgr; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u.bgr = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u = v.stp; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; u = v.pts; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u.pts = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; # endif//GLM_LANG return Error; } #if !GLM_HAS_ONLY_XYZW int test_vec3_swizzle_operators() { int Error = 0; glm::vec3 u = glm::vec3(1, 2, 3); glm::vec3 v = glm::vec3(10, 20, 30); # if(GLM_LANG & GLM_LANG_CXXMS_FLAG) glm::vec3 q; // Swizzle, swizzle binary operators q = u.xyz + v.xyz; Error += (q == (u + v)) ? 0 : 1; q = (u.zyx + v.zyx).zyx; Error += (q == (u + v)) ? 0 : 1; q = (u.xyz - v.xyz); Error += (q == (u - v)) ? 0 : 1; q = (u.xyz * v.xyz); Error += (q == (u * v)) ? 0 : 1; q = (u.xxx * v.xxx); Error += (q == glm::vec3(u.x * v.x)) ? 0 : 1; q = (u.xyz / v.xyz); Error += (q == (u / v)) ? 0 : 1; // vec, swizzle binary operators q = u + v.xyz; Error += (q == (u + v)) ? 0 : 1; q = (u - v.xyz); Error += (q == (u - v)) ? 0 : 1; q = (u * v.xyz); Error += (q == (u * v)) ? 0 : 1; q = (u * v.xxx); Error += (q == v.x * u) ? 0 : 1; q = (u / v.xyz); Error += (q == (u / v)) ? 0 : 1; // swizzle,vec binary operators q = u.xyz + v; Error += (q == (u + v)) ? 0 : 1; q = (u.xyz - v); Error += (q == (u - v)) ? 0 : 1; q = (u.xyz * v); Error += (q == (u * v)) ? 0 : 1; q = (u.xxx * v); Error += (q == u.x * v) ? 0 : 1; q = (u.xyz / v); Error += (q == (u / v)) ? 0 : 1; # endif//GLM_LANG // Compile errors //q = (u.yz * v.xyz); //q = (u * v.xy); return Error; } int test_vec3_swizzle_functions() { int Error = 0; // NOTE: template functions cannot pick up the implicit conversion from // a swizzle to the unswizzled type, therefore the operator() must be // used. E.g.: // // glm::dot(u.xy, v.xy); <--- Compile error // glm::dot(u.xy(), v.xy()); <--- Compiles correctly float r; // vec2 glm::vec2 a(1, 2); glm::vec2 b(10, 20); r = glm::dot(a, b); Error += (int(r) == 50) ? 0 : 1; r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.xy())); Error += (int(r) == 50) ? 0 : 1; r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.yy())); Error += (int(r) == 60) ? 0 : 1; // vec3 glm::vec3 u = glm::vec3(1, 2, 3); glm::vec3 v = glm::vec3(10, 20, 30); r = glm::dot(u, v); Error += (int(r) == 140) ? 0 : 1; r = glm::dot(u.xyz(), v.zyz()); Error += (int(r) == 160) ? 0 : 1; r = glm::dot(u, v.zyx()); Error += (int(r) == 100) ? 0 : 1; r = glm::dot(u.xyz(), v); Error += (int(r) == 140) ? 0 : 1; r = glm::dot(u.xy(), v.xy()); Error += (int(r) == 50) ? 0 : 1; // vec4 glm::vec4 s = glm::vec4(1, 2, 3, 4); glm::vec4 t = glm::vec4(10, 20, 30, 40); r = glm::dot(s, t); Error += (int(r) == 300) ? 0 : 1; r = glm::dot(s.xyzw(), t.xyzw()); Error += (int(r) == 300) ? 0 : 1; r = glm::dot(s.xyz(), t.xyz()); Error += (int(r) == 140) ? 0 : 1; return Error; } int test_vec3_swizzle_partial() { int Error = 0; glm::vec3 A(1, 2, 3); # if(GLM_LANG & GLM_LANG_CXXMS_FLAG) { glm::vec3 B(A.xy, 3.0f); Error += A == B ? 0 : 1; } { glm::vec3 B(1.0f, A.yz); Error += A == B ? 0 : 1; } { glm::vec3 B(A.xyz); Error += A == B ? 0 : 1; } # endif//GLM_LANG return Error; } #endif//!GLM_HAS_ONLY_XYZW int test_operator_increment() { int Error(0); glm::ivec3 v0(1); glm::ivec3 v1(v0); glm::ivec3 v2(v0); glm::ivec3 v3 = ++v1; glm::ivec3 v4 = v2++; Error += glm::all(glm::equal(v0, v4)) ? 0 : 1; Error += glm::all(glm::equal(v1, v2)) ? 0 : 1; Error += glm::all(glm::equal(v1, v3)) ? 0 : 1; int i0(1); int i1(i0); int i2(i0); int i3 = ++i1; int i4 = i2++; Error += i0 == i4 ? 0 : 1; Error += i1 == i2 ? 0 : 1; Error += i1 == i3 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_vec3_ctor(); Error += test_vec3_operators(); Error += test_vec3_size(); Error += test_vec3_swizzle3_2(); Error += test_vec3_swizzle3_3(); Error += test_operator_increment(); # if !GLM_HAS_ONLY_XYZW Error += test_vec3_swizzle_partial(); Error += test_vec3_swizzle_operators(); Error += test_vec3_swizzle_functions(); # endif//!GLM_HAS_ONLY_XYZW return Error; } glm-0.9.9-a2/test/core/core_force_unrestricted_gentype.cpp0000600000175000001440000000016013173131001022534 0ustar guususers#define GLM_FORCE_UNRESTRICTED_GENTYPE #include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/core/core_func_integer_find_msb.cpp0000600000175000001440000003126313173131001021431 0ustar guususers#include #include #include // To define "exit", req'd by XLC. #include #define LE 1 // 1 for little-endian, 0 for big-endian. int pop(unsigned x) { x = x - ((x >> 1) & 0x55555555); x = (x & 0x33333333) + ((x >> 2) & 0x33333333); x = (x + (x >> 4)) & 0x0F0F0F0F; x = x + (x << 8); x = x + (x << 16); return x >> 24; } int nlz1(unsigned x) { int n; if (x == 0) return(32); n = 0; if (x <= 0x0000FFFF) {n = n +16; x = x <<16;} if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;} if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;} if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;} if (x <= 0x7FFFFFFF) {n = n + 1;} return n; } int nlz1a(unsigned x) { int n; /* if (x == 0) return(32); */ if (static_cast(x) <= 0) return (~x >> 26) & 32; n = 1; if ((x >> 16) == 0) {n = n +16; x = x <<16;} if ((x >> 24) == 0) {n = n + 8; x = x << 8;} if ((x >> 28) == 0) {n = n + 4; x = x << 4;} if ((x >> 30) == 0) {n = n + 2; x = x << 2;} n = n - (x >> 31); return n; } // On basic Risc, 12 to 20 instructions. int nlz2(unsigned x) { unsigned y; int n; n = 32; y = x >>16; if (y != 0) {n = n -16; x = y;} y = x >> 8; if (y != 0) {n = n - 8; x = y;} y = x >> 4; if (y != 0) {n = n - 4; x = y;} y = x >> 2; if (y != 0) {n = n - 2; x = y;} y = x >> 1; if (y != 0) return n - 2; return n - x; } // As above but coded as a loop for compactness: // 23 to 33 basic Risc instructions. int nlz2a(unsigned x) { unsigned y; int n, c; n = 32; c = 16; do { y = x >> c; if (y != 0) {n = n - c; x = y;} c = c >> 1; } while (c != 0); return n - x; } int nlz3(int x) { int y, n; n = 0; y = x; L: if (x < 0) return n; if (y == 0) return 32 - n; n = n + 1; x = x << 1; y = y >> 1; goto L; } int nlz4(unsigned x) { int y, m, n; y = -(x >> 16); // If left half of x is 0, m = (y >> 16) & 16; // set n = 16. If left half n = 16 - m; // is nonzero, set n = 0 and x = x >> m; // shift x right 16. // Now x is of the form 0000xxxx. y = x - 0x100; // If positions 8-15 are 0, m = (y >> 16) & 8; // add 8 to n and shift x left 8. n = n + m; x = x << m; y = x - 0x1000; // If positions 12-15 are 0, m = (y >> 16) & 4; // add 4 to n and shift x left 4. n = n + m; x = x << m; y = x - 0x4000; // If positions 14-15 are 0, m = (y >> 16) & 2; // add 2 to n and shift x left 2. n = n + m; x = x << m; y = x >> 14; // Set y = 0, 1, 2, or 3. m = y & ~(y >> 1); // Set m = 0, 1, 2, or 2 resp. return n + 2 - m; } int nlz5(unsigned x) { int pop(unsigned x); x = x | (x >> 1); x = x | (x >> 2); x = x | (x >> 4); x = x | (x >> 8); x = x | (x >>16); return pop(~x); } /* The four programs below are not valid ANSI C programs. This is because they refer to the same storage locations as two different types. However, they work with xlc/AIX, gcc/AIX, and gcc/NT. If you try to code them more compactly by declaring a variable xx to be "double," and then using n = 1054 - (*((unsigned *)&xx + LE) >> 20); then you are violating not only the rule above, but also the ANSI C rule that pointer arithmetic can be performed only on pointers to array elements. When coded with the above statement, the program fails with xlc, gcc/AIX, and gcc/NT, at some optimization levels. BTW, these programs use the "anonymous union" feature of C++, not available in C. */ int nlz6(unsigned k) { union { unsigned asInt[2]; double asDouble; }; int n; asDouble = static_cast(k) + 0.5; n = 1054 - (asInt[LE] >> 20); return n; } int nlz7(unsigned k) { union { unsigned asInt[2]; double asDouble; }; int n; asDouble = static_cast(k); n = 1054 - (asInt[LE] >> 20); n = (n & 31) + (n >> 9); return n; } /* In single qualifier, round-to-nearest mode, the basic method fails for: k = 0, k = 01FFFFFF, 03FFFFFE <= k <= 03FFFFFF, 07FFFFFC <= k <= 07FFFFFF, 0FFFFFF8 <= k <= 0FFFFFFF, ... 7FFFFFC0 <= k <= 7FFFFFFF. FFFFFF80 <= k <= FFFFFFFF. For k = 0 it gives 158, and for the other values it is too low by 1. */ int nlz8(unsigned k) { union { unsigned asInt; float asFloat; }; int n; k = k & ~(k >> 1); /* Fix problem with rounding. */ asFloat = static_cast(k) + 0.5f; n = 158 - (asInt >> 23); return n; } /* The example below shows how to make a macro for nlz. It uses an extension to the C and C++ languages that is provided by the GNU C/C++ compiler, namely, that of allowing statements and declarations in expressions (see "Using and Porting GNU CC", by Richard M. Stallman (1998). The underscores are necessary to protect against the possibility that the macro argument will conflict with one of its local variables, e.g., NLZ(k). */ int nlz9(unsigned k) { union { unsigned asInt; float asFloat; }; int n; k = k & ~(k >> 1); /* Fix problem with rounding. */ asFloat = static_cast(k); n = 158 - (asInt >> 23); n = (n & 31) + (n >> 6); /* Fix problem with k = 0. */ return n; } /* Below are three nearly equivalent programs for computing the number of leading zeros in a word. This material is not in HD, but may be in a future edition. Immediately below is Robert Harley's algorithm, found at the comp.arch newsgroup entry dated 7/12/96, pointed out to me by Norbert Juffa. Table entries marked "u" are unused. 14 ops including a multiply, plus an indexed load. The smallest multiplier that works is 0x045BCED1 = 17*65*129*513 (all of form 2**k + 1). There are no multipliers of three terms of the form 2**k +- 1 that work, with a table size of 64 or 128. There are some, with a table size of 64, if you precede the multiplication with x = x - (x >> 1), but that seems less elegant. There are also some if you use a table size of 256, the smallest is 0x01033CBF = 65*255*1025 (this would save two instructions in the form of this algorithm with the multiplication expanded into shifts and adds, but the table size is getting a bit large). */ #define u 99 int nlz10(unsigned x) { static char table[64] = {32,31, u,16, u,30, 3, u, 15, u, u, u,29,10, 2, u, u, u,12,14,21, u,19, u, u,28, u,25, u, 9, 1, u, 17, u, 4, u, u, u,11, u, 13,22,20, u,26, u, u,18, 5, u, u,23, u,27, u, 6, u,24, 7, u, 8, u, 0, u}; x = x | (x >> 1); // Propagate leftmost x = x | (x >> 2); // 1-bit to the right. x = x | (x >> 4); x = x | (x >> 8); x = x | (x >>16); x = x*0x06EB14F9; // Multiplier is 7*255**3. return table[x >> 26]; } /* Harley's algorithm with multiply expanded. 19 elementary ops plus an indexed load. */ int nlz10a(unsigned x) { static char table[64] = {32,31, u,16, u,30, 3, u, 15, u, u, u,29,10, 2, u, u, u,12,14,21, u,19, u, u,28, u,25, u, 9, 1, u, 17, u, 4, u, u, u,11, u, 13,22,20, u,26, u, u,18, 5, u, u,23, u,27, u, 6, u,24, 7, u, 8, u, 0, u}; x = x | (x >> 1); // Propagate leftmost x = x | (x >> 2); // 1-bit to the right. x = x | (x >> 4); x = x | (x >> 8); x = x | (x >> 16); x = (x << 3) - x; // Multiply by 7. x = (x << 8) - x; // Multiply by 255. x = (x << 8) - x; // Again. x = (x << 8) - x; // Again. return table[x >> 26]; } /* Julius Goryavsky's version of Harley's algorithm. 17 elementary ops plus an indexed load, if the machine has "and not." */ int nlz10b(unsigned x) { static char table[64] = {32,20,19, u, u,18, u, 7, 10,17, u, u,14, u, 6, u, u, 9, u,16, u, u, 1,26, u,13, u, u,24, 5, u, u, u,21, u, 8,11, u,15, u, u, u, u, 2,27, 0,25, u, 22, u,12, u, u, 3,28, u, 23, u, 4,29, u, u,30,31}; x = x | (x >> 1); // Propagate leftmost x = x | (x >> 2); // 1-bit to the right. x = x | (x >> 4); x = x | (x >> 8); x = x & ~(x >> 16); x = x*0xFD7049FF; // Activate this line or the following 3. // x = (x << 9) - x; // Multiply by 511. // x = (x << 11) - x; // Multiply by 2047. // x = (x << 14) - x; // Multiply by 16383. return table[x >> 26]; } int errors; void error(int x, int y) { errors = errors + 1; printf("Error for x = %08x, got %d\n", x, y); } int main() { # ifdef NDEBUG int i, n; static unsigned test[] = {0,32, 1,31, 2,30, 3,30, 4,29, 5,29, 6,29, 7,29, 8,28, 9,28, 16,27, 32,26, 64,25, 128,24, 255,24, 256,23, 512,22, 1024,21, 2048,20, 4096,19, 8192,18, 16384,17, 32768,16, 65536,15, 0x20000,14, 0x40000,13, 0x80000,12, 0x100000,11, 0x200000,10, 0x400000,9, 0x800000,8, 0x1000000,7, 0x2000000,6, 0x4000000,5, 0x8000000,4, 0x0FFFFFFF,4, 0x10000000,3, 0x3000FFFF,2, 0x50003333,1, 0x7FFFFFFF,1, 0x80000000,0, 0xFFFFFFFF,0}; std::size_t const Count = 1000; n = sizeof(test)/4; std::clock_t TimestampBeg = 0; std::clock_t TimestampEnd = 0; TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz1(test[i]) != test[i+1]) error(test[i], nlz1(test[i]));} TimestampEnd = std::clock(); printf("nlz1: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz1a(test[i]) != test[i+1]) error(test[i], nlz1a(test[i]));} TimestampEnd = std::clock(); printf("nlz1a: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz2(test[i]) != test[i+1]) error(test[i], nlz2(test[i]));} TimestampEnd = std::clock(); printf("nlz2: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz2a(test[i]) != test[i+1]) error(test[i], nlz2a(test[i]));} TimestampEnd = std::clock(); printf("nlz2a: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz3(test[i]) != test[i+1]) error(test[i], nlz3(test[i]));} TimestampEnd = std::clock(); printf("nlz3: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz4(test[i]) != test[i+1]) error(test[i], nlz4(test[i]));} TimestampEnd = std::clock(); printf("nlz4: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz5(test[i]) != test[i+1]) error(test[i], nlz5(test[i]));} TimestampEnd = std::clock(); printf("nlz5: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz6(test[i]) != test[i+1]) error(test[i], nlz6(test[i]));} TimestampEnd = std::clock(); printf("nlz6: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz7(test[i]) != test[i+1]) error(test[i], nlz7(test[i]));} TimestampEnd = std::clock(); printf("nlz7: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz8(test[i]) != test[i+1]) error(test[i], nlz8(test[i]));} TimestampEnd = std::clock(); printf("nlz8: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz9(test[i]) != test[i+1]) error(test[i], nlz9(test[i]));} TimestampEnd = std::clock(); printf("nlz9: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz10(test[i]) != test[i+1]) error(test[i], nlz10(test[i]));} TimestampEnd = std::clock(); printf("nlz10: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz10a(test[i]) != test[i+1]) error(test[i], nlz10a(test[i]));} TimestampEnd = std::clock(); printf("nlz10a: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); TimestampBeg = std::clock(); for (std::size_t k = 0; k < Count; ++k) for (i = 0; i < n; i += 2) { if (nlz10b(test[i]) != test[i+1]) error(test[i], nlz10b(test[i]));} TimestampEnd = std::clock(); printf("nlz10b: %d clocks\n", static_cast(TimestampEnd - TimestampBeg)); if (errors == 0) printf("Passed all %d cases.\n", static_cast(sizeof(test)/8)); # endif//NDEBUG } glm-0.9.9-a2/test/core/core_setup_force_cxx98.cpp0000600000175000001440000000016613173131001020477 0ustar guususers#define GLM_FORCE_CXX98 #include #include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/core/core_func_matrix.cpp0000600000175000001440000002227213173131001017437 0ustar guususers#include #include #include #include #include #include #include #include using namespace glm; int test_matrixCompMult() { int Error(0); { mat2 m(0, 1, 2, 3); mat2 n = matrixCompMult(m, m); mat2 expected = mat2(0, 1, 4, 9); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat2x3 m(0, 1, 2, 3, 4, 5); mat2x3 n = matrixCompMult(m, m); mat2x3 expected = mat2x3(0, 1, 4, 9, 16, 25); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat2x4 m(0, 1, 2, 3, 4, 5, 6, 7); mat2x4 n = matrixCompMult(m, m); mat2x4 expected = mat2x4(0, 1, 4, 9, 16, 25, 36, 49); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat3 m(0, 1, 2, 3, 4, 5, 6, 7, 8); mat3 n = matrixCompMult(m, m); mat3 expected = mat3(0, 1, 4, 9, 16, 25, 36, 49, 64); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat3x2 m(0, 1, 2, 3, 4, 5); mat3x2 n = matrixCompMult(m, m); mat3x2 expected = mat3x2(0, 1, 4, 9, 16, 25); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat3x4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); mat3x4 n = matrixCompMult(m, m); mat3x4 expected = mat3x4(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); mat4 n = matrixCompMult(m, m); mat4 expected = mat4(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat4x2 m(0, 1, 2, 3, 4, 5, 6, 7); mat4x2 n = matrixCompMult(m, m); mat4x2 expected = mat4x2(0, 1, 4, 9, 16, 25, 36, 49); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } { mat4x3 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); mat4x3 n = matrixCompMult(m, m); mat4x3 expected = mat4x3(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121); for (length_t l = 0; l < m.length(); ++l) Error += all(epsilonEqual(n[l], expected[l], epsilon())) ? 0 : 1; } return Error; } int test_outerProduct() { { glm::mat2 m = glm::outerProduct(glm::vec2(1.0f), glm::vec2(1.0f)); } { glm::mat3 m = glm::outerProduct(glm::vec3(1.0f), glm::vec3(1.0f)); } { glm::mat4 m = glm::outerProduct(glm::vec4(1.0f), glm::vec4(1.0f)); } { glm::mat2x3 m = glm::outerProduct(glm::vec3(1.0f), glm::vec2(1.0f)); } { glm::mat2x4 m = glm::outerProduct(glm::vec4(1.0f), glm::vec2(1.0f)); } { glm::mat3x2 m = glm::outerProduct(glm::vec2(1.0f), glm::vec3(1.0f)); } { glm::mat3x4 m = glm::outerProduct(glm::vec4(1.0f), glm::vec3(1.0f)); } { glm::mat4x2 m = glm::outerProduct(glm::vec2(1.0f), glm::vec4(1.0f)); } { glm::mat4x3 m = glm::outerProduct(glm::vec3(1.0f), glm::vec4(1.0f)); } return 0; } int test_transpose() { int Error(0); { mat2 const m(0, 1, 2, 3); mat2 const t = transpose(m); mat2 const expected = mat2(0, 2, 1, 3); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat2x3 m(0, 1, 2, 3, 4, 5); mat3x2 t = transpose(m); mat3x2 const expected = mat3x2(0, 3, 1, 4, 2, 5); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat2x4 m(0, 1, 2, 3, 4, 5, 6, 7); mat4x2 t = transpose(m); mat4x2 const expected = mat4x2(0, 4, 1, 5, 2, 6, 3, 7); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat3 m(0, 1, 2, 3, 4, 5, 6, 7, 8); mat3 t = transpose(m); mat3 const expected = mat3(0, 3, 6, 1, 4, 7, 2, 5, 8); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat3x2 m(0, 1, 2, 3, 4, 5); mat2x3 t = transpose(m); mat2x3 const expected = mat2x3(0, 2, 4, 1, 3, 5); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat3x4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); mat4x3 t = transpose(m); mat4x3 const expected = mat4x3(0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); mat4 t = transpose(m); mat4 const expected = mat4(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat4x2 m(0, 1, 2, 3, 4, 5, 6, 7); mat2x4 t = transpose(m); mat2x4 const expected = mat2x4(0, 2, 4, 6, 1, 3, 5, 7); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } { mat4x3 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); mat3x4 t = transpose(m); mat3x4 const expected = mat3x4(0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11); for (length_t l = 0; l < expected.length(); ++l) Error += all(epsilonEqual(t[l], expected[l], epsilon())) ? 0 : 1; } return Error; } int test_determinant() { return 0; } int test_inverse() { int Error = 0; { glm::mat4x4 A4x4( glm::vec4(1, 0, 1, 0), glm::vec4(0, 1, 0, 0), glm::vec4(0, 0, 1, 0), glm::vec4(0, 0, 0, 1)); glm::mat4x4 B4x4 = inverse(A4x4); glm::mat4x4 I4x4 = A4x4 * B4x4; glm::mat4x4 Identity(1); for (length_t l = 0; l < Identity.length(); ++l) Error += all(epsilonEqual(I4x4[l], Identity[l], epsilon())) ? 0 : 1; } { glm::mat3x3 A3x3( glm::vec3(1, 0, 1), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1)); glm::mat3x3 B3x3 = glm::inverse(A3x3); glm::mat3x3 I3x3 = A3x3 * B3x3; glm::mat3x3 Identity(1); for (length_t l = 0; l < Identity.length(); ++l) Error += all(epsilonEqual(I3x3[l], Identity[l], epsilon())) ? 0 : 1; } { glm::mat2x2 A2x2( glm::vec2(1, 1), glm::vec2(0, 1)); glm::mat2x2 B2x2 = glm::inverse(A2x2); glm::mat2x2 I2x2 = A2x2 * B2x2; glm::mat2x2 Identity(1); for (length_t l = 0; l < Identity.length(); ++l) Error += all(epsilonEqual(I2x2[l], Identity[l], epsilon())) ? 0 : 1; } return Error; } int test_inverse_simd() { int Error = 0; glm::mat4x4 const Identity(1); glm::mat4x4 const A4x4( glm::vec4(1, 0, 1, 0), glm::vec4(0, 1, 0, 0), glm::vec4(0, 0, 1, 0), glm::vec4(0, 0, 0, 1)); glm::mat4x4 const B4x4 = glm::inverse(A4x4); glm::mat4x4 const I4x4 = A4x4 * B4x4; Error += glm::all(glm::epsilonEqual(I4x4[0], Identity[0], 0.001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(I4x4[1], Identity[1], 0.001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(I4x4[2], Identity[2], 0.001f)) ? 0 : 1; Error += glm::all(glm::epsilonEqual(I4x4[3], Identity[3], 0.001f)) ? 0 : 1; return Error; } template int test_inverse_perf(std::size_t Count, std::size_t Instance, char const * Message) { std::vector TestInputs; TestInputs.resize(Count); std::vector TestOutputs; TestOutputs.resize(TestInputs.size()); VEC3 Axis(glm::normalize(VEC3(1.0f, 2.0f, 3.0f))); for(std::size_t i = 0; i < TestInputs.size(); ++i) { typename MAT4::value_type f = static_cast(i + Instance) * typename MAT4::value_type(0.1) + typename MAT4::value_type(0.1); TestInputs[i] = glm::rotate(glm::translate(MAT4(1), Axis * f), f, Axis); //TestInputs[i] = glm::translate(MAT4(1), Axis * f); } std::clock_t StartTime = std::clock(); for(std::size_t i = 0; i < TestInputs.size(); ++i) TestOutputs[i] = glm::inverse(TestInputs[i]); std::clock_t EndTime = std::clock(); for(std::size_t i = 0; i < TestInputs.size(); ++i) TestOutputs[i] = TestOutputs[i] * TestInputs[i]; typename MAT4::value_type Diff(0); for(std::size_t Entry = 0; Entry < TestOutputs.size(); ++Entry) { MAT4 i(1.0); MAT4 m(TestOutputs[Entry]); for(glm::length_t y = 0; y < m.length(); ++y) for(glm::length_t x = 0; x < m[y].length(); ++x) Diff = glm::max(m[y][x], i[y][x]); } //glm::uint Ulp = 0; //Ulp = glm::max(glm::float_distance(*Dst, *Src), Ulp); printf("inverse<%s>(%f): %lu\n", Message, static_cast(Diff), EndTime - StartTime); return 0; } int main() { int Error = 0; Error += test_matrixCompMult(); Error += test_outerProduct(); Error += test_transpose(); Error += test_determinant(); Error += test_inverse(); Error += test_inverse_simd(); # ifdef NDEBUG std::size_t const Samples = 1000; # else std::size_t const Samples = 1; # endif//NDEBUG for(std::size_t i = 0; i < 1; ++i) { Error += test_inverse_perf(Samples, i, "mat4"); Error += test_inverse_perf(Samples, i, "dmat4"); } return Error; } glm-0.9.9-a2/test/core/core_type_mat2x4.cpp0000600000175000001440000000502013173131001017270 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include #include #include static int test_operators() { glm::mat2x4 l(1.0f); glm::mat2x4 m(1.0f); glm::vec2 u(1.0f); glm::vec4 v(1.0f); float x = 1.0f; glm::vec4 a = m * u; glm::vec2 b = v * m; glm::mat2x4 n = x / m; glm::mat2x4 o = m / x; glm::mat2x4 p = x * m; glm::mat2x4 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_ctr() { int Error(0); #if(GLM_HAS_INITIALIZER_LISTS) glm::mat2x4 m0( glm::vec4(0, 1, 2, 3), glm::vec4(4, 5, 6, 7)); glm::mat2x4 m1{0, 1, 2, 3, 4, 5, 6, 7}; glm::mat2x4 m2{ {0, 1, 2, 3}, {4, 5, 6, 7}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6, 7} }; std::vector v2{ { { 0, 1, 2, 3}, { 4, 5, 6, 7} }, { { 0, 1, 2, 3}, { 4, 5, 6, 7} } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat2x4 B(A); glm::mat2x4 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::epsilonEqual(B[i], Identity[i], glm::epsilon())) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 32 == sizeof(glm::mat2x4) ? 0 : 1; Error += 64 == sizeof(glm::dmat2x4) ? 0 : 1; Error += glm::mat2x4().length() == 2 ? 0 : 1; Error += glm::dmat2x4().length() == 2 ? 0 : 1; Error += glm::mat2x4::length() == 2 ? 0 : 1; Error += glm::dmat2x4::length() == 2 ? 0 : 1; return Error; } int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/core_setup_message.cpp0000600000175000001440000001031713173131001017761 0ustar guususers#define GLM_FORCE_MESSAGES #include #include int test_compiler() { int Error(0); if(GLM_COMPILER & GLM_COMPILER_VC) { switch(GLM_COMPILER) { case GLM_COMPILER_VC12: std::printf("Visual C++ 12 - 2013\n"); break; case GLM_COMPILER_VC14: std::printf("Visual C++ 14 - 2015\n"); break; case GLM_COMPILER_VC15: std::printf("Visual C++ 15 - 2017\n"); break; case GLM_COMPILER_VC16: std::printf("Visual C++ 16 - 20XX\n"); break; default: std::printf("Visual C++ version not detected\n"); Error += 1; break; } } else if(GLM_COMPILER & GLM_COMPILER_GCC) { switch(GLM_COMPILER) { case GLM_COMPILER_GCC46: std::printf("GCC 4.6\n"); break; case GLM_COMPILER_GCC47: std::printf("GCC 4.7\n"); break; case GLM_COMPILER_GCC48: std::printf("GCC 4.8\n"); break; case GLM_COMPILER_GCC49: std::printf("GCC 4.9\n"); break; case GLM_COMPILER_GCC5: std::printf("GCC 5\n"); break; case GLM_COMPILER_GCC6: std::printf("GCC 6\n"); break; case GLM_COMPILER_GCC7: std::printf("GCC 7\n"); break; case GLM_COMPILER_GCC8: std::printf("GCC 8\n"); break; default: std::printf("GCC version not detected\n"); Error += 1; break; } } else if(GLM_COMPILER & GLM_COMPILER_CUDA) { std::printf("CUDA\n"); } else if(GLM_COMPILER & GLM_COMPILER_CLANG) { switch(GLM_COMPILER) { case GLM_COMPILER_CLANG34: std::printf("Clang 3.4\n"); break; case GLM_COMPILER_CLANG35: std::printf("Clang 3.5\n"); break; case GLM_COMPILER_CLANG36: std::printf("Clang 3.6\n"); break; case GLM_COMPILER_CLANG37: std::printf("Clang 3.7\n"); break; case GLM_COMPILER_CLANG38: std::printf("Clang 3.8\n"); break; case GLM_COMPILER_CLANG39: std::printf("Clang 3.9\n"); break; case GLM_COMPILER_CLANG40: std::printf("Clang 4.0\n"); break; case GLM_COMPILER_CLANG41: std::printf("Clang 4.1\n"); break; case GLM_COMPILER_CLANG42: std::printf("Clang 4.2\n"); break; default: std::printf("LLVM version not detected\n"); break; } } else if(GLM_COMPILER & GLM_COMPILER_INTEL) { switch(GLM_COMPILER) { case GLM_COMPILER_INTEL14: std::printf("ICC 14 - 2013 SP1\n"); break; case GLM_COMPILER_INTEL15: std::printf("ICC 15 - 2015\n"); break; case GLM_COMPILER_INTEL16: std::printf("ICC 16 - 2017\n"); break; case GLM_COMPILER_INTEL17: std::printf("ICC 17 - 20XX\n"); break; default: std::printf("Intel compiler version not detected\n"); Error += 1; break; } } else { std::printf("Undetected compiler\n"); Error += 1; } return Error; } int test_model() { int Error = 0; Error += ((sizeof(void*) == 4) && (GLM_MODEL == GLM_MODEL_32)) || ((sizeof(void*) == 8) && (GLM_MODEL == GLM_MODEL_64)) ? 0 : 1; if(GLM_MODEL == GLM_MODEL_32) std::printf("GLM_MODEL_32\n"); else if(GLM_MODEL == GLM_MODEL_64) std::printf("GLM_MODEL_64\n"); return Error; } int test_instruction_set() { int Error = 0; std::printf("GLM_ARCH: "); if(GLM_ARCH == GLM_ARCH_PURE) std::printf("GLM_ARCH_PURE "); if(GLM_ARCH & GLM_ARCH_ARM_BIT) std::printf("ARM "); if(GLM_ARCH & GLM_ARCH_NEON_BIT) std::printf("NEON "); if(GLM_ARCH & GLM_ARCH_AVX2) std::printf("AVX2 "); if(GLM_ARCH & GLM_ARCH_AVX) std::printf("AVX "); if(GLM_ARCH & GLM_ARCH_SSE42_BIT) std::printf("SSE4.2 "); if(GLM_ARCH & GLM_ARCH_SSE41_BIT) std::printf("SSE4.1 "); if(GLM_ARCH & GLM_ARCH_SSSE3_BIT) std::printf("SSSE3 "); if(GLM_ARCH & GLM_ARCH_SSE3_BIT) std::printf("SSE3 "); if(GLM_ARCH & GLM_ARCH_SSE2_BIT) std::printf("SSE2 "); std::printf("\n"); return Error; } int test_cpp_version() { std::printf("__cplusplus: %d\n", static_cast(__cplusplus)); return 0; } int test_operators() { glm::vec3 A(1.0f); glm::vec3 B(1.0f); bool R = A != B; bool S = A == B; return (S && !R) ? 0 : 1; } template struct vec { }; template class C, typename T> struct Class { }; template struct Class { }; int main() { //Class C; int Error = 0; Error += test_cpp_version(); Error += test_compiler(); Error += test_model(); Error += test_instruction_set(); Error += test_operators(); return Error; } glm-0.9.9-a2/test/core/core_type_vec2.cpp0000600000175000001440000001542413173131001017021 0ustar guususers#define GLM_FORCE_SWIZZLE #include #include #include #include #if GLM_HAS_TRIVIAL_QUERIES # include #endif static glm::vec2 g1; static glm::vec2 g2(1); static glm::vec2 g3(1, 1); int test_vec2_operators() { int Error = 0; { glm::vec2 A(1.0f); glm::vec2 B(1.0f); Error += A != B ? 1 : 0; Error += A == B ? 0 : 1; } { glm::vec2 A(1.0f); glm::vec2 C = A + 1.0f; A += 1.0f; Error += glm::all(glm::epsilonEqual(A, glm::vec2(2.0f), glm::epsilon())) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, C, glm::epsilon())) ? 0 : 1; } { glm::vec2 A(1.0f); glm::vec2 B(2.0f,-1.0f); glm::vec2 C = A + B; A += B; Error += glm::all(glm::epsilonEqual(A, glm::vec2(3.0f, 0.0f), glm::epsilon())) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, C, glm::epsilon())) ? 0 : 1; } { glm::vec2 A(1.0f); glm::vec2 C = A - 1.0f; A -= 1.0f; Error += glm::all(glm::epsilonEqual(A, glm::vec2(0.0f), glm::epsilon())) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, C, glm::epsilon())) ? 0 : 1; } { glm::vec2 A(1.0f); glm::vec2 B(2.0f,-1.0f); glm::vec2 C = A - B; A -= B; Error += glm::all(glm::epsilonEqual(A, glm::vec2(-1.0f, 2.0f), glm::epsilon())) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, C, glm::epsilon())) ? 0 : 1; } { glm::vec2 A(1.0f); glm::vec2 C = A * 2.0f; A *= 2.0f; Error += glm::all(glm::epsilonEqual(A, glm::vec2(2.0f), glm::epsilon())) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, C, glm::epsilon())) ? 0 : 1; } { glm::vec2 A(2.0f); glm::vec2 B(2.0f); glm::vec2 C = A / B; A /= B; Error += glm::all(glm::epsilonEqual(A, glm::vec2(1.0f), glm::epsilon())) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, C, glm::epsilon())) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B(4.0f, 5.0f); glm::vec2 C = A + B; Error += C == glm::vec2(5, 7) ? 0 : 1; glm::vec2 D = B - A; Error += D == glm::vec2(3, 3) ? 0 : 1; glm::vec2 E = A * B; Error += E == glm::vec2(4, 10) ? 0 : 1; glm::vec2 F = B / A; Error += F == glm::vec2(4, 2.5) ? 0 : 1; glm::vec2 G = A + 1.0f; Error += G == glm::vec2(2, 3) ? 0 : 1; glm::vec2 H = B - 1.0f; Error += H == glm::vec2(3, 4) ? 0 : 1; glm::vec2 I = A * 2.0f; Error += I == glm::vec2(2, 4) ? 0 : 1; glm::vec2 J = B / 2.0f; Error += J == glm::vec2(2, 2.5) ? 0 : 1; glm::vec2 K = 1.0f + A; Error += K == glm::vec2(2, 3) ? 0 : 1; glm::vec2 L = 1.0f - B; Error += L == glm::vec2(-3, -4) ? 0 : 1; glm::vec2 M = 2.0f * A; Error += M == glm::vec2(2, 4) ? 0 : 1; glm::vec2 N = 2.0f / B; Error += N == glm::vec2(0.5, 2.0 / 5.0) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B(4.0f, 5.0f); A += B; Error += A == glm::vec2(5, 7) ? 0 : 1; A += 1.0f; Error += A == glm::vec2(6, 8) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B(4.0f, 5.0f); B -= A; Error += B == glm::vec2(3, 3) ? 0 : 1; B -= 1.0f; Error += B == glm::vec2(2, 2) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B(4.0f, 5.0f); A *= B; Error += A == glm::vec2(4, 10) ? 0 : 1; A *= 2.0f; Error += A == glm::vec2(8, 20) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B(4.0f, 5.0f); B /= A; Error += B == glm::vec2(4, 2.5) ? 0 : 1; B /= 2.0f; Error += B == glm::vec2(2, 1.25) ? 0 : 1; } { glm::vec2 B(2.0f); B /= B.y; Error += B == glm::vec2(1.0f) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B = -A; Error += B == glm::vec2(-1.0f, -2.0f) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B = --A; Error += B == glm::vec2(0.0f, 1.0f) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B = A--; Error += B == glm::vec2(1.0f, 2.0f) ? 0 : 1; Error += A == glm::vec2(0.0f, 1.0f) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B = ++A; Error += B == glm::vec2(2.0f, 3.0f) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::vec2 B = A++; Error += B == glm::vec2(1.0f, 2.0f) ? 0 : 1; Error += A == glm::vec2(2.0f, 3.0f) ? 0 : 1; } return Error; } int test_vec2_ctor() { int Error = 0; { glm::vec2 A(1); glm::vec2 B(A); Error += A == B ? 0 : 1; } # if GLM_HAS_TRIVIAL_QUERIES // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; # endif #if GLM_HAS_INITIALIZER_LISTS { glm::vec2 a{ 0, 1 }; std::vector v = { {0, 1}, {4, 5}, {8, 9}}; } { glm::dvec2 a{ 0, 1 }; std::vector v = { {0, 1}, {4, 5}, {8, 9}}; } #endif #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) { glm::vec2 A = glm::vec2(1.0f, 2.0f); glm::vec2 B = A.xy; glm::vec2 C(A.xy); glm::vec2 D(A.xy()); Error += glm::all(glm::equal(A, B)) ? 0 : 1; Error += glm::all(glm::equal(A, C)) ? 0 : 1; Error += glm::all(glm::equal(A, D)) ? 0 : 1; } #endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) { glm::vec2 A = glm::vec2(2.0f); glm::vec2 B = glm::vec2(2.0f, 3.0f); glm::vec2 C = glm::vec2(2.0f, 3.0); //glm::vec2 D = glm::dvec2(2.0); // Build error TODO: What does the specification says? glm::vec2 E(glm::dvec2(2.0)); glm::vec2 F(glm::ivec2(2)); } return Error; } int test_vec2_size() { int Error = 0; Error += sizeof(glm::vec2) == sizeof(glm::mediump_vec2) ? 0 : 1; Error += 8 == sizeof(glm::mediump_vec2) ? 0 : 1; Error += sizeof(glm::dvec2) == sizeof(glm::highp_dvec2) ? 0 : 1; Error += 16 == sizeof(glm::highp_dvec2) ? 0 : 1; Error += glm::vec2().length() == 2 ? 0 : 1; Error += glm::dvec2().length() == 2 ? 0 : 1; Error += glm::vec2::length() == 2 ? 0 : 1; Error += glm::dvec2::length() == 2 ? 0 : 1; # if GLM_HAS_CONSTEXPR_PARTIAL constexpr std::size_t Length = glm::vec2::length(); Error += Length == 2 ? 0 : 1; # endif return Error; } int test_operator_increment() { int Error(0); glm::ivec2 v0(1); glm::ivec2 v1(v0); glm::ivec2 v2(v0); glm::ivec2 v3 = ++v1; glm::ivec2 v4 = v2++; Error += glm::all(glm::equal(v0, v4)) ? 0 : 1; Error += glm::all(glm::equal(v1, v2)) ? 0 : 1; Error += glm::all(glm::equal(v1, v3)) ? 0 : 1; int i0(1); int i1(i0); int i2(i0); int i3 = ++i1; int i4 = i2++; Error += i0 == i4 ? 0 : 1; Error += i1 == i2 ? 0 : 1; Error += i1 == i3 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_vec2_size(); Error += test_vec2_ctor(); Error += test_vec2_operators(); Error += test_operator_increment(); return Error; } glm-0.9.9-a2/test/core/core_force_pure.cpp0000600000175000001440000002202613173131001017246 0ustar guususers#ifndef GLM_FORCE_PURE # define GLM_FORCE_PURE #endif//GLM_FORCE_PURE #define GLM_FORCE_ALIGNED #define GLM_FORCE_SWIZZLE #include #include #include #include #include #include #include int test_vec4_ctor() { int Error = 0; { glm::ivec4 A(1, 2, 3, 4); glm::ivec4 B(A); Error += glm::all(glm::equal(A, B)) ? 0 : 1; } # if GLM_HAS_TRIVIAL_QUERIES // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; # endif #if GLM_HAS_INITIALIZER_LISTS { glm::vec4 a{ 0, 1, 2, 3 }; std::vector v = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 0, 1}}; } { glm::dvec4 a{ 0, 1, 2, 3 }; std::vector v = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 0, 1}}; } #endif #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) { glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A.xyzw; glm::vec4 C(A.xyzw); glm::vec4 D(A.xyzw()); glm::vec4 E(A.x, A.yzw); glm::vec4 F(A.x, A.yzw()); glm::vec4 G(A.xyz, A.w); glm::vec4 H(A.xyz(), A.w); glm::vec4 I(A.xy, A.zw); glm::vec4 J(A.xy(), A.zw()); glm::vec4 K(A.x, A.y, A.zw); glm::vec4 L(A.x, A.yz, A.w); glm::vec4 M(A.xy, A.z, A.w); Error += glm::all(glm::equal(A, B)) ? 0 : 1; Error += glm::all(glm::equal(A, C)) ? 0 : 1; Error += glm::all(glm::equal(A, D)) ? 0 : 1; Error += glm::all(glm::equal(A, E)) ? 0 : 1; Error += glm::all(glm::equal(A, F)) ? 0 : 1; Error += glm::all(glm::equal(A, G)) ? 0 : 1; Error += glm::all(glm::equal(A, H)) ? 0 : 1; Error += glm::all(glm::equal(A, I)) ? 0 : 1; Error += glm::all(glm::equal(A, J)) ? 0 : 1; Error += glm::all(glm::equal(A, K)) ? 0 : 1; Error += glm::all(glm::equal(A, L)) ? 0 : 1; Error += glm::all(glm::equal(A, M)) ? 0 : 1; } #endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) { glm::vec4 A(1); glm::vec4 B(1, 1, 1, 1); Error += A == B ? 0 : 1; } { std::vector Tests; Tests.push_back(glm::vec4(glm::vec2(1, 2), 3, 4)); Tests.push_back(glm::vec4(1, glm::vec2(2, 3), 4)); Tests.push_back(glm::vec4(1, 2, glm::vec2(3, 4))); Tests.push_back(glm::vec4(glm::vec3(1, 2, 3), 4)); Tests.push_back(glm::vec4(1, glm::vec3(2, 3, 4))); Tests.push_back(glm::vec4(glm::vec2(1, 2), glm::vec2(3, 4))); Tests.push_back(glm::vec4(1, 2, 3, 4)); Tests.push_back(glm::vec4(glm::vec4(1, 2, 3, 4))); for(std::size_t i = 0; i < Tests.size(); ++i) Error += Tests[i] == glm::vec4(1, 2, 3, 4) ? 0 : 1; } return Error; } int test_bvec4_ctor() { int Error = 0; glm::bvec4 const A(true); glm::bvec4 const B(true); glm::bvec4 const C(false); glm::bvec4 const D = A && B; glm::bvec4 const E = A && C; glm::bvec4 const F = A || C; Error += D == glm::bvec4(true) ? 0 : 1; Error += E == glm::bvec4(false) ? 0 : 1; Error += F == glm::bvec4(true) ? 0 : 1; bool const G = A == C; bool const H = A != C; Error += !G ? 0 : 1; Error += H ? 0 : 1; return Error; } int test_vec4_operators() { int Error = 0; { glm::vec4 A(1.0f); glm::vec4 B(1.0f); bool R = A != B; bool S = A == B; Error += (S && !R) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); glm::vec4 C = A + B; Error += C == glm::vec4(5, 7, 9, 11) ? 0 : 1; glm::vec4 D = B - A; Error += D == glm::vec4(3, 3, 3, 3) ? 0 : 1; glm::vec4 E = A * B; Error += E == glm::vec4(4, 10, 18, 28) ? 0 : 1; glm::vec4 F = B / A; Error += F == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1; glm::vec4 G = A + 1.0f; Error += G == glm::vec4(2, 3, 4, 5) ? 0 : 1; glm::vec4 H = B - 1.0f; Error += H == glm::vec4(3, 4, 5, 6) ? 0 : 1; glm::vec4 I = A * 2.0f; Error += I == glm::vec4(2, 4, 6, 8) ? 0 : 1; glm::vec4 J = B / 2.0f; Error += J == glm::vec4(2, 2.5, 3, 3.5) ? 0 : 1; glm::vec4 K = 1.0f + A; Error += K == glm::vec4(2, 3, 4, 5) ? 0 : 1; glm::vec4 L = 1.0f - B; Error += L == glm::vec4(-3, -4, -5, -6) ? 0 : 1; glm::vec4 M = 2.0f * A; Error += M == glm::vec4(2, 4, 6, 8) ? 0 : 1; glm::vec4 N = 2.0f / B; Error += N == glm::vec4(0.5, 2.0 / 5.0, 2.0 / 6.0, 2.0 / 7.0) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); A += B; Error += A == glm::vec4(5, 7, 9, 11) ? 0 : 1; A += 1.0f; Error += A == glm::vec4(6, 8, 10, 12) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); B -= A; Error += B == glm::vec4(3, 3, 3, 3) ? 0 : 1; B -= 1.0f; Error += B == glm::vec4(2, 2, 2, 2) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); A *= B; Error += A == glm::vec4(4, 10, 18, 28) ? 0 : 1; A *= 2.0f; Error += A == glm::vec4(8, 20, 36, 56) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); B /= A; Error += B == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1; B /= 2.0f; Error += B == glm::vec4(2, 1.25, 1, 7.0f / 4.0f / 2.0f) ? 0 : 1; } { glm::vec4 B(2.0f); B /= B.y; Error += B == glm::vec4(1.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = -A; Error += B == glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = --A; Error += B == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A--; Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1; Error += A == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = ++A; Error += B == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A++; Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1; Error += A == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1; } return Error; } int test_vec4_equal() { int Error = 0; { glm::vec4 const A(1, 2, 3, 4); glm::vec4 const B(1, 2, 3, 4); Error += A == B ? 0 : 1; Error += A != B ? 1 : 0; } { glm::ivec4 const A(1, 2, 3, 4); glm::ivec4 const B(1, 2, 3, 4); Error += A == B ? 0 : 1; Error += A != B ? 1 : 0; } return Error; } int test_vec4_size() { int Error = 0; Error += sizeof(glm::vec4) == sizeof(glm::lowp_vec4) ? 0 : 1; Error += sizeof(glm::vec4) == sizeof(glm::mediump_vec4) ? 0 : 1; Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1; Error += 16 == sizeof(glm::mediump_vec4) ? 0 : 1; Error += sizeof(glm::dvec4) == sizeof(glm::lowp_dvec4) ? 0 : 1; Error += sizeof(glm::dvec4) == sizeof(glm::mediump_dvec4) ? 0 : 1; Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1; Error += 32 == sizeof(glm::highp_dvec4) ? 0 : 1; Error += glm::vec4().length() == 4 ? 0 : 1; Error += glm::dvec4().length() == 4 ? 0 : 1; return Error; } int test_vec4_swizzle_partial() { int Error = 0; glm::vec4 A(1, 2, 3, 4); # if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE_RELAX) { glm::vec4 B(A.xy, A.zw); Error += A == B ? 0 : 1; } { glm::vec4 B(A.xy, 3.0f, 4.0f); Error += A == B ? 0 : 1; } { glm::vec4 B(1.0f, A.yz, 4.0f); Error += A == B ? 0 : 1; } { glm::vec4 B(1.0f, 2.0f, A.zw); Error += A == B ? 0 : 1; } { glm::vec4 B(A.xyz, 4.0f); Error += A == B ? 0 : 1; } { glm::vec4 B(1.0f, A.yzw); Error += A == B ? 0 : 1; } # endif return Error; } int test_operator_increment() { int Error(0); glm::ivec4 v0(1); glm::ivec4 v1(v0); glm::ivec4 v2(v0); glm::ivec4 v3 = ++v1; glm::ivec4 v4 = v2++; Error += glm::all(glm::equal(v0, v4)) ? 0 : 1; Error += glm::all(glm::equal(v1, v2)) ? 0 : 1; Error += glm::all(glm::equal(v1, v3)) ? 0 : 1; int i0(1); int i1(i0); int i2(i0); int i3 = ++i1; int i4 = i2++; Error += i0 == i4 ? 0 : 1; Error += i1 == i2 ? 0 : 1; Error += i1 == i3 ? 0 : 1; return Error; } namespace heap { struct A { float f; }; struct B : public A { float g; glm::vec4 v; }; int test() { int Error = 0; A* p = new B; p->f = 0.f; delete p; Error += sizeof(B) == (sizeof(glm::vec4) + sizeof(float) * 2) ? 0 : 1; return Error; } }//namespace heap int test_vec4_simd() { int Error = 0; glm::vec4 const a(std::clock(), std::clock(), std::clock(), std::clock()); glm::vec4 const b(std::clock(), std::clock(), std::clock(), std::clock()); glm::vec4 const c(b * a); glm::vec4 const d(a + c); Error += glm::all(glm::greaterThanEqual(d, glm::vec4(0))) ? 0 : 1; return Error; } int main() { int Error(0); Error += test_vec4_ctor(); Error += test_bvec4_ctor(); Error += test_vec4_size(); Error += test_vec4_operators(); Error += test_vec4_equal(); Error += test_vec4_swizzle_partial(); Error += test_vec4_simd(); Error += test_operator_increment(); Error += heap::test(); return Error; } glm-0.9.9-a2/test/core/core_setup_force_size_t_length.cpp0000600000175000001440000000057613173131001022357 0ustar guususers#define GLM_FORCE_SIZE_T_LENGTH #include #include template genType add(genType const& a, genType const& b) { genType result(0); for(glm::length_t i = 0; i < a.length(); ++i) result[i] = a[i] + b[i]; return result; } int main() { int Error = 0; glm::ivec4 v(1); Error += add(v, v) == glm::ivec4(2) ? 0 : 1; return Error; } glm-0.9.9-a2/test/core/core_func_geometric.cpp0000600000175000001440000001147513173131001020114 0ustar guususers#include #include #include #include #include namespace length { int test() { float Length1 = glm::length(glm::vec1(1)); float Length2 = glm::length(glm::vec2(1, 0)); float Length3 = glm::length(glm::vec3(1, 0, 0)); float Length4 = glm::length(glm::vec4(1, 0, 0, 0)); int Error = 0; Error += glm::abs(Length1 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Length2 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Length3 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Length4 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; return Error; } }//namespace length namespace distance { int test() { float Distance1 = glm::distance(glm::vec1(1), glm::vec1(1)); float Distance2 = glm::distance(glm::vec2(1, 0), glm::vec2(1, 0)); float Distance3 = glm::distance(glm::vec3(1, 0, 0), glm::vec3(1, 0, 0)); float Distance4 = glm::distance(glm::vec4(1, 0, 0, 0), glm::vec4(1, 0, 0, 0)); int Error = 0; Error += glm::abs(Distance1) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Distance2) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Distance3) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Distance4) < std::numeric_limits::epsilon() ? 0 : 1; return Error; } }//namespace distance namespace dot { int test() { float Dot1 = glm::dot(glm::vec1(1), glm::vec1(1)); float Dot2 = glm::dot(glm::vec2(1), glm::vec2(1)); float Dot3 = glm::dot(glm::vec3(1), glm::vec3(1)); float Dot4 = glm::dot(glm::vec4(1), glm::vec4(1)); int Error = 0; Error += glm::abs(Dot1 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Dot2 - 2.0f) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Dot3 - 3.0f) < std::numeric_limits::epsilon() ? 0 : 1; Error += glm::abs(Dot4 - 4.0f) < std::numeric_limits::epsilon() ? 0 : 1; return Error; } }//namespace dot namespace cross { int test() { glm::vec3 Cross1 = glm::cross(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0)); glm::vec3 Cross2 = glm::cross(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0)); int Error = 0; Error += glm::all(glm::lessThan(glm::abs(Cross1 - glm::vec3(0, 0, 1)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; Error += glm::all(glm::lessThan(glm::abs(Cross2 - glm::vec3(0, 0,-1)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; return Error; } }//namespace cross namespace normalize { int test() { glm::vec3 Normalize1 = glm::normalize(glm::vec3(1, 0, 0)); glm::vec3 Normalize2 = glm::normalize(glm::vec3(2, 0, 0)); glm::vec3 Normalize3 = glm::normalize(glm::vec3(-0.6, 0.7, -0.5)); glm::vec3 ro = glm::vec3(glm::cos(5.f) * 3.f, 2.f, glm::sin(5.f) * 3.f); glm::vec3 w = glm::normalize(glm::vec3(0, -0.2f, 0) - ro); glm::vec3 u = glm::normalize(glm::cross(w, glm::vec3(0, 1, 0))); glm::vec3 v = glm::cross(u, w); int Error = 0; Error += glm::all(glm::lessThan(glm::abs(Normalize1 - glm::vec3(1, 0, 0)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; Error += glm::all(glm::lessThan(glm::abs(Normalize2 - glm::vec3(1, 0, 0)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; return Error; } }//namespace normalize namespace faceforward { int test() { int Error = 0; { glm::vec3 N(0.0f, 0.0f, 1.0f); glm::vec3 I(1.0f, 0.0f, 1.0f); glm::vec3 Nref(0.0f, 0.0f, 1.0f); glm::vec3 F = glm::faceforward(N, I, Nref); } return Error; } }//namespace faceforward namespace reflect { int test() { int Error = 0; { glm::vec2 A(1.0f,-1.0f); glm::vec2 B(0.0f, 1.0f); glm::vec2 C = glm::reflect(A, B); Error += C == glm::vec2(1.0, 1.0) ? 0 : 1; } { glm::dvec2 A(1.0f,-1.0f); glm::dvec2 B(0.0f, 1.0f); glm::dvec2 C = glm::reflect(A, B); Error += C == glm::dvec2(1.0, 1.0) ? 0 : 1; } return Error; } }//namespace reflect namespace refract { int test() { int Error = 0; { float A(-1.0f); float B(1.0f); float C = glm::refract(A, B, 0.5f); Error += glm::epsilonEqual(C, -1.0f, 0.0001f) ? 0 : 1; } { glm::vec2 A(0.0f,-1.0f); glm::vec2 B(0.0f, 1.0f); glm::vec2 C = glm::refract(A, B, 0.5f); Error += glm::all(glm::epsilonEqual(C, glm::vec2(0.0, -1.0), 0.0001f)) ? 0 : 1; } { glm::dvec2 A(0.0f,-1.0f); glm::dvec2 B(0.0f, 1.0f); glm::dvec2 C = glm::refract(A, B, 0.5); Error += C == glm::dvec2(0.0, -1.0) ? 0 : 1; } return Error; } }//namespace refract int main() { int Error(0); Error += length::test(); Error += distance::test(); Error += dot::test(); Error += cross::test(); Error += normalize::test(); Error += faceforward::test(); Error += reflect::test(); Error += refract::test(); return Error; } glm-0.9.9-a2/test/core/core_func_trigonometric.cpp0000600000175000001440000000012313173131001021007 0ustar guususers#include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/core/core_func_common.cpp0000600000175000001440000010524313173131001017423 0ustar guususers#define GLM_FORCE_EXPLICIT_CTOR #include #include #include #include #include #include #include #include #include // This file has divisions by zero to test isnan #if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(disable : 4723) #endif namespace floor_ { static int test() { int Error(0); { float A = 1.1f; float B = glm::floor(A); Error += glm::epsilonEqual(B, 1.f, 0.0001f) ? 0 : 1; } { double A = 1.1; double B = glm::floor(A); Error += glm::epsilonEqual(B, 1.0, 0.0001) ? 0 : 1; } { glm::vec1 A(1.1f); glm::vec1 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::vec1(1.0), 0.0001f)) ? 0 : 1; } { glm::dvec1 A(1.1); glm::dvec1 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::dvec1(1.0), 0.0001)) ? 0 : 1; } { glm::vec2 A(1.1f); glm::vec2 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::vec2(1.0), 0.0001f)) ? 0 : 1; } { glm::dvec2 A(1.1); glm::dvec2 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::dvec2(1.0), 0.0001)) ? 0 : 1; } { glm::vec3 A(1.1f); glm::vec3 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::vec3(1.0), 0.0001f)) ? 0 : 1; } { glm::dvec3 A(1.1); glm::dvec3 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::dvec3(1.0), 0.0001)) ? 0 : 1; } { glm::vec4 A(1.1f); glm::vec4 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::vec4(1.0), 0.0001f)) ? 0 : 1; } { glm::dvec4 A(1.1); glm::dvec4 B = glm::floor(A); Error += glm::all(glm::epsilonEqual(B, glm::dvec4(1.0), 0.0001)) ? 0 : 1; } return Error; } }//namespace floor namespace modf_ { static int test() { int Error(0); { float X(1.5f); float I(0.0f); float A = glm::modf(X, I); Error += I == 1.0f ? 0 : 1; Error += A == 0.5f ? 0 : 1; } { glm::vec4 X(1.1f, 1.2f, 1.5f, 1.7f); glm::vec4 I(0.0f); glm::vec4 A = glm::modf(X, I); Error += I == glm::vec4(1.0f) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, glm::vec4(0.1f, 0.2f, 0.5f, 0.7f), 0.00001f)) ? 0 : 1; } { glm::dvec4 X(1.1, 1.2, 1.5, 1.7); glm::dvec4 I(0.0); glm::dvec4 A = glm::modf(X, I); Error += I == glm::dvec4(1.0) ? 0 : 1; Error += glm::all(glm::epsilonEqual(A, glm::dvec4(0.1, 0.2, 0.5, 0.7), 0.000000001)) ? 0 : 1; } { double X(1.5); double I(0.0); double A = glm::modf(X, I); Error += I == 1.0 ? 0 : 1; Error += A == 0.5 ? 0 : 1; } return Error; } }//namespace modf namespace mod_ { static int test() { int Error(0); { float A(1.5f); float B(1.0f); float C = glm::mod(A, B); Error += glm::abs(C - 0.5f) < 0.00001f ? 0 : 1; } { float A(-0.2f); float B(1.0f); float C = glm::mod(A, B); Error += glm::abs(C - 0.8f) < 0.00001f ? 0 : 1; } { float A(3.0); float B(2.0f); float C = glm::mod(A, B); Error += glm::abs(C - 1.0f) < 0.00001f ? 0 : 1; } { glm::vec4 A(3.0); float B(2.0f); glm::vec4 C = glm::mod(A, B); Error += glm::all(glm::epsilonEqual(C, glm::vec4(1.0f), 0.00001f)) ? 0 : 1; } { glm::vec4 A(3.0); glm::vec4 B(2.0f); glm::vec4 C = glm::mod(A, B); Error += glm::all(glm::epsilonEqual(C, glm::vec4(1.0f), 0.00001f)) ? 0 : 1; } return Error; } }//namespace mod_ namespace floatBitsToInt { static int test() { int Error = 0; { float A = 1.0f; int B = glm::floatBitsToInt(A); float C = glm::intBitsToFloat(B); Error += glm::epsilonEqual(A, C, 0.0001f) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::ivec2 B = glm::floatBitsToInt(A); glm::vec2 C = glm::intBitsToFloat(B); Error += glm::all(glm::epsilonEqual(A, C, 0.0001f)) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::ivec3 B = glm::floatBitsToInt(A); glm::vec3 C = glm::intBitsToFloat(B); Error += glm::all(glm::epsilonEqual(A, C, 0.0001f)) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::ivec4 B = glm::floatBitsToInt(A); glm::vec4 C = glm::intBitsToFloat(B); Error += glm::all(glm::epsilonEqual(A, C, 0.0001f)) ? 0 : 1; } return Error; } }//namespace floatBitsToInt namespace floatBitsToUint { static int test() { int Error = 0; { float A = 1.0f; glm::uint B = glm::floatBitsToUint(A); float C = glm::intBitsToFloat(B); Error += glm::epsilonEqual(A, C, 0.0001f) ? 0 : 1; } { glm::vec2 A(1.0f, 2.0f); glm::uvec2 B = glm::floatBitsToUint(A); glm::vec2 C = glm::uintBitsToFloat(B); Error += glm::all(glm::epsilonEqual(A, C, 0.0001f)) ? 0 : 1; } { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::uvec3 B = glm::floatBitsToUint(A); glm::vec3 C = glm::uintBitsToFloat(B); Error += glm::all(glm::epsilonEqual(A, C, 0.0001f)) ? 0 : 1; } { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::uvec4 B = glm::floatBitsToUint(A); glm::vec4 C = glm::uintBitsToFloat(B); Error += glm::all(glm::epsilonEqual(A, C, 0.0001f)) ? 0 : 1; } return Error; } }//namespace floatBitsToUint namespace min_ { static int test() { int Error = 0; glm::vec1 A0 = glm::min(glm::vec1(1), glm::vec1(1)); glm::vec2 B0 = glm::min(glm::vec2(1), glm::vec2(1)); glm::vec2 B1 = glm::min(glm::vec2(1), 1.0f); bool B2 = glm::all(glm::equal(B0, B1)); Error += B2 ? 0 : 1; glm::vec3 C0 = glm::min(glm::vec3(1), glm::vec3(1)); glm::vec3 C1 = glm::min(glm::vec3(1), 1.0f); bool C2 = glm::all(glm::equal(C0, C1)); Error += C2 ? 0 : 1; glm::vec4 D0 = glm::min(glm::vec4(1), glm::vec4(1)); glm::vec4 D1 = glm::min(glm::vec4(1), 1.0f); bool D2 = glm::all(glm::equal(D0, D1)); Error += D2 ? 0 : 1; return Error; } }//namespace min_ namespace max_ { static int test() { int Error = 0; glm::vec1 A0 = glm::max(glm::vec1(1), glm::vec1(1)); glm::vec2 B0 = glm::max(glm::vec2(1), glm::vec2(1)); glm::vec2 B1 = glm::max(glm::vec2(1), 1.0f); bool B2 = glm::all(glm::equal(B0, B1)); Error += B2 ? 0 : 1; glm::vec3 C0 = glm::max(glm::vec3(1), glm::vec3(1)); glm::vec3 C1 = glm::max(glm::vec3(1), 1.0f); bool C2 = glm::all(glm::equal(C0, C1)); Error += C2 ? 0 : 1; glm::vec4 D0 = glm::max(glm::vec4(1), glm::vec4(1)); glm::vec4 D1 = glm::max(glm::vec4(1), 1.0f); bool D2 = glm::all(glm::equal(D0, D1)); Error += D2 ? 0 : 1; return Error; } }//namespace max_ namespace clamp_ { static int test() { int Error = 0; return Error; } }//namespace clamp_ namespace mix_ { template struct entry { T x; T y; B a; T Result; }; entry const TestBool[] = { {0.0f, 1.0f, false, 0.0f}, {0.0f, 1.0f, true, 1.0f}, {-1.0f, 1.0f, false, -1.0f}, {-1.0f, 1.0f, true, 1.0f} }; entry const TestFloat[] = { {0.0f, 1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 1.0f, 1.0f}, {-1.0f, 1.0f, 0.0f, -1.0f}, {-1.0f, 1.0f, 1.0f, 1.0f} }; entry const TestVec2Bool[] = { {glm::vec2(0.0f), glm::vec2(1.0f), false, glm::vec2(0.0f)}, {glm::vec2(0.0f), glm::vec2(1.0f), true, glm::vec2(1.0f)}, {glm::vec2(-1.0f), glm::vec2(1.0f), false, glm::vec2(-1.0f)}, {glm::vec2(-1.0f), glm::vec2(1.0f), true, glm::vec2(1.0f)} }; entry const TestBVec2[] = { {glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(false), glm::vec2(0.0f)}, {glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)}, {glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(false), glm::vec2(-1.0f)}, {glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)}, {glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true, false), glm::vec2(1.0f, -1.0f)} }; entry const TestVec3Bool[] = { {glm::vec3(0.0f), glm::vec3(1.0f), false, glm::vec3(0.0f)}, {glm::vec3(0.0f), glm::vec3(1.0f), true, glm::vec3(1.0f)}, {glm::vec3(-1.0f), glm::vec3(1.0f), false, glm::vec3(-1.0f)}, {glm::vec3(-1.0f), glm::vec3(1.0f), true, glm::vec3(1.0f)} }; entry const TestBVec3[] = { {glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(false), glm::vec3(0.0f)}, {glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)}, {glm::vec3(-1.0f), glm::vec3(1.0f), glm::bvec3(false), glm::vec3(-1.0f)}, {glm::vec3(-1.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)}, {glm::vec3(1.0f, 2.0f, 3.0f), glm::vec3(4.0f, 5.0f, 6.0f), glm::bvec3(true, false, true), glm::vec3(4.0f, 2.0f, 6.0f)} }; entry const TestVec4Bool[] = { {glm::vec4(0.0f), glm::vec4(1.0f), false, glm::vec4(0.0f)}, {glm::vec4(0.0f), glm::vec4(1.0f), true, glm::vec4(1.0f)}, {glm::vec4(-1.0f), glm::vec4(1.0f), false, glm::vec4(-1.0f)}, {glm::vec4(-1.0f), glm::vec4(1.0f), true, glm::vec4(1.0f)} }; entry const TestBVec4[] = { {glm::vec4(0.0f, 0.0f, 1.0f, 1.0f), glm::vec4(2.0f, 2.0f, 3.0f, 3.0f), glm::bvec4(false, true, false, true), glm::vec4(0.0f, 2.0f, 1.0f, 3.0f)}, {glm::vec4(0.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)}, {glm::vec4(-1.0f), glm::vec4(1.0f), glm::bvec4(false), glm::vec4(-1.0f)}, {glm::vec4(-1.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)}, {glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(5.0f, 6.0f, 7.0f, 8.0f), glm::bvec4(true, false, true, false), glm::vec4(5.0f, 2.0f, 7.0f, 4.0f)} }; static int test() { int Error = 0; // Float with bool { for(std::size_t i = 0; i < sizeof(TestBool) / sizeof(entry); ++i) { float Result = glm::mix(TestBool[i].x, TestBool[i].y, TestBool[i].a); Error += glm::epsilonEqual(Result, TestBool[i].Result, glm::epsilon()) ? 0 : 1; } } // Float with float { for(std::size_t i = 0; i < sizeof(TestFloat) / sizeof(entry); ++i) { float Result = glm::mix(TestFloat[i].x, TestFloat[i].y, TestFloat[i].a); Error += glm::epsilonEqual(Result, TestFloat[i].Result, glm::epsilon()) ? 0 : 1; } } // vec2 with bool { for(std::size_t i = 0; i < sizeof(TestVec2Bool) / sizeof(entry); ++i) { glm::vec2 Result = glm::mix(TestVec2Bool[i].x, TestVec2Bool[i].y, TestVec2Bool[i].a); Error += glm::epsilonEqual(Result.x, TestVec2Bool[i].Result.x, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.y, TestVec2Bool[i].Result.y, glm::epsilon()) ? 0 : 1; } } // vec2 with bvec2 { for(std::size_t i = 0; i < sizeof(TestBVec2) / sizeof(entry); ++i) { glm::vec2 Result = glm::mix(TestBVec2[i].x, TestBVec2[i].y, TestBVec2[i].a); Error += glm::epsilonEqual(Result.x, TestBVec2[i].Result.x, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.y, TestBVec2[i].Result.y, glm::epsilon()) ? 0 : 1; } } // vec3 with bool { for(std::size_t i = 0; i < sizeof(TestVec3Bool) / sizeof(entry); ++i) { glm::vec3 Result = glm::mix(TestVec3Bool[i].x, TestVec3Bool[i].y, TestVec3Bool[i].a); Error += glm::epsilonEqual(Result.x, TestVec3Bool[i].Result.x, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.y, TestVec3Bool[i].Result.y, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.z, TestVec3Bool[i].Result.z, glm::epsilon()) ? 0 : 1; } } // vec3 with bvec3 { for(std::size_t i = 0; i < sizeof(TestBVec3) / sizeof(entry); ++i) { glm::vec3 Result = glm::mix(TestBVec3[i].x, TestBVec3[i].y, TestBVec3[i].a); Error += glm::epsilonEqual(Result.x, TestBVec3[i].Result.x, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.y, TestBVec3[i].Result.y, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.z, TestBVec3[i].Result.z, glm::epsilon()) ? 0 : 1; } } // vec4 with bool { for(std::size_t i = 0; i < sizeof(TestVec4Bool) / sizeof(entry); ++i) { glm::vec4 Result = glm::mix(TestVec4Bool[i].x, TestVec4Bool[i].y, TestVec4Bool[i].a); Error += glm::epsilonEqual(Result.x, TestVec4Bool[i].Result.x, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.y, TestVec4Bool[i].Result.y, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.z, TestVec4Bool[i].Result.z, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.w, TestVec4Bool[i].Result.w, glm::epsilon()) ? 0 : 1; } } // vec4 with bvec4 { for(std::size_t i = 0; i < sizeof(TestBVec4) / sizeof(entry); ++i) { glm::vec4 Result = glm::mix(TestBVec4[i].x, TestBVec4[i].y, TestBVec4[i].a); Error += glm::epsilonEqual(Result.x, TestBVec4[i].Result.x, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.y, TestBVec4[i].Result.y, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.z, TestBVec4[i].Result.z, glm::epsilon()) ? 0 : 1; Error += glm::epsilonEqual(Result.w, TestBVec4[i].Result.w, glm::epsilon()) ? 0 : 1; } } return Error; } }//namespace mix_ namespace step_ { template struct entry { EDGE edge; VEC x; VEC result; }; entry TestVec4Scalar [] = { { 1.0f, glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) }, { 0.0f, glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) }, { 0.0f, glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f), glm::vec4(0.0f) } }; entry TestVec4Vector [] = { { glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f), glm::vec4(-2.0f, -3.0f, -4.0f, -5.0f), glm::vec4(0.0f) }, { glm::vec4( 0.0f, 1.0f, 2.0f, 3.0f), glm::vec4( 1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) }, { glm::vec4( 2.0f, 3.0f, 4.0f, 5.0f), glm::vec4( 1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(0.0f) }, { glm::vec4( 0.0f, 1.0f, 2.0f, 3.0f), glm::vec4(-1.0f,-2.0f,-3.0f,-4.0f), glm::vec4(0.0f) } }; static int test() { int Error = 0; // scalar { float const Edge = 2.0f; float const A = glm::step(Edge, 1.0f); Error += glm::epsilonEqual(A, 0.0f, glm::epsilon()) ? 0 : 1; float const B = glm::step(Edge, 3.0f); Error += glm::epsilonEqual(B, 1.0f, glm::epsilon()) ? 0 : 1; float const C = glm::step(Edge, 2.0f); Error += glm::epsilonEqual(C, 1.0f, glm::epsilon()) ? 0 : 1; } // vec4 and float { for (std::size_t i = 0; i < sizeof(TestVec4Scalar) / sizeof(entry); ++i) { glm::vec4 Result = glm::step(TestVec4Scalar[i].edge, TestVec4Scalar[i].x); Error += glm::all(glm::epsilonEqual(Result, TestVec4Scalar[i].result, glm::epsilon())) ? 0 : 1; } } // vec4 and vec4 { for (std::size_t i = 0; i < sizeof(TestVec4Vector) / sizeof(entry); ++i) { glm::vec4 Result = glm::step(TestVec4Vector[i].edge, TestVec4Vector[i].x); Error += glm::all(glm::epsilonEqual(Result, TestVec4Vector[i].result, glm::epsilon())) ? 0 : 1; } } return Error; } }//namespace step_ namespace round_ { static int test() { int Error = 0; { float A = glm::round(0.0f); Error += glm::epsilonEqual(A, 0.0f, glm::epsilon()) ? 0 : 1; float B = glm::round(0.5f); Error += glm::epsilonEqual(B, 1.0f, glm::epsilon()) ? 0 : 1; float C = glm::round(1.0f); Error += glm::epsilonEqual(C, 1.0f, glm::epsilon()) ? 0 : 1; float D = glm::round(0.1f); Error += glm::epsilonEqual(D, 0.0f, glm::epsilon()) ? 0 : 1; float E = glm::round(0.9f); Error += glm::epsilonEqual(E, 1.0f, glm::epsilon()) ? 0 : 1; float F = glm::round(1.5f); Error += glm::epsilonEqual(F, 2.0f, glm::epsilon()) ? 0 : 1; float G = glm::round(1.9f); Error += glm::epsilonEqual(G, 2.0f, glm::epsilon()) ? 0 : 1; } { float A = glm::round(-0.0f); Error += glm::epsilonEqual(A, 0.0f, glm::epsilon()) ? 0 : 1; float B = glm::round(-0.5f); Error += glm::epsilonEqual(B, -1.0f, glm::epsilon()) ? 0 : 1; float C = glm::round(-1.0f); Error += glm::epsilonEqual(C, -1.0f, glm::epsilon()) ? 0 : 1; float D = glm::round(-0.1f); Error += glm::epsilonEqual(D, 0.0f, glm::epsilon()) ? 0 : 1; float E = glm::round(-0.9f); Error += glm::epsilonEqual(E, -1.0f, glm::epsilon()) ? 0 : 1; float F = glm::round(-1.5f); Error += glm::epsilonEqual(F, -2.0f, glm::epsilon()) ? 0 : 1; float G = glm::round(-1.9f); Error += glm::epsilonEqual(G, -2.0f, glm::epsilon()) ? 0 : 1; } return Error; } }//namespace round_ namespace roundEven { static int test() { int Error = 0; { float A1 = glm::roundEven(-1.5f); Error += glm::epsilonEqual(A1, -2.0f, 0.0001f) ? 0 : 1; float A2 = glm::roundEven(1.5f); Error += glm::epsilonEqual(A2, 2.0f, 0.0001f) ? 0 : 1; float A5 = glm::roundEven(-2.5f); Error += glm::epsilonEqual(A5, -2.0f, 0.0001f) ? 0 : 1; float A6 = glm::roundEven(2.5f); Error += glm::epsilonEqual(A6, 2.0f, 0.0001f) ? 0 : 1; float A3 = glm::roundEven(-3.5f); Error += glm::epsilonEqual(A3, -4.0f, 0.0001f) ? 0 : 1; float A4 = glm::roundEven(3.5f); Error += glm::epsilonEqual(A4, 4.0f, 0.0001f) ? 0 : 1; float C7 = glm::roundEven(-4.5f); Error += glm::epsilonEqual(C7, -4.0f, 0.0001f) ? 0 : 1; float C8 = glm::roundEven(4.5f); Error += glm::epsilonEqual(C8, 4.0f, 0.0001f) ? 0 : 1; float C1 = glm::roundEven(-5.5f); Error += glm::epsilonEqual(C1, -6.0f, 0.0001f) ? 0 : 1; float C2 = glm::roundEven(5.5f); Error += glm::epsilonEqual(C2, 6.0f, 0.0001f) ? 0 : 1; float C3 = glm::roundEven(-6.5f); Error += glm::epsilonEqual(C3, -6.0f, 0.0001f) ? 0 : 1; float C4 = glm::roundEven(6.5f); Error += glm::epsilonEqual(C4, 6.0f, 0.0001f) ? 0 : 1; float C5 = glm::roundEven(-7.5f); Error += glm::epsilonEqual(C5, -8.0f, 0.0001f) ? 0 : 1; float C6 = glm::roundEven(7.5f); Error += glm::epsilonEqual(C6, 8.0f, 0.0001f) ? 0 : 1; Error += 0; } { float A7 = glm::roundEven(-2.4f); Error += glm::epsilonEqual(A7, -2.0f, 0.0001f) ? 0 : 1; float A8 = glm::roundEven(2.4f); Error += glm::epsilonEqual(A8, 2.0f, 0.0001f) ? 0 : 1; float B1 = glm::roundEven(-2.6f); Error += glm::epsilonEqual(B1, -3.0f, 0.0001f) ? 0 : 1; float B2 = glm::roundEven(2.6f); Error += glm::epsilonEqual(B2, 3.0f, 0.0001f) ? 0 : 1; float B3 = glm::roundEven(-2.0f); Error += glm::epsilonEqual(B3, -2.0f, 0.0001f) ? 0 : 1; float B4 = glm::roundEven(2.0f); Error += glm::epsilonEqual(B4, 2.0f, 0.0001f) ? 0 : 1; Error += 0; } { float A = glm::roundEven(0.0f); Error += glm::epsilonEqual(A, 0.0f, glm::epsilon()) ? 0 : 1; float B = glm::roundEven(0.5f); Error += glm::epsilonEqual(B, 0.0f, glm::epsilon()) ? 0 : 1; float C = glm::roundEven(1.0f); Error += glm::epsilonEqual(C, 1.0f, glm::epsilon()) ? 0 : 1; float D = glm::roundEven(0.1f); Error += glm::epsilonEqual(D, 0.0f, glm::epsilon()) ? 0 : 1; float E = glm::roundEven(0.9f); Error += glm::epsilonEqual(E, 1.0f, glm::epsilon()) ? 0 : 1; float F = glm::roundEven(1.5f); Error += glm::epsilonEqual(F, 2.0f, glm::epsilon()) ? 0 : 1; float G = glm::roundEven(1.9f); Error += glm::epsilonEqual(G, 2.0f, glm::epsilon()) ? 0 : 1; } { float A = glm::roundEven(-0.0f); Error += glm::epsilonEqual(A, 0.0f, glm::epsilon()) ? 0 : 1; float B = glm::roundEven(-0.5f); Error += glm::epsilonEqual(B, -0.0f, glm::epsilon()) ? 0 : 1; float C = glm::roundEven(-1.0f); Error += glm::epsilonEqual(C, -1.0f, glm::epsilon()) ? 0 : 1; float D = glm::roundEven(-0.1f); Error += glm::epsilonEqual(D, 0.0f, glm::epsilon()) ? 0 : 1; float E = glm::roundEven(-0.9f); Error += glm::epsilonEqual(E, -1.0f, glm::epsilon()) ? 0 : 1; float F = glm::roundEven(-1.5f); Error += glm::epsilonEqual(F, -2.0f, glm::epsilon()) ? 0 : 1; float G = glm::roundEven(-1.9f); Error += glm::epsilonEqual(G, -2.0f, glm::epsilon()) ? 0 : 1; } { float A = glm::roundEven(1.5f); Error += glm::epsilonEqual(A, 2.0f, glm::epsilon()) ? 0 : 1; float B = glm::roundEven(2.5f); Error += glm::epsilonEqual(B, 2.0f, glm::epsilon()) ? 0 : 1; float C = glm::roundEven(3.5f); Error += glm::epsilonEqual(C, 4.0f, glm::epsilon()) ? 0 : 1; float D = glm::roundEven(4.5f); Error += glm::epsilonEqual(D, 4.0f, glm::epsilon()) ? 0 : 1; float E = glm::roundEven(5.5f); Error += glm::epsilonEqual(E, 6.0f, glm::epsilon()) ? 0 : 1; float F = glm::roundEven(6.5f); Error += glm::epsilonEqual(F, 6.0f, glm::epsilon()) ? 0 : 1; float G = glm::roundEven(7.5f); Error += glm::epsilonEqual(G, 8.0f, glm::epsilon()) ? 0 : 1; } { float A = glm::roundEven(-1.5f); Error += glm::epsilonEqual(A, -2.0f, glm::epsilon()) ? 0 : 1; float B = glm::roundEven(-2.5f); Error += glm::epsilonEqual(B, -2.0f, glm::epsilon()) ? 0 : 1; float C = glm::roundEven(-3.5f); Error += glm::epsilonEqual(C, -4.0f, glm::epsilon()) ? 0 : 1; float D = glm::roundEven(-4.5f); Error += glm::epsilonEqual(D, -4.0f, glm::epsilon()) ? 0 : 1; float E = glm::roundEven(-5.5f); Error += glm::epsilonEqual(E, -6.0f, glm::epsilon()) ? 0 : 1; float F = glm::roundEven(-6.5f); Error += glm::epsilonEqual(F, -6.0f, glm::epsilon()) ? 0 : 1; float G = glm::roundEven(-7.5f); Error += glm::epsilonEqual(G, -8.0f, glm::epsilon()) ? 0 : 1; } return Error; } }//namespace roundEven namespace isnan_ { static int test() { int Error = 0; float Zero_f = 0.0; double Zero_d = 0.0; { Error += true == glm::isnan(0.0/Zero_d) ? 0 : 1; Error += true == glm::any(glm::isnan(glm::dvec2(0.0 / Zero_d))) ? 0 : 1; Error += true == glm::any(glm::isnan(glm::dvec3(0.0 / Zero_d))) ? 0 : 1; Error += true == glm::any(glm::isnan(glm::dvec4(0.0 / Zero_d))) ? 0 : 1; } { Error += true == glm::isnan(0.0f/Zero_f) ? 0 : 1; Error += true == glm::any(glm::isnan(glm::vec2(0.0f/Zero_f))) ? 0 : 1; Error += true == glm::any(glm::isnan(glm::vec3(0.0f/Zero_f))) ? 0 : 1; Error += true == glm::any(glm::isnan(glm::vec4(0.0f/Zero_f))) ? 0 : 1; } return Error; } }//namespace isnan_ namespace isinf_ { static int test() { int Error = 0; float Zero_f = 0.0; double Zero_d = 0.0; { Error += true == glm::isinf( 1.0/Zero_d) ? 0 : 1; Error += true == glm::isinf(-1.0/Zero_d) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::dvec2( 1.0/Zero_d))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::dvec2(-1.0/Zero_d))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::dvec3( 1.0/Zero_d))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::dvec3(-1.0/Zero_d))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::dvec4( 1.0/Zero_d))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::dvec4(-1.0/Zero_d))) ? 0 : 1; } { Error += true == glm::isinf( 1.0f/Zero_f) ? 0 : 1; Error += true == glm::isinf(-1.0f/Zero_f) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::vec2( 1.0f/Zero_f))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::vec2(-1.0f/Zero_f))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::vec3( 1.0f/Zero_f))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::vec3(-1.0f/Zero_f))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::vec4( 1.0f/Zero_f))) ? 0 : 1; Error += true == glm::any(glm::isinf(glm::vec4(-1.0f/Zero_f))) ? 0 : 1; } return Error; } }//namespace isinf_ namespace sign { template GLM_FUNC_QUALIFIER genFIType sign_if(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_iec559 || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); genFIType result; if(x > genFIType(0)) result = genFIType(1); else if(x < genFIType(0)) result = genFIType(-1); else result = genFIType(0); return result; } template GLM_FUNC_QUALIFIER genFIType sign_alu1(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); return (x >> 31) | (static_cast(-x) >> 31); } GLM_FUNC_QUALIFIER int sign_alu2(int x) { GLM_STATIC_ASSERT(std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable : 4146) //cast truncates constant value # endif return -(static_cast(x) >> 31) | (-static_cast(x) >> 31); # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif } template GLM_FUNC_QUALIFIER genFIType sign_sub(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); return (static_cast(-x) >> 31) - (static_cast(x) >> 31); } template GLM_FUNC_QUALIFIER genFIType sign_cmp(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); return (x > 0) - (x < 0); } template struct type { genType Value; genType Return; }; int test_int32() { type const Data[] = { { std::numeric_limits::max(), 1}, { std::numeric_limits::min(), -1}, { 0, 0}, { 1, 1}, { 2, 1}, { 3, 1}, {-1,-1}, {-2,-1}, {-3,-1} }; int Error = 0; for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::int32 Result = glm::sign(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::int32 Result = sign_cmp(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::int32 Result = sign_if(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::int32 Result = sign_alu1(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::int32 Result = sign_alu2(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } return Error; } int test_i32vec4() { type const Data[] = { {glm::i32vec4( 1), glm::i32vec4( 1)}, {glm::i32vec4( 0), glm::i32vec4( 0)}, {glm::i32vec4( 2), glm::i32vec4( 1)}, {glm::i32vec4( 3), glm::i32vec4( 1)}, {glm::i32vec4(-1), glm::i32vec4(-1)}, {glm::i32vec4(-2), glm::i32vec4(-1)}, {glm::i32vec4(-3), glm::i32vec4(-1)} }; int Error = 0; for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::i32vec4 Result = glm::sign(Data[i].Value); Error += glm::all(glm::equal(Data[i].Return, Result)) ? 0 : 1; } return Error; } int test_f32vec4() { type const Data[] = { {glm::vec4( 1), glm::vec4( 1)}, {glm::vec4( 0), glm::vec4( 0)}, {glm::vec4( 2), glm::vec4( 1)}, {glm::vec4( 3), glm::vec4( 1)}, {glm::vec4(-1), glm::vec4(-1)}, {glm::vec4(-2), glm::vec4(-1)}, {glm::vec4(-3), glm::vec4(-1)} }; int Error = 0; for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::vec4 Result = glm::sign(Data[i].Value); Error += glm::all(glm::equal(Data[i].Return, Result)) ? 0 : 1; } return Error; } static int test() { int Error = 0; Error += test_int32(); Error += test_i32vec4(); Error += test_f32vec4(); return Error; } int perf_rand(std::size_t Samples) { int Error = 0; std::size_t const Count = Samples; std::vector Input, Output; Input.resize(Count); Output.resize(Count); for(std::size_t i = 0; i < Count; ++i) Input[i] = static_cast(glm::linearRand(-65536.f, 65536.f)); std::clock_t Timestamp0 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_cmp(Input[i]); std::clock_t Timestamp1 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_if(Input[i]); std::clock_t Timestamp2 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_alu1(Input[i]); std::clock_t Timestamp3 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_alu2(Input[i]); std::clock_t Timestamp4 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_sub(Input[i]); std::clock_t Timestamp5 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = glm::sign(Input[i]); std::clock_t Timestamp6 = std::clock(); std::printf("sign_cmp(rand) Time %d clocks\n", static_cast(Timestamp1 - Timestamp0)); std::printf("sign_if(rand) Time %d clocks\n", static_cast(Timestamp2 - Timestamp1)); std::printf("sign_alu1(rand) Time %d clocks\n", static_cast(Timestamp3 - Timestamp2)); std::printf("sign_alu2(rand) Time %d clocks\n", static_cast(Timestamp4 - Timestamp3)); std::printf("sign_sub(rand) Time %d clocks\n", static_cast(Timestamp5 - Timestamp4)); std::printf("glm::sign(rand) Time %d clocks\n", static_cast(Timestamp6 - Timestamp5)); return Error; } int perf_linear(std::size_t Samples) { int Error = 0; std::size_t const Count = Samples; std::vector Input, Output; Input.resize(Count); Output.resize(Count); for(std::size_t i = 0; i < Count; ++i) Input[i] = static_cast(i); std::clock_t Timestamp0 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_cmp(Input[i]); std::clock_t Timestamp1 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_if(Input[i]); std::clock_t Timestamp2 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_alu1(Input[i]); std::clock_t Timestamp3 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_alu2(Input[i]); std::clock_t Timestamp4 = std::clock(); for(std::size_t i = 0; i < Count; ++i) Output[i] = sign_sub(Input[i]); std::clock_t Timestamp5 = std::clock(); std::printf("sign_cmp(linear) Time %d clocks\n", static_cast(Timestamp1 - Timestamp0)); std::printf("sign_if(linear) Time %d clocks\n", static_cast(Timestamp2 - Timestamp1)); std::printf("sign_alu1(linear) Time %d clocks\n", static_cast(Timestamp3 - Timestamp2)); std::printf("sign_alu2(linear) Time %d clocks\n", static_cast(Timestamp4 - Timestamp3)); std::printf("sign_sub(linear) Time %d clocks\n", static_cast(Timestamp5 - Timestamp4)); return Error; } int perf_linear_cal(std::size_t Samples) { int Error = 0; glm::int32 const Count = static_cast(Samples); std::clock_t Timestamp0 = std::clock(); glm::int32 Sum = 0; for(glm::int32 i = 1; i < Count; ++i) Sum += sign_cmp(i); std::clock_t Timestamp1 = std::clock(); for(glm::int32 i = 1; i < Count; ++i) Sum += sign_if(i); std::clock_t Timestamp2 = std::clock(); for(glm::int32 i = 1; i < Count; ++i) Sum += sign_alu1(i); std::clock_t Timestamp3 = std::clock(); for(glm::int32 i = 1; i < Count; ++i) Sum += sign_alu2(i); std::clock_t Timestamp4 = std::clock(); for(glm::int32 i = 1; i < Count; ++i) Sum += sign_sub(i); std::clock_t Timestamp5 = std::clock(); std::printf("Sum %d\n", static_cast(Sum)); std::printf("sign_cmp(linear_cal) Time %d clocks\n", static_cast(Timestamp1 - Timestamp0)); std::printf("sign_if(linear_cal) Time %d clocks\n", static_cast(Timestamp2 - Timestamp1)); std::printf("sign_alu1(linear_cal) Time %d clocks\n", static_cast(Timestamp3 - Timestamp2)); std::printf("sign_alu2(linear_cal) Time %d clocks\n", static_cast(Timestamp4 - Timestamp3)); std::printf("sign_sub(linear_cal) Time %d clocks\n", static_cast(Timestamp5 - Timestamp4)); return Error; } static int perf(std::size_t Samples) { int Error(0); Error += perf_linear_cal(Samples); Error += perf_linear(Samples); Error += perf_rand(Samples); return Error; } }//namespace sign namespace frexp_ { static int test() { int Error(0); { glm::vec1 x(1024); glm::ivec1 exp; glm::vec1 A = glm::frexp(x, exp); Error += glm::all(glm::epsilonEqual(A, glm::vec1(0.5), 0.00001f)) ? 0 : 1; Error += glm::all(glm::equal(exp, glm::ivec1(11))) ? 0 : 1; } { glm::vec2 x(1024, 0.24); glm::ivec2 exp; glm::vec2 A = glm::frexp(x, exp); Error += glm::all(glm::epsilonEqual(A, glm::vec2(0.5, 0.96), 0.00001f)) ? 0 : 1; Error += glm::all(glm::equal(exp, glm::ivec2(11, -2))) ? 0 : 1; } { glm::vec3 x(1024, 0.24, 0); glm::ivec3 exp; glm::vec3 A = glm::frexp(x, exp); Error += glm::all(glm::epsilonEqual(A, glm::vec3(0.5, 0.96, 0.0), 0.00001f)) ? 0 : 1; Error += glm::all(glm::equal(exp, glm::ivec3(11, -2, 0))) ? 0 : 1; } { glm::vec4 x(1024, 0.24, 0, -1.33); glm::ivec4 exp; glm::vec4 A = glm::frexp(x, exp); Error += glm::all(glm::epsilonEqual(A, glm::vec4(0.5, 0.96, 0.0, -0.665), 0.00001f)) ? 0 : 1; Error += glm::all(glm::equal(exp, glm::ivec4(11, -2, 0, 1))) ? 0 : 1; } return Error; } }//namespace frexp_ namespace ldexp_ { static int test() { int Error(0); { glm::vec1 A = glm::vec1(0.5); glm::ivec1 exp = glm::ivec1(11); glm::vec1 x = glm::ldexp(A, exp); Error += glm::all(glm::epsilonEqual(x, glm::vec1(1024),0.00001f)) ? 0 : 1; } { glm::vec2 A = glm::vec2(0.5, 0.96); glm::ivec2 exp = glm::ivec2(11, -2); glm::vec2 x = glm::ldexp(A, exp); Error += glm::all(glm::epsilonEqual(x, glm::vec2(1024, .24),0.00001f)) ? 0 : 1; } { glm::vec3 A = glm::vec3(0.5, 0.96, 0.0); glm::ivec3 exp = glm::ivec3(11, -2, 0); glm::vec3 x = glm::ldexp(A, exp); Error += glm::all(glm::epsilonEqual(x, glm::vec3(1024, .24, 0),0.00001f)) ? 0 : 1; } { glm::vec4 A = glm::vec4(0.5, 0.96, 0.0, -0.665); glm::ivec4 exp = glm::ivec4(11, -2, 0, 1); glm::vec4 x = glm::ldexp(A, exp); Error += glm::all(glm::epsilonEqual(x, glm::vec4(1024, .24, 0, -1.33),0.00001f)) ? 0 : 1; } return Error; } }//namespace ldexp_ int main() { int Error = 0; Error += sign::test(); Error += floor_::test(); Error += mod_::test(); Error += modf_::test(); Error += floatBitsToInt::test(); Error += floatBitsToUint::test(); Error += mix_::test(); Error += step_::test(); Error += max_::test(); Error += min_::test(); Error += clamp_::test(); Error += round_::test(); Error += roundEven::test(); Error += isnan_::test(); Error += isinf_::test(); Error += frexp_::test(); Error += ldexp_::test(); # ifdef NDEBUG std::size_t Samples = 1000; # else std::size_t Samples = 1; # endif Error += sign::perf(Samples); return Error; } glm-0.9.9-a2/test/core/core_type_mat4x2.cpp0000600000175000001440000000475013173131001017301 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include static int test_operators() { glm::mat4x2 l(1.0f); glm::mat4x2 m(1.0f); glm::vec4 u(1.0f); glm::vec2 v(1.0f); float x = 1.0f; glm::vec2 a = m * u; glm::vec4 b = v * m; glm::mat4x2 n = x / m; glm::mat4x2 o = m / x; glm::mat4x2 p = x * m; glm::mat4x2 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_ctr() { int Error(0); #if(GLM_HAS_INITIALIZER_LISTS) glm::mat4x2 m0( glm::vec2(0, 1), glm::vec2(2, 3), glm::vec2(4, 5), glm::vec2(6, 7)); glm::mat4x2 m1{0, 1, 2, 3, 4, 5, 6, 7}; glm::mat4x2 m2{ {0, 1}, {2, 3}, {4, 5}, {6, 7}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6, 7} }; std::vector v2{ { { 0, 1}, { 4, 5}, { 8, 9}, { 12, 13} }, { { 0, 1}, { 4, 5}, { 8, 9}, { 12, 13} } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat4x2 B(A); glm::mat4x2 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::equal(B[i], Identity[i])) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 32 == sizeof(glm::mat4x2) ? 0 : 1; Error += 64 == sizeof(glm::dmat4x2) ? 0 : 1; Error += glm::mat4x2().length() == 4 ? 0 : 1; Error += glm::dmat4x2().length() == 4 ? 0 : 1; Error += glm::mat4x2::length() == 4 ? 0 : 1; Error += glm::dmat4x2::length() == 4 ? 0 : 1; return Error; } int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/core_func_exponential.cpp0000600000175000001440000001174213173131001020461 0ustar guususers#include #include #include #include #include #include static int test_pow() { int Error(0); float A = glm::pow(2.f, 2.f); Error += glm::epsilonEqual(A, 4.f, 0.01f) ? 0 : 1; glm::vec1 B = glm::pow(glm::vec1(2.f), glm::vec1(2.f)); Error += glm::all(glm::epsilonEqual(B, glm::vec1(4.f), 0.01f)) ? 0 : 1; glm::vec2 C = glm::pow(glm::vec2(2.f), glm::vec2(2.f)); Error += glm::all(glm::epsilonEqual(C, glm::vec2(4.f), 0.01f)) ? 0 : 1; glm::vec3 D = glm::pow(glm::vec3(2.f), glm::vec3(2.f)); Error += glm::all(glm::epsilonEqual(D, glm::vec3(4.f), 0.01f)) ? 0 : 1; glm::vec4 E = glm::pow(glm::vec4(2.f), glm::vec4(2.f)); Error += glm::all(glm::epsilonEqual(E, glm::vec4(4.f), 0.01f)) ? 0 : 1; return Error; } static int test_sqrt() { int Error = 0; float A = glm::sqrt(4.f); Error += glm::epsilonEqual(A, 2.f, 0.01f) ? 0 : 1; glm::vec1 B = glm::sqrt(glm::vec1(4.f)); Error += glm::all(glm::epsilonEqual(B, glm::vec1(2.f), 0.01f)) ? 0 : 1; glm::vec2 C = glm::sqrt(glm::vec2(4.f)); Error += glm::all(glm::epsilonEqual(C, glm::vec2(2.f), 0.01f)) ? 0 : 1; glm::vec3 D = glm::sqrt(glm::vec3(4.f)); Error += glm::all(glm::epsilonEqual(D, glm::vec3(2.f), 0.01f)) ? 0 : 1; glm::vec4 E = glm::sqrt(glm::vec4(4.f)); Error += glm::all(glm::epsilonEqual(E, glm::vec4(2.f), 0.01f)) ? 0 : 1; return Error; } static int test_exp() { int Error = 0; float A = glm::exp(1.f); Error += glm::epsilonEqual(A, glm::e(), 0.01f) ? 0 : 1; glm::vec1 B = glm::exp(glm::vec1(1.f)); Error += glm::all(glm::epsilonEqual(B, glm::vec1(glm::e()), 0.01f)) ? 0 : 1; glm::vec2 C = glm::exp(glm::vec2(1.f)); Error += glm::all(glm::epsilonEqual(C, glm::vec2(glm::e()), 0.01f)) ? 0 : 1; glm::vec3 D = glm::exp(glm::vec3(1.f)); Error += glm::all(glm::epsilonEqual(D, glm::vec3(glm::e()), 0.01f)) ? 0 : 1; glm::vec4 E = glm::exp(glm::vec4(1.f)); Error += glm::all(glm::epsilonEqual(E, glm::vec4(glm::e()), 0.01f)) ? 0 : 1; return Error; } static int test_log() { int Error = 0; float const A = glm::log(glm::e()); Error += glm::epsilonEqual(A, 1.f, 0.01f) ? 0 : 1; glm::vec1 const B = glm::log(glm::vec1(glm::e())); Error += glm::all(glm::epsilonEqual(B, glm::vec1(1.f), 0.01f)) ? 0 : 1; glm::vec2 const C = glm::log(glm::vec2(glm::e())); Error += glm::all(glm::epsilonEqual(C, glm::vec2(1.f), 0.01f)) ? 0 : 1; glm::vec3 const D = glm::log(glm::vec3(glm::e())); Error += glm::all(glm::epsilonEqual(D, glm::vec3(1.f), 0.01f)) ? 0 : 1; glm::vec4 const E = glm::log(glm::vec4(glm::e())); Error += glm::all(glm::epsilonEqual(E, glm::vec4(1.f), 0.01f)) ? 0 : 1; return Error; } static int test_exp2() { int Error = 0; float A = glm::exp2(4.f); Error += glm::epsilonEqual(A, 16.f, 0.01f) ? 0 : 1; glm::vec1 B = glm::exp2(glm::vec1(4.f)); Error += glm::all(glm::epsilonEqual(B, glm::vec1(16.f), 0.01f)) ? 0 : 1; glm::vec2 C = glm::exp2(glm::vec2(4.f, 3.f)); Error += glm::all(glm::epsilonEqual(C, glm::vec2(16.f, 8.f), 0.01f)) ? 0 : 1; glm::vec3 D = glm::exp2(glm::vec3(4.f, 3.f, 2.f)); Error += glm::all(glm::epsilonEqual(D, glm::vec3(16.f, 8.f, 4.f), 0.01f)) ? 0 : 1; glm::vec4 E = glm::exp2(glm::vec4(4.f, 3.f, 2.f, 1.f)); Error += glm::all(glm::epsilonEqual(E, glm::vec4(16.f, 8.f, 4.f, 2.f), 0.01f)) ? 0 : 1; return Error; } static int test_log2() { int Error = 0; float A = glm::log2(16.f); Error += glm::epsilonEqual(A, 4.f, 0.01f) ? 0 : 1; glm::vec1 B = glm::log2(glm::vec1(16.f)); Error += glm::all(glm::epsilonEqual(B, glm::vec1(4.f), 0.01f)) ? 0 : 1; glm::vec2 C = glm::log2(glm::vec2(16.f, 8.f)); Error += glm::all(glm::epsilonEqual(C, glm::vec2(4.f, 3.f), 0.01f)) ? 0 : 1; glm::vec3 D = glm::log2(glm::vec3(16.f, 8.f, 4.f)); Error += glm::all(glm::epsilonEqual(D, glm::vec3(4.f, 3.f, 2.f), 0.01f)) ? 0 : 1; glm::vec4 E = glm::log2(glm::vec4(16.f, 8.f, 4.f, 2.f)); Error += glm::all(glm::epsilonEqual(E, glm::vec4(4.f, 3.f, 2.f, 1.f), 0.01f)) ? 0 : 1; return Error; } static int test_inversesqrt() { int Error = 0; float A = glm::inversesqrt(16.f) * glm::sqrt(16.f); Error += glm::epsilonEqual(A, 1.f, 0.01f) ? 0 : 1; glm::vec1 B = glm::inversesqrt(glm::vec1(16.f)) * glm::sqrt(16.f);; Error += glm::all(glm::epsilonEqual(B, glm::vec1(1.f), 0.01f)) ? 0 : 1; glm::vec2 C = glm::inversesqrt(glm::vec2(16.f)) * glm::sqrt(16.f);; Error += glm::all(glm::epsilonEqual(C, glm::vec2(1.f), 0.01f)) ? 0 : 1; glm::vec3 D = glm::inversesqrt(glm::vec3(16.f)) * glm::sqrt(16.f);; Error += glm::all(glm::epsilonEqual(D, glm::vec3(1.f), 0.01f)) ? 0 : 1; glm::vec4 E = glm::inversesqrt(glm::vec4(16.f)) * glm::sqrt(16.f); Error += glm::all(glm::epsilonEqual(E, glm::vec4(1.f), 0.01f)) ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_pow(); Error += test_sqrt(); Error += test_exp(); Error += test_log(); Error += test_exp2(); Error += test_log2(); Error += test_inversesqrt(); return Error; } glm-0.9.9-a2/test/core/core_type_vec1.cpp0000600000175000001440000000616513173131001017022 0ustar guususers#define GLM_FORCE_SWIZZLE #include #include #include #include static glm::vec1 g1; static glm::vec1 g2(1); int test_vec1_operators() { int Error(0); glm::vec1 A(1.0f); glm::vec1 B(1.0f); { bool R = A != B; bool S = A == B; Error += (S && !R) ? 0 : 1; } { A *= 1.0f; B *= 1.0; A += 1.0f; B += 1.0; bool R = A != B; bool S = A == B; Error += (S && !R) ? 0 : 1; } return Error; } int test_vec1_ctor() { int Error = 0; # if GLM_HAS_TRIVIAL_QUERIES // Error += std::is_trivially_default_constructible::value ? 0 : 1; // Error += std::is_trivially_copy_assignable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; # endif /* #if GLM_HAS_INITIALIZER_LISTS { glm::vec1 a{ 0 }; std::vector v = { {0.f}, {4.f}, {8.f}}; } { glm::dvec2 a{ 0 }; std::vector v = { {0.0}, {4.0}, {8.0}}; } #endif */ #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) { glm::vec2 A = glm::vec2(1.0f, 2.0f); glm::vec2 B = A.xy; glm::vec2 C(A.xy); glm::vec2 D(A.xy()); Error += glm::all(glm::equal(A, B)) ? 0 : 1; Error += glm::all(glm::equal(A, C)) ? 0 : 1; Error += glm::all(glm::equal(A, D)) ? 0 : 1; } #endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) { glm::vec2 A = glm::vec2(2.0f); glm::vec2 B = glm::vec2(2.0f, 3.0f); glm::vec2 C = glm::vec2(2.0f, 3.0); //glm::vec2 D = glm::dvec2(2.0); // Build error TODO: What does the specification says? glm::vec2 E(glm::dvec2(2.0)); glm::vec2 F(glm::ivec2(2)); } return Error; } int test_vec1_size() { int Error = 0; Error += sizeof(glm::vec1) == sizeof(glm::mediump_vec1) ? 0 : 1; Error += 4 == sizeof(glm::mediump_vec1) ? 0 : 1; Error += sizeof(glm::dvec1) == sizeof(glm::highp_dvec1) ? 0 : 1; Error += 8 == sizeof(glm::highp_dvec1) ? 0 : 1; Error += glm::vec1().length() == 1 ? 0 : 1; Error += glm::dvec1().length() == 1 ? 0 : 1; Error += glm::vec1::length() == 1 ? 0 : 1; Error += glm::dvec1::length() == 1 ? 0 : 1; # if GLM_HAS_CONSTEXPR_PARTIAL constexpr std::size_t Length = glm::vec1::length(); Error += Length == 1 ? 0 : 1; # endif return Error; } int test_vec1_operator_increment() { int Error(0); glm::ivec1 v0(1); glm::ivec1 v1(v0); glm::ivec1 v2(v0); glm::ivec1 v3 = ++v1; glm::ivec1 v4 = v2++; Error += glm::all(glm::equal(v0, v4)) ? 0 : 1; Error += glm::all(glm::equal(v1, v2)) ? 0 : 1; Error += glm::all(glm::equal(v1, v3)) ? 0 : 1; int i0(1); int i1(i0); int i2(i0); int i3 = ++i1; int i4 = i2++; Error += i0 == i4 ? 0 : 1; Error += i1 == i2 ? 0 : 1; Error += i1 == i3 ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_vec1_size(); Error += test_vec1_ctor(); Error += test_vec1_operators(); Error += test_vec1_operator_increment(); return Error; } glm-0.9.9-a2/test/core/core_type_mat3x2.cpp0000600000175000001440000000464613173131001017304 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include static bool test_operators() { glm::mat3x2 l(1.0f); glm::mat3x2 m(1.0f); glm::vec3 u(1.0f); glm::vec2 v(1.0f); float x = 1.0f; glm::vec2 a = m * u; glm::vec3 b = v * m; glm::mat3x2 n = x / m; glm::mat3x2 o = m / x; glm::mat3x2 p = x * m; glm::mat3x2 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_ctr() { int Error(0); #if(GLM_HAS_INITIALIZER_LISTS) glm::mat3x2 m0( glm::vec2(0, 1), glm::vec2(2, 3), glm::vec2(4, 5)); glm::mat3x2 m1{0, 1, 2, 3, 4, 5}; glm::mat3x2 m2{ {0, 1}, {2, 3}, {4, 5}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 4, 5} }; std::vector v2{ { { 0, 1}, { 2, 3}, { 4, 5} }, { { 0, 1}, { 2, 3}, { 4, 5} } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat3x2 B(A); glm::mat3x2 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::equal(B[i], Identity[i])) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 24 == sizeof(glm::mat3x2) ? 0 : 1; Error += 48 == sizeof(glm::dmat3x2) ? 0 : 1; Error += glm::mat3x2().length() == 3 ? 0 : 1; Error += glm::dmat3x2().length() == 3 ? 0 : 1; Error += glm::mat3x2::length() == 3 ? 0 : 1; Error += glm::dmat3x2::length() == 3 ? 0 : 1; return Error; } int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/core_func_integer.cpp0000600000175000001440000011623513173131001017573 0ustar guususers#include #include #include #include #include #include enum result { SUCCESS, FAIL, ASSERT, STATIC_ASSERT }; namespace bitfieldInsert { template struct type { genType Base; genType Insert; int Offset; int Bits; genType Return; }; typedef type typeU32; typeU32 const Data32[] = { {0x00000000, 0xffffffff, 0, 32, 0xffffffff}, {0x00000000, 0xffffffff, 0, 31, 0x7fffffff}, {0x00000000, 0xffffffff, 0, 0, 0x00000000}, {0xff000000, 0x0000ff00, 8, 8, 0xff00ff00}, {0xffff0000, 0x0000ffff, 16, 16, 0x00000000}, {0x0000ffff, 0xffff0000, 16, 16, 0xffffffff} }; static int test() { int Error = 0; glm::uint count = sizeof(Data32) / sizeof(typeU32); for(glm::uint i = 0; i < count; ++i) { glm::uint Return = glm::bitfieldInsert( Data32[i].Base, Data32[i].Insert, Data32[i].Offset, Data32[i].Bits); Error += Data32[i].Return == Return ? 0 : 1; } return Error; } }//bitfieldInsert namespace bitfieldExtract { template struct type { genType Value; int Offset; int Bits; genType Return; result Result; }; typedef type typeU32; typeU32 const Data32[] = { {0xffffffff, 0,32, 0xffffffff, SUCCESS}, {0xffffffff, 8, 0, 0x00000000, SUCCESS}, {0x00000000, 0,32, 0x00000000, SUCCESS}, {0x0f0f0f0f, 0,32, 0x0f0f0f0f, SUCCESS}, {0x00000000, 8, 0, 0x00000000, SUCCESS}, {0x80000000,31, 1, 0x00000001, SUCCESS}, {0x7fffffff,31, 1, 0x00000000, SUCCESS}, {0x00000300, 8, 8, 0x00000003, SUCCESS}, {0x0000ff00, 8, 8, 0x000000ff, SUCCESS}, {0xfffffff0, 0, 5, 0x00000010, SUCCESS}, {0x000000ff, 1, 3, 0x00000007, SUCCESS}, {0x000000ff, 0, 3, 0x00000007, SUCCESS}, {0x00000000, 0, 2, 0x00000000, SUCCESS}, {0xffffffff, 0, 8, 0x000000ff, SUCCESS}, {0xffff0000,16,16, 0x0000ffff, SUCCESS}, {0xfffffff0, 0, 8, 0x00000000, FAIL}, {0xffffffff,16,16, 0x00000000, FAIL}, //{0xffffffff,32, 1, 0x00000000, ASSERT}, // Throw an assert //{0xffffffff, 0,33, 0x00000000, ASSERT}, // Throw an assert //{0xffffffff,16,16, 0x00000000, ASSERT}, // Throw an assert }; static int test() { int Error = 0; glm::uint count = sizeof(Data32) / sizeof(typeU32); for(glm::uint i = 0; i < count; ++i) { glm::uint Return = glm::bitfieldExtract( Data32[i].Value, Data32[i].Offset, Data32[i].Bits); bool Compare = Data32[i].Return == Return; if(Data32[i].Result == SUCCESS && Compare) continue; else if(Data32[i].Result == FAIL && !Compare) continue; Error += 1; } return Error; } }//extractField namespace bitfieldReverse { /* GLM_FUNC_QUALIFIER unsigned int bitfieldReverseLoop(unsigned int v) { unsigned int Result(0); unsigned int const BitSize = static_cast(sizeof(unsigned int) * 8); for(unsigned int i = 0; i < BitSize; ++i) { unsigned int const BitSet(v & (static_cast(1) << i)); unsigned int const BitFirst(BitSet >> i); Result |= BitFirst << (BitSize - 1 - i); } return Result; } GLM_FUNC_QUALIFIER glm::uint64_t bitfieldReverseLoop(glm::uint64_t v) { glm::uint64_t Result(0); glm::uint64_t const BitSize = static_cast(sizeof(unsigned int) * 8); for(glm::uint64_t i = 0; i < BitSize; ++i) { glm::uint64_t const BitSet(v & (static_cast(1) << i)); glm::uint64_t const BitFirst(BitSet >> i); Result |= BitFirst << (BitSize - 1 - i); } return Result; } */ template GLM_FUNC_QUALIFIER glm::vec bitfieldReverseLoop(glm::vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); glm::vec Result(0); T const BitSize = static_cast(sizeof(T) * 8); for(T i = 0; i < BitSize; ++i) { glm::vec const BitSet(v & (static_cast(1) << i)); glm::vec const BitFirst(BitSet >> i); Result |= BitFirst << (BitSize - 1 - i); } return Result; } template GLM_FUNC_QUALIFIER T bitfieldReverseLoop(T v) { return bitfieldReverseLoop(glm::vec<1, T>(v)).x; } GLM_FUNC_QUALIFIER glm::uint32_t bitfieldReverseUint32(glm::uint32_t x) { x = (x & 0x55555555) << 1 | (x & 0xAAAAAAAA) >> 1; x = (x & 0x33333333) << 2 | (x & 0xCCCCCCCC) >> 2; x = (x & 0x0F0F0F0F) << 4 | (x & 0xF0F0F0F0) >> 4; x = (x & 0x00FF00FF) << 8 | (x & 0xFF00FF00) >> 8; x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16; return x; } GLM_FUNC_QUALIFIER glm::uint64_t bitfieldReverseUint64(glm::uint64_t x) { x = (x & 0x5555555555555555) << 1 | (x & 0xAAAAAAAAAAAAAAAA) >> 1; x = (x & 0x3333333333333333) << 2 | (x & 0xCCCCCCCCCCCCCCCC) >> 2; x = (x & 0x0F0F0F0F0F0F0F0F) << 4 | (x & 0xF0F0F0F0F0F0F0F0) >> 4; x = (x & 0x00FF00FF00FF00FF) << 8 | (x & 0xFF00FF00FF00FF00) >> 8; x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16; x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32; return x; } template struct compute_bitfieldReverseStep { template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const& v, T, T) { return v; } }; template<> struct compute_bitfieldReverseStep { template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const& v, T Mask, T Shift) { return (v & Mask) << Shift | (v & (~Mask)) >> Shift; } }; template GLM_FUNC_QUALIFIER glm::vec bitfieldReverseOps(glm::vec const& v) { glm::vec x(v); x = compute_bitfieldReverseStep= 2>::call(x, static_cast(0x5555555555555555ull), static_cast( 1)); x = compute_bitfieldReverseStep= 4>::call(x, static_cast(0x3333333333333333ull), static_cast( 2)); x = compute_bitfieldReverseStep= 8>::call(x, static_cast(0x0F0F0F0F0F0F0F0Full), static_cast( 4)); x = compute_bitfieldReverseStep= 16>::call(x, static_cast(0x00FF00FF00FF00FFull), static_cast( 8)); x = compute_bitfieldReverseStep= 32>::call(x, static_cast(0x0000FFFF0000FFFFull), static_cast(16)); x = compute_bitfieldReverseStep= 64>::call(x, static_cast(0x00000000FFFFFFFFull), static_cast(32)); return x; } template GLM_FUNC_QUALIFIER genType bitfieldReverseOps(genType x) { return bitfieldReverseOps(glm::vec<1, genType, glm::defaultp>(x)).x; } template struct type { genType Value; genType Return; result Result; }; typedef type typeU32; typeU32 const Data32[] = { {0x00000001, 0x80000000, SUCCESS}, {0x0000000f, 0xf0000000, SUCCESS}, {0x000000ff, 0xff000000, SUCCESS}, {0xf0000000, 0x0000000f, SUCCESS}, {0xff000000, 0x000000ff, SUCCESS}, {0xffffffff, 0xffffffff, SUCCESS}, {0x00000000, 0x00000000, SUCCESS} }; typedef type typeU64; typeU64 const Data64[] = { {0x00000000000000ff, 0xff00000000000000, SUCCESS}, {0x000000000000000f, 0xf000000000000000, SUCCESS}, {0xf000000000000000, 0x000000000000000f, SUCCESS}, {0xffffffffffffffff, 0xffffffffffffffff, SUCCESS}, {0x0000000000000000, 0x0000000000000000, SUCCESS} }; static int test32_bitfieldReverse() { int Error = 0; std::size_t const Count = sizeof(Data32) / sizeof(typeU32); for(std::size_t i = 0; i < Count; ++i) { glm::uint Return = glm::bitfieldReverse(Data32[i].Value); bool Compare = Data32[i].Return == Return; if(Data32[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test32_bitfieldReverseLoop() { int Error = 0; std::size_t const Count = sizeof(Data32) / sizeof(typeU32); for(std::size_t i = 0; i < Count; ++i) { glm::uint Return = bitfieldReverseLoop(Data32[i].Value); bool Compare = Data32[i].Return == Return; if(Data32[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test32_bitfieldReverseUint32() { int Error = 0; std::size_t const Count = sizeof(Data32) / sizeof(typeU32); for(std::size_t i = 0; i < Count; ++i) { glm::uint Return = bitfieldReverseUint32(Data32[i].Value); bool Compare = Data32[i].Return == Return; if(Data32[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test32_bitfieldReverseOps() { int Error = 0; std::size_t const Count = sizeof(Data32) / sizeof(typeU32); for(std::size_t i = 0; i < Count; ++i) { glm::uint Return = bitfieldReverseOps(Data32[i].Value); bool Compare = Data32[i].Return == Return; if(Data32[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test64_bitfieldReverse() { int Error = 0; std::size_t const Count = sizeof(Data64) / sizeof(typeU64); for(std::size_t i = 0; i < Count; ++i) { glm::uint64 Return = glm::bitfieldReverse(Data64[i].Value); bool Compare = Data64[i].Return == Return; if(Data64[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test64_bitfieldReverseLoop() { int Error = 0; std::size_t const Count = sizeof(Data64) / sizeof(typeU64); for(std::size_t i = 0; i < Count; ++i) { glm::uint64 Return = bitfieldReverseLoop(Data64[i].Value); bool Compare = Data64[i].Return == Return; if(Data32[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test64_bitfieldReverseUint64() { int Error = 0; std::size_t const Count = sizeof(Data64) / sizeof(typeU64); for(std::size_t i = 0; i < Count; ++i) { glm::uint64 Return = bitfieldReverseUint64(Data64[i].Value); bool Compare = Data64[i].Return == Return; if(Data64[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test64_bitfieldReverseOps() { int Error = 0; std::size_t const Count = sizeof(Data64) / sizeof(typeU64); for(std::size_t i = 0; i < Count; ++i) { glm::uint64 Return = bitfieldReverseOps(Data64[i].Value); bool Compare = Data64[i].Return == Return; if(Data64[i].Result == SUCCESS) Error += Compare ? 0 : 1; else Error += Compare ? 1 : 0; } return Error; } static int test() { int Error = 0; Error += test32_bitfieldReverse(); Error += test32_bitfieldReverseLoop(); Error += test32_bitfieldReverseUint32(); Error += test32_bitfieldReverseOps(); Error += test64_bitfieldReverse(); Error += test64_bitfieldReverseLoop(); Error += test64_bitfieldReverseUint64(); Error += test64_bitfieldReverseOps(); return Error; } static int perf32(glm::uint32 Count) { int Error = 0; std::vector Data; Data.resize(static_cast(Count)); std::clock_t Timestamps0 = std::clock(); for(glm::uint32 k = 0; k < Count; ++k) Data[k] = glm::bitfieldReverse(k); std::clock_t Timestamps1 = std::clock(); for(glm::uint32 k = 0; k < Count; ++k) Data[k] = bitfieldReverseLoop(k); std::clock_t Timestamps2 = std::clock(); for(glm::uint32 k = 0; k < Count; ++k) Data[k] = bitfieldReverseUint32(k); std::clock_t Timestamps3 = std::clock(); for(glm::uint32 k = 0; k < Count; ++k) Data[k] = bitfieldReverseOps(k); std::clock_t Timestamps4 = std::clock(); std::printf("glm::bitfieldReverse: %d clocks\n", static_cast(Timestamps1 - Timestamps0)); std::printf("bitfieldReverseLoop: %d clocks\n", static_cast(Timestamps2 - Timestamps1)); std::printf("bitfieldReverseUint32: %d clocks\n", static_cast(Timestamps3 - Timestamps2)); std::printf("bitfieldReverseOps: %d clocks\n", static_cast(Timestamps4 - Timestamps3)); return Error; } static int perf64(glm::uint64 Count) { int Error = 0; std::vector Data; Data.resize(static_cast(Count)); std::clock_t Timestamps0 = std::clock(); for(glm::uint64 k = 0; k < Count; ++k) Data[static_cast(k)] = glm::bitfieldReverse(k); std::clock_t Timestamps1 = std::clock(); for(glm::uint64 k = 0; k < Count; ++k) Data[static_cast(k)] = bitfieldReverseLoop(k); std::clock_t Timestamps2 = std::clock(); for(glm::uint64 k = 0; k < Count; ++k) Data[static_cast(k)] = bitfieldReverseUint64(k); std::clock_t Timestamps3 = std::clock(); for(glm::uint64 k = 0; k < Count; ++k) Data[static_cast(k)] = bitfieldReverseOps(k); std::clock_t Timestamps4 = std::clock(); std::printf("glm::bitfieldReverse - 64: %d clocks\n", static_cast(Timestamps1 - Timestamps0)); std::printf("bitfieldReverseLoop - 64: %d clocks\n", static_cast(Timestamps2 - Timestamps1)); std::printf("bitfieldReverseUint - 64: %d clocks\n", static_cast(Timestamps3 - Timestamps2)); std::printf("bitfieldReverseOps - 64: %d clocks\n", static_cast(Timestamps4 - Timestamps3)); return Error; } static int perf(std::size_t Samples) { int Error = 0; Error += perf32(static_cast(Samples)); Error += perf64(static_cast(Samples)); return Error; } }//bitfieldReverse namespace findMSB { template struct type { genType Value; retType Return; }; # if GLM_HAS_BITSCAN_WINDOWS template static int findMSB_intrinsic(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if(Value == 0) return -1; unsigned long Result(0); _BitScanReverse(&Result, Value); return int(Result); } # endif//GLM_HAS_BITSCAN_WINDOWS # if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC template static int findMSB_avx(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if(Value == 0) return -1; return int(_tzcnt_u32(Value)); } # endif//GLM_ARCH & GLM_ARCH_AVX && GLM_PLATFORM & GLM_PLATFORM_WINDOWS template static int findMSB_095(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if(Value == genIUType(0) || Value == genIUType(-1)) return -1; else if(Value > 0) { genIUType Bit = genIUType(-1); for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){} return static_cast(Bit); } else //if(Value < 0) { int const BitCount(sizeof(genIUType) * 8); int MostSignificantBit(-1); for(int BitIndex(0); BitIndex < BitCount; ++BitIndex) MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex; assert(MostSignificantBit >= 0); return MostSignificantBit; } } template static int findMSB_nlz1(genIUType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if (x == 0) return -1; int n = 0; if (x <= 0x0000FFFF) {n = n +16; x = x <<16;} if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;} if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;} if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;} if (x <= 0x7FFFFFFF) {n = n + 1;} return 31 - n; } static int findMSB_nlz2(unsigned int x) { unsigned int y; int n = 32; y = x >>16; if (y != 0) {n = n -16; x = y;} y = x >> 8; if (y != 0) {n = n - 8; x = y;} y = x >> 4; if (y != 0) {n = n - 4; x = y;} y = x >> 2; if (y != 0) {n = n - 2; x = y;} y = x >> 1; if (y != 0) return n - 2; return 32 - (n - static_cast(x)); } static int findMSB_pop(unsigned int x) { x = x | (x >> 1); x = x | (x >> 2); x = x | (x >> 4); x = x | (x >> 8); x = x | (x >>16); return 31 - glm::bitCount(~x); } static int perf_int(std::size_t Count) { type const Data[] = { {0x00000000, -1}, {0x00000001, 0}, {0x00000002, 1}, {0x00000003, 1}, {0x00000004, 2}, {0x00000005, 2}, {0x00000007, 2}, {0x00000008, 3}, {0x00000010, 4}, {0x00000020, 5}, {0x00000040, 6}, {0x00000080, 7}, {0x00000100, 8}, {0x00000200, 9}, {0x00000400, 10}, {0x00000800, 11}, {0x00001000, 12}, {0x00002000, 13}, {0x00004000, 14}, {0x00008000, 15}, {0x00010000, 16}, {0x00020000, 17}, {0x00040000, 18}, {0x00080000, 19}, {0x00100000, 20}, {0x00200000, 21}, {0x00400000, 22}, {0x00800000, 23}, {0x01000000, 24}, {0x02000000, 25}, {0x04000000, 26}, {0x08000000, 27}, {0x10000000, 28}, {0x20000000, 29}, {0x40000000, 30} }; int Error(0); std::clock_t Timestamps0 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = glm::findMSB(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } std::clock_t Timestamps1 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = findMSB_nlz1(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } std::clock_t Timestamps2 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = findMSB_nlz2(static_cast(Data[i].Value)); Error += Data[i].Return == Result ? 0 : 1; } std::clock_t Timestamps3 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = findMSB_095(static_cast(Data[i].Value)); Error += Data[i].Return == Result ? 0 : 1; } std::clock_t Timestamps4 = std::clock(); # if GLM_HAS_BITSCAN_WINDOWS for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = findMSB_intrinsic(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } # endif//GLM_HAS_BITSCAN_WINDOWS std::clock_t Timestamps5 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = findMSB_pop(static_cast(Data[i].Value)); Error += Data[i].Return == Result ? 0 : 1; } std::clock_t Timestamps6 = std::clock(); # if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { int Result = findMSB_avx(Data[i].Value); Error += Data[i].Return == Result ? 0 : 1; } std::clock_t Timestamps7 = std::clock(); # endif std::printf("glm::findMSB: %d clocks\n", static_cast(Timestamps1 - Timestamps0)); std::printf("findMSB - nlz1: %d clocks\n", static_cast(Timestamps2 - Timestamps1)); std::printf("findMSB - nlz2: %d clocks\n", static_cast(Timestamps3 - Timestamps2)); std::printf("findMSB - 0.9.5: %d clocks\n", static_cast(Timestamps4 - Timestamps3)); # if GLM_HAS_BITSCAN_WINDOWS std::printf("findMSB - intrinsics: %d clocks\n", static_cast(Timestamps5 - Timestamps4)); # endif//GLM_HAS_BITSCAN_WINDOWS std::printf("findMSB - pop: %d clocks\n", static_cast(Timestamps6 - Timestamps5)); # if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC std::printf("findMSB - avx tzcnt: %d clocks\n", static_cast(Timestamps7 - Timestamps6)); # endif//GLM_ARCH & GLM_ARCH_AVX && GLM_PLATFORM & GLM_PLATFORM_WINDOWS return Error; } static int test_ivec4() { type const Data[] = { {glm::ivec4(0x00000000), glm::ivec4(-1)}, {glm::ivec4(0x00000001), glm::ivec4( 0)}, {glm::ivec4(0x00000002), glm::ivec4( 1)}, {glm::ivec4(0x00000003), glm::ivec4( 1)}, {glm::ivec4(0x00000004), glm::ivec4( 2)}, {glm::ivec4(0x00000005), glm::ivec4( 2)}, {glm::ivec4(0x00000007), glm::ivec4( 2)}, {glm::ivec4(0x00000008), glm::ivec4( 3)}, {glm::ivec4(0x00000010), glm::ivec4( 4)}, {glm::ivec4(0x00000020), glm::ivec4( 5)}, {glm::ivec4(0x00000040), glm::ivec4( 6)}, {glm::ivec4(0x00000080), glm::ivec4( 7)}, {glm::ivec4(0x00000100), glm::ivec4( 8)}, {glm::ivec4(0x00000200), glm::ivec4( 9)}, {glm::ivec4(0x00000400), glm::ivec4(10)}, {glm::ivec4(0x00000800), glm::ivec4(11)}, {glm::ivec4(0x00001000), glm::ivec4(12)}, {glm::ivec4(0x00002000), glm::ivec4(13)}, {glm::ivec4(0x00004000), glm::ivec4(14)}, {glm::ivec4(0x00008000), glm::ivec4(15)}, {glm::ivec4(0x00010000), glm::ivec4(16)}, {glm::ivec4(0x00020000), glm::ivec4(17)}, {glm::ivec4(0x00040000), glm::ivec4(18)}, {glm::ivec4(0x00080000), glm::ivec4(19)}, {glm::ivec4(0x00100000), glm::ivec4(20)}, {glm::ivec4(0x00200000), glm::ivec4(21)}, {glm::ivec4(0x00400000), glm::ivec4(22)}, {glm::ivec4(0x00800000), glm::ivec4(23)}, {glm::ivec4(0x01000000), glm::ivec4(24)}, {glm::ivec4(0x02000000), glm::ivec4(25)}, {glm::ivec4(0x04000000), glm::ivec4(26)}, {glm::ivec4(0x08000000), glm::ivec4(27)}, {glm::ivec4(0x10000000), glm::ivec4(28)}, {glm::ivec4(0x20000000), glm::ivec4(29)}, {glm::ivec4(0x40000000), glm::ivec4(30)} }; int Error(0); for(std::size_t i = 0; i < sizeof(Data) / sizeof(type); ++i) { glm::ivec4 Result0 = glm::findMSB(Data[i].Value); Error += glm::all(glm::equal(Data[i].Return, Result0)) ? 0 : 1; } return Error; } static int test_int() { typedef type entry; entry const Data[] = { {0x00000000, -1}, {0x00000001, 0}, {0x00000002, 1}, {0x00000003, 1}, {0x00000004, 2}, {0x00000005, 2}, {0x00000007, 2}, {0x00000008, 3}, {0x00000010, 4}, {0x00000020, 5}, {0x00000040, 6}, {0x00000080, 7}, {0x00000100, 8}, {0x00000200, 9}, {0x00000400, 10}, {0x00000800, 11}, {0x00001000, 12}, {0x00002000, 13}, {0x00004000, 14}, {0x00008000, 15}, {0x00010000, 16}, {0x00020000, 17}, {0x00040000, 18}, {0x00080000, 19}, {0x00100000, 20}, {0x00200000, 21}, {0x00400000, 22}, {0x00800000, 23}, {0x01000000, 24}, {0x02000000, 25}, {0x04000000, 26}, {0x08000000, 27}, {0x10000000, 28}, {0x20000000, 29}, {0x40000000, 30} }; int Error(0); for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i) { int Result0 = glm::findMSB(Data[i].Value); Error += Data[i].Return == Result0 ? 0 : 1; } for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i) { int Result0 = findMSB_nlz1(Data[i].Value); Error += Data[i].Return == Result0 ? 0 : 1; } /* for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i) { int Result0 = findMSB_nlz2(Data[i].Value); Error += Data[i].Return == Result0 ? 0 : 1; } */ for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i) { int Result0 = findMSB_095(Data[i].Value); Error += Data[i].Return == Result0 ? 0 : 1; } # if GLM_HAS_BITSCAN_WINDOWS for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i) { int Result0 = findMSB_intrinsic(Data[i].Value); Error += Data[i].Return == Result0 ? 0 : 1; } # endif//GLM_HAS_BITSCAN_WINDOWS for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i) { int Result0 = findMSB_pop(Data[i].Value); Error += Data[i].Return == Result0 ? 0 : 1; } return Error; } static int test() { int Error(0); Error += test_ivec4(); Error += test_int(); return Error; } static int perf(std::size_t Samples) { int Error(0); Error += perf_int(Samples); return Error; } }//findMSB namespace findLSB { template struct type { genType Value; retType Return; }; typedef type entry; entry const DataI32[] = { {0x00000001, 0}, {0x00000003, 0}, {0x00000002, 1}, // {0x80000000, 31}, // Clang generates an error with this {0x00010000, 16}, {0x7FFF0000, 16}, {0x7F000000, 24}, {0x7F00FF00, 8}, {0x00000000, -1} }; # if GLM_HAS_BITSCAN_WINDOWS template static int findLSB_intrinsic(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); if(Value == 0) return -1; unsigned long Result(0); _BitScanForward(&Result, Value); return int(Result); } # endif template static int findLSB_095(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); if(Value == 0) return -1; genIUType Bit; for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){} return Bit; } template static int findLSB_ntz2(genIUType x) { if(x == 0) return -1; return glm::bitCount(~x & (x - static_cast(1))); } template static int findLSB_branchfree(genIUType x) { bool IsNull(x == 0); int const Keep(!IsNull); int const Discard(IsNull); return static_cast(glm::bitCount(~x & (x - static_cast(1)))) * Keep + Discard * -1; } static int test_int() { int Error(0); for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = glm::findLSB(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_095(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } # if GLM_HAS_BITSCAN_WINDOWS for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_intrinsic(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } # endif for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_ntz2(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_branchfree(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } return Error; } static int test() { int Error(0); Error += test_int(); return Error; } static int perf_int(std::size_t Count) { int Error(0); std::clock_t Timestamps0 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = glm::findLSB(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } std::clock_t Timestamps1 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_095(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } std::clock_t Timestamps2 = std::clock(); # if GLM_HAS_BITSCAN_WINDOWS for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_intrinsic(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } # endif std::clock_t Timestamps3 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_ntz2(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } std::clock_t Timestamps4 = std::clock(); for(std::size_t k = 0; k < Count; ++k) for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i) { int Result = findLSB_branchfree(DataI32[i].Value); Error += DataI32[i].Return == Result ? 0 : 1; } std::clock_t Timestamps5 = std::clock(); std::printf("glm::findLSB: %d clocks\n", static_cast(Timestamps1 - Timestamps0)); std::printf("findLSB - 0.9.5: %d clocks\n", static_cast(Timestamps2 - Timestamps1)); # if GLM_HAS_BITSCAN_WINDOWS std::printf("findLSB - intrinsics: %d clocks\n", static_cast(Timestamps3 - Timestamps2)); # endif std::printf("findLSB - ntz2: %d clocks\n", static_cast(Timestamps4 - Timestamps3)); std::printf("findLSB - branchfree: %d clocks\n", static_cast(Timestamps5 - Timestamps4)); return Error; } static int perf(std::size_t Samples) { int Error(0); Error += perf_int(Samples); return Error; } }//findLSB namespace uaddCarry { static int test() { int Error(0); { glm::uint x = std::numeric_limits::max(); glm::uint y = 0; glm::uint Carry = 0; glm::uint Result = glm::uaddCarry(x, y, Carry); Error += Carry == 0 ? 0 : 1; Error += Result == std::numeric_limits::max() ? 0 : 1; } { glm::uint x = std::numeric_limits::max(); glm::uint y = 1; glm::uint Carry = 0; glm::uint Result = glm::uaddCarry(x, y, Carry); Error += Carry == 1 ? 0 : 1; Error += Result == 0 ? 0 : 1; } { glm::uvec1 x(std::numeric_limits::max()); glm::uvec1 y(0); glm::uvec1 Carry(0); glm::uvec1 Result(glm::uaddCarry(x, y, Carry)); Error += glm::all(glm::equal(Carry, glm::uvec1(0))) ? 0 : 1; Error += glm::all(glm::equal(Result, glm::uvec1(std::numeric_limits::max()))) ? 0 : 1; } { glm::uvec1 x(std::numeric_limits::max()); glm::uvec1 y(1); glm::uvec1 Carry(0); glm::uvec1 Result(glm::uaddCarry(x, y, Carry)); Error += glm::all(glm::equal(Carry, glm::uvec1(1))) ? 0 : 1; Error += glm::all(glm::equal(Result, glm::uvec1(0))) ? 0 : 1; } return Error; } }//namespace uaddCarry namespace usubBorrow { static int test() { int Error(0); { glm::uint x = 16; glm::uint y = 17; glm::uint Borrow = 0; glm::uint Result = glm::usubBorrow(x, y, Borrow); Error += Borrow == 1 ? 0 : 1; Error += Result == 1 ? 0 : 1; } { glm::uvec1 x(16); glm::uvec1 y(17); glm::uvec1 Borrow(0); glm::uvec1 Result(glm::usubBorrow(x, y, Borrow)); Error += glm::all(glm::equal(Borrow, glm::uvec1(1))) ? 0 : 1; Error += glm::all(glm::equal(Result, glm::uvec1(1))) ? 0 : 1; } { glm::uvec2 x(16); glm::uvec2 y(17); glm::uvec2 Borrow(0); glm::uvec2 Result(glm::usubBorrow(x, y, Borrow)); Error += glm::all(glm::equal(Borrow, glm::uvec2(1))) ? 0 : 1; Error += glm::all(glm::equal(Result, glm::uvec2(1))) ? 0 : 1; } { glm::uvec3 x(16); glm::uvec3 y(17); glm::uvec3 Borrow(0); glm::uvec3 Result(glm::usubBorrow(x, y, Borrow)); Error += glm::all(glm::equal(Borrow, glm::uvec3(1))) ? 0 : 1; Error += glm::all(glm::equal(Result, glm::uvec3(1))) ? 0 : 1; } { glm::uvec4 x(16); glm::uvec4 y(17); glm::uvec4 Borrow(0); glm::uvec4 Result(glm::usubBorrow(x, y, Borrow)); Error += glm::all(glm::equal(Borrow, glm::uvec4(1))) ? 0 : 1; Error += glm::all(glm::equal(Result, glm::uvec4(1))) ? 0 : 1; } return Error; } }//namespace usubBorrow namespace umulExtended { static int test() { int Error(0); { glm::uint x = 2; glm::uint y = 3; glm::uint msb = 0; glm::uint lsb = 0; glm::umulExtended(x, y, msb, lsb); Error += msb == 0 ? 0 : 1; Error += lsb == 6 ? 0 : 1; } { glm::uvec1 x(2); glm::uvec1 y(3); glm::uvec1 msb(0); glm::uvec1 lsb(0); glm::umulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::uvec1(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::uvec1(6))) ? 0 : 1; } { glm::uvec2 x(2); glm::uvec2 y(3); glm::uvec2 msb(0); glm::uvec2 lsb(0); glm::umulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::uvec2(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::uvec2(6))) ? 0 : 1; } { glm::uvec3 x(2); glm::uvec3 y(3); glm::uvec3 msb(0); glm::uvec3 lsb(0); glm::umulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::uvec3(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::uvec3(6))) ? 0 : 1; } { glm::uvec4 x(2); glm::uvec4 y(3); glm::uvec4 msb(0); glm::uvec4 lsb(0); glm::umulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::uvec4(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::uvec4(6))) ? 0 : 1; } return Error; } }//namespace umulExtended namespace imulExtended { static int test() { int Error(0); { int x = 2; int y = 3; int msb = 0; int lsb = 0; glm::imulExtended(x, y, msb, lsb); Error += msb == 0 ? 0 : 1; Error += lsb == 6 ? 0 : 1; } { glm::ivec1 x(2); glm::ivec1 y(3); glm::ivec1 msb(0); glm::ivec1 lsb(0); glm::imulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::ivec1(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::ivec1(6))) ? 0 : 1; } { glm::ivec2 x(2); glm::ivec2 y(3); glm::ivec2 msb(0); glm::ivec2 lsb(0); glm::imulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::ivec2(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::ivec2(6))) ? 0 : 1; } { glm::ivec3 x(2); glm::ivec3 y(3); glm::ivec3 msb(0); glm::ivec3 lsb(0); glm::imulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::ivec3(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::ivec3(6))) ? 0 : 1; } { glm::ivec4 x(2); glm::ivec4 y(3); glm::ivec4 msb(0); glm::ivec4 lsb(0); glm::imulExtended(x, y, msb, lsb); Error += glm::all(glm::equal(msb, glm::ivec4(0))) ? 0 : 1; Error += glm::all(glm::equal(lsb, glm::ivec4(6))) ? 0 : 1; } return Error; } }//namespace imulExtended namespace bitCount { template struct type { genType Value; genType Return; }; type const DataI32[] = { {0x00000001, 1}, {0x00000003, 2}, {0x00000002, 1}, {0x7fffffff, 31}, {0x00000000, 0} }; template inline int bitCount_if(T v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); int Count(0); for(T i = 0, n = static_cast(sizeof(T) * 8); i < n; ++i) { if(v & static_cast(1 << i)) ++Count; } return Count; } template inline int bitCount_vec(T v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); int Count(0); for(T i = 0, n = static_cast(sizeof(T) * 8); i < n; ++i) { Count += static_cast((v >> i) & static_cast(1)); } return Count; } template struct compute_bitfieldBitCountStep { template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const& v, T, T) { return v; } }; template<> struct compute_bitfieldBitCountStep { template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const& v, T Mask, T Shift) { return (v & Mask) + ((v >> Shift) & Mask); } }; template static glm::vec bitCount_bitfield(glm::vec const& v) { glm::vec::type, Q> x(*reinterpret_cast::type, Q> const *>(&v)); x = compute_bitfieldBitCountStep= 2>::call(x, static_cast::type>(0x5555555555555555ull), static_cast::type>( 1)); x = compute_bitfieldBitCountStep= 4>::call(x, static_cast::type>(0x3333333333333333ull), static_cast::type>( 2)); x = compute_bitfieldBitCountStep= 8>::call(x, static_cast::type>(0x0F0F0F0F0F0F0F0Full), static_cast::type>( 4)); x = compute_bitfieldBitCountStep= 16>::call(x, static_cast::type>(0x00FF00FF00FF00FFull), static_cast::type>( 8)); x = compute_bitfieldBitCountStep= 32>::call(x, static_cast::type>(0x0000FFFF0000FFFFull), static_cast::type>(16)); x = compute_bitfieldBitCountStep= 64>::call(x, static_cast::type>(0x00000000FFFFFFFFull), static_cast::type>(32)); return glm::vec(x); } template static int bitCount_bitfield(genType x) { return bitCount_bitfield(glm::vec<1, genType, glm::defaultp>(x)).x; } static int perf(std::size_t Size) { int Error(0); std::vector v; v.resize(Size); std::vector w; w.resize(Size); std::clock_t TimestampsA = std::clock(); // bitCount - TimeIf { for(std::size_t i = 0, n = v.size(); i < n; ++i) v[i] = bitCount_if(static_cast(i)); } std::clock_t TimestampsB = std::clock(); // bitCount - TimeVec { for(std::size_t i = 0, n = v.size(); i < n; ++i) v[i] = bitCount_vec(i); } std::clock_t TimestampsC = std::clock(); // bitCount - TimeDefault { for(std::size_t i = 0, n = v.size(); i < n; ++i) v[i] = glm::bitCount(i); } std::clock_t TimestampsD = std::clock(); // bitCount - TimeVec4 { for(std::size_t i = 0, n = v.size(); i < n; ++i) w[i] = glm::bitCount(glm::ivec4(static_cast(i))); } std::clock_t TimestampsE = std::clock(); { for(std::size_t i = 0, n = v.size(); i < n; ++i) v[i] = bitCount_bitfield(static_cast(i)); } std::clock_t TimestampsF = std::clock(); std::printf("bitCount - TimeIf %d\n", static_cast(TimestampsB - TimestampsA)); std::printf("bitCount - TimeVec %d\n", static_cast(TimestampsC - TimestampsB)); std::printf("bitCount - TimeDefault %d\n", static_cast(TimestampsD - TimestampsC)); std::printf("bitCount - TimeVec4 %d\n", static_cast(TimestampsE - TimestampsD)); std::printf("bitCount - bitfield %d\n", static_cast(TimestampsF - TimestampsE)); return Error; } static int test() { int Error(0); for(std::size_t i = 0, n = sizeof(DataI32) / sizeof(type); i < n; ++i) { int ResultA = glm::bitCount(DataI32[i].Value); int ResultB = bitCount_if(DataI32[i].Value); int ResultC = bitCount_vec(DataI32[i].Value); int ResultE = bitCount_bitfield(DataI32[i].Value); Error += DataI32[i].Return == ResultA ? 0 : 1; Error += DataI32[i].Return == ResultB ? 0 : 1; Error += DataI32[i].Return == ResultC ? 0 : 1; Error += DataI32[i].Return == ResultE ? 0 : 1; assert(!Error); } return Error; } }//bitCount int main() { int Error = 0; Error += ::bitCount::test(); Error += ::bitfieldReverse::test(); Error += ::findMSB::test(); Error += ::findLSB::test(); Error += ::umulExtended::test(); Error += ::imulExtended::test(); Error += ::uaddCarry::test(); Error += ::usubBorrow::test(); Error += ::bitfieldInsert::test(); Error += ::bitfieldExtract::test(); # ifdef NDEBUG std::size_t const Samples = 1000; # else std::size_t const Samples = 1; # endif ::bitCount::perf(Samples); ::bitfieldReverse::perf(Samples); ::findMSB::perf(Samples); ::findLSB::perf(Samples); return Error; } glm-0.9.9-a2/test/core/core_type_mat3x3.cpp0000600000175000001440000001035413173131001017276 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include #include #include #include void print(glm::dmat3 const& Mat0) { printf("mat3(\n"); printf("\tvec3(%2.3f, %2.3f, %2.3f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2]); printf("\tvec3(%2.3f, %2.3f, %2.3f)\n", Mat0[1][0], Mat0[1][1], Mat0[1][2]); printf("\tvec3(%2.3f, %2.3f, %2.3f))\n\n", Mat0[2][0], Mat0[2][1], Mat0[2][2]); } int test_mat3x3() { glm::dmat3 Mat0( glm::dvec3(0.6f, 0.2f, 0.3f), glm::dvec3(0.2f, 0.7f, 0.5f), glm::dvec3(0.3f, 0.5f, 0.7f)); glm::dmat3 Inv0 = glm::inverse(Mat0); glm::dmat3 Res0 = Mat0 * Inv0; print(Mat0); print(Inv0); print(Res0); return 0; } static int test_operators() { glm::mat3x3 l(1.0f); glm::mat3x3 m(1.0f); glm::vec3 u(1.0f); glm::vec3 v(1.0f); float x = 1.0f; glm::vec3 a = m * u; glm::vec3 b = v * m; glm::mat3x3 n = x / m; glm::mat3x3 o = m / x; glm::mat3x3 p = x * m; glm::mat3x3 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_inverse() { int Error(0); { glm::mat3 const Matrix( glm::vec3(0.6f, 0.2f, 0.3f), glm::vec3(0.2f, 0.7f, 0.5f), glm::vec3(0.3f, 0.5f, 0.7f)); glm::mat3 const Inverse = glm::inverse(Matrix); glm::mat3 const Identity = Matrix * Inverse; Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[2], glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.01f))) ? 0 : 1; } { glm::mat3 const Matrix( glm::vec3(0.6f, 0.2f, 0.3f), glm::vec3(0.2f, 0.7f, 0.5f), glm::vec3(0.3f, 0.5f, 0.7f)); glm::mat3 const Identity = Matrix / Matrix; Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[2], glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.01f))) ? 0 : 1; } return Error; } int test_ctr() { int Error(0); #if(GLM_HAS_INITIALIZER_LISTS) glm::mat3x3 m0( glm::vec3(0, 1, 2), glm::vec3(3, 4, 5), glm::vec3(6, 7, 8)); glm::mat3x3 m1{0, 1, 2, 3, 4, 5, 6, 7, 8}; glm::mat3x3 m2{ {0, 1, 2}, {3, 4, 5}, {6, 7, 8}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3, 4, 5, 6, 7, 8}, {0, 1, 2, 3, 4, 5, 6, 7, 8} }; std::vector v2{ { { 0, 1, 2}, { 3, 4, 5}, { 6, 7, 8} }, { { 0, 1, 2}, { 3, 4, 5}, { 6, 7, 8} } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat3x3 B(A); glm::mat3x3 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::equal(B[i], Identity[i])) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 36 == sizeof(glm::mat3x3) ? 0 : 1; Error += 72 == sizeof(glm::dmat3x3) ? 0 : 1; Error += glm::mat3x3().length() == 3 ? 0 : 1; Error += glm::dmat3x3().length() == 3 ? 0 : 1; Error += glm::mat3x3::length() == 3 ? 0 : 1; Error += glm::dmat3x3::length() == 3 ? 0 : 1; return Error; } int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_mat3x3(); Error += test_operators(); Error += test_inverse(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/core_type_mat2x2.cpp0000600000175000001440000000612513173131001017275 0ustar guususers#include #include #include #include #include #include #include #include #include #include #include #include #include int test_operators() { glm::mat2x2 l(1.0f); glm::mat2x2 m(1.0f); glm::vec2 u(1.0f); glm::vec2 v(1.0f); float x = 1.0f; glm::vec2 a = m * u; glm::vec2 b = v * m; glm::mat2x2 n = x / m; glm::mat2x2 o = m / x; glm::mat2x2 p = x * m; glm::mat2x2 q = m * x; bool R = m != q; bool S = m == l; return (S && !R) ? 0 : 1; } int test_inverse() { int Error(0); { glm::mat2 const Matrix(1, 2, 3, 4); glm::mat2 const Inverse = glm::inverse(Matrix); glm::mat2 const Identity = Matrix * Inverse; Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec2(1.0f, 0.0f), glm::vec2(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec2(0.0f, 1.0f), glm::vec2(0.01f))) ? 0 : 1; } { glm::mat2 const Matrix(1, 2, 3, 4); glm::mat2 const Identity = Matrix / Matrix; Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec2(1.0f, 0.0f), glm::vec2(0.01f))) ? 0 : 1; Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec2(0.0f, 1.0f), glm::vec2(0.01f))) ? 0 : 1; } return Error; } int test_ctr() { int Error(0); #if GLM_HAS_INITIALIZER_LISTS glm::mat2x2 m0( glm::vec2(0, 1), glm::vec2(2, 3)); glm::mat2x2 m1{0, 1, 2, 3}; glm::mat2x2 m2{ {0, 1}, {2, 3}}; for(glm::length_t i = 0; i < m0.length(); ++i) Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1; for(glm::length_t i = 0; i < m1.length(); ++i) Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1; std::vector v1{ {0, 1, 2, 3}, {0, 1, 2, 3} }; std::vector v2{ { { 0, 1}, { 4, 5} }, { { 0, 1}, { 4, 5} } }; #endif//GLM_HAS_INITIALIZER_LISTS return Error; } namespace cast { template int entry() { int Error = 0; genType A(1.0f); glm::mat2 B(A); glm::mat2 Identity(1.0f); for(glm::length_t i = 0, length = B.length(); i < length; ++i) Error += glm::all(glm::equal(B[i], Identity[i])) ? 0 : 1; return Error; } int test() { int Error = 0; Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); Error += entry(); return Error; } }//namespace cast int test_size() { int Error = 0; Error += 16 == sizeof(glm::mat2x2) ? 0 : 1; Error += 32 == sizeof(glm::dmat2x2) ? 0 : 1; Error += glm::mat2x2().length() == 2 ? 0 : 1; Error += glm::dmat2x2().length() == 2 ? 0 : 1; Error += glm::mat2x2::length() == 2 ? 0 : 1; Error += glm::dmat2x2::length() == 2 ? 0 : 1; return Error; } int main() { int Error(0); Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_inverse(); Error += test_size(); return Error; } glm-0.9.9-a2/test/core/CMakeLists.txt0000600000175000001440000000261113173131001016137 0ustar guususersglmCreateTestGTC(core_force_pure) glmCreateTestGTC(core_force_unrestricted_gentype) glmCreateTestGTC(core_type_aligned) glmCreateTestGTC(core_type_cast) glmCreateTestGTC(core_type_ctor) glmCreateTestGTC(core_type_float) glmCreateTestGTC(core_type_int) glmCreateTestGTC(core_type_length) glmCreateTestGTC(core_type_mat2x2) glmCreateTestGTC(core_type_mat2x3) glmCreateTestGTC(core_type_mat2x4) glmCreateTestGTC(core_type_mat3x2) glmCreateTestGTC(core_type_mat3x3) glmCreateTestGTC(core_type_mat3x4) glmCreateTestGTC(core_type_mat4x2) glmCreateTestGTC(core_type_mat4x3) glmCreateTestGTC(core_type_mat4x4) glmCreateTestGTC(core_type_vec1) glmCreateTestGTC(core_type_vec2) glmCreateTestGTC(core_type_vec3) glmCreateTestGTC(core_type_vec4) glmCreateTestGTC(core_func_common) glmCreateTestGTC(core_func_exponential) glmCreateTestGTC(core_func_geometric) glmCreateTestGTC(core_func_integer) glmCreateTestGTC(core_func_integer_bit_count) glmCreateTestGTC(core_func_integer_find_lsb) glmCreateTestGTC(core_func_integer_find_msb) glmCreateTestGTC(core_func_matrix) glmCreateTestGTC(core_func_noise) glmCreateTestGTC(core_func_packing) glmCreateTestGTC(core_func_trigonometric) glmCreateTestGTC(core_func_vector_relational) glmCreateTestGTC(core_func_swizzle) glmCreateTestGTC(core_setup_force_cxx98) glmCreateTestGTC(core_setup_force_size_t_length) glmCreateTestGTC(core_setup_message) glmCreateTestGTC(core_setup_precision) glm-0.9.9-a2/test/core/core_type_cast.cpp0000600000175000001440000000563313173131001017115 0ustar guususers#include #include #include #include struct my_vec2 { operator glm::vec2() { return glm::vec2(x, y); } float x, y; }; int test_vec2_cast() { glm::vec2 A(1.0f, 2.0f); glm::lowp_vec2 B(A); glm::mediump_vec2 C(A); glm::highp_vec2 D(A); glm::vec2 E = static_cast(A); glm::lowp_vec2 F = static_cast(A); glm::mediump_vec2 G = static_cast(A); glm::highp_vec2 H = static_cast(A); my_vec2 I; glm::vec2 J = static_cast(I); glm::vec2 K(7.8f); int Error(0); Error += glm::all(glm::equal(A, E)) ? 0 : 1; Error += glm::all(glm::equal(B, F)) ? 0 : 1; Error += glm::all(glm::equal(C, G)) ? 0 : 1; Error += glm::all(glm::equal(D, H)) ? 0 : 1; return Error; } int test_vec3_cast() { glm::vec3 A(1.0f, 2.0f, 3.0f); glm::lowp_vec3 B(A); glm::mediump_vec3 C(A); glm::highp_vec3 D(A); glm::vec3 E = static_cast(A); glm::lowp_vec3 F = static_cast(A); glm::mediump_vec3 G = static_cast(A); glm::highp_vec3 H = static_cast(A); int Error(0); Error += glm::all(glm::equal(A, E)) ? 0 : 1; Error += glm::all(glm::equal(B, F)) ? 0 : 1; Error += glm::all(glm::equal(C, G)) ? 0 : 1; Error += glm::all(glm::equal(D, H)) ? 0 : 1; return Error; } int test_vec4_cast() { glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); glm::lowp_vec4 B(A); glm::mediump_vec4 C(A); glm::highp_vec4 D(A); glm::vec4 E = static_cast(A); glm::lowp_vec4 F = static_cast(A); glm::mediump_vec4 G = static_cast(A); glm::highp_vec4 H = static_cast(A); int Error(0); Error += glm::all(glm::equal(A, E)) ? 0 : 1; Error += glm::all(glm::equal(B, F)) ? 0 : 1; Error += glm::all(glm::equal(C, G)) ? 0 : 1; Error += glm::all(glm::equal(D, H)) ? 0 : 1; return Error; } int test_std_copy() { int Error = 0; { std::vector High; High.resize(64); std::vector Medium(High.size()); std::copy(High.begin(), High.end(), Medium.begin()); *Medium.begin() = *High.begin(); } { std::vector High4; High4.resize(64); std::vector Medium4(High4.size()); std::copy(High4.begin(), High4.end(), Medium4.begin()); *Medium4.begin() = *High4.begin(); } { std::vector High3; High3.resize(64); std::vector Medium3(High3.size()); std::copy(High3.begin(), High3.end(), Medium3.begin()); *Medium3.begin() = *High3.begin(); } { std::vector High2; High2.resize(64); std::vector Medium2(High2.size()); std::copy(High2.begin(), High2.end(), Medium2.begin()); *Medium2.begin() = *High2.begin(); } glm::dvec4 v1; glm::vec4 v2; v2 = v1; return Error; } int main() { int Error = 0; Error += test_std_copy(); Error += test_vec2_cast(); Error += test_vec3_cast(); Error += test_vec4_cast(); return Error; } glm-0.9.9-a2/test/core/core_type_float.cpp0000600000175000001440000000102513173131001017257 0ustar guususers#include int test_float_size() { return sizeof(glm::float_t) != sizeof(glm::lowp_float) && sizeof(glm::float_t) != sizeof(glm::mediump_float) && sizeof(glm::float_t) != sizeof(glm::highp_float); } int test_float_precision() { return ( sizeof(glm::lowp_float) <= sizeof(glm::mediump_float) && sizeof(glm::mediump_float) <= sizeof(glm::highp_float)) ? 0 : 1; } int test_vec2() { return 0; } int main() { int Error = 0; Error += test_float_size(); Error += test_float_precision(); return Error; } glm-0.9.9-a2/test/ext/0000700000175000001440000000000013173131001013245 5ustar guususersglm-0.9.9-a2/test/ext/ext_vec1.cpp0000600000175000001440000000011413173131001015465 0ustar guususers#include int main() { int Error = 0; return Error; } glm-0.9.9-a2/test/ext/ext_vector_relational.cpp0000600000175000001440000000363713173131001020360 0ustar guususers#include #include int test_equal() { int Error = 0; Error += glm::equal(1.01f, 1.02f, 0.1f) ? 0 : 1; Error += glm::all(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), 0.1f)) ? 0 : 1; Error += glm::all(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.1f))) ? 0 : 1; Error += !glm::equal(1.01f, 1.02f, 0.001f) ? 0 : 1; Error += !glm::any(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), 0.001f)) ? 0 : 1; Error += !glm::any(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.001f))) ? 0 : 1; return Error; } int test_notEqual() { int Error = 0; Error += glm::notEqual(1.01f, 1.02f, 0.001f) ? 0 : 1; Error += glm::all(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), 0.001f)) ? 0 : 1; Error += glm::all(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.001f))) ? 0 : 1; Error += !glm::notEqual(1.01f, 1.02f, 0.1f) ? 0 : 1; Error += !glm::any(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), 0.1f)) ? 0 : 1; Error += !glm::any(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.1f))) ? 0 : 1; return Error; } int test_openBounded() { int Error = 0; Error += glm::all(glm::openBounded(glm::ivec2(2), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1; Error += !glm::all(glm::openBounded(glm::ivec2(1), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1; Error += !glm::all(glm::openBounded(glm::ivec2(3), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1; return Error; } int test_closeBounded() { int Error = 0; Error += glm::all(glm::closeBounded(glm::ivec2(2), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1; Error += glm::all(glm::closeBounded(glm::ivec2(1), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1; Error += glm::all(glm::closeBounded(glm::ivec2(3), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1; return Error; } int main() { int Error = 0; Error += test_equal(); Error += test_notEqual(); Error += test_openBounded(); Error += test_closeBounded(); return Error; } glm-0.9.9-a2/test/ext/CMakeLists.txt0000600000175000001440000000010313173131001016001 0ustar guususersglmCreateTestGTC(ext_vec1) glmCreateTestGTC(ext_vector_relational) glm-0.9.9-a2/test/CMakeLists.txt0000600000175000001440000000055113173131001015210 0ustar guususersfunction(glmCreateTestGTC NAME) if(GLM_TEST_ENABLE) set(SAMPLE_NAME test-${NAME}) add_executable(${SAMPLE_NAME} ${NAME}.cpp) add_test( NAME ${SAMPLE_NAME} COMMAND $ ) endif(GLM_TEST_ENABLE) endfunction() add_subdirectory(bug) add_subdirectory(core) add_subdirectory(ext) add_subdirectory(gtc) add_subdirectory(gtx) glm-0.9.9-a2/test/bug/0000700000175000001440000000000013173131001013222 5ustar guususersglm-0.9.9-a2/test/bug/CMakeLists.txt0000600000175000001440000000004413173131001015762 0ustar guususersglmCreateTestGTC(bug_ms_vec_static) glm-0.9.9-a2/test/bug/bug_ms_vec_static.cpp0000600000175000001440000000061313173131001017410 0ustar guususers#include #if GLM_HAS_ALIGNED_TYPE struct vec2; struct _swizzle { char _buffer[1]; }; struct vec2 { GLM_CONSTEXPR_CTOR vec2() : x(0), y(0) {} union { struct { float x, y; }; struct { _swizzle xx; }; }; }; #endif // Visual C++ has a bug generating the error: fatal error C1001: An internal error has occurred in the compiler. // vec2 Bar; int main() { return 0; } glm-0.9.9-a2/cmake/0000700000175000001440000000000013173131001012546 5ustar guususersglm-0.9.9-a2/cmake/CMakePackageConfigHelpers.cmake0000600000175000001440000002504213173131001020462 0ustar guususers# - CONFIGURE_PACKAGE_CONFIG_FILE(), WRITE_BASIC_PACKAGE_VERSION_FILE() # # CONFIGURE_PACKAGE_CONFIG_FILE( INSTALL_DESTINATION # [PATH_VARS ... ] # [NO_SET_AND_CHECK_MACRO] # [NO_CHECK_REQUIRED_COMPONENTS_MACRO]) # # CONFIGURE_PACKAGE_CONFIG_FILE() should be used instead of the plain # CONFIGURE_FILE() command when creating the Config.cmake or -config.cmake # file for installing a project or library. It helps making the resulting package # relocatable by avoiding hardcoded paths in the installed Config.cmake file. # # In a FooConfig.cmake file there may be code like this to make the # install destinations know to the using project: # set(FOO_INCLUDE_DIR "@CMAKE_INSTALL_FULL_INCLUDEDIR@" ) # set(FOO_DATA_DIR "@CMAKE_INSTALL_PREFIX@/@RELATIVE_DATA_INSTALL_DIR@" ) # set(FOO_ICONS_DIR "@CMAKE_INSTALL_PREFIX@/share/icons" ) # ...logic to determine installedPrefix from the own location... # set(FOO_CONFIG_DIR "${installedPrefix}/@CONFIG_INSTALL_DIR@" ) # All 4 options shown above are not sufficient, since the first 3 hardcode # the absolute directory locations, and the 4th case works only if the logic # to determine the installedPrefix is correct, and if CONFIG_INSTALL_DIR contains # a relative path, which in general cannot be guaranteed. # This has the effect that the resulting FooConfig.cmake file would work poorly # under Windows and OSX, where users are used to choose the install location # of a binary package at install time, independent from how CMAKE_INSTALL_PREFIX # was set at build/cmake time. # # Using CONFIGURE_PACKAGE_CONFIG_FILE() helps. If used correctly, it makes the # resulting FooConfig.cmake file relocatable. # Usage: # 1. write a FooConfig.cmake.in file as you are used to # 2. insert a line containing only the string "@PACKAGE_INIT@" # 3. instead of SET(FOO_DIR "@SOME_INSTALL_DIR@"), use SET(FOO_DIR "@PACKAGE_SOME_INSTALL_DIR@") # (this must be after the @PACKAGE_INIT@ line) # 4. instead of using the normal CONFIGURE_FILE(), use CONFIGURE_PACKAGE_CONFIG_FILE() # # The and arguments are the input and output file, the same way # as in CONFIGURE_FILE(). # # The given to INSTALL_DESTINATION must be the destination where the FooConfig.cmake # file will be installed to. This can either be a relative or absolute path, both work. # # The variables to given as PATH_VARS are the variables which contain # install destinations. For each of them the macro will create a helper variable # PACKAGE_. These helper variables must be used # in the FooConfig.cmake.in file for setting the installed location. They are calculated # by CONFIGURE_PACKAGE_CONFIG_FILE() so that they are always relative to the # installed location of the package. This works both for relative and also for absolute locations. # For absolute locations it works only if the absolute location is a subdirectory # of CMAKE_INSTALL_PREFIX. # # By default configure_package_config_file() also generates two helper macros, # set_and_check() and check_required_components() into the FooConfig.cmake file. # # set_and_check() should be used instead of the normal set() # command for setting directories and file locations. Additionally to setting the # variable it also checks that the referenced file or directory actually exists # and fails with a FATAL_ERROR otherwise. This makes sure that the created # FooConfig.cmake file does not contain wrong references. # When using the NO_SET_AND_CHECK_MACRO, this macro is not generated into the # FooConfig.cmake file. # # check_required_components() should be called at the end of the # FooConfig.cmake file if the package supports components. # This macro checks whether all requested, non-optional components have been found, # and if this is not the case, sets the Foo_FOUND variable to FALSE, so that the package # is considered to be not found. # It does that by testing the Foo__FOUND variables for all requested # required components. # When using the NO_CHECK_REQUIRED_COMPONENTS option, this macro is not generated # into the FooConfig.cmake file. # # For an example see below the documentation for WRITE_BASIC_PACKAGE_VERSION_FILE(). # # # WRITE_BASIC_PACKAGE_VERSION_FILE( filename VERSION major.minor.patch COMPATIBILITY (AnyNewerVersion|SameMajorVersion|ExactVersion) ) # # Writes a file for use as ConfigVersion.cmake file to . # See the documentation of FIND_PACKAGE() for details on this. # filename is the output filename, it should be in the build tree. # major.minor.patch is the version number of the project to be installed # The COMPATIBILITY mode AnyNewerVersion means that the installed package version # will be considered compatible if it is newer or exactly the same as the requested version. # This mode should be used for packages which are fully backward compatible, # also across major versions. # If SameMajorVersion is used instead, then the behaviour differs from AnyNewerVersion # in that the major version number must be the same as requested, e.g. version 2.0 will # not be considered compatible if 1.0 is requested. # This mode should be used for packages which guarantee backward compatibility within the # same major version. # If ExactVersion is used, then the package is only considered compatible if the requested # version matches exactly its own version number (not considering the tweak version). # For example, version 1.2.3 of a package is only considered compatible to requested version 1.2.3. # This mode is for packages without compatibility guarantees. # If your project has more elaborated version matching rules, you will need to write your # own custom ConfigVersion.cmake file instead of using this macro. # # Internally, this macro executes configure_file() to create the resulting # version file. Depending on the COMPATIBILITY, either the file # BasicConfigVersion-SameMajorVersion.cmake.in or BasicConfigVersion-AnyNewerVersion.cmake.in # is used. Please note that these two files are internal to CMake and you should # not call configure_file() on them yourself, but they can be used as starting # point to create more sophisticted custom ConfigVersion.cmake files. # # # Example using both configure_package_config_file() and write_basic_package_version_file(): # CMakeLists.txt: # set(INCLUDE_INSTALL_DIR include/ ... CACHE ) # set(LIB_INSTALL_DIR lib/ ... CACHE ) # set(SYSCONFIG_INSTALL_DIR etc/foo/ ... CACHE ) # ... # include(CMakePackageConfigHelpers) # configure_package_config_file(FooConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake # INSTALL_DESTINATION ${LIB_INSTALL_DIR}/Foo/cmake # PATH_VARS INCLUDE_INSTALL_DIR SYSCONFIG_INSTALL_DIR) # write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake # VERSION 1.2.3 # COMPATIBILITY SameMajorVersion ) # install(FILES ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake # DESTINATION ${LIB_INSTALL_DIR}/Foo/cmake ) # # With a FooConfig.cmake.in: # set(FOO_VERSION x.y.z) # ... # @PACKAGE_INIT@ # ... # set_and_check(FOO_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@") # set_and_check(FOO_SYSCONFIG_DIR "@PACKAGE_SYSCONFIG_INSTALL_DIR@") # # check_required_components(Foo) #============================================================================= # Copyright 2012 Alexander Neundorf # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) include(CMakeParseArguments) include(WriteBasicConfigVersionFile) macro(WRITE_BASIC_PACKAGE_VERSION_FILE) write_basic_config_version_file(${ARGN}) endmacro() function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile) set(options NO_SET_AND_CHECK_MACRO NO_CHECK_REQUIRED_COMPONENTS_MACRO) set(oneValueArgs INSTALL_DESTINATION ) set(multiValueArgs PATH_VARS ) cmake_parse_arguments(CCF "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) if(CCF_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to CONFIGURE_PACKAGE_CONFIG_FILE(): \"${CCF_UNPARSED_ARGUMENTS}\"") endif() if(NOT CCF_INSTALL_DESTINATION) message(FATAL_ERROR "No INSTALL_DESTINATION given to CONFIGURE_PACKAGE_CONFIG_FILE()") endif() if(IS_ABSOLUTE "${CCF_INSTALL_DESTINATION}") set(absInstallDir "${CCF_INSTALL_DESTINATION}") else() set(absInstallDir "${CMAKE_INSTALL_PREFIX}/${CCF_INSTALL_DESTINATION}") endif() file(RELATIVE_PATH PACKAGE_RELATIVE_PATH "${absInstallDir}" "${CMAKE_INSTALL_PREFIX}" ) foreach(var ${CCF_PATH_VARS}) if(NOT DEFINED ${var}) message(FATAL_ERROR "Variable ${var} does not exist") else() if(IS_ABSOLUTE "${${var}}") string(REPLACE "${CMAKE_INSTALL_PREFIX}" "\${PACKAGE_PREFIX_DIR}" PACKAGE_${var} "${${var}}") else() set(PACKAGE_${var} "\${PACKAGE_PREFIX_DIR}/${${var}}") endif() endif() endforeach() set(PACKAGE_INIT " ####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### get_filename_component(PACKAGE_PREFIX_DIR \"\${CMAKE_CURRENT_LIST_DIR}/${PACKAGE_RELATIVE_PATH}\" ABSOLUTE) ") if(NOT CCF_NO_SET_AND_CHECK_MACRO) set(PACKAGE_INIT "${PACKAGE_INIT} macro(set_and_check _var _file) set(\${_var} \"\${_file}\") if(NOT EXISTS \"\${_file}\") message(FATAL_ERROR \"File or directory \${_file} referenced by variable \${_var} does not exist !\") endif() endmacro() ") endif() if(NOT CCF_NO_CHECK_REQUIRED_COMPONENTS_MACRO) set(PACKAGE_INIT "${PACKAGE_INIT} macro(check_required_components _NAME) foreach(comp \${\${_NAME}_FIND_COMPONENTS}) if(NOT \${_NAME}_\${comp}_FOUND) if(\${_NAME}_FIND_REQUIRED_\${comp}) set(\${_NAME}_FOUND FALSE) endif() endif() endforeach(comp) endmacro() ") endif() set(PACKAGE_INIT "${PACKAGE_INIT} ####################################################################################") configure_file("${_inputFile}" "${_outputFile}" @ONLY) endfunction() glm-0.9.9-a2/cmake/glm.pc.in0000600000175000001440000000022513173131001014257 0ustar guususersprefix=@CMAKE_INSTALL_PREFIX@ includedir=${prefix}/include Name: GLM Description: OpenGL Mathematics Version: @GLM_VERSION@ Cflags: -I${includedir} glm-0.9.9-a2/cmake/glmConfig.cmake.in0000600000175000001440000000034413173131001016065 0ustar guususersset(GLM_VERSION "@GLM_VERSION@") @PACKAGE_INIT@ set_and_check(GLM_INCLUDE_DIRS "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@") if (NOT CMAKE_VERSION VERSION_LESS "3.0") include("${CMAKE_CURRENT_LIST_DIR}/glmTargets.cmake") endif() glm-0.9.9-a2/cmake/GNUInstallDirs.cmake0000600000175000001440000001634513173131001016365 0ustar guususers# - Define GNU standard installation directories # Provides install directory variables as defined for GNU software: # http://www.gnu.org/prep/standards/html_node/Directory-Variables.html # Inclusion of this module defines the following variables: # CMAKE_INSTALL_ - destination for files of a given type # CMAKE_INSTALL_FULL_ - corresponding absolute path # where is one of: # BINDIR - user executables (bin) # SBINDIR - system admin executables (sbin) # LIBEXECDIR - program executables (libexec) # SYSCONFDIR - read-only single-machine data (etc) # SHAREDSTATEDIR - modifiable architecture-independent data (com) # LOCALSTATEDIR - modifiable single-machine data (var) # LIBDIR - object code libraries (lib or lib64 or lib/ on Debian) # INCLUDEDIR - C header files (include) # OLDINCLUDEDIR - C header files for non-gcc (/usr/include) # DATAROOTDIR - read-only architecture-independent data root (share) # DATADIR - read-only architecture-independent data (DATAROOTDIR) # INFODIR - info documentation (DATAROOTDIR/info) # LOCALEDIR - locale-dependent data (DATAROOTDIR/locale) # MANDIR - man documentation (DATAROOTDIR/man) # DOCDIR - documentation root (DATAROOTDIR/doc/PROJECT_NAME) # Each CMAKE_INSTALL_ value may be passed to the DESTINATION options of # install() commands for the corresponding file type. If the includer does # not define a value the above-shown default will be used and the value will # appear in the cache for editing by the user. # Each CMAKE_INSTALL_FULL_ value contains an absolute path constructed # from the corresponding destination by prepending (if necessary) the value # of CMAKE_INSTALL_PREFIX. #============================================================================= # Copyright 2011 Nikita Krupen'ko # Copyright 2011 Kitware, Inc. # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) # Installation directories # if(NOT DEFINED CMAKE_INSTALL_BINDIR) set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "user executables (bin)") endif() if(NOT DEFINED CMAKE_INSTALL_SBINDIR) set(CMAKE_INSTALL_SBINDIR "sbin" CACHE PATH "system admin executables (sbin)") endif() if(NOT DEFINED CMAKE_INSTALL_LIBEXECDIR) set(CMAKE_INSTALL_LIBEXECDIR "libexec" CACHE PATH "program executables (libexec)") endif() if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR) set(CMAKE_INSTALL_SYSCONFDIR "etc" CACHE PATH "read-only single-machine data (etc)") endif() if(NOT DEFINED CMAKE_INSTALL_SHAREDSTATEDIR) set(CMAKE_INSTALL_SHAREDSTATEDIR "com" CACHE PATH "modifiable architecture-independent data (com)") endif() if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR) set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)") endif() if(NOT DEFINED CMAKE_INSTALL_LIBDIR) set(_LIBDIR_DEFAULT "lib") # Override this default 'lib' with 'lib64' iff: # - we are on Linux system but NOT cross-compiling # - we are NOT on debian # - we are on a 64 bits system # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf # For Debian with multiarch, use 'lib/${CMAKE_LIBRARY_ARCHITECTURE}' if # CMAKE_LIBRARY_ARCHITECTURE is set (which contains e.g. "i386-linux-gnu" # See http://wiki.debian.org/Multiarch if((CMAKE_SYSTEM_NAME MATCHES "Linux|kFreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "GNU") AND NOT CMAKE_CROSSCOMPILING) if (EXISTS "/etc/debian_version") # is this a debian system ? if(CMAKE_LIBRARY_ARCHITECTURE) set(_LIBDIR_DEFAULT "lib/${CMAKE_LIBRARY_ARCHITECTURE}") endif() else() # not debian, rely on CMAKE_SIZEOF_VOID_P: if(NOT DEFINED CMAKE_SIZEOF_VOID_P) message(AUTHOR_WARNING "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. " "Please enable at least one language before including GNUInstallDirs.") else() if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") set(_LIBDIR_DEFAULT "lib64") endif() endif() endif() endif() set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})") endif() if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR) set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)") endif() if(NOT DEFINED CMAKE_INSTALL_OLDINCLUDEDIR) set(CMAKE_INSTALL_OLDINCLUDEDIR "/usr/include" CACHE PATH "C header files for non-gcc (/usr/include)") endif() if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR) set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE PATH "read-only architecture-independent data root (share)") endif() #----------------------------------------------------------------------------- # Values whose defaults are relative to DATAROOTDIR. Store empty values in # the cache and store the defaults in local variables if the cache values are # not set explicitly. This auto-updates the defaults as DATAROOTDIR changes. if(NOT CMAKE_INSTALL_DATADIR) set(CMAKE_INSTALL_DATADIR "" CACHE PATH "read-only architecture-independent data (DATAROOTDIR)") set(CMAKE_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}") endif() if(NOT CMAKE_INSTALL_INFODIR) set(CMAKE_INSTALL_INFODIR "" CACHE PATH "info documentation (DATAROOTDIR/info)") set(CMAKE_INSTALL_INFODIR "${CMAKE_INSTALL_DATAROOTDIR}/info") endif() if(NOT CMAKE_INSTALL_LOCALEDIR) set(CMAKE_INSTALL_LOCALEDIR "" CACHE PATH "locale-dependent data (DATAROOTDIR/locale)") set(CMAKE_INSTALL_LOCALEDIR "${CMAKE_INSTALL_DATAROOTDIR}/locale") endif() if(NOT CMAKE_INSTALL_MANDIR) set(CMAKE_INSTALL_MANDIR "" CACHE PATH "man documentation (DATAROOTDIR/man)") set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man") endif() if(NOT CMAKE_INSTALL_DOCDIR) set(CMAKE_INSTALL_DOCDIR "" CACHE PATH "documentation root (DATAROOTDIR/doc/PROJECT_NAME)") set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}") endif() #----------------------------------------------------------------------------- mark_as_advanced( CMAKE_INSTALL_BINDIR CMAKE_INSTALL_SBINDIR CMAKE_INSTALL_LIBEXECDIR CMAKE_INSTALL_SYSCONFDIR CMAKE_INSTALL_SHAREDSTATEDIR CMAKE_INSTALL_LOCALSTATEDIR CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_OLDINCLUDEDIR CMAKE_INSTALL_DATAROOTDIR CMAKE_INSTALL_DATADIR CMAKE_INSTALL_INFODIR CMAKE_INSTALL_LOCALEDIR CMAKE_INSTALL_MANDIR CMAKE_INSTALL_DOCDIR ) # Result directories # foreach(dir BINDIR SBINDIR LIBEXECDIR SYSCONFDIR SHAREDSTATEDIR LOCALSTATEDIR LIBDIR INCLUDEDIR OLDINCLUDEDIR DATAROOTDIR DATADIR INFODIR LOCALEDIR MANDIR DOCDIR ) if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_${dir}}) set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${dir}}") else() set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_${dir}}") endif() endforeach() glm-0.9.9-a2/cmake/glmBuildConfig.cmake.in0000600000175000001440000000030113173131001017036 0ustar guususersset(GLM_VERSION "@GLM_VERSION@") set(GLM_INCLUDE_DIRS "@CMAKE_CURRENT_SOURCE_DIR@") if (NOT CMAKE_VERSION VERSION_LESS "3.0") include("${CMAKE_CURRENT_LIST_DIR}/glmTargets.cmake") endif() glm-0.9.9-a2/.gitignore0000600000175000001440000000103113173131001013453 0ustar guususers# Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app # CMake CMakeCache.txt CMakeFiles cmake_install.cmake install_manifest.txt *.cmake # ^ May need to add future .cmake files as exceptions # Test logs Testing/* # Test input test/gtc/*.dds # Project Files Makefile *.cbp *.user # Misc. *.log # local build(s) build* /.vs /CMakeSettings.json glm-0.9.9-a2/glm/0000700000175000001440000000000013173131001012245 5ustar guususersglm-0.9.9-a2/glm/mat2x4.hpp0000600000175000001440000000300313173131001014073 0ustar guususers/// @ref core /// @file glm/mat2x4.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat2x4.hpp" namespace glm { /// 2 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, lowp> lowp_mat2x4; /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, mediump> mediump_mat2x4; /// 2 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, highp> highp_mat2x4; }//namespace glm glm-0.9.9-a2/glm/gtx/0000700000175000001440000000000013173131001013047 5ustar guususersglm-0.9.9-a2/glm/gtx/texture.hpp0000600000175000001440000000240013173131001015256 0ustar guususers/// @ref gtx_texture /// @file glm/gtx/texture.hpp /// /// @see core (dependence) /// /// @defgroup gtx_texture GLM_GTX_texture /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Wrapping mode of texture coordinates. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/integer.hpp" #include "../gtx/component_wise.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_texture is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_texture extension included") #endif namespace glm { /// @addtogroup gtx_texture /// @{ /// Compute the number of mipmaps levels necessary to create a mipmap complete texture /// /// @param Extent Extent of the texture base level mipmap /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum template T levels(vec const& Extent); /// @} }// namespace glm #include "texture.inl" glm-0.9.9-a2/glm/gtx/rotate_vector.inl0000600000175000001440000000740213173131001016440 0ustar guususers/// @ref gtx_rotate_vector /// @file glm/gtx/rotate_vector.inl namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> slerp ( vec<3, T, Q> const& x, vec<3, T, Q> const& y, T const& a ) { // get cosine of angle between vectors (-1 -> 1) T CosAlpha = dot(x, y); // get angle (0 -> pi) T Alpha = acos(CosAlpha); // get sine of angle between vectors (0 -> 1) T SinAlpha = sin(Alpha); // this breaks down when SinAlpha = 0, i.e. Alpha = 0 or pi T t1 = sin((static_cast(1) - a) * Alpha) / SinAlpha; T t2 = sin(a * Alpha) / SinAlpha; // interpolate src vectors return x * t1 + y * t2; } template GLM_FUNC_QUALIFIER vec<2, T, Q> rotate ( vec<2, T, Q> const& v, T const& angle ) { vec<2, T, Q> Result; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos - v.y * Sin; Result.y = v.x * Sin + v.y * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotate ( vec<3, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal ) { return mat<3, 3, T, Q>(glm::rotate(angle, normal)) * v; } /* template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateGTX( const vec<3, T, Q>& x, T angle, const vec<3, T, Q>& normal) { const T Cos = cos(radians(angle)); const T Sin = sin(radians(angle)); return x * Cos + ((x * normal) * (T(1) - Cos)) * normal + cross(x, normal) * Sin; } */ template GLM_FUNC_QUALIFIER vec<4, T, Q> rotate ( vec<4, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal ) { return rotate(angle, normal) * v; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateX ( vec<3, T, Q> const& v, T const& angle ) { vec<3, T, Q> Result(v); T const Cos(cos(angle)); T const Sin(sin(angle)); Result.y = v.y * Cos - v.z * Sin; Result.z = v.y * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateY ( vec<3, T, Q> const& v, T const& angle ) { vec<3, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos + v.z * Sin; Result.z = -v.x * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotateZ ( vec<3, T, Q> const& v, T const& angle ) { vec<3, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos - v.y * Sin; Result.y = v.x * Sin + v.y * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotateX ( vec<4, T, Q> const& v, T const& angle ) { vec<4, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.y = v.y * Cos - v.z * Sin; Result.z = v.y * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotateY ( vec<4, T, Q> const& v, T const& angle ) { vec<4, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos + v.z * Sin; Result.z = -v.x * Sin + v.z * Cos; return Result; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotateZ ( vec<4, T, Q> const& v, T const& angle ) { vec<4, T, Q> Result = v; T const Cos(cos(angle)); T const Sin(sin(angle)); Result.x = v.x * Cos - v.y * Sin; Result.y = v.x * Sin + v.y * Cos; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> orientation ( vec<3, T, Q> const& Normal, vec<3, T, Q> const& Up ) { if(all(equal(Normal, Up))) return mat<4, 4, T, Q>(T(1)); vec<3, T, Q> RotationAxis = cross(Up, Normal); T Angle = acos(dot(Normal, Up)); return rotate(Angle, RotationAxis); } }//namespace glm glm-0.9.9-a2/glm/gtx/handed_coordinate_space.inl0000600000175000001440000000110313173131001020355 0ustar guususers/// @ref gtx_handed_coordinate_space /// @file glm/gtx/handed_coordinate_space.inl namespace glm { template GLM_FUNC_QUALIFIER bool rightHanded ( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal ) { return dot(cross(normal, tangent), binormal) > T(0); } template GLM_FUNC_QUALIFIER bool leftHanded ( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal ) { return dot(cross(normal, tangent), binormal) < T(0); } }//namespace glm glm-0.9.9-a2/glm/gtx/float_notmalize.inl0000600000175000001440000000051313173131001016743 0ustar guususers/// @ref gtx_float_normalize /// @file glm/gtx/float_normalize.inl #include namespace glm { template GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) { return vec(v) / static_cast(std::numeric_limits::max()); } }//namespace glm glm-0.9.9-a2/glm/gtx/dual_quaternion.hpp0000600000175000001440000002234713173131001016764 0ustar guususers/// @ref gtx_dual_quaternion /// @file glm/gtx/dual_quaternion.hpp /// @author Maksim Vorobiev (msomeone@gmail.com) /// /// @see core (dependence) /// @see gtc_constants (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_dual_quaternion GLM_GTX_dual_quaternion /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines a templated dual-quaternion type and several dual-quaternion operations. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/constants.hpp" #include "../gtc/quaternion.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_dual_quaternion is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_dual_quaternion extension included") #endif namespace glm { /// @addtogroup gtx_dual_quaternion /// @{ template struct tdualquat { // -- Implementation detail -- typedef T value_type; typedef glm::tquat part_type; // -- Data -- glm::tquat real, dual; // -- Component accesses -- typedef length_t length_type; /// Return the count of components of a dual quaternion GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;} GLM_FUNC_DECL part_type & operator[](length_type i); GLM_FUNC_DECL part_type const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR tdualquat() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const& d) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const& d); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat const& real); GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat const& orientation, vec<3, T, Q> const& translation); GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat const& real, tquat const& dual); // -- Conversion constructors -- template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tdualquat(tdualquat const& q); GLM_FUNC_DECL GLM_EXPLICIT tdualquat(mat<2, 4, T, Q> const& holder_mat); GLM_FUNC_DECL GLM_EXPLICIT tdualquat(mat<3, 4, T, Q> const& aug_mat); // -- Unary arithmetic operators -- GLM_FUNC_DECL tdualquat & operator=(tdualquat const& m) GLM_DEFAULT; template GLM_FUNC_DECL tdualquat & operator=(tdualquat const& m); template GLM_FUNC_DECL tdualquat & operator*=(U s); template GLM_FUNC_DECL tdualquat & operator/=(U s); }; // -- Unary bit operators -- template GLM_FUNC_DECL tdualquat operator+(tdualquat const& q); template GLM_FUNC_DECL tdualquat operator-(tdualquat const& q); // -- Binary operators -- template GLM_FUNC_DECL tdualquat operator+(tdualquat const& q, tdualquat const& p); template GLM_FUNC_DECL tdualquat operator*(tdualquat const& q, tdualquat const& p); template GLM_FUNC_DECL vec<3, T, Q> operator*(tdualquat const& q, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v, tdualquat const& q); template GLM_FUNC_DECL vec<4, T, Q> operator*(tdualquat const& q, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v, tdualquat const& q); template GLM_FUNC_DECL tdualquat operator*(tdualquat const& q, T const& s); template GLM_FUNC_DECL tdualquat operator*(T const& s, tdualquat const& q); template GLM_FUNC_DECL tdualquat operator/(tdualquat const& q, T const& s); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(tdualquat const& q1, tdualquat const& q2); template GLM_FUNC_DECL bool operator!=(tdualquat const& q1, tdualquat const& q2); /// Creates an identity dual quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat dual_quat_identity(); /// Returns the normalized quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat normalize(tdualquat const& q); /// Returns the linear interpolation of two dual quaternion. /// /// @see gtc_dual_quaternion template GLM_FUNC_DECL tdualquat lerp(tdualquat const& x, tdualquat const& y, T const& a); /// Returns the q inverse. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat inverse(tdualquat const& q); /// Converts a quaternion to a 2 * 4 matrix. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL mat<2, 4, T, Q> mat2x4_cast(tdualquat const& x); /// Converts a quaternion to a 3 * 4 matrix. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL mat<3, 4, T, Q> mat3x4_cast(tdualquat const& x); /// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat dualquat_cast(mat<2, 4, T, Q> const& x); /// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion. /// /// @see gtx_dual_quaternion template GLM_FUNC_DECL tdualquat dualquat_cast(mat<3, 4, T, Q> const& x); /// Dual-quaternion of low single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_dualquat; /// Dual-quaternion of medium single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_dualquat; /// Dual-quaternion of high single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_dualquat; /// Dual-quaternion of low single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_fdualquat; /// Dual-quaternion of medium single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_fdualquat; /// Dual-quaternion of high single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_fdualquat; /// Dual-quaternion of low double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_ddualquat; /// Dual-quaternion of medium double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_ddualquat; /// Dual-quaternion of high double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_ddualquat; #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) /// Dual-quaternion of floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_fdualquat dualquat; /// Dual-quaternion of single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_fdualquat fdualquat; #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef highp_fdualquat dualquat; typedef highp_fdualquat fdualquat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef mediump_fdualquat dualquat; typedef mediump_fdualquat fdualquat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_fdualquat dualquat; typedef lowp_fdualquat fdualquat; #else # error "GLM error: multiple default precision requested for single-precision floating-point types" #endif #if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) /// Dual-quaternion of default double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_ddualquat ddualquat; #elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) typedef highp_ddualquat ddualquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) typedef mediump_ddualquat ddualquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_ddualquat ddualquat; #else # error "GLM error: Multiple default precision requested for double-precision floating-point types" #endif /// @} } //namespace glm #include "dual_quaternion.inl" glm-0.9.9-a2/glm/gtx/matrix_interpolation.inl0000600000175000001440000001045313173131001020033 0ustar guususers/// @ref gtx_matrix_interpolation /// @file glm/gtx/matrix_interpolation.hpp #include "../gtc/constants.hpp" namespace glm { template GLM_FUNC_QUALIFIER void axisAngle(mat<4, 4, T, Q> const& mat, vec<3, T, Q> & axis, T & angle) { T epsilon = static_cast(0.01); T epsilon2 = static_cast(0.1); if((abs(mat[1][0] - mat[0][1]) < epsilon) && (abs(mat[2][0] - mat[0][2]) < epsilon) && (abs(mat[2][1] - mat[1][2]) < epsilon)) { if ((abs(mat[1][0] + mat[0][1]) < epsilon2) && (abs(mat[2][0] + mat[0][2]) < epsilon2) && (abs(mat[2][1] + mat[1][2]) < epsilon2) && (abs(mat[0][0] + mat[1][1] + mat[2][2] - static_cast(3.0)) < epsilon2)) { angle = static_cast(0.0); axis.x = static_cast(1.0); axis.y = static_cast(0.0); axis.z = static_cast(0.0); return; } angle = static_cast(3.1415926535897932384626433832795); T xx = (mat[0][0] + static_cast(1.0)) * static_cast(0.5); T yy = (mat[1][1] + static_cast(1.0)) * static_cast(0.5); T zz = (mat[2][2] + static_cast(1.0)) * static_cast(0.5); T xy = (mat[1][0] + mat[0][1]) * static_cast(0.25); T xz = (mat[2][0] + mat[0][2]) * static_cast(0.25); T yz = (mat[2][1] + mat[1][2]) * static_cast(0.25); if((xx > yy) && (xx > zz)) { if(xx < epsilon) { axis.x = static_cast(0.0); axis.y = static_cast(0.7071); axis.z = static_cast(0.7071); } else { axis.x = sqrt(xx); axis.y = xy / axis.x; axis.z = xz / axis.x; } } else if (yy > zz) { if(yy < epsilon) { axis.x = static_cast(0.7071); axis.y = static_cast(0.0); axis.z = static_cast(0.7071); } else { axis.y = sqrt(yy); axis.x = xy / axis.y; axis.z = yz / axis.y; } } else { if (zz < epsilon) { axis.x = static_cast(0.7071); axis.y = static_cast(0.7071); axis.z = static_cast(0.0); } else { axis.z = sqrt(zz); axis.x = xz / axis.z; axis.y = yz / axis.z; } } return; } T s = sqrt((mat[2][1] - mat[1][2]) * (mat[2][1] - mat[1][2]) + (mat[2][0] - mat[0][2]) * (mat[2][0] - mat[0][2]) + (mat[1][0] - mat[0][1]) * (mat[1][0] - mat[0][1])); if (glm::abs(s) < T(0.001)) s = static_cast(1); T const angleCos = (mat[0][0] + mat[1][1] + mat[2][2] - static_cast(1)) * static_cast(0.5); if(angleCos - static_cast(1) < epsilon) angle = pi() * static_cast(0.25); else angle = acos(angleCos); axis.x = (mat[1][2] - mat[2][1]) / s; axis.y = (mat[2][0] - mat[0][2]) / s; axis.z = (mat[0][1] - mat[1][0]) / s; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> axisAngleMatrix(vec<3, T, Q> const& axis, T const angle) { T c = cos(angle); T s = sin(angle); T t = static_cast(1) - c; vec<3, T, Q> n = normalize(axis); return mat<4, 4, T, Q>( t * n.x * n.x + c, t * n.x * n.y + n.z * s, t * n.x * n.z - n.y * s, static_cast(0.0), t * n.x * n.y - n.z * s, t * n.y * n.y + c, t * n.y * n.z + n.x * s, static_cast(0.0), t * n.x * n.z + n.y * s, t * n.y * n.z - n.x * s, t * n.z * n.z + c, static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(1.0)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> extractMatrixRotation(mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( m[0][0], m[0][1], m[0][2], static_cast(0.0), m[1][0], m[1][1], m[1][2], static_cast(0.0), m[2][0], m[2][1], m[2][2], static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(1.0)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> interpolate(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2, T const delta) { mat<4, 4, T, Q> m1rot = extractMatrixRotation(m1); mat<4, 4, T, Q> dltRotation = m2 * transpose(m1rot); vec<3, T, Q> dltAxis; T dltAngle; axisAngle(dltRotation, dltAxis, dltAngle); mat<4, 4, T, Q> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot; out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]); out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]); out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]); return out; } }//namespace glm glm-0.9.9-a2/glm/gtx/log_base.inl0000600000175000001440000000075013173131001015332 0ustar guususers/// @ref gtx_log_base /// @file glm/gtx/log_base.inl namespace glm { template GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) { assert(!detail::compute_equal::call(x, static_cast(0))); return glm::log(x) / glm::log(base); } template GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) { return glm::log(x) / glm::log(base); } }//namespace glm glm-0.9.9-a2/glm/gtx/common.hpp0000600000175000001440000000374413173131001015062 0ustar guususers/// @ref gtx_common /// @file glm/gtx/common.hpp /// /// @see core (dependence) /// /// @defgroup gtx_common GLM_GTX_common /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Provide functions to increase the compatibility with Cg and HLSL languages #pragma once // Dependencies: #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../gtc/vec1.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_common is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_common extension included") #endif namespace glm { /// @addtogroup gtx_common /// @{ /// Returns true if x is a denormalized number /// Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format. /// This format is less precise but can represent values closer to zero. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL isnan man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const& x); /// Similar to 'mod' but with a different rounding and integer support. /// Returns 'x - y * trunc(x/y)' instead of 'x - y * floor(x/y)' /// /// @see GLSL mod vs HLSL fmod /// @see GLSL mod man page template GLM_FUNC_DECL vec fmod(vec const& v); /// @} }//namespace glm #include "common.inl" glm-0.9.9-a2/glm/gtx/fast_exponential.hpp0000600000175000001440000000604413173131001017131 0ustar guususers/// @ref gtx_fast_exponential /// @file glm/gtx/fast_exponential.hpp /// /// @see core (dependence) /// @see gtx_half_float (dependence) /// /// @defgroup gtx_fast_exponential GLM_GTX_fast_exponential /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Fast but less accurate implementations of exponential based functions. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_fast_exponential is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_fast_exponential extension included") #endif namespace glm { /// @addtogroup gtx_fast_exponential /// @{ /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL genType fastPow(genType x, genType y); /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastPow(vec const& x, vec const& y); /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y); /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastPow(vec const& x); /// Faster than the common exp function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastExp(T x); /// Faster than the common exp function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastExp(vec const& x); /// Faster than the common log function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastLog(T x); /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastLog(vec const& x); /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastExp2(T x); /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastExp2(vec const& x); /// Faster than the common log2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL T fastLog2(T x); /// Faster than the common log2 function but less accurate. /// @see gtx_fast_exponential template GLM_FUNC_DECL vec fastLog2(vec const& x); /// @} }//namespace glm #include "fast_exponential.inl" glm-0.9.9-a2/glm/gtx/matrix_major_storage.inl0000600000175000001440000000721213173131001017777 0ustar guususers/// @ref gtx_matrix_major_storage /// @file glm/gtx/matrix_major_storage.hpp namespace glm { template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> rowMajor2 ( vec<2, T, Q> const& v1, vec<2, T, Q> const& v2 ) { mat<2, 2, T, Q> Result; Result[0][0] = v1.x; Result[1][0] = v1.y; Result[0][1] = v2.x; Result[1][1] = v2.y; return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> rowMajor2( const mat<2, 2, T, Q>& m) { mat<2, 2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rowMajor3( const vec<3, T, Q>& v1, const vec<3, T, Q>& v2, const vec<3, T, Q>& v3) { mat<3, 3, T, Q> Result; Result[0][0] = v1.x; Result[1][0] = v1.y; Result[2][0] = v1.z; Result[0][1] = v2.x; Result[1][1] = v2.y; Result[2][1] = v2.z; Result[0][2] = v3.x; Result[1][2] = v3.y; Result[2][2] = v3.z; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rowMajor3( const mat<3, 3, T, Q>& m) { mat<3, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rowMajor4( const vec<4, T, Q>& v1, const vec<4, T, Q>& v2, const vec<4, T, Q>& v3, const vec<4, T, Q>& v4) { mat<4, 4, T, Q> Result; Result[0][0] = v1.x; Result[1][0] = v1.y; Result[2][0] = v1.z; Result[3][0] = v1.w; Result[0][1] = v2.x; Result[1][1] = v2.y; Result[2][1] = v2.z; Result[3][1] = v2.w; Result[0][2] = v3.x; Result[1][2] = v3.y; Result[2][2] = v3.z; Result[3][2] = v3.w; Result[0][3] = v4.x; Result[1][3] = v4.y; Result[2][3] = v4.z; Result[3][3] = v4.w; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rowMajor4( const mat<4, 4, T, Q>& m) { mat<4, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[2][3] = m[3][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; Result[3][2] = m[2][3]; Result[3][3] = m[3][3]; return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> colMajor2( const vec<2, T, Q>& v1, const vec<2, T, Q>& v2) { return mat<2, 2, T, Q>(v1, v2); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> colMajor2( const mat<2, 2, T, Q>& m) { return mat<2, 2, T, Q>(m); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> colMajor3( const vec<3, T, Q>& v1, const vec<3, T, Q>& v2, const vec<3, T, Q>& v3) { return mat<3, 3, T, Q>(v1, v2, v3); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> colMajor3( const mat<3, 3, T, Q>& m) { return mat<3, 3, T, Q>(m); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> colMajor4( const vec<4, T, Q>& v1, const vec<4, T, Q>& v2, const vec<4, T, Q>& v3, const vec<4, T, Q>& v4) { return mat<4, 4, T, Q>(v1, v2, v3, v4); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> colMajor4( const mat<4, 4, T, Q>& m) { return mat<4, 4, T, Q>(m); } }//namespace glm glm-0.9.9-a2/glm/gtx/color_space_YCoCg.hpp0000600000175000001440000000350013173131001017075 0ustar guususers/// @ref gtx_color_space_YCoCg /// @file glm/gtx/color_space_YCoCg.hpp /// /// @see core (dependence) /// /// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg /// @ingroup gtx /// /// Include to use the features of this extension. /// /// RGB to YCoCg conversions and operations #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_color_space_YCoCg is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_color_space_YCoCg extension included") #endif namespace glm { /// @addtogroup gtx_color_space_YCoCg /// @{ /// Convert a color from RGB color space to YCoCg color space. /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCg( vec<3, T, Q> const& rgbColor); /// Convert a color from YCoCg color space to RGB color space. /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> YCoCg2rgb( vec<3, T, Q> const& YCoCgColor); /// Convert a color from RGB color space to YCoCgR color space. /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCgR( vec<3, T, Q> const& rgbColor); /// Convert a color from YCoCgR color space to RGB color space. /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" /// @see gtx_color_space_YCoCg template GLM_FUNC_DECL vec<3, T, Q> YCoCgR2rgb( vec<3, T, Q> const& YCoCgColor); /// @} }//namespace glm #include "color_space_YCoCg.inl" glm-0.9.9-a2/glm/gtx/transform2.inl0000600000175000001440000000703613173131001015660 0ustar guususers/// @ref gtx_transform2 /// @file glm/gtx/transform2.inl namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX2D(mat<3, 3, T, Q> const& m, T s) { mat<3, 3, T, Q> r(1); r[1][0] = s; return m * r; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY2D(mat<3, 3, T, Q> const& m, T s) { mat<3, 3, T, Q> r(1); r[0][1] = s; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearX3D(mat<4, 4, T, Q> const& m, T s, T t) { mat<4, 4, T, Q> r(1); r[0][1] = s; r[0][2] = t; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearY3D(mat<4, 4, T, Q> const& m, T s, T t) { mat<4, 4, T, Q> r(1); r[1][0] = s; r[1][2] = t; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearZ3D(mat<4, 4, T, Q> const& m, T s, T t) { mat<4, 4, T, Q> r(1); r[2][0] = s; r[2][1] = t; return m * r; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> reflect2D(mat<3, 3, T, Q> const& m, vec<3, T, Q> const& normal) { mat<3, 3, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - static_cast(2) * normal.x * normal.x; r[0][1] = -static_cast(2) * normal.x * normal.y; r[1][0] = -static_cast(2) * normal.x * normal.y; r[1][1] = static_cast(1) - static_cast(2) * normal.y * normal.y; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> reflect3D(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& normal) { mat<4, 4, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - static_cast(2) * normal.x * normal.x; r[0][1] = -static_cast(2) * normal.x * normal.y; r[0][2] = -static_cast(2) * normal.x * normal.z; r[1][0] = -static_cast(2) * normal.x * normal.y; r[1][1] = static_cast(1) - static_cast(2) * normal.y * normal.y; r[1][2] = -static_cast(2) * normal.y * normal.z; r[2][0] = -static_cast(2) * normal.x * normal.z; r[2][1] = -static_cast(2) * normal.y * normal.z; r[2][2] = static_cast(1) - static_cast(2) * normal.z * normal.z; return m * r; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> proj2D( const mat<3, 3, T, Q>& m, const vec<3, T, Q>& normal) { mat<3, 3, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - normal.x * normal.x; r[0][1] = - normal.x * normal.y; r[1][0] = - normal.x * normal.y; r[1][1] = static_cast(1) - normal.y * normal.y; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> proj3D( const mat<4, 4, T, Q>& m, const vec<3, T, Q>& normal) { mat<4, 4, T, Q> r(static_cast(1)); r[0][0] = static_cast(1) - normal.x * normal.x; r[0][1] = - normal.x * normal.y; r[0][2] = - normal.x * normal.z; r[1][0] = - normal.x * normal.y; r[1][1] = static_cast(1) - normal.y * normal.y; r[1][2] = - normal.y * normal.z; r[2][0] = - normal.x * normal.z; r[2][1] = - normal.y * normal.z; r[2][2] = static_cast(1) - normal.z * normal.z; return m * r; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scaleBias(T scale, T bias) { mat<4, 4, T, Q> result; result[3] = vec<4, T, Q>(vec<3, T, Q>(bias), static_cast(1)); result[0][0] = scale; result[1][1] = scale; result[2][2] = scale; return result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scaleBias(mat<4, 4, T, Q> const& m, T scale, T bias) { return m * scaleBias(scale, bias); } }//namespace glm glm-0.9.9-a2/glm/gtx/rotate_normalized_axis.hpp0000600000175000001440000000427613173131001020341 0ustar guususers/// @ref gtx_rotate_normalized_axis /// @file glm/gtx/rotate_normalized_axis.hpp /// /// @see core (dependence) /// @see gtc_matrix_transform /// @see gtc_quaternion /// /// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Quaternions and matrices rotations around normalized axis. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/epsilon.hpp" #include "../gtc/quaternion.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_rotate_normalized_axis is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included") #endif namespace glm { /// @addtogroup gtx_rotate_normalized_axis /// @{ /// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle. /// /// @param m Input matrix multiplied by this rotation matrix. /// @param angle Rotation angle expressed in radians. /// @param axis Rotation axis, must be normalized. /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// /// @see gtx_rotate_normalized_axis /// @see - rotate(T angle, T x, T y, T z) /// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z) /// @see - rotate(T angle, vec<3, T, Q> const& v) template GLM_FUNC_DECL mat<4, 4, T, Q> rotateNormalizedAxis( mat<4, 4, T, Q> const& m, T const& angle, vec<3, T, Q> const& axis); /// Rotates a quaternion from a vector of 3 components normalized axis and an angle. /// /// @param q Source orientation /// @param angle Angle expressed in radians. /// @param axis Normalized axis of the rotation, must be normalized. /// /// @see gtx_rotate_normalized_axis template GLM_FUNC_DECL tquat rotateNormalizedAxis( tquat const& q, T const& angle, vec<3, T, Q> const& axis); /// @} }//namespace glm #include "rotate_normalized_axis.inl" glm-0.9.9-a2/glm/gtx/component_wise.inl0000600000175000001440000001020113173131001016600 0ustar guususers/// @ref gtx_component_wise /// @file glm/gtx/component_wise.inl #include namespace glm{ namespace detail { template struct compute_compNormalize {}; template struct compute_compNormalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { floatType const Min = static_cast(std::numeric_limits::min()); floatType const Max = static_cast(std::numeric_limits::max()); return (vec(v) - Min) / (Max - Min) * static_cast(2) - static_cast(1); } }; template struct compute_compNormalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return vec(v) / static_cast(std::numeric_limits::max()); } }; template struct compute_compNormalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return v; } }; template struct compute_compScale {}; template struct compute_compScale { GLM_FUNC_QUALIFIER static vec call(vec const& v) { floatType const Max = static_cast(std::numeric_limits::max()) + static_cast(0.5); vec const Scaled(v * Max); vec const Result(Scaled - static_cast(0.5)); return Result; } }; template struct compute_compScale { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return vec(vec(v) * static_cast(std::numeric_limits::max())); } }; template struct compute_compScale { GLM_FUNC_QUALIFIER static vec call(vec const& v) { return v; } }; }//namespace detail template GLM_FUNC_QUALIFIER vec compNormalize(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter"); return detail::compute_compNormalize::is_integer, std::numeric_limits::is_signed>::call(v); } template GLM_FUNC_QUALIFIER vec compScale(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter"); return detail::compute_compScale::is_integer, std::numeric_limits::is_signed>::call(v); } template GLM_FUNC_QUALIFIER T compAdd(vec const& v) { T Result(0); for(length_t i = 0, n = v.length(); i < n; ++i) Result += v[i]; return Result; } template GLM_FUNC_QUALIFIER T compMul(vec const& v) { T Result(1); for(length_t i = 0, n = v.length(); i < n; ++i) Result *= v[i]; return Result; } template GLM_FUNC_QUALIFIER T compMin(vec const& v) { T Result(v[0]); for(length_t i = 1, n = v.length(); i < n; ++i) Result = min(Result, v[i]); return Result; } template GLM_FUNC_QUALIFIER T compMax(vec const& v) { T Result(v[0]); for(length_t i = 1, n = v.length(); i < n; ++i) Result = max(Result, v[i]); return Result; } }//namespace glm glm-0.9.9-a2/glm/gtx/euler_angles.hpp0000600000175000001440000001102713173131001016230 0ustar guususers/// @ref gtx_euler_angles /// @file glm/gtx/euler_angles.hpp /// /// @see core (dependence) /// /// @defgroup gtx_euler_angles GLM_GTX_euler_angles /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build matrices from Euler angles. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_euler_angles is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_euler_angles extension included") #endif namespace glm { /// @addtogroup gtx_euler_angles /// @{ /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleX( T const& angleX); /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleY( T const& angleY); /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZ( T const& angleZ); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXY( T const& angleX, T const& angleY); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYX( T const& angleY, T const& angleX); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZ( T const& angleX, T const& angleZ); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZX( T const& angle, T const& angleX); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZ( T const& angleY, T const& angleZ); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZY( T const& angleZ, T const& angleY); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYZ( T const& t1, T const& t2, T const& t3); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXZ( T const& yaw, T const& pitch, T const& roll); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, defaultp> yawPitchRoll( T const& yaw, T const& pitch, T const& roll); /// Creates a 2D 2 * 2 rotation matrix from an euler angle. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<2, 2, T, defaultp> orientate2(T const& angle); /// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle. /// @see gtx_euler_angles template GLM_FUNC_DECL mat<3, 3, T, defaultp> orientate3(T const& angle); /// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<3, 3, T, Q> orientate3(vec<3, T, Q> const& angles); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles template GLM_FUNC_DECL mat<4, 4, T, Q> orientate4(vec<3, T, Q> const& angles); /// Extracts the (X * Y * Z) Euler angles from the rotation matrix M /// @see gtx_euler_angles template GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M, T & t1, T & t2, T & t3); /// @} }//namespace glm #include "euler_angles.inl" glm-0.9.9-a2/glm/gtx/extend.inl0000600000175000001440000000164413173131001015051 0ustar guususers/// @ref gtx_extend /// @file glm/gtx/extend.inl namespace glm { template GLM_FUNC_QUALIFIER genType extend ( genType const& Origin, genType const& Source, genType const& Distance ) { return Origin + (Source - Origin) * Distance; } template GLM_FUNC_QUALIFIER vec<2, T, Q> extend ( vec<2, T, Q> const& Origin, vec<2, T, Q> const& Source, T const& Distance ) { return Origin + (Source - Origin) * Distance; } template GLM_FUNC_QUALIFIER vec<3, T, Q> extend ( vec<3, T, Q> const& Origin, vec<3, T, Q> const& Source, T const& Distance ) { return Origin + (Source - Origin) * Distance; } template GLM_FUNC_QUALIFIER vec<4, T, Q> extend ( vec<4, T, Q> const& Origin, vec<4, T, Q> const& Source, T const& Distance ) { return Origin + (Source - Origin) * Distance; } }//namespace glm glm-0.9.9-a2/glm/gtx/orthonormalize.hpp0000600000175000001440000000244413173131001016642 0ustar guususers/// @ref gtx_orthonormalize /// @file glm/gtx/orthonormalize.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Orthonormalize matrices. #pragma once // Dependency: #include "../vec3.hpp" #include "../mat3x3.hpp" #include "../geometric.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_orthonormalize is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_orthonormalize extension included") #endif namespace glm { /// @addtogroup gtx_orthonormalize /// @{ /// Returns the orthonormalized matrix of m. /// /// @see gtx_orthonormalize template GLM_FUNC_DECL mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m); /// Orthonormalizes x according y. /// /// @see gtx_orthonormalize template GLM_FUNC_DECL vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y); /// @} }//namespace glm #include "orthonormalize.inl" glm-0.9.9-a2/glm/gtx/rotate_vector.hpp0000600000175000001440000000671013173131001016446 0ustar guususers/// @ref gtx_rotate_vector /// @file glm/gtx/rotate_vector.hpp /// /// @see core (dependence) /// @see gtx_transform (dependence) /// /// @defgroup gtx_rotate_vector GLM_GTX_rotate_vector /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Function to directly rotate a vector #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/transform.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_rotate_vector is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_rotate_vector extension included") #endif namespace glm { /// @addtogroup gtx_rotate_vector /// @{ /// Returns Spherical interpolation between two vectors /// /// @param x A first vector /// @param y A second vector /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// /// @see gtx_rotate_vector template GLM_FUNC_DECL vec<3, T, Q> slerp( vec<3, T, Q> const& x, vec<3, T, Q> const& y, T const& a); //! Rotate a two dimensional vector. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<2, T, Q> rotate( vec<2, T, Q> const& v, T const& angle); //! Rotate a three dimensional vector around an axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotate( vec<3, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal); //! Rotate a four dimensional vector around an axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotate( vec<4, T, Q> const& v, T const& angle, vec<3, T, Q> const& normal); //! Rotate a three dimensional vector around the X axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotateX( vec<3, T, Q> const& v, T const& angle); //! Rotate a three dimensional vector around the Y axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotateY( vec<3, T, Q> const& v, T const& angle); //! Rotate a three dimensional vector around the Z axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<3, T, Q> rotateZ( vec<3, T, Q> const& v, T const& angle); //! Rotate a four dimensional vector around the X axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotateX( vec<4, T, Q> const& v, T const& angle); //! Rotate a four dimensional vector around the Y axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotateY( vec<4, T, Q> const& v, T const& angle); //! Rotate a four dimensional vector around the Z axis. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL vec<4, T, Q> rotateZ( vec<4, T, Q> const& v, T const& angle); //! Build a rotation matrix from a normal and a up vector. //! From GLM_GTX_rotate_vector extension. template GLM_FUNC_DECL mat<4, 4, T, Q> orientation( vec<3, T, Q> const& Normal, vec<3, T, Q> const& Up); /// @} }//namespace glm #include "rotate_vector.inl" glm-0.9.9-a2/glm/gtx/matrix_major_storage.hpp0000600000175000001440000000730013173131001020002 0ustar guususers/// @ref gtx_matrix_major_storage /// @file glm/gtx/matrix_major_storage.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_matrix_major_storage GLM_GTX_matrix_major_storage /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build matrices with specific matrix order, row or column #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_major_storage is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_major_storage extension included") #endif namespace glm { /// @addtogroup gtx_matrix_major_storage /// @{ //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> rowMajor2( vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> rowMajor2( mat<2, 2, T, Q> const& m); //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> rowMajor3( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3); //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> rowMajor3( mat<3, 3, T, Q> const& m); //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> rowMajor4( vec<4, T, Q> const& v1, vec<4, T, Q> const& v2, vec<4, T, Q> const& v3, vec<4, T, Q> const& v4); //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> rowMajor4( mat<4, 4, T, Q> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> colMajor2( vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<2, 2, T, Q> colMajor2( mat<2, 2, T, Q> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> colMajor3( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3); //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<3, 3, T, Q> colMajor3( mat<3, 3, T, Q> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> colMajor4( vec<4, T, Q> const& v1, vec<4, T, Q> const& v2, vec<4, T, Q> const& v3, vec<4, T, Q> const& v4); //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. template GLM_FUNC_DECL mat<4, 4, T, Q> colMajor4( mat<4, 4, T, Q> const& m); /// @} }//namespace glm #include "matrix_major_storage.inl" glm-0.9.9-a2/glm/gtx/fast_exponential.inl0000600000175000001440000001020113173131001017112 0ustar guususers/// @ref gtx_fast_exponential /// @file glm/gtx/fast_exponential.inl namespace glm { // fastPow: template GLM_FUNC_QUALIFIER genType fastPow(genType x, genType y) { return exp(y * log(x)); } template GLM_FUNC_QUALIFIER vec fastPow(vec const& x, vec const& y) { return exp(y * log(x)); } template GLM_FUNC_QUALIFIER T fastPow(T x, int y) { T f = static_cast(1); for(int i = 0; i < y; ++i) f *= x; return f; } template GLM_FUNC_QUALIFIER vec fastPow(vec const& x, vec const& y) { vec Result; for(length_t i = 0, n = x.length(); i < n; ++i) Result[i] = fastPow(x[i], y[i]); return Result; } // fastExp // Note: This function provides accurate results only for value between -1 and 1, else avoid it. template GLM_FUNC_QUALIFIER T fastExp(T x) { // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower. // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f)))); T x2 = x * x; T x3 = x2 * x; T x4 = x3 * x; T x5 = x4 * x; return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333)); } /* // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance GLM_FUNC_QUALIFIER float fastExp(float x) { const float e = 2.718281828f; const float IntegerPart = floor(x); const float FloatPart = x - IntegerPart; float z = 1.f; for(int i = 0; i < int(IntegerPart); ++i) z *= e; const float x2 = FloatPart * FloatPart; const float x3 = x2 * FloatPart; const float x4 = x3 * FloatPart; const float x5 = x4 * FloatPart; return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)); } // Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers GLM_FUNC_QUALIFIER float fastExp(float x) { // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower. // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f)))); float x2 = x * x; float x3 = x2 * x; float x4 = x3 * x; float x5 = x4 * x; float x6 = x5 * x; float x7 = x6 * x; float x8 = x7 * x; return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);; } */ template GLM_FUNC_QUALIFIER vec fastExp(vec const& x) { return detail::functor1::call(fastExp, x); } // fastLog template GLM_FUNC_QUALIFIER genType fastLog(genType x) { return std::log(x); } /* Slower than the VC7.1 function... GLM_FUNC_QUALIFIER float fastLog(float x) { float y1 = (x - 1.0f) / (x + 1.0f); float y2 = y1 * y1; return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f))); } */ template GLM_FUNC_QUALIFIER vec fastLog(vec const& x) { return detail::functor1::call(fastLog, x); } //fastExp2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType fastExp2(genType x) { return fastExp(0.69314718055994530941723212145818f * x); } template GLM_FUNC_QUALIFIER vec fastExp2(vec const& x) { return detail::functor1::call(fastExp2, x); } // fastLog2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType fastLog2(genType x) { return fastLog(x) / 0.69314718055994530941723212145818f; } template GLM_FUNC_QUALIFIER vec fastLog2(vec const& x) { return detail::functor1::call(fastLog2, x); } }//namespace glm glm-0.9.9-a2/glm/gtx/normal.inl0000600000175000001440000000045713173131001015053 0ustar guususers/// @ref gtx_normal /// @file glm/gtx/normal.inl namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal ( vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3 ) { return normalize(cross(p1 - p2, p1 - p3)); } }//namespace glm glm-0.9.9-a2/glm/gtx/number_precision.hpp0000600000175000001440000000441313173131001017127 0ustar guususers/// @ref gtx_number_precision /// @file glm/gtx/number_precision.hpp /// /// @see core (dependence) /// @see gtc_type_precision (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_number_precision GLM_GTX_number_precision /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defined size types. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/type_precision.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_number_precision is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_number_precision extension included") #endif namespace glm{ namespace gtx { ///////////////////////////// // Unsigned int vector types /// @addtogroup gtx_number_precision /// @{ typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension) typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension) typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension) typedef u64 u64vec1; //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension) ////////////////////// // Float vector types typedef f32 f32vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f64 f64vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) ////////////////////// // Float matrix types typedef f32 f32mat1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f32 f32mat1x1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f64 f64mat1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) typedef f64 f64mat1x1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) /// @} }//namespace gtx }//namespace glm #include "number_precision.inl" glm-0.9.9-a2/glm/gtx/fast_trigonometry.inl0000600000175000001440000000766013173131001017345 0ustar guususers/// @ref gtx_fast_trigonometry /// @file glm/gtx/fast_trigonometry.inl namespace glm{ namespace detail { template GLM_FUNC_QUALIFIER vec taylorCos(vec const& x) { return static_cast(1) - (x * x) * (1.f / 2.f) + ((x * x) * (x * x)) * (1.f / 24.f) - (((x * x) * (x * x)) * (x * x)) * (1.f / 720.f) + (((x * x) * (x * x)) * ((x * x) * (x * x))) * (1.f / 40320.f); } template GLM_FUNC_QUALIFIER T cos_52s(T x) { T const xx(x * x); return (T(0.9999932946) + xx * (T(-0.4999124376) + xx * (T(0.0414877472) + xx * T(-0.0012712095)))); } template GLM_FUNC_QUALIFIER vec cos_52s(vec const& x) { return detail::functor1::call(cos_52s, x); } }//namespace detail // wrapAngle template GLM_FUNC_QUALIFIER T wrapAngle(T angle) { return abs(mod(angle, two_pi())); } template GLM_FUNC_QUALIFIER vec wrapAngle(vec const& x) { return detail::functor1::call(wrapAngle, x); } // cos template GLM_FUNC_QUALIFIER T fastCos(T x) { T const angle(wrapAngle(x)); if(angle < half_pi()) return detail::cos_52s(angle); if(angle < pi()) return -detail::cos_52s(pi() - angle); if(angle < (T(3) * half_pi())) return -detail::cos_52s(angle - pi()); return detail::cos_52s(two_pi() - angle); } template GLM_FUNC_QUALIFIER vec fastCos(vec const& x) { return detail::functor1::call(fastCos, x); } // sin template GLM_FUNC_QUALIFIER T fastSin(T x) { return fastCos(half_pi() - x); } template GLM_FUNC_QUALIFIER vec fastSin(vec const& x) { return detail::functor1::call(fastSin, x); } // tan template GLM_FUNC_QUALIFIER T fastTan(T x) { return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539)); } template GLM_FUNC_QUALIFIER vec fastTan(vec const& x) { return detail::functor1::call(fastTan, x); } // asin template GLM_FUNC_QUALIFIER T fastAsin(T x) { return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159)); } template GLM_FUNC_QUALIFIER vec fastAsin(vec const& x) { return detail::functor1::call(fastAsin, x); } // acos template GLM_FUNC_QUALIFIER T fastAcos(T x) { return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2) } template GLM_FUNC_QUALIFIER vec fastAcos(vec const& x) { return detail::functor1::call(fastAcos, x); } // atan template GLM_FUNC_QUALIFIER T fastAtan(T y, T x) { T sgn = sign(y) * sign(x); return abs(fastAtan(y / x)) * sgn; } template GLM_FUNC_QUALIFIER vec fastAtan(vec const& y, vec const& x) { return detail::functor2::call(fastAtan, y, x); } template GLM_FUNC_QUALIFIER T fastAtan(T x) { return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909)); } template GLM_FUNC_QUALIFIER vec fastAtan(vec const& x) { return detail::functor1::call(fastAtan, x); } }//namespace glm glm-0.9.9-a2/glm/gtx/matrix_cross_product.hpp0000600000175000001440000000244513173131001020044 0ustar guususers/// @ref gtx_matrix_cross_product /// @file glm/gtx/matrix_cross_product.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build cross product matrices #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_cross_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_cross_product extension included") #endif namespace glm { /// @addtogroup gtx_matrix_cross_product /// @{ //! Build a cross product matrix. //! From GLM_GTX_matrix_cross_product extension. template GLM_FUNC_DECL mat<3, 3, T, Q> matrixCross3( vec<3, T, Q> const& x); //! Build a cross product matrix. //! From GLM_GTX_matrix_cross_product extension. template GLM_FUNC_DECL mat<4, 4, T, Q> matrixCross4( vec<3, T, Q> const& x); /// @} }//namespace glm #include "matrix_cross_product.inl" glm-0.9.9-a2/glm/gtx/handed_coordinate_space.hpp0000600000175000001440000000274013173131001020372 0ustar guususers/// @ref gtx_handed_coordinate_space /// @file glm/gtx/handed_coordinate_space.hpp /// /// @see core (dependence) /// /// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space /// @ingroup gtx /// /// Include to use the features of this extension. /// /// To know if a set of three basis vectors defines a right or left-handed coordinate system. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_handed_coordinate_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included") #endif namespace glm { /// @addtogroup gtx_handed_coordinate_space /// @{ //! Return if a trihedron right handed or not. //! From GLM_GTX_handed_coordinate_space extension. template GLM_FUNC_DECL bool rightHanded( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal); //! Return if a trihedron left handed or not. //! From GLM_GTX_handed_coordinate_space extension. template GLM_FUNC_DECL bool leftHanded( vec<3, T, Q> const& tangent, vec<3, T, Q> const& binormal, vec<3, T, Q> const& normal); /// @} }// namespace glm #include "handed_coordinate_space.inl" glm-0.9.9-a2/glm/gtx/range.hpp0000600000175000001440000000421613173131001014661 0ustar guususers/// @ref gtx_range /// @file glm/gtx/range.hpp /// @author Joshua Moerman /// /// @defgroup gtx_range GLM_GTX_range /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines begin and end for vectors and matrices. Useful for range-based for loop. /// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements). #pragma once // Dependencies #include "../detail/setup.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_range is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if !GLM_HAS_RANGE_FOR # error "GLM_GTX_range requires C++11 suppport or 'range for'" #endif #include "../gtc/type_ptr.hpp" #include "../gtc/vec1.hpp" namespace glm { /// @addtogroup gtx_range /// @{ # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable : 4100) // unreferenced formal parameter # endif template inline length_t components(vec<1, T, Q> const& v) { return v.length(); } template inline length_t components(vec<2, T, Q> const& v) { return v.length(); } template inline length_t components(vec<3, T, Q> const& v) { return v.length(); } template inline length_t components(vec<4, T, Q> const& v) { return v.length(); } template inline length_t components(genType const& m) { return m.length() * m[0].length(); } template inline typename genType::value_type const * begin(genType const& v) { return value_ptr(v); } template inline typename genType::value_type const * end(genType const& v) { return begin(v) + components(v); } template inline typename genType::value_type * begin(genType& v) { return value_ptr(v); } template inline typename genType::value_type * end(genType& v) { return begin(v) + components(v); } # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif /// @} }//namespace glm glm-0.9.9-a2/glm/gtx/extend.hpp0000600000175000001440000000204613173131001015053 0ustar guususers/// @ref gtx_extend /// @file glm/gtx/extend.hpp /// /// @see core (dependence) /// /// @defgroup gtx_extend GLM_GTX_extend /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Extend a position from a source to a position at a defined length. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_extend extension included") #endif namespace glm { /// @addtogroup gtx_extend /// @{ /// Extends of Length the Origin position using the (Source - Origin) direction. /// @see gtx_extend template GLM_FUNC_DECL genType extend( genType const& Origin, genType const& Source, typename genType::value_type const Length); /// @} }//namespace glm #include "extend.inl" glm-0.9.9-a2/glm/gtx/integer.hpp0000600000175000001440000000416013173131001015220 0ustar guususers/// @ref gtx_integer /// @file glm/gtx/integer.hpp /// /// @see core (dependence) /// /// @defgroup gtx_integer GLM_GTX_integer /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add support for integer for core functions #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/integer.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_integer is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_integer extension included") #endif namespace glm { /// @addtogroup gtx_integer /// @{ //! Returns x raised to the y power. //! From GLM_GTX_integer extension. GLM_FUNC_DECL int pow(int x, uint y); //! Returns the positive square root of x. //! From GLM_GTX_integer extension. GLM_FUNC_DECL int sqrt(int x); //! Returns the floor log2 of x. //! From GLM_GTX_integer extension. GLM_FUNC_DECL unsigned int floor_log2(unsigned int x); //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. //! From GLM_GTX_integer extension. GLM_FUNC_DECL int mod(int x, int y); //! Return the factorial value of a number (!12 max, integer only) //! From GLM_GTX_integer extension. template GLM_FUNC_DECL genType factorial(genType const& x); //! 32bit signed integer. //! From GLM_GTX_integer extension. typedef signed int sint; //! Returns x raised to the y power. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint pow(uint x, uint y); //! Returns the positive square root of x. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint sqrt(uint x); //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint mod(uint x, uint y); //! Returns the number of leading zeros. //! From GLM_GTX_integer extension. GLM_FUNC_DECL uint nlz(uint x); /// @} }//namespace glm #include "integer.inl" glm-0.9.9-a2/glm/gtx/functions.inl0000600000175000001440000000144513173131001015571 0ustar guususers/// @ref gtx_functions /// @file glm/gtx/functions.inl #include "../exponential.hpp" namespace glm { template GLM_FUNC_QUALIFIER T gauss ( T x, T ExpectedValue, T StandardDeviation ) { return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); } template GLM_FUNC_QUALIFIER T gauss ( vec<2, T, Q> const& Coord, vec<2, T, Q> const& ExpectedValue, vec<2, T, Q> const& StandardDeviation ) { vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); return exp(-(Squared.x + Squared.y)); } }//namespace glm glm-0.9.9-a2/glm/gtx/matrix_interpolation.hpp0000600000175000001440000000373013173131001020040 0ustar guususers/// @ref gtx_matrix_interpolation /// @file glm/gtx/matrix_interpolation.hpp /// @author Ghenadii Ursachi (the.asteroth@gmail.com) /// /// @see core (dependence) /// /// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Allows to directly interpolate two exiciting matrices. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_interpolation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_interpolation extension included") #endif namespace glm { /// @addtogroup gtx_matrix_interpolation /// @{ /// Get the axis and angle of the rotation from a matrix. /// From GLM_GTX_matrix_interpolation extension. template GLM_FUNC_DECL void axisAngle( mat<4, 4, T, Q> const& mat, vec<3, T, Q> & axis, T & angle); /// Build a matrix from axis and angle. /// From GLM_GTX_matrix_interpolation extension. template GLM_FUNC_DECL mat<4, 4, T, Q> axisAngleMatrix( vec<3, T, Q> const& axis, T const angle); /// Extracts the rotation part of a matrix. /// From GLM_GTX_matrix_interpolation extension. template GLM_FUNC_DECL mat<4, 4, T, Q> extractMatrixRotation( mat<4, 4, T, Q> const& mat); /// Build a interpolation of 4 * 4 matrixes. /// From GLM_GTX_matrix_interpolation extension. /// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results. template GLM_FUNC_DECL mat<4, 4, T, Q> interpolate( mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2, T const delta); /// @} }//namespace glm #include "matrix_interpolation.inl" glm-0.9.9-a2/glm/gtx/compatibility.inl0000600000175000001440000000276013173131001016433 0ustar guususers/// @ref gtx_compatibility /// @file glm/gtx/compatibility.inl #include namespace glm { // isfinite template GLM_FUNC_QUALIFIER bool isfinite( genType const& x) { # if GLM_HAS_CXX11_STL return std::isfinite(x) != 0; # elif GLM_COMPILER & GLM_COMPILER_VC return _finite(x); # elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID return _isfinite(x) != 0; # else if (std::numeric_limits::is_integer || std::denorm_absent == std::numeric_limits::has_denorm) return std::numeric_limits::min() <= x && std::numeric_limits::max() >= x; else return -std::numeric_limits::max() <= x && std::numeric_limits::max() >= x; # endif } template GLM_FUNC_QUALIFIER vec<1, bool, Q> isfinite( vec<1, T, Q> const& x) { return vec<1, bool, Q>( isfinite(x.x)); } template GLM_FUNC_QUALIFIER vec<2, bool, Q> isfinite( vec<2, T, Q> const& x) { return vec<2, bool, Q>( isfinite(x.x), isfinite(x.y)); } template GLM_FUNC_QUALIFIER vec<3, bool, Q> isfinite( vec<3, T, Q> const& x) { return vec<3, bool, Q>( isfinite(x.x), isfinite(x.y), isfinite(x.z)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isfinite( vec<4, T, Q> const& x) { return vec<4, bool, Q>( isfinite(x.x), isfinite(x.y), isfinite(x.z), isfinite(x.w)); } }//namespace glm glm-0.9.9-a2/glm/gtx/matrix_cross_product.inl0000600000175000001440000000132113173131001020027 0ustar guususers/// @ref gtx_matrix_cross_product /// @file glm/gtx/matrix_cross_product.inl namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 ( vec<3, T, Q> const& x ) { mat<3, 3, T, Q> Result(T(0)); Result[0][1] = x.z; Result[1][0] = -x.z; Result[0][2] = -x.y; Result[2][0] = x.y; Result[1][2] = x.x; Result[2][1] = -x.x; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 ( vec<3, T, Q> const& x ) { mat<4, 4, T, Q> Result(T(0)); Result[0][1] = x.z; Result[1][0] = -x.z; Result[0][2] = -x.y; Result[2][0] = x.y; Result[1][2] = x.x; Result[2][1] = -x.x; return Result; } }//namespace glm glm-0.9.9-a2/glm/gtx/norm.hpp0000600000175000001440000000433713173131001014544 0ustar guususers/// @ref gtx_norm /// @file glm/gtx/norm.hpp /// /// @see core (dependence) /// @see gtx_quaternion (dependence) /// /// @defgroup gtx_norm GLM_GTX_norm /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Various ways to compute vector norms. #pragma once // Dependency: #include "../geometric.hpp" #include "../gtx/quaternion.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_norm is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_norm extension included") #endif namespace glm { /// @addtogroup gtx_norm /// @{ /// Returns the squared length of x. /// From GLM_GTX_norm extension. template GLM_FUNC_DECL T length2(vec const& x); /// Returns the squared distance between p0 and p1, i.e., length2(p0 - p1). /// From GLM_GTX_norm extension. template GLM_FUNC_DECL T distance2(vec const& p0, vec const& p1); //! Returns the L1 norm between x and y. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y); //! Returns the L1 norm of v. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& v); //! Returns the L2 norm between x and y. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y); //! Returns the L2 norm of v. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x); //! Returns the L norm between x and y. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth); //! Returns the L norm of v. //! From GLM_GTX_norm extension. template GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, unsigned int Depth); /// @} }//namespace glm #include "norm.inl" glm-0.9.9-a2/glm/gtx/matrix_transform_2d.inl0000600000175000001440000000255713173131001017552 0ustar guususers/// @ref gtx_matrix_transform_2d /// @file glm/gtc/matrix_transform_2d.inl /// @author Miguel Ángel Pérez Martínez #include "../trigonometric.hpp" namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v) { mat<3, 3, T, Q> Result(m); Result[2] = m[0] * v[0] + m[1] * v[1] + m[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( mat<3, 3, T, Q> const& m, T angle) { T const a = angle; T const c = cos(a); T const s = sin(a); mat<3, 3, T, Q> Result; Result[0] = m[0] * c + m[1] * s; Result[1] = m[0] * -s + m[1] * c; Result[2] = m[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v) { mat<3, 3, T, Q> Result; Result[0] = m[0] * v[0]; Result[1] = m[1] * v[1]; Result[2] = m[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( mat<3, 3, T, Q> const& m, T y) { mat<3, 3, T, Q> Result(1); Result[0][1] = y; return m * Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( mat<3, 3, T, Q> const& m, T x) { mat<3, 3, T, Q> Result(1); Result[1][0] = x; return m * Result; } }//namespace glm glm-0.9.9-a2/glm/gtx/transform.hpp0000600000175000001440000000321513173131001015576 0ustar guususers/// @ref gtx_transform /// @file glm/gtx/transform.hpp /// /// @see core (dependence) /// @see gtc_matrix_transform (dependence) /// @see gtx_transform /// @see gtx_transform2 /// /// @defgroup gtx_transform GLM_GTX_transform /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add transformation matrices #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/matrix_transform.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_transform is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_transform extension included") #endif namespace glm { /// @addtogroup gtx_transform /// @{ /// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. /// @see gtc_matrix_transform /// @see gtx_transform template GLM_FUNC_DECL mat<4, 4, T, Q> translate( vec<3, T, Q> const& v); /// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. /// @see gtc_matrix_transform /// @see gtx_transform template GLM_FUNC_DECL mat<4, 4, T, Q> rotate( T angle, vec<3, T, Q> const& v); /// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components. /// @see gtc_matrix_transform /// @see gtx_transform template GLM_FUNC_DECL mat<4, 4, T, Q> scale( vec<3, T, Q> const& v); /// @} }// namespace glm #include "transform.inl" glm-0.9.9-a2/glm/gtx/projection.inl0000600000175000001440000000041113173131001015725 0ustar guususers/// @ref gtx_projection /// @file glm/gtx/projection.inl namespace glm { template GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) { return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; } }//namespace glm glm-0.9.9-a2/glm/gtx/associated_min_max.hpp0000600000175000001440000001670013173131001017415 0ustar guususers/// @ref gtx_associated_min_max /// @file glm/gtx/associated_min_max.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_associated_min_max GLM_GTX_associated_min_max /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Min and max functions that return associated values not the compared onces. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GTX_associated_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_associated_min_max extension included") #endif namespace glm { /// @addtogroup gtx_associated_min_max /// @{ /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b); /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec<2, U, Q> associatedMin( vec const& x, vec const& a, vec const& y, vec const& b); /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( T x, const vec& a, T y, const vec& b); /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, U a, vec const& y, U b); /// Minimum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMin( T x, U a, T y, U b, T z, U c); /// Minimum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMin( T x, U a, T y, U b, T z, U c, T w, U d); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMin( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMax(T x, U a, T y, U b); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec<2, U, Q> associatedMax( vec const& x, vec const& a, vec const& y, vec const& b); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( T x, vec const& a, T y, vec const& b); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, U a, vec const& y, U b); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMax( T x, U a, T y, U b, T z, U c); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( T x, vec const& a, T y, vec const& b, T z, vec const& c); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, U a, vec const& y, U b, vec const& z, U c); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL U associatedMax( T x, U a, T y, U b, T z, U c, T w, U d); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max template GLM_FUNC_DECL vec associatedMax( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d); /// @} } //namespace glm #include "associated_min_max.inl" glm-0.9.9-a2/glm/gtx/exterior_product.inl0000600000175000001440000000122113173131001017152 0ustar guususers/// @ref core /// @file glm/detail/func_geometric.inl #include namespace glm { namespace detail { template struct compute_cross_vec2 { GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); return v.x * u.y - u.x * v.y; } }; }//namespace detail template GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) { return detail::compute_cross_vec2::value>::call(x, y); } }//namespace glm glm-0.9.9-a2/glm/gtx/color_encoding.inl0000600000175000001440000000337013173131001016544 0ustar guususers/// @ref gtx_color_encoding /// @file glm/gtx/color_encoding.inl namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB) { vec<3, T, Q> const M(0.490f, 0.17697f, 0.2f); vec<3, T, Q> const N(0.31f, 0.8124f, 0.01063f); vec<3, T, Q> const O(0.490f, 0.01f, 0.99f); return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast(5.650675255693055f); } template GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB) { vec<3, T, Q> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f); vec<3, T, Q> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f); vec<3, T, Q> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f); return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB; } template GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ) { vec<3, T, Q> const M(0.41847f, -0.091169f, 0.0009209f); vec<3, T, Q> const N(-0.15866f, 0.25243f, 0.015708f); vec<3, T, Q> const O(0.0009209f, -0.0025498f, 0.1786f); return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; } template GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ) { vec<3, T, Q> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f); vec<3, T, Q> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f); vec<3, T, Q> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f); return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; } }//namespace glm glm-0.9.9-a2/glm/gtx/log_base.hpp0000600000175000001440000000221013173131001015330 0ustar guususers/// @ref gtx_log_base /// @file glm/gtx/log_base.hpp /// /// @see core (dependence) /// /// @defgroup gtx_log_base GLM_GTX_log_base /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Logarithm for any base. base can be a vector or a scalar. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_log_base extension included") #endif namespace glm { /// @addtogroup gtx_log_base /// @{ /// Logarithm for any base. /// From GLM_GTX_log_base. template GLM_FUNC_DECL genType log( genType const& x, genType const& base); /// Logarithm for any base. /// From GLM_GTX_log_base. template GLM_FUNC_DECL vec sign( vec const& x, vec const& base); /// @} }//namespace glm #include "log_base.inl" glm-0.9.9-a2/glm/gtx/transform2.hpp0000600000175000001440000000655413173131001015671 0ustar guususers/// @ref gtx_transform2 /// @file glm/gtx/transform2.hpp /// /// @see core (dependence) /// @see gtx_transform (dependence) /// /// @defgroup gtx_transform2 GLM_GTX_transform2 /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add extra transformation matrices #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/transform.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_transform2 is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_transform2 extension included") #endif namespace glm { /// @addtogroup gtx_transform2 /// @{ //! Transforms a matrix with a shearing on X axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<3, 3, T, Q> shearX2D(mat<3, 3, T, Q> const& m, T y); //! Transforms a matrix with a shearing on Y axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<3, 3, T, Q> shearY2D(mat<3, 3, T, Q> const& m, T x); //! Transforms a matrix with a shearing on X axis //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> shearX3D(mat<4, 4, T, Q> const& m, T y, T z); //! Transforms a matrix with a shearing on Y axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> shearY3D(mat<4, 4, T, Q> const& m, T x, T z); //! Transforms a matrix with a shearing on Z axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> shearZ3D(mat<4, 4, T, Q> const& m, T x, T y); //template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shear(const mat<4, 4, T, Q> & m, shearPlane, planePoint, angle) // Identity + tan(angle) * cross(Normal, OnPlaneVector) 0 // - dot(PointOnPlane, normal) * OnPlaneVector 1 // Reflect functions seem to don't work //template mat<3, 3, T, Q> reflect2D(const mat<3, 3, T, Q> & m, const vec<3, T, Q>& normal){return reflect2DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension) //template mat<4, 4, T, Q> reflect3D(const mat<4, 4, T, Q> & m, const vec<3, T, Q>& normal){return reflect3DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension) //! Build planar projection matrix along normal axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<3, 3, T, Q> proj2D(mat<3, 3, T, Q> const& m, vec<3, T, Q> const& normal); //! Build planar projection matrix along normal axis. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> proj3D(mat<4, 4, T, Q> const & m, vec<3, T, Q> const& normal); //! Build a scale bias matrix. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> scaleBias(T scale, T bias); //! Build a scale bias matrix. //! From GLM_GTX_transform2 extension. template GLM_FUNC_DECL mat<4, 4, T, Q> scaleBias(mat<4, 4, T, Q> const& m, T scale, T bias); /// @} }// namespace glm #include "transform2.inl" glm-0.9.9-a2/glm/gtx/rotate_normalized_axis.inl0000600000175000001440000000325013173131001020323 0ustar guususers/// @ref gtx_rotate_normalized_axis /// @file glm/gtx/rotate_normalized_axis.inl namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotateNormalizedAxis ( mat<4, 4, T, Q> const& m, T const& angle, vec<3, T, Q> const& v ) { T const a = angle; T const c = cos(a); T const s = sin(a); vec<3, T, Q> const axis(v); vec<3, T, Q> const temp((static_cast(1) - c) * axis); mat<4, 4, T, Q> Rotate; Rotate[0][0] = c + temp[0] * axis[0]; Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; Rotate[1][1] = c + temp[1] * axis[1]; Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; Rotate[2][2] = c + temp[2] * axis[2]; mat<4, 4, T, Q> Result; Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; Result[3] = m[3]; return Result; } template GLM_FUNC_QUALIFIER tquat rotateNormalizedAxis ( tquat const& q, T const& angle, vec<3, T, Q> const& v ) { vec<3, T, Q> const Tmp(v); T const AngleRad(angle); T const Sin = sin(AngleRad * T(0.5)); return q * tquat(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); //return gtc::quaternion::cross(q, tquat(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin)); } }//namespace glm glm-0.9.9-a2/glm/gtx/extended_min_max.hpp0000600000175000001440000001736413173131001017105 0ustar guususers/// @ref gtx_extended_min_max /// @file glm/gtx/extended_min_max.hpp /// /// @see core (dependence) /// /// @defgroup gtx_extended_min_max GLM_GTX_extented_min_max /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Min and max functions for 3 to 4 parameters. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_extented_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_extented_min_max extension included") #endif namespace glm { /// @addtogroup gtx_extended_min_max /// @{ /// Return the minimum component-wise values of 3 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T min( T const& x, T const& y, T const& z); /// Return the minimum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, typename C::T const& y, typename C::T const& z); /// Return the minimum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, C const& y, C const& z); /// Return the minimum component-wise values of 4 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T min( T const& x, T const& y, T const& z, T const& w); /// Return the minimum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w); /// Return the minimum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C min( C const& x, C const& y, C const& z, C const& w); /// Return the maximum component-wise values of 3 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T max( T const& x, T const& y, T const& z); /// Return the maximum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, typename C::T const& y, typename C::T const& z); /// Return the maximum component-wise values of 3 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, C const& y, C const& z); /// Return the maximum component-wise values of 4 inputs /// @see gtx_extented_min_max template GLM_FUNC_DECL T max( T const& x, T const& y, T const& z, T const& w); /// Return the maximum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w); /// Return the maximum component-wise values of 4 inputs /// @see gtx_extented_min_max template class C> GLM_FUNC_DECL C max( C const& x, C const& y, C const& z, C const& w); /// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see gtx_extented_min_max template GLM_FUNC_DECL genType fmin(genType x, genType y); /// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see gtx_extented_min_max /// @see std::fmin documentation template GLM_FUNC_DECL vec fmin(vec const& x, T y); /// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see gtx_extented_min_max /// @see std::fmin documentation template GLM_FUNC_DECL vec fmin(vec const& x, vec const& y); /// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam genType Floating-point; scalar or vector types. /// /// @see gtx_extented_min_max /// @see std::fmax documentation template GLM_FUNC_DECL genType fmax(genType x, genType y); /// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see gtx_extented_min_max /// @see std::fmax documentation template GLM_FUNC_DECL vec fmax(vec const& x, T y); /// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see gtx_extented_min_max /// @see std::fmax documentation template GLM_FUNC_DECL vec fmax(vec const& x, vec const& y); /// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtx_extented_min_max template GLM_FUNC_DECL genType fclamp(genType x, genType minVal, genType maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see gtx_extented_min_max template GLM_FUNC_DECL vec fclamp(vec const& x, T minVal, T maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see gtx_extented_min_max template GLM_FUNC_DECL vec fclamp(vec const& x, vec const& minVal, vec const& maxVal); /// @} }//namespace glm #include "extended_min_max.inl" glm-0.9.9-a2/glm/gtx/matrix_decompose.inl0000600000175000001440000001453013173131001017122 0ustar guususers/// @ref gtx_matrix_decompose /// @file glm/gtx/matrix_decompose.inl #include "../gtc/constants.hpp" #include "../gtc/epsilon.hpp" namespace glm{ namespace detail { /// Make a linear combination of two vectors and return the result. // result = (a * ascl) + (b * bscl) template GLM_FUNC_QUALIFIER vec<3, T, Q> combine( vec<3, T, Q> const& a, vec<3, T, Q> const& b, T ascl, T bscl) { return (a * ascl) + (b * bscl); } template GLM_FUNC_QUALIFIER vec<3, T, Q> scale(vec<3, T, Q> const& v, T desiredLength) { return v * desiredLength / length(v); } }//namespace detail // Matrix decompose // http://www.opensource.apple.com/source/WebCore/WebCore-514/platform/graphics/transforms/TransformationMatrix.cpp // Decomposes the mode matrix to translations,rotation scale components template GLM_FUNC_QUALIFIER bool decompose(mat<4, 4, T, Q> const& ModelMatrix, vec<3, T, Q> & Scale, tquat & Orientation, vec<3, T, Q> & Translation, vec<3, T, Q> & Skew, vec<4, T, Q> & Perspective) { mat<4, 4, T, Q> LocalMatrix(ModelMatrix); // Normalize the matrix. if(epsilonEqual(LocalMatrix[3][3], static_cast(0), epsilon())) return false; for(length_t i = 0; i < 4; ++i) for(length_t j = 0; j < 4; ++j) LocalMatrix[i][j] /= LocalMatrix[3][3]; // perspectiveMatrix is used to solve for perspective, but it also provides // an easy way to test for singularity of the upper 3x3 component. mat<4, 4, T, Q> PerspectiveMatrix(LocalMatrix); for(length_t i = 0; i < 3; i++) PerspectiveMatrix[i][3] = static_cast(0); PerspectiveMatrix[3][3] = static_cast(1); /// TODO: Fixme! if(epsilonEqual(determinant(PerspectiveMatrix), static_cast(0), epsilon())) return false; // First, isolate perspective. This is the messiest. if( epsilonNotEqual(LocalMatrix[0][3], static_cast(0), epsilon()) || epsilonNotEqual(LocalMatrix[1][3], static_cast(0), epsilon()) || epsilonNotEqual(LocalMatrix[2][3], static_cast(0), epsilon())) { // rightHandSide is the right hand side of the equation. vec<4, T, Q> RightHandSide; RightHandSide[0] = LocalMatrix[0][3]; RightHandSide[1] = LocalMatrix[1][3]; RightHandSide[2] = LocalMatrix[2][3]; RightHandSide[3] = LocalMatrix[3][3]; // Solve the equation by inverting PerspectiveMatrix and multiplying // rightHandSide by the inverse. (This is the easiest way, not // necessarily the best.) mat<4, 4, T, Q> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);// inverse(PerspectiveMatrix, inversePerspectiveMatrix); mat<4, 4, T, Q> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);// transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix); Perspective = TransposedInversePerspectiveMatrix * RightHandSide; // v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint); // Clear the perspective partition LocalMatrix[0][3] = LocalMatrix[1][3] = LocalMatrix[2][3] = static_cast(0); LocalMatrix[3][3] = static_cast(1); } else { // No perspective. Perspective = vec<4, T, Q>(0, 0, 0, 1); } // Next take care of translation (easy). Translation = vec<3, T, Q>(LocalMatrix[3]); LocalMatrix[3] = vec<4, T, Q>(0, 0, 0, LocalMatrix[3].w); vec<3, T, Q> Row[3], Pdum3; // Now get scale and shear. for(length_t i = 0; i < 3; ++i) for(length_t j = 0; j < 3; ++j) Row[i][j] = LocalMatrix[i][j]; // Compute X scale factor and normalize first row. Scale.x = length(Row[0]);// v3Length(Row[0]); Row[0] = detail::scale(Row[0], static_cast(1)); // Compute XY shear factor and make 2nd row orthogonal to 1st. Skew.z = dot(Row[0], Row[1]); Row[1] = detail::combine(Row[1], Row[0], static_cast(1), -Skew.z); // Now, compute Y scale and normalize 2nd row. Scale.y = length(Row[1]); Row[1] = detail::scale(Row[1], static_cast(1)); Skew.z /= Scale.y; // Compute XZ and YZ shears, orthogonalize 3rd row. Skew.y = glm::dot(Row[0], Row[2]); Row[2] = detail::combine(Row[2], Row[0], static_cast(1), -Skew.y); Skew.x = glm::dot(Row[1], Row[2]); Row[2] = detail::combine(Row[2], Row[1], static_cast(1), -Skew.x); // Next, get Z scale and normalize 3rd row. Scale.z = length(Row[2]); Row[2] = detail::scale(Row[2], static_cast(1)); Skew.y /= Scale.z; Skew.x /= Scale.z; // At this point, the matrix (in rows[]) is orthonormal. // Check for a coordinate system flip. If the determinant // is -1, then negate the matrix and the scaling factors. Pdum3 = cross(Row[1], Row[2]); // v3Cross(row[1], row[2], Pdum3); if(dot(Row[0], Pdum3) < 0) { for(length_t i = 0; i < 3; i++) { Scale[i] *= static_cast(-1); Row[i] *= static_cast(-1); } } // Now, get the rotations out, as described in the gem. // FIXME - Add the ability to return either quaternions (which are // easier to recompose with) or Euler angles (rx, ry, rz), which // are easier for authors to deal with. The latter will only be useful // when we fix https://bugs.webkit.org/show_bug.cgi?id=23799, so I // will leave the Euler angle code here for now. // ret.rotateY = asin(-Row[0][2]); // if (cos(ret.rotateY) != 0) { // ret.rotateX = atan2(Row[1][2], Row[2][2]); // ret.rotateZ = atan2(Row[0][1], Row[0][0]); // } else { // ret.rotateX = atan2(-Row[2][0], Row[1][1]); // ret.rotateZ = 0; // } int i, j, k = 0; float root, trace = Row[0].x + Row[1].y + Row[2].z; if(trace > static_cast(0)) { root = sqrt(trace + static_cast(1.0)); Orientation.w = static_cast(0.5) * root; root = static_cast(0.5) / root; Orientation.x = root * (Row[1].z - Row[2].y); Orientation.y = root * (Row[2].x - Row[0].z); Orientation.z = root * (Row[0].y - Row[1].x); } // End if > 0 else { static int Next[3] = {1, 2, 0}; i = 0; if(Row[1].y > Row[0].x) i = 1; if(Row[2].z > Row[i][i]) i = 2; j = Next[i]; k = Next[j]; root = sqrt(Row[i][i] - Row[j][j] - Row[k][k] + static_cast(1.0)); Orientation[i] = static_cast(0.5) * root; root = static_cast(0.5) / root; Orientation[j] = root * (Row[i][j] + Row[j][i]); Orientation[k] = root * (Row[i][k] + Row[k][i]); Orientation.w = root * (Row[j][k] - Row[k][j]); } // End if <= 0 return true; } }//namespace glm glm-0.9.9-a2/glm/gtx/optimum_pow.inl0000600000175000001440000000063613173131001016141 0ustar guususers/// @ref gtx_optimum_pow /// @file glm/gtx/optimum_pow.inl namespace glm { template GLM_FUNC_QUALIFIER genType pow2(genType const& x) { return x * x; } template GLM_FUNC_QUALIFIER genType pow3(genType const& x) { return x * x * x; } template GLM_FUNC_QUALIFIER genType pow4(genType const& x) { return (x * x) * (x * x); } }//namespace glm glm-0.9.9-a2/glm/gtx/type_aligned.hpp0000600000175000001440000010103513173131001016226 0ustar guususers/// @ref gtx_type_aligned /// @file glm/gtx/type_aligned.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_type_aligned GLM_GTX_type_aligned /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines aligned types. /// /// @ref core_precision defines aligned types. #pragma once // Dependency: #include "../gtc/type_precision.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_type_aligned is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_type_aligned extension included") #endif namespace glm { /////////////////////////// // Signed int vector types /// @addtogroup gtx_type_aligned /// @{ /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int8, aligned_lowp_int8, 1); /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int16, aligned_lowp_int16, 2); /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int32, aligned_lowp_int32, 4); /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int64, aligned_lowp_int64, 8); /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int8_t, aligned_lowp_int8_t, 1); /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int16_t, aligned_lowp_int16_t, 2); /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int32_t, aligned_lowp_int32_t, 4); /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int64_t, aligned_lowp_int64_t, 8); /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i8, aligned_lowp_i8, 1); /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i16, aligned_lowp_i16, 2); /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i32, aligned_lowp_i32, 4); /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i64, aligned_lowp_i64, 8); /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int8, aligned_mediump_int8, 1); /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int16, aligned_mediump_int16, 2); /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int32, aligned_mediump_int32, 4); /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int64, aligned_mediump_int64, 8); /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int8_t, aligned_mediump_int8_t, 1); /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int16_t, aligned_mediump_int16_t, 2); /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int32_t, aligned_mediump_int32_t, 4); /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int64_t, aligned_mediump_int64_t, 8); /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i8, aligned_mediump_i8, 1); /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i16, aligned_mediump_i16, 2); /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i32, aligned_mediump_i32, 4); /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i64, aligned_mediump_i64, 8); /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int8, aligned_highp_int8, 1); /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int16, aligned_highp_int16, 2); /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int32, aligned_highp_int32, 4); /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int64, aligned_highp_int64, 8); /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int8_t, aligned_highp_int8_t, 1); /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int16_t, aligned_highp_int16_t, 2); /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int32_t, aligned_highp_int32_t, 4); /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int64_t, aligned_highp_int64_t, 8); /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i8, aligned_highp_i8, 1); /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i16, aligned_highp_i16, 2); /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i32, aligned_highp_i32, 4); /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i64, aligned_highp_i64, 8); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int8, aligned_int8, 1); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int16, aligned_int16, 2); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int32, aligned_int32, 4); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int64, aligned_int64, 8); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int8_t, aligned_int8_t, 1); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int16_t, aligned_int16_t, 2); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int32_t, aligned_int32_t, 4); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int64_t, aligned_int64_t, 8); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8, aligned_i8, 1); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16, aligned_i16, 2); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32, aligned_i32, 4); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64, aligned_i64, 8); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec1, aligned_ivec1, 4); /// Default qualifier 32 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec2, aligned_ivec2, 8); /// Default qualifier 32 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec3, aligned_ivec3, 16); /// Default qualifier 32 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec4, aligned_ivec4, 16); /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec1, aligned_i8vec1, 1); /// Default qualifier 8 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec2, aligned_i8vec2, 2); /// Default qualifier 8 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec3, aligned_i8vec3, 4); /// Default qualifier 8 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec4, aligned_i8vec4, 4); /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec1, aligned_i16vec1, 2); /// Default qualifier 16 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec2, aligned_i16vec2, 4); /// Default qualifier 16 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec3, aligned_i16vec3, 8); /// Default qualifier 16 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec4, aligned_i16vec4, 8); /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec1, aligned_i32vec1, 4); /// Default qualifier 32 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec2, aligned_i32vec2, 8); /// Default qualifier 32 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec3, aligned_i32vec3, 16); /// Default qualifier 32 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec4, aligned_i32vec4, 16); /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec1, aligned_i64vec1, 8); /// Default qualifier 64 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec2, aligned_i64vec2, 16); /// Default qualifier 64 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec3, aligned_i64vec3, 32); /// Default qualifier 64 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec4, aligned_i64vec4, 32); ///////////////////////////// // Unsigned int vector types /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint8, aligned_lowp_uint8, 1); /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint16, aligned_lowp_uint16, 2); /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint32, aligned_lowp_uint32, 4); /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint64, aligned_lowp_uint64, 8); /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint8_t, aligned_lowp_uint8_t, 1); /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint16_t, aligned_lowp_uint16_t, 2); /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint32_t, aligned_lowp_uint32_t, 4); /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint64_t, aligned_lowp_uint64_t, 8); /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u8, aligned_lowp_u8, 1); /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u16, aligned_lowp_u16, 2); /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u32, aligned_lowp_u32, 4); /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u64, aligned_lowp_u64, 8); /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint8, aligned_mediump_uint8, 1); /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint16, aligned_mediump_uint16, 2); /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint32, aligned_mediump_uint32, 4); /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint64, aligned_mediump_uint64, 8); /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint8_t, aligned_mediump_uint8_t, 1); /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint16_t, aligned_mediump_uint16_t, 2); /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint32_t, aligned_mediump_uint32_t, 4); /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint64_t, aligned_mediump_uint64_t, 8); /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u8, aligned_mediump_u8, 1); /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u16, aligned_mediump_u16, 2); /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u32, aligned_mediump_u32, 4); /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u64, aligned_mediump_u64, 8); /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint8, aligned_highp_uint8, 1); /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint16, aligned_highp_uint16, 2); /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint32, aligned_highp_uint32, 4); /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint64, aligned_highp_uint64, 8); /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint8_t, aligned_highp_uint8_t, 1); /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint16_t, aligned_highp_uint16_t, 2); /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint32_t, aligned_highp_uint32_t, 4); /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint64_t, aligned_highp_uint64_t, 8); /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u8, aligned_highp_u8, 1); /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u16, aligned_highp_u16, 2); /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u32, aligned_highp_u32, 4); /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u64, aligned_highp_u64, 8); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint8, aligned_uint8, 1); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint16, aligned_uint16, 2); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint32, aligned_uint32, 4); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint64, aligned_uint64, 8); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint8_t, aligned_uint8_t, 1); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint16_t, aligned_uint16_t, 2); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint32_t, aligned_uint32_t, 4); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint64_t, aligned_uint64_t, 8); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8, aligned_u8, 1); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16, aligned_u16, 2); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32, aligned_u32, 4); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64, aligned_u64, 8); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec1, aligned_uvec1, 4); /// Default qualifier 32 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec2, aligned_uvec2, 8); /// Default qualifier 32 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec3, aligned_uvec3, 16); /// Default qualifier 32 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec4, aligned_uvec4, 16); /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec1, aligned_u8vec1, 1); /// Default qualifier 8 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec2, aligned_u8vec2, 2); /// Default qualifier 8 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec3, aligned_u8vec3, 4); /// Default qualifier 8 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec4, aligned_u8vec4, 4); /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec1, aligned_u16vec1, 2); /// Default qualifier 16 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec2, aligned_u16vec2, 4); /// Default qualifier 16 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec3, aligned_u16vec3, 8); /// Default qualifier 16 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec4, aligned_u16vec4, 8); /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec1, aligned_u32vec1, 4); /// Default qualifier 32 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec2, aligned_u32vec2, 8); /// Default qualifier 32 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec3, aligned_u32vec3, 16); /// Default qualifier 32 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec4, aligned_u32vec4, 16); /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec1, aligned_u64vec1, 8); /// Default qualifier 64 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec2, aligned_u64vec2, 16); /// Default qualifier 64 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec3, aligned_u64vec3, 32); /// Default qualifier 64 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec4, aligned_u64vec4, 32); ////////////////////// // Float vector types /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32, aligned_float32, 4); /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32_t, aligned_float32_t, 4); /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32, aligned_f32, 4); # ifndef GLM_FORCE_SINGLE_ONLY /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64, aligned_float64, 8); /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64_t, aligned_float64_t, 8); /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64, aligned_f64, 8); # endif//GLM_FORCE_SINGLE_ONLY /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec1, aligned_vec1, 4); /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec2, aligned_vec2, 8); /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec3, aligned_vec3, 16); /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec4, aligned_vec4, 16); /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec1, aligned_fvec1, 4); /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec2, aligned_fvec2, 8); /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec3, aligned_fvec3, 16); /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec4, aligned_fvec4, 16); /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec1, aligned_f32vec1, 4); /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec2, aligned_f32vec2, 8); /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec3, aligned_f32vec3, 16); /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec4, aligned_f32vec4, 16); /// Double-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec1, aligned_dvec1, 8); /// Double-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec2, aligned_dvec2, 16); /// Double-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec3, aligned_dvec3, 32); /// Double-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec4, aligned_dvec4, 32); # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec1, aligned_f64vec1, 8); /// Double-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec2, aligned_f64vec2, 16); /// Double-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec3, aligned_f64vec3, 32); /// Double-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec4, aligned_f64vec4, 32); # endif//GLM_FORCE_SINGLE_ONLY ////////////////////// // Float matrix types /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1 mat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat2, aligned_mat2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat3, aligned_mat3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat4, aligned_mat4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 mat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat2x2, aligned_mat2x2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat3x3, aligned_mat3x3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat4x4, aligned_mat4x4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 fmat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f32 fmat1x1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2x2, 16); /// Single-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x3, aligned_fmat2x3, 16); /// Single-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x4, aligned_fmat2x4, 16); /// Single-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x2, aligned_fmat3x2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3x3, 16); /// Single-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x4, aligned_fmat3x4, 16); /// Single-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x2, aligned_fmat4x2, 16); /// Single-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x3, aligned_fmat4x3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4x4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 f32mat1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4, 16); /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f32 f32mat1x1; /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2x2, 16); /// Single-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x3, aligned_f32mat2x3, 16); /// Single-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x4, aligned_f32mat2x4, 16); /// Single-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x2, aligned_f32mat3x2, 16); /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3x3, 16); /// Single-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x4, aligned_f32mat3x4, 16); /// Single-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x2, aligned_f32mat4x2, 16); /// Single-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x3, aligned_f32mat4x3, 16); /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4x4, 16); # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 f64mat1; /// Double-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2, 32); /// Double-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3, 32); /// Double-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4, 32); /// Double-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f64 f64mat1x1; /// Double-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2x2, 32); /// Double-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x3, aligned_f64mat2x3, 32); /// Double-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x4, aligned_f64mat2x4, 32); /// Double-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x2, aligned_f64mat3x2, 32); /// Double-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3x3, 32); /// Double-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x4, aligned_f64mat3x4, 32); /// Double-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x2, aligned_f64mat4x2, 32); /// Double-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x3, aligned_f64mat4x3, 32); /// Double-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4x4, 32); # endif//GLM_FORCE_SINGLE_ONLY ////////////////////////// // Quaternion types /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(quat, aligned_quat, 16); /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fquat, aligned_fquat, 16); /// Double-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dquat, aligned_dquat, 32); /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32quat, aligned_f32quat, 16); # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64quat, aligned_f64quat, 32); # endif//GLM_FORCE_SINGLE_ONLY /// @} }//namespace glm #include "type_aligned.inl" glm-0.9.9-a2/glm/gtx/integer.inl0000600000175000001440000000741613173131001015222 0ustar guususers/// @ref gtx_integer /// @file glm/gtx/integer.inl namespace glm { // pow GLM_FUNC_QUALIFIER int pow(int x, uint y) { if(y == 0) return x >= 0 ? 1 : -1; int result = x; for(uint i = 1; i < y; ++i) result *= x; return result; } // sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387 GLM_FUNC_QUALIFIER int sqrt(int x) { if(x <= 1) return x; int NextTrial = x >> 1; int CurrentAnswer; do { CurrentAnswer = NextTrial; NextTrial = (NextTrial + x / NextTrial) >> 1; } while(NextTrial < CurrentAnswer); return CurrentAnswer; } // Henry Gordon Dietz: http://aggregate.org/MAGIC/ namespace detail { GLM_FUNC_QUALIFIER unsigned int ones32(unsigned int x) { /* 32-bit recursive reduction using SWAR... but first step is mapping 2-bit values into sum of 2 1-bit values in sneaky way */ x -= ((x >> 1) & 0x55555555); x = (((x >> 2) & 0x33333333) + (x & 0x33333333)); x = (((x >> 4) + x) & 0x0f0f0f0f); x += (x >> 8); x += (x >> 16); return(x & 0x0000003f); } }//namespace detail // Henry Gordon Dietz: http://aggregate.org/MAGIC/ /* GLM_FUNC_QUALIFIER unsigned int floor_log2(unsigned int x) { x |= (x >> 1); x |= (x >> 2); x |= (x >> 4); x |= (x >> 8); x |= (x >> 16); return _detail::ones32(x) >> 1; } */ // mod GLM_FUNC_QUALIFIER int mod(int x, int y) { return x - y * (x / y); } // factorial (!12 max, integer only) template GLM_FUNC_QUALIFIER genType factorial(genType const& x) { genType Temp = x; genType Result; for(Result = 1; Temp > 1; --Temp) Result *= Temp; return Result; } template GLM_FUNC_QUALIFIER vec<2, T, Q> factorial( vec<2, T, Q> const& x) { return vec<2, T, Q>( factorial(x.x), factorial(x.y)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> factorial( vec<3, T, Q> const& x) { return vec<3, T, Q>( factorial(x.x), factorial(x.y), factorial(x.z)); } template GLM_FUNC_QUALIFIER vec<4, T, Q> factorial( vec<4, T, Q> const& x) { return vec<4, T, Q>( factorial(x.x), factorial(x.y), factorial(x.z), factorial(x.w)); } GLM_FUNC_QUALIFIER uint pow(uint x, uint y) { if (y == 0) return 1u; uint result = x; for(uint i = 1; i < y; ++i) result *= x; return result; } GLM_FUNC_QUALIFIER uint sqrt(uint x) { if(x <= 1) return x; uint NextTrial = x >> 1; uint CurrentAnswer; do { CurrentAnswer = NextTrial; NextTrial = (NextTrial + x / NextTrial) >> 1; } while(NextTrial < CurrentAnswer); return CurrentAnswer; } GLM_FUNC_QUALIFIER uint mod(uint x, uint y) { return x - y * (x / y); } #if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC)) GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) { return 31u - findMSB(x); } #else // Hackers Delight: http://www.hackersdelight.org/HDcode/nlz.c.txt GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) { int y, m, n; y = -int(x >> 16); // If left half of x is 0, m = (y >> 16) & 16; // set n = 16. If left half n = 16 - m; // is nonzero, set n = 0 and x = x >> m; // shift x right 16. // Now x is of the form 0000xxxx. y = x - 0x100; // If positions 8-15 are 0, m = (y >> 16) & 8; // add 8 to n and shift x left 8. n = n + m; x = x << m; y = x - 0x1000; // If positions 12-15 are 0, m = (y >> 16) & 4; // add 4 to n and shift x left 4. n = n + m; x = x << m; y = x - 0x4000; // If positions 14-15 are 0, m = (y >> 16) & 2; // add 2 to n and shift x left 2. n = n + m; x = x << m; y = x >> 14; // Set y = 0, 1, 2, or 3. m = y & ~(y >> 1); // Set m = 0, 1, 2, or 2 resp. return unsigned(n + 2 - m); } #endif//(GLM_COMPILER) }//namespace glm glm-0.9.9-a2/glm/gtx/compatibility.hpp0000600000175000001440000003520313173131001016436 0ustar guususers/// @ref gtx_compatibility /// @file glm/gtx/compatibility.hpp /// /// @see core (dependence) /// /// @defgroup gtx_compatibility GLM_GTX_compatibility /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Provide functions to increase the compatibility with Cg and HLSL languages #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/quaternion.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_compatibility is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_compatibility extension included") #endif #if GLM_COMPILER & GLM_COMPILER_VC # include #elif GLM_COMPILER & GLM_COMPILER_GCC # include # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) # undef isfinite # endif #endif//GLM_COMPILER namespace glm { /// @addtogroup gtx_compatibility /// @{ template GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, const vec<2, T, Q>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, const vec<3, T, Q>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, const vec<4, T, Q>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> saturate(const vec<2, T, Q>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> saturate(const vec<3, T, Q>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> saturate(const vec<4, T, Q>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<2, T, Q> atan2(const vec<2, T, Q>& x, const vec<2, T, Q>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<3, T, Q> atan2(const vec<3, T, Q>& x, const vec<3, T, Q>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_QUALIFIER vec<4, T, Q> atan2(const vec<4, T, Q>& x, const vec<4, T, Q>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) template GLM_FUNC_DECL bool isfinite(genType const& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<1, bool, Q> isfinite(const vec<1, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<2, bool, Q> isfinite(const vec<2, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<3, bool, Q> isfinite(const vec<3, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template GLM_FUNC_DECL vec<4, bool, Q> isfinite(const vec<4, T, Q>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, bool, highp> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, bool, highp> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension) typedef bool bool1x1; //!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, bool, highp> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, bool, highp> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, bool, highp> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, bool, highp> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, bool, highp> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, bool, highp> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, bool, highp> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, bool, highp> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, bool, highp> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) typedef int int1; //!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, int, highp> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, int, highp> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, int, highp> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension) typedef int int1x1; //!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, int, highp> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, int, highp> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, int, highp> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, int, highp> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, int, highp> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, int, highp> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, int, highp> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, int, highp> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, int, highp> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) typedef float float1; //!< \brief single-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, float, highp> float2; //!< \brief single-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, float, highp> float3; //!< \brief single-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, float, highp> float4; //!< \brief single-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension) typedef float float1x1; //!< \brief single-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, float, highp> float2x2; //!< \brief single-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, float, highp> float2x3; //!< \brief single-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, float, highp> float2x4; //!< \brief single-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, float, highp> float3x2; //!< \brief single-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, float, highp> float3x3; //!< \brief single-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, float, highp> float3x4; //!< \brief single-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, float, highp> float4x2; //!< \brief single-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, float, highp> float4x3; //!< \brief single-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, float, highp> float4x4; //!< \brief single-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) typedef double double1; //!< \brief double-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) typedef vec<2, double, highp> double2; //!< \brief double-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) typedef vec<3, double, highp> double3; //!< \brief double-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) typedef vec<4, double, highp> double4; //!< \brief double-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension) typedef double double1x1; //!< \brief double-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) typedef mat<2, 2, double, highp> double2x2; //!< \brief double-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<2, 3, double, highp> double2x3; //!< \brief double-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<2, 4, double, highp> double2x4; //!< \brief double-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<3, 2, double, highp> double3x2; //!< \brief double-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<3, 3, double, highp> double3x3; //!< \brief double-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<3, 4, double, highp> double3x4; //!< \brief double-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) typedef mat<4, 2, double, highp> double4x2; //!< \brief double-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) typedef mat<4, 3, double, highp> double4x3; //!< \brief double-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, double, highp> double4x4; //!< \brief double-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) /// @} }//namespace glm #include "compatibility.inl" glm-0.9.9-a2/glm/gtx/vector_angle.inl0000600000175000001440000000265513173131001016235 0ustar guususers/// @ref gtx_vector_angle /// @file glm/gtx/vector_angle.inl namespace glm { template GLM_FUNC_QUALIFIER genType angle ( genType const& x, genType const& y ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); return acos(clamp(dot(x, y), genType(-1), genType(1))); } template GLM_FUNC_QUALIFIER T angle(vec const& x, vec const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); return acos(clamp(dot(x, y), T(-1), T(1))); } //! \todo epsilon is hard coded to 0.01 template GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); if(all(epsilonEqual(y, glm::rotate(x, Angle), T(0.0001)))) return Angle; else return -Angle; } template GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); } }//namespace glm glm-0.9.9-a2/glm/gtx/normalize_dot.hpp0000600000175000001440000000276013173131001016435 0ustar guususers/// @ref gtx_normalize_dot /// @file glm/gtx/normalize_dot.hpp /// /// @see core (dependence) /// @see gtx_fast_square_root (dependence) /// /// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Dot product of vectors that need to be normalize with a single square root. #pragma once // Dependency: #include "../gtx/fast_square_root.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_normalize_dot is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_normalize_dot extension included") #endif namespace glm { /// @addtogroup gtx_normalize_dot /// @{ /// Normalize parameters and returns the dot product of x and y. /// It's faster that dot(normalize(x), normalize(y)). /// /// @see gtx_normalize_dot extension. template GLM_FUNC_DECL T normalizeDot(vec const& x, vec const& y); /// Normalize parameters and returns the dot product of x and y. /// Faster that dot(fastNormalize(x), fastNormalize(y)). /// /// @see gtx_normalize_dot extension. template GLM_FUNC_DECL T fastNormalizeDot(vec const& x, vec const& y); /// @} }//namespace glm #include "normalize_dot.inl" glm-0.9.9-a2/glm/gtx/vector_query.hpp0000600000175000001440000000422413173131001016313 0ustar guususers/// @ref gtx_vector_query /// @file glm/gtx/vector_query.hpp /// /// @see core (dependence) /// /// @defgroup gtx_vector_query GLM_GTX_vector_query /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Query informations of vector types #pragma once // Dependency: #include "../glm.hpp" #include #include #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_vector_query is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_vector_query extension included") #endif namespace glm { /// @addtogroup gtx_vector_query /// @{ //! Check whether two vectors are collinears. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool areCollinear(vec const& v0, vec const& v1, T const& epsilon); //! Check whether two vectors are orthogonals. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon); //! Check whether a vector is normalized. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool isNormalized(vec const& v, T const& epsilon); //! Check whether a vector is null. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool isNull(vec const& v, T const& epsilon); //! Check whether a each component of a vector is null. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL vec isCompNull(vec const& v, T const& epsilon); //! Check whether two vectors are orthonormal. /// @see gtx_vector_query extensions. template GLM_FUNC_DECL bool areOrthonormal(vec const& v0, vec const& v1, T const& epsilon); /// @} }// namespace glm #include "vector_query.inl" glm-0.9.9-a2/glm/gtx/matrix_factorisation.hpp0000600000175000001440000000547513173131001020026 0ustar guususers/// @ref gtx_matrix_factorisation /// @file glm/gtx/matrix_factorisation.hpp /// /// @see core (dependence) /// /// @defgroup gtx_matrix_factorisation GLM_GTX_matrix_factorisation /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Functions to factor matrices in various forms #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_factorisation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_factorisation extension included") #endif /* Suggestions: - Move helper functions flipud and fliplr to another file: They may be helpful in more general circumstances. - Implement other types of matrix factorisation, such as: QL and LQ, L(D)U, eigendecompositions, etc... */ namespace glm { /// @addtogroup gtx_matrix_factorisation /// @{ /// Flips the matrix rows up and down. /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL mat flipud(mat const& in); /// Flips the matrix columns right and left. /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL mat fliplr(mat const& in); /// Performs QR factorisation of a matrix. /// Returns 2 matrices, q and r, such that the columns of q are orthonormal and span the same subspace than those of the input matrix, r is an upper triangular matrix, and q*r=in. /// Given an n-by-m input matrix, q has dimensions min(n,m)-by-m, and r has dimensions n-by-min(n,m). /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL void qr_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& q, mat& r); /// Performs RQ factorisation of a matrix. /// Returns 2 matrices, r and q, such that r is an upper triangular matrix, the rows of q are orthonormal and span the same subspace than those of the input matrix, and r*q=in. /// Note that in the context of RQ factorisation, the diagonal is seen as starting in the lower-right corner of the matrix, instead of the usual upper-left. /// Given an n-by-m input matrix, r has dimensions min(n,m)-by-m, and q has dimensions n-by-min(n,m). /// /// From GLM_GTX_matrix_factorisation extension. template GLM_FUNC_DECL void rq_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& r, mat& q); /// @} } #include "matrix_factorisation.inl" glm-0.9.9-a2/glm/gtx/optimum_pow.hpp0000600000175000001440000000242113173131001016140 0ustar guususers/// @ref gtx_optimum_pow /// @file glm/gtx/optimum_pow.hpp /// /// @see core (dependence) /// /// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Integer exponentiation of power functions. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_optimum_pow is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_optimum_pow extension included") #endif namespace glm{ namespace gtx { /// @addtogroup gtx_optimum_pow /// @{ /// Returns x raised to the power of 2. /// /// @see gtx_optimum_pow template GLM_FUNC_DECL genType pow2(genType const& x); /// Returns x raised to the power of 3. /// /// @see gtx_optimum_pow template GLM_FUNC_DECL genType pow3(genType const& x); /// Returns x raised to the power of 4. /// /// @see gtx_optimum_pow template GLM_FUNC_DECL genType pow4(genType const& x); /// @} }//namespace gtx }//namespace glm #include "optimum_pow.inl" glm-0.9.9-a2/glm/gtx/fast_square_root.hpp0000600000175000001440000000555713173131001017156 0ustar guususers/// @ref gtx_fast_square_root /// @file glm/gtx/fast_square_root.hpp /// /// @see core (dependence) /// /// @defgroup gtx_fast_square_root GLM_GTX_fast_square_root /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Fast but less accurate implementations of square root based functions. /// - Sqrt optimisation based on Newton's method, /// www.gamedev.net/community/forums/topic.asp?topic id=139956 #pragma once // Dependency: #include "../common.hpp" #include "../exponential.hpp" #include "../geometric.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_fast_square_root is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_fast_square_root extension included") #endif namespace glm { /// @addtogroup gtx_fast_square_root /// @{ /// Faster than the common sqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastSqrt(genType x); /// Faster than the common sqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL vec fastSqrt(vec const& x); /// Faster than the common inversesqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastInverseSqrt(genType x); /// Faster than the common inversesqrt function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL vec fastInverseSqrt(vec const& x); /// Faster than the common length function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastLength(genType x); /// Faster than the common length function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL T fastLength(vec const& x); /// Faster than the common distance function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastDistance(genType x, genType y); /// Faster than the common distance function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL T fastDistance(vec const& x, vec const& y); /// Faster than the common normalize function but less accurate. /// /// @see gtx_fast_square_root extension. template GLM_FUNC_DECL genType fastNormalize(genType const& x); /// @} }// namespace glm #include "fast_square_root.inl" glm-0.9.9-a2/glm/gtx/texture.inl0000600000175000001440000000052313173131001015255 0ustar guususers/// @ref gtx_texture /// @file glm/gtx/texture.inl namespace glm { template inline T levels(vec const& Extent) { return glm::log2(compMax(Extent)) + static_cast(1); } template inline T levels(T Extent) { return vec<1, T, defaultp>(Extent).x; } }//namespace glm glm-0.9.9-a2/glm/gtx/bit.inl0000600000175000001440000000432713173131001014341 0ustar guususers/// @ref gtx_bit /// @file glm/gtx/bit.inl namespace glm { /////////////////// // highestBitValue template GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value) { genIUType tmp = Value; genIUType result = genIUType(0); while(tmp) { result = (tmp & (~tmp + 1)); // grab lowest bit tmp &= ~result; // clear lowest bit } return result; } template GLM_FUNC_QUALIFIER vec highestBitValue(vec const& v) { return detail::functor1::call(highestBitValue, v); } /////////////////// // lowestBitValue template GLM_FUNC_QUALIFIER genIUType lowestBitValue(genIUType Value) { return (Value & (~Value + 1)); } template GLM_FUNC_QUALIFIER vec lowestBitValue(vec const& v) { return detail::functor1::call(lowestBitValue, v); } /////////////////// // powerOfTwoAbove template GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value) { return isPowerOfTwo(value) ? value : highestBitValue(value) << 1; } template GLM_FUNC_QUALIFIER vec powerOfTwoAbove(vec const& v) { return detail::functor1::call(powerOfTwoAbove, v); } /////////////////// // powerOfTwoBelow template GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value) { return isPowerOfTwo(value) ? value : highestBitValue(value); } template GLM_FUNC_QUALIFIER vec powerOfTwoBelow(vec const& v) { return detail::functor1::call(powerOfTwoBelow, v); } ///////////////////// // powerOfTwoNearest template GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value) { if(isPowerOfTwo(value)) return value; genType const prev = highestBitValue(value); genType const next = prev << 1; return (next - value) < (value - prev) ? next : prev; } template GLM_FUNC_QUALIFIER vec powerOfTwoNearest(vec const& v) { return detail::functor1::call(powerOfTwoNearest, v); } }//namespace glm glm-0.9.9-a2/glm/gtx/fast_trigonometry.hpp0000600000175000001440000000453713173131001017352 0ustar guususers/// @ref gtx_fast_trigonometry /// @file glm/gtx/fast_trigonometry.hpp /// /// @see core (dependence) /// /// @defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Fast but less accurate implementations of trigonometric functions. #pragma once // Dependency: #include "../gtc/constants.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_fast_trigonometry is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_fast_trigonometry extension included") #endif namespace glm { /// @addtogroup gtx_fast_trigonometry /// @{ /// Wrap an angle to [0 2pi[ /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T wrapAngle(T angle); /// Faster than the common sin function but less accurate. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastSin(T angle); /// Faster than the common cos function but less accurate. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastCos(T angle); /// Faster than the common tan function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastTan(T angle); /// Faster than the common asin function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAsin(T angle); /// Faster than the common acos function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAcos(T angle); /// Faster than the common atan function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAtan(T y, T x); /// Faster than the common atan function but less accurate. /// Defined between -2pi and 2pi. /// From GLM_GTX_fast_trigonometry extension. template GLM_FUNC_DECL T fastAtan(T angle); /// @} }//namespace glm #include "fast_trigonometry.inl" glm-0.9.9-a2/glm/gtx/exterior_product.hpp0000600000175000001440000000211613173131001017163 0ustar guususers/// @ref gtx_exterior_product /// @file glm/gtx/exterior_product.hpp /// /// @see core (dependence) /// @see gtx_exterior_product (dependence) /// /// @defgroup gtx_exterior_product GLM_GTX_exterior_product /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_exterior_product extension included") #endif namespace glm { /// @addtogroup gtx_exterior_product /// @{ /// Returns the cross product of x and y. /// /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see Exterior product template GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u); /// @} } //namespace glm #include "exterior_product.inl" glm-0.9.9-a2/glm/gtx/component_wise.hpp0000600000175000001440000000445413173131001016622 0ustar guususers/// @ref gtx_component_wise /// @file glm/gtx/component_wise.hpp /// @date 2007-05-21 / 2011-06-07 /// @author Christophe Riccio /// /// @see core (dependence) /// /// @defgroup gtx_component_wise GLM_GTX_component_wise /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Operations between components of a type #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_component_wise is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_component_wise extension included") #endif namespace glm { /// @addtogroup gtx_component_wise /// @{ /// Convert an integer vector to a normalized float vector. /// If the parameter value type is already a floating qualifier type, the value is passed through. /// @see gtx_component_wise template GLM_FUNC_DECL vec compNormalize(vec const& v); /// Convert a normalized float vector to an integer vector. /// If the parameter value type is already a floating qualifier type, the value is passed through. /// @see gtx_component_wise template GLM_FUNC_DECL vec compScale(vec const& v); /// Add all vector components together. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compAdd(genType const& v); /// Multiply all vector components together. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compMul(genType const& v); /// Find the minimum value between single vector components. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compMin(genType const& v); /// Find the maximum value between single vector components. /// @see gtx_component_wise template GLM_FUNC_DECL typename genType::value_type compMax(genType const& v); /// @} }//namespace glm #include "component_wise.inl" glm-0.9.9-a2/glm/gtx/type_trait.hpp0000600000175000001440000001043113173131001015745 0ustar guususers/// @ref gtx_type_trait /// @file glm/gtx/type_trait.hpp /// /// @see core (dependence) /// /// @defgroup gtx_type_trait GLM_GTX_type_trait /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines traits for each type. #pragma once #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_type_trait is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif // Dependency: #include "../detail/type_vec2.hpp" #include "../detail/type_vec3.hpp" #include "../detail/type_vec4.hpp" #include "../detail/type_mat2x2.hpp" #include "../detail/type_mat2x3.hpp" #include "../detail/type_mat2x4.hpp" #include "../detail/type_mat3x2.hpp" #include "../detail/type_mat3x3.hpp" #include "../detail/type_mat3x4.hpp" #include "../detail/type_mat4x2.hpp" #include "../detail/type_mat4x3.hpp" #include "../detail/type_mat4x4.hpp" #include "../gtc/quaternion.hpp" #include "../gtx/dual_quaternion.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_type_trait extension included") #endif namespace glm { /// @addtogroup gtx_type_trait /// @{ template struct type { static bool const is_vec = false; static bool const is_mat = false; static bool const is_quat = false; static length_t const components = 0; static length_t const cols = 0; static length_t const rows = 0; }; template struct type > { static bool const is_vec = true; static bool const is_mat = false; static bool const is_quat = false; enum { components = L }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 2, cols = 2, rows = 2 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 2, cols = 2, rows = 3 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 2, cols = 2, rows = 4 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 3, cols = 3, rows = 2 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 3, cols = 3, rows = 3 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 3, cols = 3, rows = 4 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 4, cols = 4, rows = 2 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 4, cols = 4, rows = 3 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = true; static bool const is_quat = false; enum { components = 4, cols = 4, rows = 4 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = false; static bool const is_quat = true; enum { components = 4 }; }; template struct type > { static bool const is_vec = false; static bool const is_mat = false; static bool const is_quat = true; enum { components = 8 }; }; /// @} }//namespace glm #include "type_trait.inl" glm-0.9.9-a2/glm/gtx/wrap.hpp0000600000175000001440000000262613173131001014541 0ustar guususers/// @ref gtx_wrap /// @file glm/gtx/wrap.hpp /// /// @see core (dependence) /// /// @defgroup gtx_wrap GLM_GTX_wrap /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Wrapping mode of texture coordinates. #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/vec1.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_wrap extension included") #endif namespace glm { /// @addtogroup gtx_wrap /// @{ /// Simulate GL_CLAMP OpenGL wrap mode /// @see gtx_wrap extension. template GLM_FUNC_DECL genType clamp(genType const& Texcoord); /// Simulate GL_REPEAT OpenGL wrap mode /// @see gtx_wrap extension. template GLM_FUNC_DECL genType repeat(genType const& Texcoord); /// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode /// @see gtx_wrap extension. template GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord); /// Simulate GL_MIRROR_REPEAT OpenGL wrap mode /// @see gtx_wrap extension. template GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord); /// @} }// namespace glm #include "wrap.inl" glm-0.9.9-a2/glm/gtx/hash.hpp0000600000175000001440000000640513173131001014512 0ustar guususers/// @ref gtx_hash /// @file glm/gtx/hash.hpp /// /// @see core (dependence) /// /// @defgroup gtx_hash GLM_GTX_hash /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add std::hash support for glm types #pragma once #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_hash is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #include #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../gtc/vec1.hpp" #include "../gtc/quaternion.hpp" #include "../gtx/dual_quaternion.hpp" #include "../mat2x2.hpp" #include "../mat2x3.hpp" #include "../mat2x4.hpp" #include "../mat3x2.hpp" #include "../mat3x3.hpp" #include "../mat3x4.hpp" #include "../mat4x2.hpp" #include "../mat4x3.hpp" #include "../mat4x4.hpp" #if !GLM_HAS_CXX11_STL # error "GLM_GTX_hash requires C++11 standard library support" #endif namespace std { template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<1, T, Q> const& v) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<2, T, Q> const& v) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<3, T, Q> const& v) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<4, T, Q> const& v) const; }; template struct hash> { GLM_FUNC_DECL size_t operator()(glm::tquat const& q) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::tdualquat const& q) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 2, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 3, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 4, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 2, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 3, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 4, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 2, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 3, T,Q> const& m) const; }; template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 4, T,Q> const& m) const; }; } // namespace std #include "hash.inl" glm-0.9.9-a2/glm/gtx/number_precision.inl0000600000175000001440000000013113173131001017113 0ustar guususers/// @ref gtx_number_precision /// @file glm/gtx/number_precision.inl namespace glm { } glm-0.9.9-a2/glm/gtx/normalize_dot.inl0000600000175000001440000000102013173131001016414 0ustar guususers/// @ref gtx_normalize_dot /// @file glm/gtx/normalize_dot.inl namespace glm { template GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) { return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); } template GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) { return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); } }//namespace glm glm-0.9.9-a2/glm/gtx/matrix_query.hpp0000600000175000001440000000526513173131001016323 0ustar guususers/// @ref gtx_matrix_query /// @file glm/gtx/matrix_query.hpp /// /// @see core (dependence) /// @see gtx_vector_query (dependence) /// /// @defgroup gtx_matrix_query GLM_GTX_matrix_query /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Query to evaluate matrix properties #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/vector_query.hpp" #include #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_query is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_query extension included") #endif namespace glm { /// @addtogroup gtx_matrix_query /// @{ /// Return whether a matrix a null matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNull(mat<2, 2, T, Q> const& m, T const& epsilon); /// Return whether a matrix a null matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNull(mat<3, 3, T, Q> const& m, T const& epsilon); /// Return whether a matrix is a null matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNull(mat<4, 4, T, Q> const& m, T const& epsilon); /// Return whether a matrix is an identity matrix. /// From GLM_GTX_matrix_query extension. template class matType> GLM_FUNC_DECL bool isIdentity(matType const& m, T const& epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNormalized(mat<2, 2, T, Q> const& m, T const& epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNormalized(mat<3, 3, T, Q> const& m, T const& epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. template GLM_FUNC_DECL bool isNormalized(mat<4, 4, T, Q> const& m, T const& epsilon); /// Return whether a matrix is an orthonormalized matrix. /// From GLM_GTX_matrix_query extension. template class matType> GLM_FUNC_DECL bool isOrthogonal(matType const& m, T const& epsilon); /// @} }//namespace glm #include "matrix_query.inl" glm-0.9.9-a2/glm/gtx/mixed_product.inl0000600000175000001440000000044113173131001016422 0ustar guususers/// @ref gtx_mixed_product /// @file glm/gtx/mixed_product.inl namespace glm { template GLM_FUNC_QUALIFIER T mixedProduct ( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3 ) { return dot(cross(v1, v2), v3); } }//namespace glm glm-0.9.9-a2/glm/gtx/color_space.inl0000600000175000001440000000630013173131001016045 0ustar guususers/// @ref gtx_color_space /// @file glm/gtx/color_space.inl namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> rgbColor(const vec<3, T, Q>& hsvColor) { vec<3, T, Q> hsv = hsvColor; vec<3, T, Q> rgbColor; if(hsv.y == static_cast(0)) // achromatic (grey) rgbColor = vec<3, T, Q>(hsv.z); else { T sector = floor(hsv.x * (T(1) / T(60))); T frac = (hsv.x * (T(1) / T(60))) - sector; // factorial part of h T o = hsv.z * (T(1) - hsv.y); T p = hsv.z * (T(1) - hsv.y * frac); T q = hsv.z * (T(1) - hsv.y * (T(1) - frac)); switch(int(sector)) { default: case 0: rgbColor.r = hsv.z; rgbColor.g = q; rgbColor.b = o; break; case 1: rgbColor.r = p; rgbColor.g = hsv.z; rgbColor.b = o; break; case 2: rgbColor.r = o; rgbColor.g = hsv.z; rgbColor.b = q; break; case 3: rgbColor.r = o; rgbColor.g = p; rgbColor.b = hsv.z; break; case 4: rgbColor.r = q; rgbColor.g = o; rgbColor.b = hsv.z; break; case 5: rgbColor.r = hsv.z; rgbColor.g = o; rgbColor.b = p; break; } } return rgbColor; } template GLM_FUNC_QUALIFIER vec<3, T, Q> hsvColor(const vec<3, T, Q>& rgbColor) { vec<3, T, Q> hsv = rgbColor; float Min = min(min(rgbColor.r, rgbColor.g), rgbColor.b); float Max = max(max(rgbColor.r, rgbColor.g), rgbColor.b); float Delta = Max - Min; hsv.z = Max; if(Max != static_cast(0)) { hsv.y = Delta / hsv.z; T h = static_cast(0); if(rgbColor.r == Max) // between yellow & magenta h = static_cast(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta; else if(rgbColor.g == Max) // between cyan & yellow h = static_cast(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta; else // between magenta & cyan h = static_cast(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta; if(h < T(0)) hsv.x = h + T(360); else hsv.x = h; } else { // If r = g = b = 0 then s = 0, h is undefined hsv.y = static_cast(0); hsv.x = static_cast(0); } return hsv; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> saturation(T const s) { vec<3, T, defaultp> rgbw = vec<3, T, defaultp>(T(0.2126), T(0.7152), T(0.0722)); vec<3, T, defaultp> const col((T(1) - s) * rgbw); mat<4, 4, T, defaultp> result(T(1)); result[0][0] = col.x + s; result[0][1] = col.x; result[0][2] = col.x; result[1][0] = col.y; result[1][1] = col.y + s; result[1][2] = col.y; result[2][0] = col.z; result[2][1] = col.z; result[2][2] = col.z + s; return result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> saturation(const T s, const vec<3, T, Q>& color) { return vec<3, T, Q>(saturation(s) * vec<4, T, Q>(color, T(0))); } template GLM_FUNC_QUALIFIER vec<4, T, Q> saturation(const T s, const vec<4, T, Q>& color) { return saturation(s) * color; } template GLM_FUNC_QUALIFIER T luminosity(const vec<3, T, Q>& color) { const vec<3, T, Q> tmp = vec<3, T, Q>(0.33, 0.59, 0.11); return dot(color, tmp); } }//namespace glm glm-0.9.9-a2/glm/gtx/matrix_decompose.hpp0000600000175000001440000000255613173131001017134 0ustar guususers/// @ref gtx_matrix_decompose /// @file glm/gtx/matrix_decompose.hpp /// /// @see core (dependence) /// /// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Decomposes a model matrix to translations, rotation and scale components #pragma once // Dependencies #include "../mat4x4.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../geometric.hpp" #include "../gtc/quaternion.hpp" #include "../gtc/matrix_transform.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_decompose is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_decompose extension included") #endif namespace glm { /// @addtogroup gtx_matrix_decompose /// @{ /// Decomposes a model matrix to translations, rotation and scale components /// @see gtx_matrix_decompose template GLM_FUNC_DECL bool decompose( mat<4, 4, T, Q> const& modelMatrix, vec<3, T, Q> & scale, tquat & orientation, vec<3, T, Q> & translation, vec<3, T, Q> & skew, vec<4, T, Q> & perspective); /// @} }//namespace glm #include "matrix_decompose.inl" glm-0.9.9-a2/glm/gtx/gradient_paint.hpp0000600000175000001440000000265313173131001016560 0ustar guususers/// @ref gtx_gradient_paint /// @file glm/gtx/gradient_paint.hpp /// /// @see core (dependence) /// @see gtx_optimum_pow (dependence) /// /// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Functions that return the color of procedural gradient for specific coordinates. #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/optimum_pow.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_gradient_paint is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_gradient_paint extension included") #endif namespace glm { /// @addtogroup gtx_gradient_paint /// @{ /// Return a color from a radial gradient. /// @see - gtx_gradient_paint template GLM_FUNC_DECL T radialGradient( vec<2, T, Q> const& Center, T const& Radius, vec<2, T, Q> const& Focal, vec<2, T, Q> const& Position); /// Return a color from a linear gradient. /// @see - gtx_gradient_paint template GLM_FUNC_DECL T linearGradient( vec<2, T, Q> const& Point0, vec<2, T, Q> const& Point1, vec<2, T, Q> const& Position); /// @} }// namespace glm #include "gradient_paint.inl" glm-0.9.9-a2/glm/gtx/type_trait.inl0000600000175000001440000000000013173131001015727 0ustar guususersglm-0.9.9-a2/glm/gtx/vector_angle.hpp0000600000175000001440000000336713173131001016243 0ustar guususers/// @ref gtx_vector_angle /// @file glm/gtx/vector_angle.hpp /// /// @see core (dependence) /// @see gtx_quaternion (dependence) /// @see gtx_epsilon (dependence) /// /// @defgroup gtx_vector_angle GLM_GTX_vector_angle /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Compute angle between vectors #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/epsilon.hpp" #include "../gtx/quaternion.hpp" #include "../gtx/rotate_vector.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_vector_angle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_vector_angle extension included") #endif namespace glm { /// @addtogroup gtx_vector_angle /// @{ //! Returns the absolute angle between two vectors. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. template GLM_FUNC_DECL T angle(vec const& x, vec const& y); //! Returns the oriented angle between two 2d vectors. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. template GLM_FUNC_DECL T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y); //! Returns the oriented angle between two 3d vectors based from a reference axis. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. template GLM_FUNC_DECL T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref); /// @} }// namespace glm #include "vector_angle.inl" glm-0.9.9-a2/glm/gtx/quaternion.hpp0000600000175000001440000001377513173131001015764 0ustar guususers/// @ref gtx_quaternion /// @file glm/gtx/quaternion.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_quaternion GLM_GTX_quaternion /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Extented quaternion types and functions #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/constants.hpp" #include "../gtc/quaternion.hpp" #include "../gtx/norm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_quaternion is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_quaternion extension included") #endif namespace glm { /// @addtogroup gtx_quaternion /// @{ /// Create an identity quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat quat_identity(); /// Compute a cross product between a quaternion and a vector. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<3, T, Q> cross( tquat const& q, vec<3, T, Q> const& v); //! Compute a cross product between a vector and a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<3, T, Q> cross( vec<3, T, Q> const& v, tquat const& q); //! Compute a point on a path according squad equation. //! q1 and q2 are control points; s1 and s2 are intermediate control points. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat squad( tquat const& q1, tquat const& q2, tquat const& s1, tquat const& s2, T const& h); //! Returns an intermediate control point for squad interpolation. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat intermediate( tquat const& prev, tquat const& curr, tquat const& next); //! Returns a exp of a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat exp( tquat const& q); //! Returns a log of a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat log( tquat const& q); /// Returns x raised to the y power. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat pow( tquat const& x, T const& y); //! Returns quarternion square root. /// /// @see gtx_quaternion //template //tquat sqrt( // tquat const& q); //! Rotates a 3 components vector by a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<3, T, Q> rotate( tquat const& q, vec<3, T, Q> const& v); /// Rotates a 4 components vector by a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL vec<4, T, Q> rotate( tquat const& q, vec<4, T, Q> const& v); /// Extract the real component of a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL T extractRealComponent( tquat const& q); /// Converts a quaternion to a 3 * 3 matrix. /// /// @see gtx_quaternion template GLM_FUNC_DECL mat<3, 3, T, Q> toMat3( tquat const& x){return mat3_cast(x);} /// Converts a quaternion to a 4 * 4 matrix. /// /// @see gtx_quaternion template GLM_FUNC_DECL mat<4, 4, T, Q> toMat4( tquat const& x){return mat4_cast(x);} /// Converts a 3 * 3 matrix to a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat toQuat( mat<3, 3, T, Q> const& x){return quat_cast(x);} /// Converts a 4 * 4 matrix to a quaternion. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat toQuat( mat<4, 4, T, Q> const& x){return quat_cast(x);} /// Quaternion interpolation using the rotation short path. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat shortMix( tquat const& x, tquat const& y, T const& a); /// Quaternion normalized linear interpolation. /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat fastMix( tquat const& x, tquat const& y, T const& a); /// Compute the rotation between two vectors. /// param orig vector, needs to be normalized /// param dest vector, needs to be normalized /// /// @see gtx_quaternion template GLM_FUNC_DECL tquat rotation( vec<3, T, Q> const& orig, vec<3, T, Q> const& dest); /// Build a look at quaternion based on the default handedness. /// /// @param direction Desired forward direction. Needs to be normalized. /// @param up Up vector, how the camera is oriented. Typically (0, 1, 0). template GLM_FUNC_DECL tquat quatLookAt( vec<3, T, Q> const& direction, vec<3, T, Q> const& up); /// Build a right-handed look at quaternion. /// /// @param direction Desired forward direction onto which the -z-axis gets mapped. Needs to be normalized. /// @param up Up vector, how the camera is oriented. Typically (0, 1, 0). template GLM_FUNC_DECL tquat quatLookAtRH( vec<3, T, Q> const& direction, vec<3, T, Q> const& up); /// Build a left-handed look at quaternion. /// /// @param direction Desired forward direction onto which the +z-axis gets mapped. Needs to be normalized. /// @param up Up vector, how the camera is oriented. Typically (0, 1, 0). template GLM_FUNC_DECL tquat quatLookAtLH( vec<3, T, Q> const& direction, vec<3, T, Q> const& up); /// Returns the squared length of x. /// /// @see gtx_quaternion template GLM_FUNC_DECL T length2(tquat const& q); /// @} }//namespace glm #include "quaternion.inl" glm-0.9.9-a2/glm/gtx/polar_coordinates.inl0000600000175000001440000000140613173131001017265 0ustar guususers/// @ref gtx_polar_coordinates /// @file glm/gtx/polar_coordinates.inl namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> polar ( vec<3, T, Q> const& euclidean ) { T const Length(length(euclidean)); vec<3, T, Q> const tmp(euclidean / Length); T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); return vec<3, T, Q>( asin(tmp.y), // latitude atan(tmp.x, tmp.z), // longitude xz_dist); // xz distance } template GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean ( vec<2, T, Q> const& polar ) { T const latitude(polar.x); T const longitude(polar.y); return vec<3, T, Q>( cos(latitude) * sin(longitude), sin(latitude), cos(latitude) * cos(longitude)); } }//namespace glm glm-0.9.9-a2/glm/gtx/dual_quaternion.inl0000600000175000001440000002413313173131001016752 0ustar guususers/// @ref gtx_dual_quaternion /// @file glm/gtx/dual_quaternion.inl #include "../geometric.hpp" #include namespace glm { // -- Component accesses -- template GLM_FUNC_QUALIFIER typename tdualquat::part_type & tdualquat::operator[](typename tdualquat::length_type i) { assert(i >= 0 && i < this->length()); return (&real)[i]; } template GLM_FUNC_QUALIFIER typename tdualquat::part_type const& tdualquat::operator[](typename tdualquat::length_type i) const { assert(i >= 0 && i < this->length()); return (&real)[i]; } // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const& d) : real(d.real) , dual(d.dual) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const& d) : real(d.real) , dual(d.dual) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const& r) : real(r), dual(tquat(0, 0, 0, 0)) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const& q, vec<3, T, Q> const& p) : real(q), dual( T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z), T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y), T(+0.5) * (-p.x*q.z + p.y*q.w + p.z*q.x), T(+0.5) * ( p.x*q.y - p.y*q.x + p.z*q.w)) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const& r, tquat const& d) : real(r), dual(d) {} // -- Conversion constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const& q) : real(q.real) , dual(q.dual) {} template GLM_FUNC_QUALIFIER tdualquat::tdualquat(mat<2, 4, T, Q> const& m) { *this = dualquat_cast(m); } template GLM_FUNC_QUALIFIER tdualquat::tdualquat(mat<3, 4, T, Q> const& m) { *this = dualquat_cast(m); } // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const& q) { this->real = q.real; this->dual = q.dual; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const& q) { this->real = q.real; this->dual = q.dual; return *this; } template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator*=(U s) { this->real *= static_cast(s); this->dual *= static_cast(s); return *this; } template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator/=(U s) { this->real /= static_cast(s); this->dual /= static_cast(s); return *this; } // -- Unary bit operators -- template GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const& q) { return q; } template GLM_FUNC_QUALIFIER tdualquat operator-(tdualquat const& q) { return tdualquat(-q.real, -q.dual); } // -- Binary operators -- template GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const& q, tdualquat const& p) { return tdualquat(q.real + p.real,q.dual + p.dual); } template GLM_FUNC_QUALIFIER tdualquat operator*(tdualquat const& p, tdualquat const& o) { return tdualquat(p.real * o.real,p.real * o.dual + p.dual * o.real); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(tdualquat const& q, vec<3, T, Q> const& v) { vec<3, T, Q> const real_v3(q.real.x,q.real.y,q.real.z); vec<3, T, Q> const dual_v3(q.dual.x,q.dual.y,q.dual.z); return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v; } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v, tdualquat const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(tdualquat const& q, vec<4, T, Q> const& v) { return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w); } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v, tdualquat const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER tdualquat operator*(tdualquat const& q, T const& s) { return tdualquat(q.real * s, q.dual * s); } template GLM_FUNC_QUALIFIER tdualquat operator*(T const& s, tdualquat const& q) { return q * s; } template GLM_FUNC_QUALIFIER tdualquat operator/(tdualquat const& q, T const& s) { return tdualquat(q.real / s, q.dual / s); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(tdualquat const& q1, tdualquat const& q2) { return (q1.real == q2.real) && (q1.dual == q2.dual); } template GLM_FUNC_QUALIFIER bool operator!=(tdualquat const& q1, tdualquat const& q2) { return (q1.real != q2.real) || (q1.dual != q2.dual); } // -- Operations -- template GLM_FUNC_QUALIFIER tdualquat dual_quat_identity() { return tdualquat( tquat(static_cast(1), static_cast(0), static_cast(0), static_cast(0)), tquat(static_cast(0), static_cast(0), static_cast(0), static_cast(0))); } template GLM_FUNC_QUALIFIER tdualquat normalize(tdualquat const& q) { return q / length(q.real); } template GLM_FUNC_QUALIFIER tdualquat lerp(tdualquat const& x, tdualquat const& y, T const& a) { // Dual Quaternion Linear blend aka DLB: // Lerp is only defined in [0, 1] assert(a >= static_cast(0)); assert(a <= static_cast(1)); T const k = dot(x.real,y.real) < static_cast(0) ? -a : a; T const one(1); return tdualquat(x * (one - a) + y * k); } template GLM_FUNC_QUALIFIER tdualquat inverse(tdualquat const& q) { const glm::tquat real = conjugate(q.real); const glm::tquat dual = conjugate(q.dual); return tdualquat(real, dual + (real * (-2.0f * dot(real,dual)))); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat2x4_cast(tdualquat const& x) { return mat<2, 4, T, Q>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w ); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat3x4_cast(tdualquat const& x) { tquat r = x.real / length2(x.real); tquat const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z); r *= static_cast(2); T const xy = r.x * x.real.y; T const xz = r.x * x.real.z; T const yz = r.y * x.real.z; T const wx = r.w * x.real.x; T const wy = r.w * x.real.y; T const wz = r.w * x.real.z; vec<4, T, Q> const a( rr.w + rr.x - rr.y - rr.z, xy - wz, xz + wy, -(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y)); vec<4, T, Q> const b( xy + wz, rr.w + rr.y - rr.x - rr.z, yz - wx, -(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x)); vec<4, T, Q> const c( xz - wy, yz + wx, rr.w + rr.z - rr.x - rr.y, -(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w)); return mat<3, 4, T, Q>(a, b, c); } template GLM_FUNC_QUALIFIER tdualquat dualquat_cast(mat<2, 4, T, Q> const& x) { return tdualquat( tquat( x[0].w, x[0].x, x[0].y, x[0].z ), tquat( x[1].w, x[1].x, x[1].y, x[1].z )); } template GLM_FUNC_QUALIFIER tdualquat dualquat_cast(mat<3, 4, T, Q> const& x) { tquat real; T const trace = x[0].x + x[1].y + x[2].z; if(trace > static_cast(0)) { T const r = sqrt(T(1) + trace); T const invr = static_cast(0.5) / r; real.w = static_cast(0.5) * r; real.x = (x[2].y - x[1].z) * invr; real.y = (x[0].z - x[2].x) * invr; real.z = (x[1].x - x[0].y) * invr; } else if(x[0].x > x[1].y && x[0].x > x[2].z) { T const r = sqrt(T(1) + x[0].x - x[1].y - x[2].z); T const invr = static_cast(0.5) / r; real.x = static_cast(0.5)*r; real.y = (x[1].x + x[0].y) * invr; real.z = (x[0].z + x[2].x) * invr; real.w = (x[2].y - x[1].z) * invr; } else if(x[1].y > x[2].z) { T const r = sqrt(T(1) + x[1].y - x[0].x - x[2].z); T const invr = static_cast(0.5) / r; real.x = (x[1].x + x[0].y) * invr; real.y = static_cast(0.5) * r; real.z = (x[2].y + x[1].z) * invr; real.w = (x[0].z - x[2].x) * invr; } else { T const r = sqrt(T(1) + x[2].z - x[0].x - x[1].y); T const invr = static_cast(0.5) / r; real.x = (x[0].z + x[2].x) * invr; real.y = (x[2].y + x[1].z) * invr; real.z = static_cast(0.5) * r; real.w = (x[1].x - x[0].y) * invr; } tquat dual; dual.x = static_cast(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y); dual.y = static_cast(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x); dual.z = static_cast(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w); dual.w = -static_cast(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z); return tdualquat(real, dual); } }//namespace glm glm-0.9.9-a2/glm/gtx/spline.inl0000600000175000001440000000346213173131001015054 0ustar guususers/// @ref gtx_spline /// @file glm/gtx/spline.inl namespace glm { template GLM_FUNC_QUALIFIER genType catmullRom ( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s ) { typename genType::value_type s2 = pow2(s); typename genType::value_type s3 = pow3(s); typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s; typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2); typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s; typename genType::value_type f4 = s3 - s2; return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2); } template GLM_FUNC_QUALIFIER genType hermite ( genType const& v1, genType const& t1, genType const& v2, genType const& t2, typename genType::value_type const& s ) { typename genType::value_type s2 = pow2(s); typename genType::value_type s3 = pow3(s); typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1); typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2; typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s; typename genType::value_type f4 = s3 - s2; return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2; } template GLM_FUNC_QUALIFIER genType cubic ( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s ) { return ((v1 * s + v2) * s + v3) * s + v4; } }//namespace glm glm-0.9.9-a2/glm/gtx/extended_min_max.inl0000600000175000001440000001074513173131001017074 0ustar guususers/// @ref gtx_extended_min_max /// @file glm/gtx/extended_min_max.inl namespace glm { template GLM_FUNC_QUALIFIER T min( T const& x, T const& y, T const& z) { return glm::min(glm::min(x, y), z); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, typename C::T const& y, typename C::T const& z ) { return glm::min(glm::min(x, y), z); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, C const& y, C const& z ) { return glm::min(glm::min(x, y), z); } template GLM_FUNC_QUALIFIER T min ( T const& x, T const& y, T const& z, T const& w ) { return glm::min(glm::min(x, y), glm::min(z, w)); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w ) { return glm::min(glm::min(x, y), glm::min(z, w)); } template class C> GLM_FUNC_QUALIFIER C min ( C const& x, C const& y, C const& z, C const& w ) { return glm::min(glm::min(x, y), glm::min(z, w)); } template GLM_FUNC_QUALIFIER T max( T const& x, T const& y, T const& z) { return glm::max(glm::max(x, y), z); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, typename C::T const& y, typename C::T const& z ) { return glm::max(glm::max(x, y), z); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, C const& y, C const& z ) { return glm::max(glm::max(x, y), z); } template GLM_FUNC_QUALIFIER T max ( T const& x, T const& y, T const& z, T const& w ) { return glm::max(glm::max(x, y), glm::max(z, w)); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, typename C::T const& y, typename C::T const& z, typename C::T const& w ) { return glm::max(glm::max(x, y), glm::max(z, w)); } template class C> GLM_FUNC_QUALIFIER C max ( C const& x, C const& y, C const& z, C const& w ) { return glm::max(glm::max(x, y), glm::max(z, w)); } // fmin # if GLM_HAS_CXX11_STL using std::fmin; # else template GLM_FUNC_QUALIFIER genType fmin(genType x, genType y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point input"); if (isnan(x)) return y; if (isnan(y)) return x; return min(x, y); } # endif template GLM_FUNC_QUALIFIER vec fmin(vec const& a, T b) { return detail::functor2::call(fmin, a, vec(b)); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, vec const& b) { return detail::functor2::call(fmin, a, b); } // fmax # if GLM_HAS_CXX11_STL using std::fmax; # else template GLM_FUNC_QUALIFIER genType fmax(genType x, genType y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point input"); if (isnan(x)) return y; if (isnan(y)) return x; return max(x, y); } # endif template GLM_FUNC_QUALIFIER vec fmax(vec const& a, T b) { return detail::functor2::call(fmax, a, vec(b)); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, vec const& b) { return detail::functor2::call(fmax, a, b); } // fclamp template GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fclamp' only accept floating-point or integer inputs"); return fmin(fmax(x, minVal), maxVal); } template GLM_FUNC_QUALIFIER vec fclamp(vec const& x, T minVal, T maxVal) { return fmin(fmax(x, vec(minVal)), vec(maxVal)); } template GLM_FUNC_QUALIFIER vec fclamp(vec const& x, vec const& minVal, vec const& maxVal) { return fmin(fmax(x, minVal), maxVal); } }//namespace glm glm-0.9.9-a2/glm/gtx/fast_square_root.inl0000600000175000001440000000442013173131001017135 0ustar guususers/// @ref gtx_fast_square_root /// @file glm/gtx/fast_square_root.inl namespace glm { // fastSqrt template GLM_FUNC_QUALIFIER genType fastSqrt(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastSqrt' only accept floating-point input"); return genType(1) / fastInverseSqrt(x); } template GLM_FUNC_QUALIFIER vec fastSqrt(vec const& x) { return detail::functor1::call(fastSqrt, x); } // fastInversesqrt template GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x) { # ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6 vec<1, T, Q> tmp(detail::compute_inversesqrt::value>::call(vec<1, genType, lowp>(x))); return tmp.x; # else return detail::compute_inversesqrt<1, genType, lowp, detail::is_aligned::value>::call(vec<1, genType, lowp>(x)).x; # endif } template GLM_FUNC_QUALIFIER vec fastInverseSqrt(vec const& x) { return detail::compute_inversesqrt::value>::call(x); } // fastLength template GLM_FUNC_QUALIFIER genType fastLength(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); return abs(x); } template GLM_FUNC_QUALIFIER T fastLength(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); return fastSqrt(dot(x, x)); } // fastDistance template GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y) { return fastLength(y - x); } template GLM_FUNC_QUALIFIER T fastDistance(vec const& x, vec const& y) { return fastLength(y - x); } // fastNormalize template GLM_FUNC_QUALIFIER genType fastNormalize(genType x) { return x > genType(0) ? genType(1) : -genType(1); } template GLM_FUNC_QUALIFIER vec fastNormalize(vec const& x) { return x * fastInverseSqrt(dot(x, x)); } }//namespace glm glm-0.9.9-a2/glm/gtx/perpendicular.inl0000600000175000001440000000035313173131001016413 0ustar guususers/// @ref gtx_perpendicular /// @file glm/gtx/perpendicular.inl namespace glm { template GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) { return x - proj(x, Normal); } }//namespace glm glm-0.9.9-a2/glm/gtx/color_space.hpp0000600000175000001440000000366113173131001016061 0ustar guususers/// @ref gtx_color_space /// @file glm/gtx/color_space.hpp /// /// @see core (dependence) /// /// @defgroup gtx_color_space GLM_GTX_color_space /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Related to RGB to HSV conversions and operations. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_color_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_color_space extension included") #endif namespace glm { /// @addtogroup gtx_color_space /// @{ /// Converts a color from HSV color space to its color in RGB color space. /// @see gtx_color_space template GLM_FUNC_DECL vec<3, T, Q> rgbColor( vec<3, T, Q> const& hsvValue); /// Converts a color from RGB color space to its color in HSV color space. /// @see gtx_color_space template GLM_FUNC_DECL vec<3, T, Q> hsvColor( vec<3, T, Q> const& rgbValue); /// Build a saturation matrix. /// @see gtx_color_space template GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation( T const s); /// Modify the saturation of a color. /// @see gtx_color_space template GLM_FUNC_DECL vec<3, T, Q> saturation( T const s, vec<3, T, Q> const& color); /// Modify the saturation of a color. /// @see gtx_color_space template GLM_FUNC_DECL vec<4, T, Q> saturation( T const s, vec<4, T, Q> const& color); /// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. /// @see gtx_color_space template GLM_FUNC_DECL T luminosity( vec<3, T, Q> const& color); /// @} }//namespace glm #include "color_space.inl" glm-0.9.9-a2/glm/gtx/functions.hpp0000600000175000001440000000204313173131001015571 0ustar guususers/// @ref gtx_functions /// @file glm/gtx/functions.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_functions GLM_GTX_functions /// @ingroup gtx /// /// Include to use the features of this extension. /// /// List of useful common functions. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/type_vec2.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_functions extension included") #endif namespace glm { /// @addtogroup gtx_functions /// @{ /// 1D gauss function /// /// @see gtc_epsilon template GLM_FUNC_DECL T gauss( T x, T ExpectedValue, T StandardDeviation); /// 2D gauss function /// /// @see gtc_epsilon template GLM_FUNC_DECL T gauss( vec<2, T, Q> const& Coord, vec<2, T, Q> const& ExpectedValue, vec<2, T, Q> const& StandardDeviation); /// @} }//namespace glm #include "functions.inl" glm-0.9.9-a2/glm/gtx/matrix_transform_2d.hpp0000600000175000001440000000474213173131001017555 0ustar guususers/// @ref gtx_matrix_transform_2d /// @file glm/gtx/matrix_transform_2d.hpp /// @author Miguel Ángel Pérez Martínez /// /// @see core (dependence) /// /// @defgroup gtx_matrix_transform_2d GLM_GTX_matrix_transform_2d /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Defines functions that generate common 2d transformation matrices. #pragma once // Dependency: #include "../mat3x3.hpp" #include "../vec2.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_transform_2d is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_transform_2d extension included") #endif namespace glm { /// @addtogroup gtx_matrix_transform_2d /// @{ /// Builds a translation 3 * 3 matrix created from a vector of 2 components. /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a translation vector. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v); /// Builds a rotation 3 * 3 matrix created from an angle. /// /// @param m Input matrix multiplied by this translation matrix. /// @param angle Rotation angle expressed in radians. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( mat<3, 3, T, Q> const& m, T angle); /// Builds a scale 3 * 3 matrix created from a vector of 2 components. /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a scale vector. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( mat<3, 3, T, Q> const& m, vec<2, T, Q> const& v); /// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix. /// /// @param m Input matrix multiplied by this translation matrix. /// @param y Shear factor. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( mat<3, 3, T, Q> const& m, T y); /// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix. /// /// @param m Input matrix multiplied by this translation matrix. /// @param x Shear factor. template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( mat<3, 3, T, Q> const& m, T x); /// @} }//namespace glm #include "matrix_transform_2d.inl" glm-0.9.9-a2/glm/gtx/type_aligned.inl0000600000175000001440000000012113173131001016213 0ustar guususers/// @ref gtc_type_aligned /// @file glm/gtc/type_aligned.inl namespace glm { } glm-0.9.9-a2/glm/gtx/wrap.inl0000600000175000001440000000323013173131001014524 0ustar guususers/// @ref gtx_wrap /// @file glm/gtx/wrap.inl namespace glm { template GLM_FUNC_QUALIFIER vec clamp(vec const& Texcoord) { return glm::clamp(Texcoord, vec(0), vec(1)); } template GLM_FUNC_QUALIFIER genType clamp(genType const& Texcoord) { return clamp(vec<1, genType, defaultp>(Texcoord)).x; } template GLM_FUNC_QUALIFIER vec repeat(vec const& Texcoord) { return glm::fract(Texcoord); } template GLM_FUNC_QUALIFIER genType repeat(genType const& Texcoord) { return repeat(vec<1, genType, defaultp>(Texcoord)).x; } template GLM_FUNC_QUALIFIER vec mirrorClamp(vec const& Texcoord) { return glm::fract(glm::abs(Texcoord)); } template GLM_FUNC_QUALIFIER genType mirrorClamp(genType const& Texcoord) { return mirrorClamp(vec<1, genType, defaultp>(Texcoord)).x; } template GLM_FUNC_QUALIFIER vec mirrorRepeat(vec const& Texcoord) { vec const Abs = glm::abs(Texcoord); vec const Clamp = glm::mod(glm::floor(Abs), vec(2)); vec const Floor = glm::floor(Abs); vec const Rest = Abs - Floor; vec const Mirror = Clamp + Rest; return mix(Rest, vec(1) - Rest, glm::greaterThanEqual(Mirror, vec(1))); } template GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const& Texcoord) { return mirrorRepeat(vec<1, genType, defaultp>(Texcoord)).x; } }//namespace glm glm-0.9.9-a2/glm/gtx/spline.hpp0000600000175000001440000000306613173131001015061 0ustar guususers/// @ref gtx_spline /// @file glm/gtx/spline.hpp /// /// @see core (dependence) /// /// @defgroup gtx_spline GLM_GTX_spline /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Spline functions #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/optimum_pow.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_spline is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_spline extension included") #endif namespace glm { /// @addtogroup gtx_spline /// @{ /// Return a point from a catmull rom curve. /// @see gtx_spline extension. template GLM_FUNC_DECL genType catmullRom( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s); /// Return a point from a hermite curve. /// @see gtx_spline extension. template GLM_FUNC_DECL genType hermite( genType const& v1, genType const& t1, genType const& v2, genType const& t2, typename genType::value_type const& s); /// Return a point from a cubic curve. /// @see gtx_spline extension. template GLM_FUNC_DECL genType cubic( genType const& v1, genType const& v2, genType const& v3, genType const& v4, typename genType::value_type const& s); /// @} }//namespace glm #include "spline.inl" glm-0.9.9-a2/glm/gtx/color_space_YCoCg.inl0000600000175000001440000000533113173131001017074 0ustar guususers/// @ref gtx_color_space_YCoCg /// @file glm/gtx/color_space_YCoCg.inl namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCg ( vec<3, T, Q> const& rgbColor ) { vec<3, T, Q> result; result.x/*Y */ = rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4); result.y/*Co*/ = rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2); result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4); return result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCg2rgb ( vec<3, T, Q> const& YCoCgColor ) { vec<3, T, Q> result; result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z; result.g = YCoCgColor.x + YCoCgColor.z; result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z; return result; } template class compute_YCoCgR { public: static GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR ( vec<3, T, Q> const& rgbColor ) { vec<3, T, Q> result; result.x/*Y */ = rgbColor.g * static_cast(0.5) + (rgbColor.r + rgbColor.b) * static_cast(0.25); result.y/*Co*/ = rgbColor.r - rgbColor.b; result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) * static_cast(0.5); return result; } static GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb ( vec<3, T, Q> const& YCoCgRColor ) { vec<3, T, Q> result; T tmp = YCoCgRColor.x - (YCoCgRColor.z * static_cast(0.5)); result.g = YCoCgRColor.z + tmp; result.b = tmp - (YCoCgRColor.y * static_cast(0.5)); result.r = result.b + YCoCgRColor.y; return result; } }; template class compute_YCoCgR { public: static GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR ( vec<3, T, Q> const& rgbColor ) { vec<3, T, Q> result; result.y/*Co*/ = rgbColor.r - rgbColor.b; T tmp = rgbColor.b + (result.y >> 1); result.z/*Cg*/ = rgbColor.g - tmp; result.x/*Y */ = tmp + (result.z >> 1); return result; } static GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb ( vec<3, T, Q> const& YCoCgRColor ) { vec<3, T, Q> result; T tmp = YCoCgRColor.x - (YCoCgRColor.z >> 1); result.g = YCoCgRColor.z + tmp; result.b = tmp - (YCoCgRColor.y >> 1); result.r = result.b + YCoCgRColor.y; return result; } }; template GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR ( vec<3, T, Q> const& rgbColor ) { return compute_YCoCgR::is_integer>::rgb2YCoCgR(rgbColor); } template GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb ( vec<3, T, Q> const& YCoCgRColor ) { return compute_YCoCgR::is_integer>::YCoCgR2rgb(YCoCgRColor); } }//namespace glm glm-0.9.9-a2/glm/gtx/transform.inl0000600000175000001440000000113113173131001015564 0ustar guususers/// @ref gtx_transform /// @file glm/gtx/transform.inl namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) { return translate(mat<4, 4, T, Q>(static_cast(1)), v); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) { return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) { return scale(mat<4, 4, T, Q>(static_cast(1)), v); } }//namespace glm glm-0.9.9-a2/glm/gtx/std_based_type.hpp0000600000175000001440000000372313173131001016560 0ustar guususers/// @ref gtx_std_based_type /// @file glm/gtx/std_based_type.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_std_based_type GLM_GTX_std_based_type /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Adds vector types based on STL value types. #pragma once // Dependency: #include "../glm.hpp" #include #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_std_based_type is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_std_based_type extension included") #endif namespace glm { /// @addtogroup gtx_std_based_type /// @{ /// Vector type based of one std::size_t component. /// @see GLM_GTX_std_based_type typedef vec<1, std::size_t, defaultp> size1; /// Vector type based of two std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<2, std::size_t, defaultp> size2; /// Vector type based of three std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<3, std::size_t, defaultp> size3; /// Vector type based of four std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<4, std::size_t, defaultp> size4; /// Vector type based of one std::size_t component. /// @see GLM_GTX_std_based_type typedef vec<1, std::size_t, defaultp> size1_t; /// Vector type based of two std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<2, std::size_t, defaultp> size2_t; /// Vector type based of three std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<3, std::size_t, defaultp> size3_t; /// Vector type based of four std::size_t components. /// @see GLM_GTX_std_based_type typedef vec<4, std::size_t, defaultp> size4_t; /// @} }//namespace glm #include "std_based_type.inl" glm-0.9.9-a2/glm/gtx/projection.hpp0000600000175000001440000000170713173131001015743 0ustar guususers/// @ref gtx_projection /// @file glm/gtx/projection.hpp /// /// @see core (dependence) /// /// @defgroup gtx_projection GLM_GTX_projection /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Projection of a vector to other one #pragma once // Dependency: #include "../geometric.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_projection is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_projection extension included") #endif namespace glm { /// @addtogroup gtx_projection /// @{ /// Projects x on Normal. /// /// @see gtx_projection template GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); /// @} }//namespace glm #include "projection.inl" glm-0.9.9-a2/glm/gtx/orthonormalize.inl0000600000175000001440000000120213173131001016624 0ustar guususers/// @ref gtx_orthonormalize /// @file glm/gtx/orthonormalize.inl namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) { mat<3, 3, T, Q> r = m; r[0] = normalize(r[0]); T d0 = dot(r[0], r[1]); r[1] -= r[0] * d0; r[1] = normalize(r[1]); T d1 = dot(r[1], r[2]); d0 = dot(r[0], r[2]); r[2] -= r[0] * d0 + r[1] * d1; r[2] = normalize(r[2]); return r; } template GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) { return normalize(x - y * dot(y, x)); } }//namespace glm glm-0.9.9-a2/glm/gtx/raw_data.inl0000600000175000001440000000006513173131001015340 0ustar guususers/// @ref gtx_raw_data /// @file glm/gtx/raw_data.inl glm-0.9.9-a2/glm/gtx/common.inl0000600000175000001440000000564613173131001015060 0ustar guususers/// @ref gtx_common /// @file glm/gtx/common.inl #include #include "../gtc/epsilon.hpp" #include "../gtc/constants.hpp" namespace glm{ namespace detail { template struct compute_fmod { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) { return detail::functor2::call(std::fmod, a, b); } }; template struct compute_fmod { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) { return a % b; } }; }//namespace detail template GLM_FUNC_QUALIFIER bool isdenormal(T const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); # if GLM_HAS_CXX11_STL return std::fpclassify(x) == FP_SUBNORMAL; # else return epsilonNotEqual(x, static_cast(0), epsilon()) && std::fabs(x) < std::numeric_limits::min(); # endif } template GLM_FUNC_QUALIFIER typename vec<1, T, Q>::bool_type isdenormal ( vec<1, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<1, T, Q>::bool_type( isdenormal(x.x)); } template GLM_FUNC_QUALIFIER typename vec<2, T, Q>::bool_type isdenormal ( vec<2, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<2, T, Q>::bool_type( isdenormal(x.x), isdenormal(x.y)); } template GLM_FUNC_QUALIFIER typename vec<3, T, Q>::bool_type isdenormal ( vec<3, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<3, T, Q>::bool_type( isdenormal(x.x), isdenormal(x.y), isdenormal(x.z)); } template GLM_FUNC_QUALIFIER typename vec<4, T, Q>::bool_type isdenormal ( vec<4, T, Q> const& x ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); return typename vec<4, T, Q>::bool_type( isdenormal(x.x), isdenormal(x.y), isdenormal(x.z), isdenormal(x.w)); } // fmod template GLM_FUNC_QUALIFIER genType fmod(genType x, genType y) { return fmod(vec<1, genType>(x), y).x; } template GLM_FUNC_QUALIFIER vec fmod(vec const& x, T y) { return detail::compute_fmod::is_iec559>::call(x, vec(y)); } template GLM_FUNC_QUALIFIER vec fmod(vec const& x, vec const& y) { return detail::compute_fmod::is_iec559>::call(x, y); } }//namespace glm glm-0.9.9-a2/glm/gtx/matrix_operation.hpp0000600000175000001440000000470313173131001017152 0ustar guususers/// @ref gtx_matrix_operation /// @file glm/gtx/matrix_operation.hpp /// /// @see core (dependence) /// /// @defgroup gtx_matrix_operation GLM_GTX_matrix_operation /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Build diagonal matrices from vectors. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_matrix_operation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_matrix_operation extension included") #endif namespace glm { /// @addtogroup gtx_matrix_operation /// @{ //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<2, 2, T, Q> diagonal2x2( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<2, 3, T, Q> diagonal2x3( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<2, 4, T, Q> diagonal2x4( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<3, 2, T, Q> diagonal3x2( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<3, 3, T, Q> diagonal3x3( vec<3, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<3, 4, T, Q> diagonal3x4( vec<3, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<4, 2, T, Q> diagonal4x2( vec<2, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<4, 3, T, Q> diagonal4x3( vec<3, T, Q> const& v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. template GLM_FUNC_DECL mat<4, 4, T, Q> diagonal4x4( vec<4, T, Q> const& v); /// @} }//namespace glm #include "matrix_operation.inl" glm-0.9.9-a2/glm/gtx/mixed_product.hpp0000600000175000001440000000203513173131001016430 0ustar guususers/// @ref gtx_mixed_product /// @file glm/gtx/mixed_product.hpp /// /// @see core (dependence) /// /// @defgroup gtx_mixed_product GLM_GTX_mixed_producte /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Mixed product of 3 vectors. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_mixed_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_mixed_product extension included") #endif namespace glm { /// @addtogroup gtx_mixed_product /// @{ /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) template GLM_FUNC_DECL T mixedProduct( vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q> const& v3); /// @} }// namespace glm #include "mixed_product.inl" glm-0.9.9-a2/glm/gtx/matrix_operation.inl0000600000175000001440000000434313173131001017145 0ustar guususers/// @ref gtx_matrix_operation /// @file glm/gtx/matrix_operation.inl namespace glm { template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> diagonal2x2 ( vec<2, T, Q> const& v ) { mat<2, 2, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> diagonal2x3 ( vec<2, T, Q> const& v ) { mat<2, 3, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> diagonal2x4 ( vec<2, T, Q> const& v ) { mat<2, 4, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> diagonal3x2 ( vec<2, T, Q> const& v ) { mat<3, 2, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> diagonal3x3 ( vec<3, T, Q> const& v ) { mat<3, 3, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; return Result; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> diagonal3x4 ( vec<3, T, Q> const& v ) { mat<3, 4, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> diagonal4x4 ( vec<4, T, Q> const& v ) { mat<4, 4, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; Result[3][3] = v[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> diagonal4x3 ( vec<3, T, Q> const& v ) { mat<4, 3, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; Result[2][2] = v[2]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> diagonal4x2 ( vec<2, T, Q> const& v ) { mat<4, 2, T, Q> Result(static_cast(1)); Result[0][0] = v[0]; Result[1][1] = v[1]; return Result; } }//namespace glm glm-0.9.9-a2/glm/gtx/raw_data.hpp0000600000175000001440000000231713173131001015347 0ustar guususers/// @ref gtx_raw_data /// @file glm/gtx/raw_data.hpp /// /// @see core (dependence) /// /// @defgroup gtx_raw_data GLM_GTX_raw_data /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Projection of a vector to other one #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/type_int.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_raw_data is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_raw_data extension included") #endif namespace glm { /// @addtogroup gtx_raw_data /// @{ //! Type for byte numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint8 byte; //! Type for word numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint16 word; //! Type for dword numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint32 dword; //! Type for qword numbers. //! From GLM_GTX_raw_data extension. typedef detail::uint64 qword; /// @} }// namespace glm #include "raw_data.inl" glm-0.9.9-a2/glm/gtx/euler_angles.inl0000600000175000001440000001661113173131001016227 0ustar guususers/// @ref gtx_euler_angles /// @file glm/gtx/euler_angles.inl #include "compatibility.hpp" // glm::atan2 namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleX ( T const& angleX ) { T cosX = glm::cos(angleX); T sinX = glm::sin(angleX); return mat<4, 4, T, defaultp>( T(1), T(0), T(0), T(0), T(0), cosX, sinX, T(0), T(0),-sinX, cosX, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleY ( T const& angleY ) { T cosY = glm::cos(angleY); T sinY = glm::sin(angleY); return mat<4, 4, T, defaultp>( cosY, T(0), -sinY, T(0), T(0), T(1), T(0), T(0), sinY, T(0), cosY, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZ ( T const& angleZ ) { T cosZ = glm::cos(angleZ); T sinZ = glm::sin(angleZ); return mat<4, 4, T, defaultp>( cosZ, sinZ, T(0), T(0), -sinZ, cosZ, T(0), T(0), T(0), T(0), T(1), T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXY ( T const& angleX, T const& angleY ) { T cosX = glm::cos(angleX); T sinX = glm::sin(angleX); T cosY = glm::cos(angleY); T sinY = glm::sin(angleY); return mat<4, 4, T, defaultp>( cosY, -sinX * -sinY, cosX * -sinY, T(0), T(0), cosX, sinX, T(0), sinY, -sinX * cosY, cosX * cosY, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYX ( T const& angleY, T const& angleX ) { T cosX = glm::cos(angleX); T sinX = glm::sin(angleX); T cosY = glm::cos(angleY); T sinY = glm::sin(angleY); return mat<4, 4, T, defaultp>( cosY, 0, -sinY, T(0), sinY * sinX, cosX, cosY * sinX, T(0), sinY * cosX, -sinX, cosY * cosX, T(0), T(0), T(0), T(0), T(1)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZ ( T const& angleX, T const& angleZ ) { return eulerAngleX(angleX) * eulerAngleZ(angleZ); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZX ( T const& angleZ, T const& angleX ) { return eulerAngleZ(angleZ) * eulerAngleX(angleX); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZ ( T const& angleY, T const& angleZ ) { return eulerAngleY(angleY) * eulerAngleZ(angleZ); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZY ( T const& angleZ, T const& angleY ) { return eulerAngleZ(angleZ) * eulerAngleY(angleY); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYZ ( T const& t1, T const& t2, T const& t3 ) { T c1 = glm::cos(-t1); T c2 = glm::cos(-t2); T c3 = glm::cos(-t3); T s1 = glm::sin(-t1); T s2 = glm::sin(-t2); T s3 = glm::sin(-t3); mat<4, 4, T, defaultp> Result; Result[0][0] = c2 * c3; Result[0][1] =-c1 * s3 + s1 * s2 * c3; Result[0][2] = s1 * s3 + c1 * s2 * c3; Result[0][3] = static_cast(0); Result[1][0] = c2 * s3; Result[1][1] = c1 * c3 + s1 * s2 * s3; Result[1][2] =-s1 * c3 + c1 * s2 * s3; Result[1][3] = static_cast(0); Result[2][0] =-s2; Result[2][1] = s1 * c2; Result[2][2] = c1 * c2; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXZ ( T const& yaw, T const& pitch, T const& roll ) { T tmp_ch = glm::cos(yaw); T tmp_sh = glm::sin(yaw); T tmp_cp = glm::cos(pitch); T tmp_sp = glm::sin(pitch); T tmp_cb = glm::cos(roll); T tmp_sb = glm::sin(roll); mat<4, 4, T, defaultp> Result; Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb; Result[0][1] = tmp_sb * tmp_cp; Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb; Result[0][3] = static_cast(0); Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb; Result[1][1] = tmp_cb * tmp_cp; Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb; Result[1][3] = static_cast(0); Result[2][0] = tmp_sh * tmp_cp; Result[2][1] = -tmp_sp; Result[2][2] = tmp_ch * tmp_cp; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> yawPitchRoll ( T const& yaw, T const& pitch, T const& roll ) { T tmp_ch = glm::cos(yaw); T tmp_sh = glm::sin(yaw); T tmp_cp = glm::cos(pitch); T tmp_sp = glm::sin(pitch); T tmp_cb = glm::cos(roll); T tmp_sb = glm::sin(roll); mat<4, 4, T, defaultp> Result; Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb; Result[0][1] = tmp_sb * tmp_cp; Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb; Result[0][3] = static_cast(0); Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb; Result[1][1] = tmp_cb * tmp_cp; Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb; Result[1][3] = static_cast(0); Result[2][0] = tmp_sh * tmp_cp; Result[2][1] = -tmp_sp; Result[2][2] = tmp_ch * tmp_cp; Result[2][3] = static_cast(0); Result[3][0] = static_cast(0); Result[3][1] = static_cast(0); Result[3][2] = static_cast(0); Result[3][3] = static_cast(1); return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> orientate2 ( T const& angle ) { T c = glm::cos(angle); T s = glm::sin(angle); mat<2, 2, T, defaultp> Result; Result[0][0] = c; Result[0][1] = s; Result[1][0] = -s; Result[1][1] = c; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> orientate3 ( T const& angle ) { T c = glm::cos(angle); T s = glm::sin(angle); mat<3, 3, T, defaultp> Result; Result[0][0] = c; Result[0][1] = s; Result[0][2] = 0.0f; Result[1][0] = -s; Result[1][1] = c; Result[1][2] = 0.0f; Result[2][0] = 0.0f; Result[2][1] = 0.0f; Result[2][2] = 1.0f; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orientate3 ( vec<3, T, Q> const& angles ) { return mat<3, 3, T, Q>(yawPitchRoll(angles.z, angles.x, angles.y)); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> orientate4 ( vec<3, T, Q> const& angles ) { return yawPitchRoll(angles.z, angles.x, angles.y); } template GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M, T & t1, T & t2, T & t3) { float T1 = glm::atan2(M[2][1], M[2][2]); float C2 = glm::sqrt(M[0][0]*M[0][0] + M[1][0]*M[1][0]); float T2 = glm::atan2(-M[2][0], C2); float S1 = glm::sin(T1); float C1 = glm::cos(T1); float T3 = glm::atan2(S1*M[0][2] - C1*M[0][1], C1*M[1][1] - S1*M[1][2 ]); t1 = -T1; t2 = -T2; t3 = -T3; } }//namespace glm glm-0.9.9-a2/glm/gtx/string_cast.inl0000600000175000001440000004235113173131001016102 0ustar guususers/// @ref gtx_string_cast /// @file glm/gtx/string_cast.inl #include #include namespace glm{ namespace detail { template struct cast { typedef T value_type; }; template <> struct cast { typedef double value_type; }; GLM_FUNC_QUALIFIER std::string format(const char* msg, ...) { std::size_t const STRING_BUFFER(4096); char text[STRING_BUFFER]; va_list list; if(msg == 0) return std::string(); va_start(list, msg); # if(GLM_COMPILER & GLM_COMPILER_VC) vsprintf_s(text, STRING_BUFFER, msg, list); # else// vsprintf(text, msg, list); # endif// va_end(list); return std::string(text); } static const char* LabelTrue = "true"; static const char* LabelFalse = "false"; template struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%d";} }; template struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%f";} }; # if GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC template<> struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%lld";} }; template<> struct literal { GLM_FUNC_QUALIFIER static char const * value() {return "%lld";} }; # endif//GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC template struct prefix{}; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "d";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "b";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u8";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i8";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u16";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i16";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "u64";} }; template<> struct prefix { GLM_FUNC_QUALIFIER static char const * value() {return "i64";} }; template struct compute_to_string {}; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<1, bool, Q> const& x) { return detail::format("bvec1(%s)", x[0] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<2, bool, Q> const& x) { return detail::format("bvec2(%s, %s)", x[0] ? detail::LabelTrue : detail::LabelFalse, x[1] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<3, bool, Q> const& x) { return detail::format("bvec3(%s, %s, %s)", x[0] ? detail::LabelTrue : detail::LabelFalse, x[1] ? detail::LabelTrue : detail::LabelFalse, x[2] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<4, bool, Q> const& x) { return detail::format("bvec4(%s, %s, %s, %s)", x[0] ? detail::LabelTrue : detail::LabelFalse, x[1] ? detail::LabelTrue : detail::LabelFalse, x[2] ? detail::LabelTrue : detail::LabelFalse, x[3] ? detail::LabelTrue : detail::LabelFalse); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<1, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec1(%s)", PrefixStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec2(%s, %s)", PrefixStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0]), static_cast::value_type>(x[1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec3(%s, %s, %s)", PrefixStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0]), static_cast::value_type>(x[1]), static_cast::value_type>(x[2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%svec4(%s, %s, %s, %s)", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0]), static_cast::value_type>(x[1]), static_cast::value_type>(x[2]), static_cast::value_type>(x[3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat2x2((%s, %s), (%s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat2x3((%s, %s, %s), (%s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat2x4((%s, %s, %s, %s), (%s, %s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[0][3]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[1][3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat3x2((%s, %s), (%s, %s), (%s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat3x3((%s, %s, %s), (%s, %s, %s), (%s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat3x4((%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[0][3]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[1][3]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2]), static_cast::value_type>(x[2][3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 2, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat4x2((%s, %s), (%s, %s), (%s, %s), (%s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[3][0]), static_cast::value_type>(x[3][1])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 3, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat4x3((%s, %s, %s), (%s, %s, %s), (%s, %s, %s), (%s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2]), static_cast::value_type>(x[3][0]), static_cast::value_type>(x[3][1]), static_cast::value_type>(x[3][2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 4, T, Q> const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%smat4x4((%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[0][0]), static_cast::value_type>(x[0][1]), static_cast::value_type>(x[0][2]), static_cast::value_type>(x[0][3]), static_cast::value_type>(x[1][0]), static_cast::value_type>(x[1][1]), static_cast::value_type>(x[1][2]), static_cast::value_type>(x[1][3]), static_cast::value_type>(x[2][0]), static_cast::value_type>(x[2][1]), static_cast::value_type>(x[2][2]), static_cast::value_type>(x[2][3]), static_cast::value_type>(x[3][0]), static_cast::value_type>(x[3][1]), static_cast::value_type>(x[3][2]), static_cast::value_type>(x[3][3])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(tquat const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%squat(%s, {%s, %s, %s})", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x[3]), static_cast::value_type>(x[0]), static_cast::value_type>(x[1]), static_cast::value_type>(x[2])); } }; template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(tdualquat const& x) { char const * PrefixStr = prefix::value(); char const * LiteralStr = literal::is_iec559>::value(); std::string FormatStr(detail::format("%sdualquat((%s, {%s, %s, %s}), (%s, {%s, %s, %s}))", PrefixStr, LiteralStr, LiteralStr, LiteralStr, LiteralStr)); return detail::format(FormatStr.c_str(), static_cast::value_type>(x.real[3]), static_cast::value_type>(x.real[0]), static_cast::value_type>(x.real[1]), static_cast::value_type>(x.real[2]), static_cast::value_type>(x.dual[3]), static_cast::value_type>(x.dual[0]), static_cast::value_type>(x.dual[1]), static_cast::value_type>(x.dual[2])); } }; }//namespace detail template GLM_FUNC_QUALIFIER std::string to_string(matType const& x) { return detail::compute_to_string::call(x); } }//namespace glm glm-0.9.9-a2/glm/gtx/matrix_factorisation.inl0000600000175000001440000000540013173131001020005 0ustar guususers/// @ref gtx_matrix_factorisation /// @file glm/gtx/matrix_factorisation.inl namespace glm { template GLM_FUNC_QUALIFIER mat flipud(mat const& in) { mat tin = transpose(in); tin = fliplr(tin); mat out = transpose(tin); return out; } template GLM_FUNC_QUALIFIER mat fliplr(mat const& in) { mat out; for (length_t i = 0; i < C; i++) { out[i] = in[(C - i) - 1]; } return out; } template GLM_FUNC_QUALIFIER void qr_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& q, mat& r) { // Uses modified Gram-Schmidt method // Source: https://en.wikipedia.org/wiki/GramSchmidt_process // And https://en.wikipedia.org/wiki/QR_decomposition //For all the linearly independs columns of the input... // (there can be no more linearly independents columns than there are rows.) for (length_t i = 0; i < (C < R ? C : R); i++) { //Copy in Q the input's i-th column. q[i] = in[i]; //j = [0,i[ // Make that column orthogonal to all the previous ones by substracting to it the non-orthogonal projection of all the previous columns. // Also: Fill the zero elements of R for (length_t j = 0; j < i; j++) { q[i] -= dot(q[i], q[j])*q[j]; r[j][i] = 0; } //Now, Q i-th column is orthogonal to all the previous columns. Normalize it. q[i] = normalize(q[i]); //j = [i,C[ //Finally, compute the corresponding coefficients of R by computing the projection of the resulting column on the other columns of the input. for (length_t j = i; j < C; j++) { r[j][i] = dot(in[j], q[i]); } } } template GLM_FUNC_QUALIFIER void rq_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& r, mat& q) { // From https://en.wikipedia.org/wiki/QR_decomposition: // The RQ decomposition transforms a matrix A into the product of an upper triangular matrix R (also known as right-triangular) and an orthogonal matrix Q. The only difference from QR decomposition is the order of these matrices. // QR decomposition is GramSchmidt orthogonalization of columns of A, started from the first column. // RQ decomposition is GramSchmidt orthogonalization of rows of A, started from the last row. mat tin = transpose(in); tin = fliplr(tin); mat tr; mat<(C < R ? C : R), C, T, Q> tq; qr_decompose(tin, tq, tr); tr = fliplr(tr); r = transpose(tr); r = fliplr(r); tq = fliplr(tq); q = transpose(tq); } } //namespace glm glm-0.9.9-a2/glm/gtx/perpendicular.hpp0000600000175000001440000000211113173131001016412 0ustar guususers/// @ref gtx_perpendicular /// @file glm/gtx/perpendicular.hpp /// /// @see core (dependence) /// @see gtx_projection (dependence) /// /// @defgroup gtx_perpendicular GLM_GTX_perpendicular /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Perpendicular of a vector from other one #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/projection.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_perpendicular is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_perpendicular extension included") #endif namespace glm { /// @addtogroup gtx_perpendicular /// @{ //! Projects x a perpendicular axis of Normal. //! From GLM_GTX_perpendicular extension. template GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); /// @} }//namespace glm #include "perpendicular.inl" glm-0.9.9-a2/glm/gtx/gradient_paint.inl0000600000175000001440000000165513173131001016554 0ustar guususers/// @ref gtx_gradient_paint /// @file glm/gtx/gradient_paint.inl namespace glm { template GLM_FUNC_QUALIFIER T radialGradient ( vec<2, T, Q> const& Center, T const& Radius, vec<2, T, Q> const& Focal, vec<2, T, Q> const& Position ) { vec<2, T, Q> F = Focal - Center; vec<2, T, Q> D = Position - Focal; T Radius2 = pow2(Radius); T Fx2 = pow2(F.x); T Fy2 = pow2(F.y); T Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x)); T Denominator = Radius2 - (Fx2 + Fy2); return Numerator / Denominator; } template GLM_FUNC_QUALIFIER T linearGradient ( vec<2, T, Q> const& Point0, vec<2, T, Q> const& Point1, vec<2, T, Q> const& Position ) { vec<2, T, Q> Dist = Point1 - Point0; return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); } }//namespace glm glm-0.9.9-a2/glm/gtx/polar_coordinates.hpp0000600000175000001440000000245413173131001017276 0ustar guususers/// @ref gtx_polar_coordinates /// @file glm/gtx/polar_coordinates.hpp /// /// @see core (dependence) /// /// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Conversion from Euclidean space to polar space and revert. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_polar_coordinates is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_polar_coordinates extension included") #endif namespace glm { /// @addtogroup gtx_polar_coordinates /// @{ /// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude. /// /// @see gtx_polar_coordinates template GLM_FUNC_DECL vec<3, T, Q> polar( vec<3, T, Q> const& euclidean); /// Convert Polar to Euclidean coordinates. /// /// @see gtx_polar_coordinates template GLM_FUNC_DECL vec<3, T, Q> euclidean( vec<2, T, Q> const& polar); /// @} }//namespace glm #include "polar_coordinates.inl" glm-0.9.9-a2/glm/gtx/scalar_multiplication.hpp0000600000175000001440000000431713173131001020151 0ustar guususers/// @ref gtx /// @file glm/gtx/scalar_multiplication.hpp /// @author Joshua Moerman /// /// Include to use the features of this extension. /// /// Enables scalar multiplication for all types /// /// Since GLSL is very strict about types, the following (often used) combinations do not work: /// double * vec4 /// int * vec4 /// vec4 / int /// So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic) #pragma once #include "../detail/setup.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_scalar_multiplication is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if !GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC) # error "GLM_GTX_scalar_multiplication requires C++11 support or alias templates and if not support for GCC" #endif #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../mat2x2.hpp" #include namespace glm { template using return_type_scalar_multiplication = typename std::enable_if< !std::is_same::value // T may not be a float && std::is_arithmetic::value, Vec // But it may be an int or double (no vec3 or mat3, ...) >::type; #define GLM_IMPLEMENT_SCAL_MULT(Vec) \ template \ return_type_scalar_multiplication \ operator*(T const& s, Vec rh){ \ return rh *= static_cast(s); \ } \ \ template \ return_type_scalar_multiplication \ operator*(Vec lh, T const& s){ \ return lh *= static_cast(s); \ } \ \ template \ return_type_scalar_multiplication \ operator/(Vec lh, T const& s){ \ return lh *= 1.0f / s; \ } GLM_IMPLEMENT_SCAL_MULT(vec2) GLM_IMPLEMENT_SCAL_MULT(vec3) GLM_IMPLEMENT_SCAL_MULT(vec4) GLM_IMPLEMENT_SCAL_MULT(mat2) GLM_IMPLEMENT_SCAL_MULT(mat2x3) GLM_IMPLEMENT_SCAL_MULT(mat2x4) GLM_IMPLEMENT_SCAL_MULT(mat3x2) GLM_IMPLEMENT_SCAL_MULT(mat3) GLM_IMPLEMENT_SCAL_MULT(mat3x4) GLM_IMPLEMENT_SCAL_MULT(mat4x2) GLM_IMPLEMENT_SCAL_MULT(mat4x3) GLM_IMPLEMENT_SCAL_MULT(mat4) #undef GLM_IMPLEMENT_SCAL_MULT } // namespace glm glm-0.9.9-a2/glm/gtx/quaternion.inl0000600000175000001440000001605413173131001015750 0ustar guususers/// @ref gtx_quaternion /// @file glm/gtx/quaternion.inl #include #include "../gtc/constants.hpp" namespace glm { template GLM_FUNC_QUALIFIER tquat quat_identity() { return tquat(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& v, tquat const& q) { return inverse(q) * v; } template GLM_FUNC_QUALIFIER vec<3, T, Q> cross(tquat const& q, vec<3, T, Q> const& v) { return q * v; } template GLM_FUNC_QUALIFIER tquat squad ( tquat const& q1, tquat const& q2, tquat const& s1, tquat const& s2, T const& h) { return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast(2) * (static_cast(1) - h) * h); } template GLM_FUNC_QUALIFIER tquat intermediate ( tquat const& prev, tquat const& curr, tquat const& next ) { tquat invQuat = inverse(curr); return exp((log(next + invQuat) + log(prev + invQuat)) / static_cast(-4)) * curr; } template GLM_FUNC_QUALIFIER tquat exp(tquat const& q) { vec<3, T, Q> u(q.x, q.y, q.z); T const Angle = glm::length(u); if (Angle < epsilon()) return tquat(); vec<3, T, Q> const v(u / Angle); return tquat(cos(Angle), sin(Angle) * v); } template GLM_FUNC_QUALIFIER tquat log(tquat const& q) { vec<3, T, Q> u(q.x, q.y, q.z); T Vec3Len = length(u); if (Vec3Len < epsilon()) { if(q.w > static_cast(0)) return tquat(log(q.w), static_cast(0), static_cast(0), static_cast(0)); else if(q.w < static_cast(0)) return tquat(log(-q.w), pi(), static_cast(0), static_cast(0)); else return tquat(std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity()); } else { T t = atan(Vec3Len, T(q.w)) / Vec3Len; T QuatLen2 = Vec3Len * Vec3Len + q.w * q.w; return tquat(static_cast(0.5) * log(QuatLen2), t * q.x, t * q.y, t * q.z); } } template GLM_FUNC_QUALIFIER tquat pow(tquat const& x, T const& y) { //Raising to the power of 0 should yield 1 //Needed to prevent a division by 0 error later on if(y > -epsilon() && y < epsilon()) return tquat(1,0,0,0); //To deal with non-unit quaternions T magnitude = sqrt(x.x * x.x + x.y * x.y + x.z * x.z + x.w *x.w); //Equivalent to raising a real number to a power //Needed to prevent a division by 0 error later on if(abs(x.w / magnitude) > static_cast(1) - epsilon() && abs(x.w / magnitude) < static_cast(1) + epsilon()) return tquat(pow(x.w, y),0,0,0); T Angle = acos(x.w / magnitude); T NewAngle = Angle * y; T Div = sin(NewAngle) / sin(Angle); T Mag = pow(magnitude, y - static_cast(1)); return tquat(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag); } template GLM_FUNC_QUALIFIER vec<3, T, Q> rotate(tquat const& q, vec<3, T, Q> const& v) { return q * v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> rotate(tquat const& q, vec<4, T, Q> const& v) { return q * v; } template GLM_FUNC_QUALIFIER T extractRealComponent(tquat const& q) { T w = static_cast(1) - q.x * q.x - q.y * q.y - q.z * q.z; if(w < T(0)) return T(0); else return -sqrt(w); } template GLM_FUNC_QUALIFIER T length2(tquat const& q) { return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w; } template GLM_FUNC_QUALIFIER tquat shortMix(tquat const& x, tquat const& y, T const& a) { if(a <= static_cast(0)) return x; if(a >= static_cast(1)) return y; T fCos = dot(x, y); tquat y2(y); //BUG!!! tquat y2; if(fCos < static_cast(0)) { y2 = -y; fCos = -fCos; } //if(fCos > 1.0f) // problem T k0, k1; if(fCos > (static_cast(1) - epsilon())) { k0 = static_cast(1) - a; k1 = static_cast(0) + a; //BUG!!! 1.0f + a; } else { T fSin = sqrt(T(1) - fCos * fCos); T fAngle = atan(fSin, fCos); T fOneOverSin = static_cast(1) / fSin; k0 = sin((static_cast(1) - a) * fAngle) * fOneOverSin; k1 = sin((static_cast(0) + a) * fAngle) * fOneOverSin; } return tquat( k0 * x.w + k1 * y2.w, k0 * x.x + k1 * y2.x, k0 * x.y + k1 * y2.y, k0 * x.z + k1 * y2.z); } template GLM_FUNC_QUALIFIER tquat fastMix(tquat const& x, tquat const& y, T const& a) { return glm::normalize(x * (static_cast(1) - a) + (y * a)); } template GLM_FUNC_QUALIFIER tquat rotation(vec<3, T, Q> const& orig, vec<3, T, Q> const& dest) { T cosTheta = dot(orig, dest); vec<3, T, Q> rotationAxis; if(cosTheta >= static_cast(1) - epsilon()) { // orig and dest point in the same direction return quat_identity(); } if(cosTheta < static_cast(-1) + epsilon()) { // special case when vectors in opposite directions : // there is no "ideal" rotation axis // So guess one; any will do as long as it's perpendicular to start // This implementation favors a rotation around the Up axis (Y), // since it's often what you want to do. rotationAxis = cross(vec<3, T, Q>(0, 0, 1), orig); if(length2(rotationAxis) < epsilon()) // bad luck, they were parallel, try again! rotationAxis = cross(vec<3, T, Q>(1, 0, 0), orig); rotationAxis = normalize(rotationAxis); return angleAxis(pi(), rotationAxis); } // Implementation from Stan Melax's Game Programming Gems 1 article rotationAxis = cross(orig, dest); T s = sqrt((T(1) + cosTheta) * static_cast(2)); T invs = static_cast(1) / s; return tquat( s * static_cast(0.5f), rotationAxis.x * invs, rotationAxis.y * invs, rotationAxis.z * invs); } template GLM_FUNC_QUALIFIER tquat quatLookAt(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return quatLookAtLH(direction, up); # else return quatLookAtRH(direction, up); # endif } template GLM_FUNC_QUALIFIER tquat quatLookAtRH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) { mat<3, 3, T, Q> Result; Result[2] = -direction; Result[0] = normalize(cross(up, Result[2])); Result[1] = cross(Result[2], Result[0]); return quat_cast(Result); } template GLM_FUNC_QUALIFIER tquat quatLookAtLH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) { mat<3, 3, T, Q> Result; Result[2] = direction; Result[0] = normalize(cross(up, Result[2])); Result[1] = cross(Result[2], Result[0]); return quat_cast(Result); } }//namespace glm glm-0.9.9-a2/glm/gtx/normal.hpp0000600000175000001440000000202213173131001015046 0ustar guususers/// @ref gtx_normal /// @file glm/gtx/normal.hpp /// /// @see core (dependence) /// @see gtx_extented_min_max (dependence) /// /// @defgroup gtx_normal GLM_GTX_normal /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Compute the normal of a triangle. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_normal is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_normal extension included") #endif namespace glm { /// @addtogroup gtx_normal /// @{ /// Computes triangle normal from triangle points. /// /// @see gtx_normal template GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); /// @} }//namespace glm #include "normal.inl" glm-0.9.9-a2/glm/gtx/hash.inl0000600000175000001440000001301413173131001014477 0ustar guususers/// @ref gtx_hash /// @file glm/gtx/hash.inl /// /// @see core (dependence) /// /// @defgroup gtx_hash GLM_GTX_hash /// @ingroup gtx /// /// @brief Add std::hash support for glm types /// /// need to be included to use the features of this extension. namespace glm { namespace detail { GLM_INLINE void hash_combine(size_t &seed, size_t hash) { hash += 0x9e3779b9 + (seed << 6) + (seed >> 2); seed ^= hash; } }} namespace std { template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<1, T, Q> const& v) const { hash hasher; return hasher(v.x); } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<2, T, Q> const& v) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(v.x)); glm::detail::hash_combine(seed, hasher(v.y)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<3, T, Q> const& v) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(v.x)); glm::detail::hash_combine(seed, hasher(v.y)); glm::detail::hash_combine(seed, hasher(v.z)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<4, T, Q> const& v) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(v.x)); glm::detail::hash_combine(seed, hasher(v.y)); glm::detail::hash_combine(seed, hasher(v.z)); glm::detail::hash_combine(seed, hasher(v.w)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tquat const& q) const { size_t seed = 0; hash hasher; glm::detail::hash_combine(seed, hasher(q.x)); glm::detail::hash_combine(seed, hasher(q.y)); glm::detail::hash_combine(seed, hasher(q.z)); glm::detail::hash_combine(seed, hasher(q.w)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tdualquat const& q) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(q.real)); glm::detail::hash_combine(seed, hasher(q.dual)); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 2, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 3, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 4, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 2, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 3, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 4, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 2, T,Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); glm::detail::hash_combine(seed, hasher(m[3])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 3, T,Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); glm::detail::hash_combine(seed, hasher(m[3])); return seed; } template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 4, T, Q> const& m) const { size_t seed = 0; hash> hasher; glm::detail::hash_combine(seed, hasher(m[0])); glm::detail::hash_combine(seed, hasher(m[1])); glm::detail::hash_combine(seed, hasher(m[2])); glm::detail::hash_combine(seed, hasher(m[3])); return seed; } } glm-0.9.9-a2/glm/gtx/associated_min_max.inl0000600000175000001440000002060513173131001017407 0ustar guususers/// @ref gtx_associated_min_max /// @file glm/gtx/associated_min_max.inl namespace glm{ // Min comparison between 2 variables template GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b) { return x < y ? a : b; } template GLM_FUNC_QUALIFIER vec<2, U, Q> associatedMin ( vec const& x, vec const& a, vec const& y, vec const& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] < y[i] ? a[i] : b[i]; return Result; } template GLM_FUNC_QUALIFIER vec associatedMin ( T x, const vec& a, T y, const vec& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x < y ? a[i] : b[i]; return Result; } template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, U a, vec const& y, U b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] < y[i] ? a : b; return Result; } // Min comparison between 3 variables template GLM_FUNC_QUALIFIER U associatedMin ( T x, U a, T y, U b, T z, U c ) { U Result = x < y ? (x < z ? a : c) : (y < z ? b : c); return Result; } template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]); return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER U associatedMin ( T x, U a, T y, U b, T z, U c, T w, U d ) { T Test1 = min(x, y); T Test2 = min(z, w);; U Result1 = x < y ? a : b; U Result2 = z < w ? c : d; U Result = Test1 < Test2 ? Result1 : Result2; return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = min(x[i], y[i]); T Test2 = min(z[i], w[i]); U Result1 = x[i] < y[i] ? a[i] : b[i]; U Result2 = z[i] < w[i] ? c[i] : d[i]; Result[i] = Test1 < Test2 ? Result1 : Result2; } return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMin ( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d ) { T Test1 = min(x, y); T Test2 = min(z, w); vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { U Result1 = x < y ? a[i] : b[i]; U Result2 = z < w ? c[i] : d[i]; Result[i] = Test1 < Test2 ? Result1 : Result2; } return Result; } // Min comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMin ( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = min(x[i], y[i]); T Test2 = min(z[i], w[i]);; U Result1 = x[i] < y[i] ? a : b; U Result2 = z[i] < w[i] ? c : d; Result[i] = Test1 < Test2 ? Result1 : Result2; } return Result; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b) { return x > y ? a : b; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER vec<2, U, Q> associatedMax ( vec const& x, vec const& a, vec const& y, vec const& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? a[i] : b[i]; return Result; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER vec associatedMax ( T x, vec const& a, T y, vec const& b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x > y ? a[i] : b[i]; return Result; } // Max comparison between 2 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, U a, vec const& y, U b ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? a : b; return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER U associatedMax ( T x, U a, T y, U b, T z, U c ) { U Result = x > y ? (x > z ? a : c) : (y > z ? b : c); return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]); return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER vec associatedMax ( T x, vec const& a, T y, vec const& b, T z, vec const& c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]); return Result; } // Max comparison between 3 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, U a, vec const& y, U b, vec const& z, U c ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c); return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER U associatedMax ( T x, U a, T y, U b, T z, U c, T w, U d ) { T Test1 = max(x, y); T Test2 = max(z, w);; U Result1 = x > y ? a : b; U Result2 = z > w ? c : d; U Result = Test1 > Test2 ? Result1 : Result2; return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, vec const& a, vec const& y, vec const& b, vec const& z, vec const& c, vec const& w, vec const& d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = max(x[i], y[i]); T Test2 = max(z[i], w[i]); U Result1 = x[i] > y[i] ? a[i] : b[i]; U Result2 = z[i] > w[i] ? c[i] : d[i]; Result[i] = Test1 > Test2 ? Result1 : Result2; } return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMax ( T x, vec const& a, T y, vec const& b, T z, vec const& c, T w, vec const& d ) { T Test1 = max(x, y); T Test2 = max(z, w); vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { U Result1 = x > y ? a[i] : b[i]; U Result2 = z > w ? c[i] : d[i]; Result[i] = Test1 > Test2 ? Result1 : Result2; } return Result; } // Max comparison between 4 variables template GLM_FUNC_QUALIFIER vec associatedMax ( vec const& x, U a, vec const& y, U b, vec const& z, U c, vec const& w, U d ) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = max(x[i], y[i]); T Test2 = max(z[i], w[i]);; U Result1 = x[i] > y[i] ? a : b; U Result2 = z[i] > w[i] ? c : d; Result[i] = Test1 > Test2 ? Result1 : Result2; } return Result; } }//namespace glm glm-0.9.9-a2/glm/gtx/intersect.inl0000600000175000001440000001570413173131001015564 0ustar guususers/// @ref gtx_intersect /// @file glm/gtx/intersect.inl namespace glm { template GLM_FUNC_QUALIFIER bool intersectRayPlane ( genType const& orig, genType const& dir, genType const& planeOrig, genType const& planeNormal, typename genType::value_type & intersectionDistance ) { typename genType::value_type d = glm::dot(dir, planeNormal); typename genType::value_type Epsilon = std::numeric_limits::epsilon(); if(d < -Epsilon) { intersectionDistance = glm::dot(planeOrig - orig, planeNormal) / d; return true; } return false; } template GLM_FUNC_QUALIFIER bool intersectRayTriangle ( vec<3, T, Q> const& orig, vec<3, T, Q> const& dir, vec<3, T, Q> const& vert0, vec<3, T, Q> const& vert1, vec<3, T, Q> const& vert2, vec<2, T, Q>& baryPosition, T& distance ) { // find vectors for two edges sharing vert0 vec<3, T, Q> const edge1 = vert1 - vert0; vec<3, T, Q> const edge2 = vert2 - vert0; // begin calculating determinant - also used to calculate U parameter vec<3, T, Q> const p = glm::cross(dir, edge2); // if determinant is near zero, ray lies in plane of triangle T const det = glm::dot(edge1, p); vec<3, T, Q> qvec; if(det > std::numeric_limits::epsilon()) { // calculate distance from vert0 to ray origin vec<3, T, Q> const tvec = orig - vert0; // calculate U parameter and test bounds baryPosition.x = glm::dot(tvec, p); if(baryPosition.x < static_cast(0) || baryPosition.x > det) return false; // prepare to test V parameter qvec = glm::cross(tvec, edge1); // calculate V parameter and test bounds baryPosition.y = glm::dot(dir, qvec); if((baryPosition.y < static_cast(0)) || ((baryPosition.x + baryPosition.y) > det)) return false; } else if(det < -std::numeric_limits::epsilon()) { // calculate distance from vert0 to ray origin vec<3, T, Q> const tvec = orig - vert0; // calculate U parameter and test bounds baryPosition.x = glm::dot(tvec, p); if((baryPosition.x > static_cast(0)) || (baryPosition.x < det)) return false; // prepare to test V parameter qvec = glm::cross(tvec, edge1); // calculate V parameter and test bounds baryPosition.y = glm::dot(dir, qvec); if((baryPosition.y > static_cast(0)) || (baryPosition.x + baryPosition.y < det)) return false; } else return false; // ray is parallel to the plane of the triangle T inv_det = static_cast(1) / det; // calculate distance, ray intersects triangle distance = glm::dot(edge2, qvec) * inv_det; baryPosition *= inv_det; return true; } /* typename genType::value_type Epsilon = std::numeric_limits::epsilon(); if(a < Epsilon && a > -Epsilon) return false; typename genType::value_type f = typename genType::value_type(1.0f) / a; genType s = orig - v0; baryPosition.x = f * glm::dot(s, p); if(baryPosition.x < typename genType::value_type(0.0f)) return false; if(baryPosition.x > typename genType::value_type(1.0f)) return false; genType q = glm::cross(s, e1); baryPosition.y = f * glm::dot(dir, q); if(baryPosition.y < typename genType::value_type(0.0f)) return false; if(baryPosition.y + baryPosition.x > typename genType::value_type(1.0f)) return false; baryPosition.z = f * glm::dot(e2, q); return baryPosition.z >= typename genType::value_type(0.0f); } */ template GLM_FUNC_QUALIFIER bool intersectLineTriangle ( genType const& orig, genType const& dir, genType const& vert0, genType const& vert1, genType const& vert2, genType & position ) { typename genType::value_type Epsilon = std::numeric_limits::epsilon(); genType edge1 = vert1 - vert0; genType edge2 = vert2 - vert0; genType pvec = cross(dir, edge2); float det = dot(edge1, pvec); if (det > -Epsilon && det < Epsilon) return false; float inv_det = typename genType::value_type(1) / det; genType tvec = orig - vert0; position.y = dot(tvec, pvec) * inv_det; if (position.y < typename genType::value_type(0) || position.y > typename genType::value_type(1)) return false; genType qvec = cross(tvec, edge1); position.z = dot(dir, qvec) * inv_det; if (position.z < typename genType::value_type(0) || position.y + position.z > typename genType::value_type(1)) return false; position.x = dot(edge2, qvec) * inv_det; return true; } template GLM_FUNC_QUALIFIER bool intersectRaySphere ( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, const typename genType::value_type sphereRadiusSquered, typename genType::value_type & intersectionDistance ) { typename genType::value_type Epsilon = std::numeric_limits::epsilon(); genType diff = sphereCenter - rayStarting; typename genType::value_type t0 = dot(diff, rayNormalizedDirection); typename genType::value_type dSquared = dot(diff, diff) - t0 * t0; if( dSquared > sphereRadiusSquered ) { return false; } typename genType::value_type t1 = sqrt( sphereRadiusSquered - dSquared ); intersectionDistance = t0 > t1 + Epsilon ? t0 - t1 : t0 + t1; return intersectionDistance > Epsilon; } template GLM_FUNC_QUALIFIER bool intersectRaySphere ( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, const typename genType::value_type sphereRadius, genType & intersectionPosition, genType & intersectionNormal ) { typename genType::value_type distance; if( intersectRaySphere( rayStarting, rayNormalizedDirection, sphereCenter, sphereRadius * sphereRadius, distance ) ) { intersectionPosition = rayStarting + rayNormalizedDirection * distance; intersectionNormal = (intersectionPosition - sphereCenter) / sphereRadius; return true; } return false; } template GLM_FUNC_QUALIFIER bool intersectLineSphere ( genType const& point0, genType const& point1, genType const& sphereCenter, typename genType::value_type sphereRadius, genType & intersectionPoint1, genType & intersectionNormal1, genType & intersectionPoint2, genType & intersectionNormal2 ) { typename genType::value_type Epsilon = std::numeric_limits::epsilon(); genType dir = normalize(point1 - point0); genType diff = sphereCenter - point0; typename genType::value_type t0 = dot(diff, dir); typename genType::value_type dSquared = dot(diff, diff) - t0 * t0; if( dSquared > sphereRadius * sphereRadius ) { return false; } typename genType::value_type t1 = sqrt( sphereRadius * sphereRadius - dSquared ); if( t0 < t1 + Epsilon ) t1 = -t1; intersectionPoint1 = point0 + dir * (t0 - t1); intersectionNormal1 = (intersectionPoint1 - sphereCenter) / sphereRadius; intersectionPoint2 = point0 + dir * (t0 + t1); intersectionNormal2 = (intersectionPoint2 - sphereCenter) / sphereRadius; return true; } }//namespace glm glm-0.9.9-a2/glm/gtx/io.inl0000600000175000001440000002727313173131001014177 0ustar guususers/// @ref gtx_io /// @file glm/gtx/io.inl /// @author Jan P Springer (regnirpsj@gmail.com) #include // std::fixed, std::setfill<>, std::setprecision, std::right, std::setw #include // std::basic_ostream<> #include "../gtc/matrix_access.hpp" // glm::col, glm::row #include "../gtx/type_trait.hpp" // glm::type<> namespace glm{ namespace io { template GLM_FUNC_QUALIFIER format_punct::format_punct(size_t a) : std::locale::facet(a) , formatted(true) , precision(3) , width(1 + 4 + 1 + precision) , separator(',') , delim_left('[') , delim_right(']') , space(' ') , newline('\n') , order(column_major) {} template GLM_FUNC_QUALIFIER format_punct::format_punct(format_punct const& a) : std::locale::facet(0) , formatted(a.formatted) , precision(a.precision) , width(a.width) , separator(a.separator) , delim_left(a.delim_left) , delim_right(a.delim_right) , space(a.space) , newline(a.newline) , order(a.order) {} template std::locale::id format_punct::id; template GLM_FUNC_QUALIFIER basic_state_saver::basic_state_saver(std::basic_ios& a) : state_(a) , flags_(a.flags()) , precision_(a.precision()) , width_(a.width()) , fill_(a.fill()) , locale_(a.getloc()) {} template GLM_FUNC_QUALIFIER basic_state_saver::~basic_state_saver() { state_.imbue(locale_); state_.fill(fill_); state_.width(width_); state_.precision(precision_); state_.flags(flags_); } template GLM_FUNC_QUALIFIER basic_format_saver::basic_format_saver(std::basic_ios& a) : bss_(a) { a.imbue(std::locale(a.getloc(), new format_punct(get_facet >(a)))); } template GLM_FUNC_QUALIFIER basic_format_saver::~basic_format_saver() {} GLM_FUNC_QUALIFIER precision::precision(unsigned a) : value(a) {} GLM_FUNC_QUALIFIER width::width(unsigned a) : value(a) {} template GLM_FUNC_QUALIFIER delimeter::delimeter(CTy a, CTy b, CTy c) : value() { value[0] = a; value[1] = b; value[2] = c; } GLM_FUNC_QUALIFIER order::order(order_type a) : value(a) {} template GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios& ios) { if(!std::has_facet(ios.getloc())) ios.imbue(std::locale(ios.getloc(), new FTy)); return std::use_facet(ios.getloc()); } template GLM_FUNC_QUALIFIER std::basic_ios& formatted(std::basic_ios& ios) { const_cast&>(get_facet >(ios)).formatted = true; return ios; } template GLM_FUNC_QUALIFIER std::basic_ios& unformatted(std::basic_ios& ios) { const_cast&>(get_facet >(ios)).formatted = false; return ios; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, precision const& a) { const_cast&>(get_facet >(os)).precision = a.value; return os; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, width const& a) { const_cast&>(get_facet >(os)).width = a.value; return os; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, delimeter const& a) { format_punct & fmt(const_cast&>(get_facet >(os))); fmt.delim_left = a.value[0]; fmt.delim_right = a.value[1]; fmt.separator = a.value[2]; return os; } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, order const& a) { const_cast&>(get_facet >(os)).order = a.value; return os; } } // namespace io namespace detail { template GLM_FUNC_QUALIFIER std::basic_ostream& print_vector_on(std::basic_ostream& os, V const& a) { typename std::basic_ostream::sentry const cerberus(os); if(cerberus) { io::format_punct const& fmt(io::get_facet >(os)); length_t const& components(type::components); if(fmt.formatted) { io::basic_state_saver const bss(os); os << std::fixed << std::right << std::setprecision(fmt.precision) << std::setfill(fmt.space) << fmt.delim_left; for(length_t i(0); i < components; ++i) { os << std::setw(fmt.width) << a[i]; if(components-1 != i) os << fmt.separator; } os << fmt.delim_right; } else { for(length_t i(0); i < components; ++i) { os << a[i]; if(components-1 != i) os << fmt.space; } } } return os; } }//namespace detail template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tquat const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<1, T, Q> const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<2, T, Q> const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<3, T, Q> const& a) { return detail::print_vector_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<4, T, Q> const& a) { return detail::print_vector_on(os, a); } namespace detail { template class M, length_t C, length_t R, typename T, qualifier Q> GLM_FUNC_QUALIFIER std::basic_ostream& print_matrix_on(std::basic_ostream& os, M const& a) { typename std::basic_ostream::sentry const cerberus(os); if(cerberus) { io::format_punct const& fmt(io::get_facet >(os)); length_t const& cols(type >::cols); length_t const& rows(type >::rows); if(fmt.formatted) { os << fmt.newline << fmt.delim_left; switch(fmt.order) { case io::column_major: { for(length_t i(0); i < rows; ++i) { if (0 != i) os << fmt.space; os << row(a, i); if(rows-1 != i) os << fmt.newline; } } break; case io::row_major: { for(length_t i(0); i < cols; ++i) { if(0 != i) os << fmt.space; os << column(a, i); if(cols-1 != i) os << fmt.newline; } } break; } os << fmt.delim_right; } else { switch (fmt.order) { case io::column_major: { for(length_t i(0); i < cols; ++i) { os << column(a, i); if(cols - 1 != i) os << fmt.space; } } break; case io::row_major: { for (length_t i(0); i < rows; ++i) { os << row(a, i); if (rows-1 != i) os << fmt.space; } } break; } } } return os; } }//namespace detail template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 2, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 3, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 4, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<3, 2, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<3, 3, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<3, 4, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 2, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 3, T, Q> const& a) { return detail::print_matrix_on(os, a); } template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 4, T, Q> const& a) { return detail::print_matrix_on(os, a); } namespace detail { template class M, length_t C, length_t R, typename T, qualifier Q> GLM_FUNC_QUALIFIER std::basic_ostream& print_matrix_pair_on(std::basic_ostream& os, std::pair const, M const> const& a) { typename std::basic_ostream::sentry const cerberus(os); if(cerberus) { io::format_punct const& fmt(io::get_facet >(os)); M const& ml(a.first); M const& mr(a.second); length_t const& cols(type >::cols); length_t const& rows(type >::rows); if(fmt.formatted) { os << fmt.newline << fmt.delim_left; switch(fmt.order) { case io::column_major: { for(length_t i(0); i < rows; ++i) { if(0 != i) os << fmt.space; os << row(ml, i) << ((rows-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << row(mr, i); if(rows-1 != i) os << fmt.newline; } } break; case io::row_major: { for(length_t i(0); i < cols; ++i) { if(0 != i) os << fmt.space; os << column(ml, i) << ((cols-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << column(mr, i); if(cols-1 != i) os << fmt.newline; } } break; } os << fmt.delim_right; } else { os << ml << fmt.space << mr; } } return os; } }//namespace detail template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<( std::basic_ostream & os, std::pair const, mat<4, 4, T, Q> const> const& a) { return detail::print_matrix_pair_on(os, a); } }//namespace glm glm-0.9.9-a2/glm/gtx/std_based_type.inl0000600000175000001440000000012513173131001016544 0ustar guususers/// @ref gtx_std_based_type /// @file glm/gtx/std_based_type.inl namespace glm { } glm-0.9.9-a2/glm/gtx/matrix_query.inl0000600000175000001440000000631213173131001016310 0ustar guususers/// @ref gtx_matrix_query /// @file glm/gtx/matrix_query.inl namespace glm { template GLM_FUNC_QUALIFIER bool isNull(mat<2, 2, T, Q> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) result = isNull(m[i], epsilon); return result; } template GLM_FUNC_QUALIFIER bool isNull(mat<3, 3, T, Q> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) result = isNull(m[i], epsilon); return result; } template GLM_FUNC_QUALIFIER bool isNull(mat<4, 4, T, Q> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) result = isNull(m[i], epsilon); return result; } template GLM_FUNC_QUALIFIER bool isIdentity(mat const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m[0].length() ; ++i) { for(length_t j = 0; result && j < i ; ++j) result = abs(m[i][j]) <= epsilon; if(result) result = abs(m[i][i] - 1) <= epsilon; for(length_t j = i + 1; result && j < m.length(); ++j) result = abs(m[i][j]) <= epsilon; } return result; } template GLM_FUNC_QUALIFIER bool isNormalized(mat<2, 2, T, Q> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) result = isNormalized(m[i], epsilon); for(length_t i = 0; result && i < m.length(); ++i) { typename mat<2, 2, T, Q>::col_type v; for(length_t j = 0; j < m.length(); ++j) v[j] = m[j][i]; result = isNormalized(v, epsilon); } return result; } template GLM_FUNC_QUALIFIER bool isNormalized(mat<3, 3, T, Q> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) result = isNormalized(m[i], epsilon); for(length_t i = 0; result && i < m.length(); ++i) { typename mat<3, 3, T, Q>::col_type v; for(length_t j = 0; j < m.length(); ++j) v[j] = m[j][i]; result = isNormalized(v, epsilon); } return result; } template GLM_FUNC_QUALIFIER bool isNormalized(mat<4, 4, T, Q> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) result = isNormalized(m[i], epsilon); for(length_t i = 0; result && i < m.length(); ++i) { typename mat<4, 4, T, Q>::col_type v; for(length_t j = 0; j < m.length(); ++j) v[j] = m[j][i]; result = isNormalized(v, epsilon); } return result; } template GLM_FUNC_QUALIFIER bool isOrthogonal(mat const& m, T const& epsilon) { bool result = true; for(length_t i(0); result && i < m.length() - 1; ++i) for(length_t j(i + 1); result && j < m.length(); ++j) result = areOrthogonal(m[i], m[j], epsilon); if(result) { mat tmp = transpose(m); for(length_t i(0); result && i < m.length() - 1 ; ++i) for(length_t j(i + 1); result && j < m.length(); ++j) result = areOrthogonal(tmp[i], tmp[j], epsilon); } return result; } }//namespace glm glm-0.9.9-a2/glm/gtx/scalar_relational.inl0000600000175000001440000000206013173131001017232 0ustar guususers/// @ref gtx_scalar_relational /// @file glm/gtx/scalar_relational.inl namespace glm { template GLM_FUNC_QUALIFIER bool lessThan ( T const& x, T const& y ) { return x < y; } template GLM_FUNC_QUALIFIER bool lessThanEqual ( T const& x, T const& y ) { return x <= y; } template GLM_FUNC_QUALIFIER bool greaterThan ( T const& x, T const& y ) { return x > y; } template GLM_FUNC_QUALIFIER bool greaterThanEqual ( T const& x, T const& y ) { return x >= y; } template GLM_FUNC_QUALIFIER bool equal ( T const& x, T const& y ) { return detail::compute_equal::call(x, y); } template GLM_FUNC_QUALIFIER bool notEqual ( T const& x, T const& y ) { return !detail::compute_equal::call(x, y); } GLM_FUNC_QUALIFIER bool any ( bool const& x ) { return x; } GLM_FUNC_QUALIFIER bool all ( bool const& x ) { return x; } GLM_FUNC_QUALIFIER bool not_ ( bool const& x ) { return !x; } }//namespace glm glm-0.9.9-a2/glm/gtx/bit.hpp0000600000175000001440000000602013173131001014336 0ustar guususers/// @ref gtx_bit /// @file glm/gtx/bit.hpp /// /// @see core (dependence) /// /// @defgroup gtx_bit GLM_GTX_bit /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Allow to perform bit operations on integer values #pragma once // Dependencies #include "../gtc/bitfield.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_bit is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_bit extension is deprecated, include GLM_GTC_bitfield and GLM_GTC_integer instead") #endif namespace glm { /// @addtogroup gtx_bit /// @{ /// @see gtx_bit template GLM_FUNC_DECL genIUType highestBitValue(genIUType Value); /// @see gtx_bit template GLM_FUNC_DECL genIUType lowestBitValue(genIUType Value); /// Find the highest bit set to 1 in a integer variable and return its value. /// /// @see gtx_bit template GLM_FUNC_DECL vec highestBitValue(vec const& value); /// Return the power of two number which value is just higher the input value. /// Deprecated, use ceilPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value); /// Return the power of two number which value is just higher the input value. /// Deprecated, use ceilPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoAbove(vec const& value); /// Return the power of two number which value is just lower the input value. /// Deprecated, use floorPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value); /// Return the power of two number which value is just lower the input value. /// Deprecated, use floorPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoBelow(vec const& value); /// Return the power of two number which value is the closet to the input value. /// Deprecated, use roundPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value); /// Return the power of two number which value is the closet to the input value. /// Deprecated, use roundPowerOfTwo from GTC_round instead /// /// @see gtc_round /// @see gtx_bit template GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoNearest(vec const& value); /// @} } //namespace glm #include "bit.inl" glm-0.9.9-a2/glm/gtx/closest_point.hpp0000600000175000001440000000245313173131001016453 0ustar guususers/// @ref gtx_closest_point /// @file glm/gtx/closest_point.hpp /// /// @see core (dependence) /// /// @defgroup gtx_closest_point GLM_GTX_closest_point /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Find the point on a straight line which is the closet of a point. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_closest_point extension included") #endif namespace glm { /// @addtogroup gtx_closest_point /// @{ /// Find the point on a straight line which is the closet of a point. /// @see gtx_closest_point template GLM_FUNC_DECL vec<3, T, Q> closestPointOnLine( vec<3, T, Q> const& point, vec<3, T, Q> const& a, vec<3, T, Q> const& b); /// 2d lines work as well template GLM_FUNC_DECL vec<2, T, Q> closestPointOnLine( vec<2, T, Q> const& point, vec<2, T, Q> const& a, vec<2, T, Q> const& b); /// @} }// namespace glm #include "closest_point.inl" glm-0.9.9-a2/glm/gtx/intersect.hpp0000600000175000001440000000641513173131001015570 0ustar guususers/// @ref gtx_intersect /// @file glm/gtx/intersect.hpp /// /// @see core (dependence) /// @see gtx_closest_point (dependence) /// /// @defgroup gtx_intersect GLM_GTX_intersect /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Add intersection functions #pragma once // Dependency: #include #include #include "../glm.hpp" #include "../geometric.hpp" #include "../gtx/closest_point.hpp" #include "../gtx/vector_query.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_closest_point extension included") #endif namespace glm { /// @addtogroup gtx_intersect /// @{ //! Compute the intersection of a ray and a plane. //! Ray direction and plane normal must be unit length. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRayPlane( genType const& orig, genType const& dir, genType const& planeOrig, genType const& planeNormal, typename genType::value_type & intersectionDistance); //! Compute the intersection of a ray and a triangle. /// Based om Tomas Mller implementation http://fileadmin.cs.lth.se/cs/Personal/Tomas_Akenine-Moller/raytri/ //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRayTriangle( vec<3, T, Q> const& orig, vec<3, T, Q> const& dir, vec<3, T, Q> const& v0, vec<3, T, Q> const& v1, vec<3, T, Q> const& v2, vec<3, T, Q>& baryPosition, T& distance); //! Compute the intersection of a line and a triangle. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectLineTriangle( genType const& orig, genType const& dir, genType const& vert0, genType const& vert1, genType const& vert2, genType & position); //! Compute the intersection distance of a ray and a sphere. //! The ray direction vector is unit length. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRaySphere( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, typename genType::value_type const sphereRadiusSquered, typename genType::value_type & intersectionDistance); //! Compute the intersection of a ray and a sphere. //! From GLM_GTX_intersect extension. template GLM_FUNC_DECL bool intersectRaySphere( genType const& rayStarting, genType const& rayNormalizedDirection, genType const& sphereCenter, const typename genType::value_type sphereRadius, genType & intersectionPosition, genType & intersectionNormal); //! Compute the intersection of a line and a sphere. //! From GLM_GTX_intersect extension template GLM_FUNC_DECL bool intersectLineSphere( genType const& point0, genType const& point1, genType const& sphereCenter, typename genType::value_type sphereRadius, genType & intersectionPosition1, genType & intersectionNormal1, genType & intersectionPosition2 = genType(), genType & intersectionNormal2 = genType()); /// @} }//namespace glm #include "intersect.inl" glm-0.9.9-a2/glm/gtx/vec_swizzle.hpp0000600000175000001440000022450713173131001016140 0ustar guususers/// @ref gtx_vec_swizzle /// @file glm/gtx/vec_swizzle.hpp /// /// @see core (dependence) /// /// @defgroup gtx_vec_swizzle GLM_GTX_vec_swizzle /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Functions to perform swizzle operation. #pragma once #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_vec_swizzle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif namespace glm { // xx template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<1, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } template GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.x); } // xy template GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.y); } template GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.y); } template GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.y); } // xz template GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.z); } template GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.z); } // xw template GLM_INLINE glm::vec<2, T, Q> xw(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.x, v.w); } // yx template GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.x); } template GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.x); } template GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.x); } // yy template GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<2, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.y); } template GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.y); } template GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.y); } // yz template GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.z); } template GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.z); } // yw template GLM_INLINE glm::vec<2, T, Q> yw(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.y, v.w); } // zx template GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.x); } template GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.x); } // zy template GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.y); } template GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.y); } // zz template GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<3, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.z); } template GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.z); } // zw template GLM_INLINE glm::vec<2, T, Q> zw(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.z, v.w); } // wx template GLM_INLINE glm::vec<2, T, Q> wx(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.x); } // wy template GLM_INLINE glm::vec<2, T, Q> wy(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.y); } // wz template GLM_INLINE glm::vec<2, T, Q> wz(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.z); } // ww template GLM_INLINE glm::vec<2, T, Q> ww(const glm::vec<4, T, Q> &v) { return glm::vec<2, T, Q>(v.w, v.w); } // xxx template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<1, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.x); } // xxy template GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.y); } // xxz template GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.z); } template GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.z); } // xxw template GLM_INLINE glm::vec<3, T, Q> xxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.x, v.w); } // xyx template GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.x); } // xyy template GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.y); } // xyz template GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.z); } template GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.z); } // xyw template GLM_INLINE glm::vec<3, T, Q> xyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.y, v.w); } // xzx template GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.x); } template GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.x); } // xzy template GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.y); } template GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.y); } // xzz template GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.z); } template GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.z); } // xzw template GLM_INLINE glm::vec<3, T, Q> xzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.z, v.w); } // xwx template GLM_INLINE glm::vec<3, T, Q> xwx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.x); } // xwy template GLM_INLINE glm::vec<3, T, Q> xwy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.y); } // xwz template GLM_INLINE glm::vec<3, T, Q> xwz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.z); } // xww template GLM_INLINE glm::vec<3, T, Q> xww(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.x, v.w, v.w); } // yxx template GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.x); } // yxy template GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.y); } // yxz template GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.z); } template GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.z); } // yxw template GLM_INLINE glm::vec<3, T, Q> yxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.x, v.w); } // yyx template GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.x); } // yyy template GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<2, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.y); } // yyz template GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.z); } template GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.z); } // yyw template GLM_INLINE glm::vec<3, T, Q> yyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.y, v.w); } // yzx template GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.x); } template GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.x); } // yzy template GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.y); } template GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.y); } // yzz template GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.z); } template GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.z); } // yzw template GLM_INLINE glm::vec<3, T, Q> yzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.z, v.w); } // ywx template GLM_INLINE glm::vec<3, T, Q> ywx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.x); } // ywy template GLM_INLINE glm::vec<3, T, Q> ywy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.y); } // ywz template GLM_INLINE glm::vec<3, T, Q> ywz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.z); } // yww template GLM_INLINE glm::vec<3, T, Q> yww(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.y, v.w, v.w); } // zxx template GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.x); } template GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.x); } // zxy template GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.y); } template GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.y); } // zxz template GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.z); } template GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.z); } // zxw template GLM_INLINE glm::vec<3, T, Q> zxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.x, v.w); } // zyx template GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.x); } template GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.x); } // zyy template GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.y); } template GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.y); } // zyz template GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.z); } template GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.z); } // zyw template GLM_INLINE glm::vec<3, T, Q> zyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.y, v.w); } // zzx template GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.x); } template GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.x); } // zzy template GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.y); } template GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.y); } // zzz template GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<3, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.z); } template GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.z); } // zzw template GLM_INLINE glm::vec<3, T, Q> zzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.z, v.w); } // zwx template GLM_INLINE glm::vec<3, T, Q> zwx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.x); } // zwy template GLM_INLINE glm::vec<3, T, Q> zwy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.y); } // zwz template GLM_INLINE glm::vec<3, T, Q> zwz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.z); } // zww template GLM_INLINE glm::vec<3, T, Q> zww(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.z, v.w, v.w); } // wxx template GLM_INLINE glm::vec<3, T, Q> wxx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.x); } // wxy template GLM_INLINE glm::vec<3, T, Q> wxy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.y); } // wxz template GLM_INLINE glm::vec<3, T, Q> wxz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.z); } // wxw template GLM_INLINE glm::vec<3, T, Q> wxw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.x, v.w); } // wyx template GLM_INLINE glm::vec<3, T, Q> wyx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.x); } // wyy template GLM_INLINE glm::vec<3, T, Q> wyy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.y); } // wyz template GLM_INLINE glm::vec<3, T, Q> wyz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.z); } // wyw template GLM_INLINE glm::vec<3, T, Q> wyw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.y, v.w); } // wzx template GLM_INLINE glm::vec<3, T, Q> wzx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.x); } // wzy template GLM_INLINE glm::vec<3, T, Q> wzy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.y); } // wzz template GLM_INLINE glm::vec<3, T, Q> wzz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.z); } // wzw template GLM_INLINE glm::vec<3, T, Q> wzw(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.z, v.w); } // wwx template GLM_INLINE glm::vec<3, T, Q> wwx(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.x); } // wwy template GLM_INLINE glm::vec<3, T, Q> wwy(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.y); } // wwz template GLM_INLINE glm::vec<3, T, Q> wwz(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.z); } // www template GLM_INLINE glm::vec<3, T, Q> www(const glm::vec<4, T, Q> &v) { return glm::vec<3, T, Q>(v.w, v.w, v.w); } // xxxx template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<1, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x); } // xxxy template GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y); } // xxxz template GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z); } // xxxw template GLM_INLINE glm::vec<4, T, Q> xxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.x, v.w); } // xxyx template GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x); } // xxyy template GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y); } // xxyz template GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z); } // xxyw template GLM_INLINE glm::vec<4, T, Q> xxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.y, v.w); } // xxzx template GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x); } // xxzy template GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y); } // xxzz template GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z); } // xxzw template GLM_INLINE glm::vec<4, T, Q> xxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.z, v.w); } // xxwx template GLM_INLINE glm::vec<4, T, Q> xxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.x); } // xxwy template GLM_INLINE glm::vec<4, T, Q> xxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.y); } // xxwz template GLM_INLINE glm::vec<4, T, Q> xxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.z); } // xxww template GLM_INLINE glm::vec<4, T, Q> xxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.x, v.w, v.w); } // xyxx template GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x); } // xyxy template GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y); } // xyxz template GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z); } // xyxw template GLM_INLINE glm::vec<4, T, Q> xyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.x, v.w); } // xyyx template GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x); } // xyyy template GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y); } // xyyz template GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z); } // xyyw template GLM_INLINE glm::vec<4, T, Q> xyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.y, v.w); } // xyzx template GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x); } // xyzy template GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y); } // xyzz template GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z); } // xyzw template GLM_INLINE glm::vec<4, T, Q> xyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.z, v.w); } // xywx template GLM_INLINE glm::vec<4, T, Q> xywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.x); } // xywy template GLM_INLINE glm::vec<4, T, Q> xywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.y); } // xywz template GLM_INLINE glm::vec<4, T, Q> xywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.z); } // xyww template GLM_INLINE glm::vec<4, T, Q> xyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.y, v.w, v.w); } // xzxx template GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x); } // xzxy template GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y); } // xzxz template GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z); } // xzxw template GLM_INLINE glm::vec<4, T, Q> xzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.x, v.w); } // xzyx template GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x); } // xzyy template GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y); } // xzyz template GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z); } // xzyw template GLM_INLINE glm::vec<4, T, Q> xzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.y, v.w); } // xzzx template GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x); } // xzzy template GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y); } // xzzz template GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z); } // xzzw template GLM_INLINE glm::vec<4, T, Q> xzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.z, v.w); } // xzwx template GLM_INLINE glm::vec<4, T, Q> xzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.x); } // xzwy template GLM_INLINE glm::vec<4, T, Q> xzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.y); } // xzwz template GLM_INLINE glm::vec<4, T, Q> xzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.z); } // xzww template GLM_INLINE glm::vec<4, T, Q> xzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.z, v.w, v.w); } // xwxx template GLM_INLINE glm::vec<4, T, Q> xwxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.x); } // xwxy template GLM_INLINE glm::vec<4, T, Q> xwxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.y); } // xwxz template GLM_INLINE glm::vec<4, T, Q> xwxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.z); } // xwxw template GLM_INLINE glm::vec<4, T, Q> xwxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.x, v.w); } // xwyx template GLM_INLINE glm::vec<4, T, Q> xwyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.x); } // xwyy template GLM_INLINE glm::vec<4, T, Q> xwyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.y); } // xwyz template GLM_INLINE glm::vec<4, T, Q> xwyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.z); } // xwyw template GLM_INLINE glm::vec<4, T, Q> xwyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.y, v.w); } // xwzx template GLM_INLINE glm::vec<4, T, Q> xwzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.x); } // xwzy template GLM_INLINE glm::vec<4, T, Q> xwzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.y); } // xwzz template GLM_INLINE glm::vec<4, T, Q> xwzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.z); } // xwzw template GLM_INLINE glm::vec<4, T, Q> xwzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.z, v.w); } // xwwx template GLM_INLINE glm::vec<4, T, Q> xwwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.x); } // xwwy template GLM_INLINE glm::vec<4, T, Q> xwwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.y); } // xwwz template GLM_INLINE glm::vec<4, T, Q> xwwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.z); } // xwww template GLM_INLINE glm::vec<4, T, Q> xwww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.x, v.w, v.w, v.w); } // yxxx template GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x); } // yxxy template GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y); } // yxxz template GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z); } // yxxw template GLM_INLINE glm::vec<4, T, Q> yxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.x, v.w); } // yxyx template GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x); } // yxyy template GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y); } // yxyz template GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z); } // yxyw template GLM_INLINE glm::vec<4, T, Q> yxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.y, v.w); } // yxzx template GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x); } // yxzy template GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y); } // yxzz template GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z); } // yxzw template GLM_INLINE glm::vec<4, T, Q> yxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.z, v.w); } // yxwx template GLM_INLINE glm::vec<4, T, Q> yxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.x); } // yxwy template GLM_INLINE glm::vec<4, T, Q> yxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.y); } // yxwz template GLM_INLINE glm::vec<4, T, Q> yxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.z); } // yxww template GLM_INLINE glm::vec<4, T, Q> yxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.x, v.w, v.w); } // yyxx template GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x); } // yyxy template GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y); } // yyxz template GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z); } // yyxw template GLM_INLINE glm::vec<4, T, Q> yyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.x, v.w); } // yyyx template GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x); } // yyyy template GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<2, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y); } // yyyz template GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z); } // yyyw template GLM_INLINE glm::vec<4, T, Q> yyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.y, v.w); } // yyzx template GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x); } // yyzy template GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y); } // yyzz template GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z); } // yyzw template GLM_INLINE glm::vec<4, T, Q> yyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.z, v.w); } // yywx template GLM_INLINE glm::vec<4, T, Q> yywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.x); } // yywy template GLM_INLINE glm::vec<4, T, Q> yywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.y); } // yywz template GLM_INLINE glm::vec<4, T, Q> yywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.z); } // yyww template GLM_INLINE glm::vec<4, T, Q> yyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.y, v.w, v.w); } // yzxx template GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x); } // yzxy template GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y); } // yzxz template GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z); } // yzxw template GLM_INLINE glm::vec<4, T, Q> yzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.x, v.w); } // yzyx template GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x); } // yzyy template GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y); } // yzyz template GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z); } // yzyw template GLM_INLINE glm::vec<4, T, Q> yzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.y, v.w); } // yzzx template GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x); } // yzzy template GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y); } // yzzz template GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z); } // yzzw template GLM_INLINE glm::vec<4, T, Q> yzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.z, v.w); } // yzwx template GLM_INLINE glm::vec<4, T, Q> yzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.x); } // yzwy template GLM_INLINE glm::vec<4, T, Q> yzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.y); } // yzwz template GLM_INLINE glm::vec<4, T, Q> yzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.z); } // yzww template GLM_INLINE glm::vec<4, T, Q> yzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.z, v.w, v.w); } // ywxx template GLM_INLINE glm::vec<4, T, Q> ywxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.x); } // ywxy template GLM_INLINE glm::vec<4, T, Q> ywxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.y); } // ywxz template GLM_INLINE glm::vec<4, T, Q> ywxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.z); } // ywxw template GLM_INLINE glm::vec<4, T, Q> ywxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.x, v.w); } // ywyx template GLM_INLINE glm::vec<4, T, Q> ywyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.x); } // ywyy template GLM_INLINE glm::vec<4, T, Q> ywyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.y); } // ywyz template GLM_INLINE glm::vec<4, T, Q> ywyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.z); } // ywyw template GLM_INLINE glm::vec<4, T, Q> ywyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.y, v.w); } // ywzx template GLM_INLINE glm::vec<4, T, Q> ywzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.x); } // ywzy template GLM_INLINE glm::vec<4, T, Q> ywzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.y); } // ywzz template GLM_INLINE glm::vec<4, T, Q> ywzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.z); } // ywzw template GLM_INLINE glm::vec<4, T, Q> ywzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.z, v.w); } // ywwx template GLM_INLINE glm::vec<4, T, Q> ywwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.x); } // ywwy template GLM_INLINE glm::vec<4, T, Q> ywwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.y); } // ywwz template GLM_INLINE glm::vec<4, T, Q> ywwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.z); } // ywww template GLM_INLINE glm::vec<4, T, Q> ywww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.y, v.w, v.w, v.w); } // zxxx template GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x); } // zxxy template GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y); } // zxxz template GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z); } // zxxw template GLM_INLINE glm::vec<4, T, Q> zxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.x, v.w); } // zxyx template GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x); } // zxyy template GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y); } // zxyz template GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z); } // zxyw template GLM_INLINE glm::vec<4, T, Q> zxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.y, v.w); } // zxzx template GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x); } // zxzy template GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y); } // zxzz template GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z); } // zxzw template GLM_INLINE glm::vec<4, T, Q> zxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.z, v.w); } // zxwx template GLM_INLINE glm::vec<4, T, Q> zxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.x); } // zxwy template GLM_INLINE glm::vec<4, T, Q> zxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.y); } // zxwz template GLM_INLINE glm::vec<4, T, Q> zxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.z); } // zxww template GLM_INLINE glm::vec<4, T, Q> zxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.x, v.w, v.w); } // zyxx template GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x); } // zyxy template GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y); } // zyxz template GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z); } // zyxw template GLM_INLINE glm::vec<4, T, Q> zyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.x, v.w); } // zyyx template GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x); } // zyyy template GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y); } // zyyz template GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z); } // zyyw template GLM_INLINE glm::vec<4, T, Q> zyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.y, v.w); } // zyzx template GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x); } // zyzy template GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y); } // zyzz template GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z); } // zyzw template GLM_INLINE glm::vec<4, T, Q> zyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.z, v.w); } // zywx template GLM_INLINE glm::vec<4, T, Q> zywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.x); } // zywy template GLM_INLINE glm::vec<4, T, Q> zywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.y); } // zywz template GLM_INLINE glm::vec<4, T, Q> zywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.z); } // zyww template GLM_INLINE glm::vec<4, T, Q> zyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.y, v.w, v.w); } // zzxx template GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x); } template GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x); } // zzxy template GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y); } template GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y); } // zzxz template GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z); } template GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z); } // zzxw template GLM_INLINE glm::vec<4, T, Q> zzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.x, v.w); } // zzyx template GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x); } template GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x); } // zzyy template GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y); } template GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y); } // zzyz template GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z); } template GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z); } // zzyw template GLM_INLINE glm::vec<4, T, Q> zzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.y, v.w); } // zzzx template GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x); } template GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x); } // zzzy template GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y); } template GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y); } // zzzz template GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<3, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z); } template GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z); } // zzzw template GLM_INLINE glm::vec<4, T, Q> zzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.z, v.w); } // zzwx template GLM_INLINE glm::vec<4, T, Q> zzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.x); } // zzwy template GLM_INLINE glm::vec<4, T, Q> zzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.y); } // zzwz template GLM_INLINE glm::vec<4, T, Q> zzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.z); } // zzww template GLM_INLINE glm::vec<4, T, Q> zzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.z, v.w, v.w); } // zwxx template GLM_INLINE glm::vec<4, T, Q> zwxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.x); } // zwxy template GLM_INLINE glm::vec<4, T, Q> zwxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.y); } // zwxz template GLM_INLINE glm::vec<4, T, Q> zwxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.z); } // zwxw template GLM_INLINE glm::vec<4, T, Q> zwxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.x, v.w); } // zwyx template GLM_INLINE glm::vec<4, T, Q> zwyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.x); } // zwyy template GLM_INLINE glm::vec<4, T, Q> zwyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.y); } // zwyz template GLM_INLINE glm::vec<4, T, Q> zwyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.z); } // zwyw template GLM_INLINE glm::vec<4, T, Q> zwyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.y, v.w); } // zwzx template GLM_INLINE glm::vec<4, T, Q> zwzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.x); } // zwzy template GLM_INLINE glm::vec<4, T, Q> zwzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.y); } // zwzz template GLM_INLINE glm::vec<4, T, Q> zwzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.z); } // zwzw template GLM_INLINE glm::vec<4, T, Q> zwzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.z, v.w); } // zwwx template GLM_INLINE glm::vec<4, T, Q> zwwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.x); } // zwwy template GLM_INLINE glm::vec<4, T, Q> zwwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.y); } // zwwz template GLM_INLINE glm::vec<4, T, Q> zwwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.z); } // zwww template GLM_INLINE glm::vec<4, T, Q> zwww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.z, v.w, v.w, v.w); } // wxxx template GLM_INLINE glm::vec<4, T, Q> wxxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.x); } // wxxy template GLM_INLINE glm::vec<4, T, Q> wxxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.y); } // wxxz template GLM_INLINE glm::vec<4, T, Q> wxxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.z); } // wxxw template GLM_INLINE glm::vec<4, T, Q> wxxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.x, v.w); } // wxyx template GLM_INLINE glm::vec<4, T, Q> wxyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.x); } // wxyy template GLM_INLINE glm::vec<4, T, Q> wxyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.y); } // wxyz template GLM_INLINE glm::vec<4, T, Q> wxyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.z); } // wxyw template GLM_INLINE glm::vec<4, T, Q> wxyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.y, v.w); } // wxzx template GLM_INLINE glm::vec<4, T, Q> wxzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.x); } // wxzy template GLM_INLINE glm::vec<4, T, Q> wxzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.y); } // wxzz template GLM_INLINE glm::vec<4, T, Q> wxzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.z); } // wxzw template GLM_INLINE glm::vec<4, T, Q> wxzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.z, v.w); } // wxwx template GLM_INLINE glm::vec<4, T, Q> wxwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.x); } // wxwy template GLM_INLINE glm::vec<4, T, Q> wxwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.y); } // wxwz template GLM_INLINE glm::vec<4, T, Q> wxwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.z); } // wxww template GLM_INLINE glm::vec<4, T, Q> wxww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.x, v.w, v.w); } // wyxx template GLM_INLINE glm::vec<4, T, Q> wyxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.x); } // wyxy template GLM_INLINE glm::vec<4, T, Q> wyxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.y); } // wyxz template GLM_INLINE glm::vec<4, T, Q> wyxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.z); } // wyxw template GLM_INLINE glm::vec<4, T, Q> wyxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.x, v.w); } // wyyx template GLM_INLINE glm::vec<4, T, Q> wyyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.x); } // wyyy template GLM_INLINE glm::vec<4, T, Q> wyyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.y); } // wyyz template GLM_INLINE glm::vec<4, T, Q> wyyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.z); } // wyyw template GLM_INLINE glm::vec<4, T, Q> wyyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.y, v.w); } // wyzx template GLM_INLINE glm::vec<4, T, Q> wyzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.x); } // wyzy template GLM_INLINE glm::vec<4, T, Q> wyzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.y); } // wyzz template GLM_INLINE glm::vec<4, T, Q> wyzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.z); } // wyzw template GLM_INLINE glm::vec<4, T, Q> wyzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.z, v.w); } // wywx template GLM_INLINE glm::vec<4, T, Q> wywx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.x); } // wywy template GLM_INLINE glm::vec<4, T, Q> wywy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.y); } // wywz template GLM_INLINE glm::vec<4, T, Q> wywz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.z); } // wyww template GLM_INLINE glm::vec<4, T, Q> wyww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.y, v.w, v.w); } // wzxx template GLM_INLINE glm::vec<4, T, Q> wzxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.x); } // wzxy template GLM_INLINE glm::vec<4, T, Q> wzxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.y); } // wzxz template GLM_INLINE glm::vec<4, T, Q> wzxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.z); } // wzxw template GLM_INLINE glm::vec<4, T, Q> wzxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.x, v.w); } // wzyx template GLM_INLINE glm::vec<4, T, Q> wzyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.x); } // wzyy template GLM_INLINE glm::vec<4, T, Q> wzyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.y); } // wzyz template GLM_INLINE glm::vec<4, T, Q> wzyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.z); } // wzyw template GLM_INLINE glm::vec<4, T, Q> wzyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.y, v.w); } // wzzx template GLM_INLINE glm::vec<4, T, Q> wzzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.x); } // wzzy template GLM_INLINE glm::vec<4, T, Q> wzzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.y); } // wzzz template GLM_INLINE glm::vec<4, T, Q> wzzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.z); } // wzzw template GLM_INLINE glm::vec<4, T, Q> wzzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.z, v.w); } // wzwx template GLM_INLINE glm::vec<4, T, Q> wzwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.x); } // wzwy template GLM_INLINE glm::vec<4, T, Q> wzwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.y); } // wzwz template GLM_INLINE glm::vec<4, T, Q> wzwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.z); } // wzww template GLM_INLINE glm::vec<4, T, Q> wzww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.z, v.w, v.w); } // wwxx template GLM_INLINE glm::vec<4, T, Q> wwxx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.x); } // wwxy template GLM_INLINE glm::vec<4, T, Q> wwxy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.y); } // wwxz template GLM_INLINE glm::vec<4, T, Q> wwxz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.z); } // wwxw template GLM_INLINE glm::vec<4, T, Q> wwxw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.x, v.w); } // wwyx template GLM_INLINE glm::vec<4, T, Q> wwyx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.x); } // wwyy template GLM_INLINE glm::vec<4, T, Q> wwyy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.y); } // wwyz template GLM_INLINE glm::vec<4, T, Q> wwyz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.z); } // wwyw template GLM_INLINE glm::vec<4, T, Q> wwyw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.y, v.w); } // wwzx template GLM_INLINE glm::vec<4, T, Q> wwzx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.x); } // wwzy template GLM_INLINE glm::vec<4, T, Q> wwzy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.y); } // wwzz template GLM_INLINE glm::vec<4, T, Q> wwzz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.z); } // wwzw template GLM_INLINE glm::vec<4, T, Q> wwzw(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.z, v.w); } // wwwx template GLM_INLINE glm::vec<4, T, Q> wwwx(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.x); } // wwwy template GLM_INLINE glm::vec<4, T, Q> wwwy(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.y); } // wwwz template GLM_INLINE glm::vec<4, T, Q> wwwz(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.z); } // wwww template GLM_INLINE glm::vec<4, T, Q> wwww(const glm::vec<4, T, Q> &v) { return glm::vec<4, T, Q>(v.w, v.w, v.w, v.w); } } glm-0.9.9-a2/glm/gtx/string_cast.hpp0000600000175000001440000000253513173131001016107 0ustar guususers/// @ref gtx_string_cast /// @file glm/gtx/string_cast.hpp /// /// @see core (dependence) /// @see gtx_integer (dependence) /// @see gtx_quaternion (dependence) /// /// @defgroup gtx_string_cast GLM_GTX_string_cast /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Setup strings for GLM type values /// /// This extension is not supported with CUDA #pragma once // Dependency: #include "../glm.hpp" #include "../gtc/type_precision.hpp" #include "../gtc/quaternion.hpp" #include "../gtx/dual_quaternion.hpp" #include #include #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if(GLM_COMPILER & GLM_COMPILER_CUDA) # error "GLM_GTX_string_cast is not supported on CUDA compiler" #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_string_cast extension included") #endif namespace glm { /// @addtogroup gtx_string_cast /// @{ /// Create a string from a GLM vector or matrix typed variable. /// @see gtx_string_cast extension. template GLM_FUNC_DECL std::string to_string(genType const& x); /// @} }//namespace glm #include "string_cast.inl" glm-0.9.9-a2/glm/gtx/color_encoding.hpp0000600000175000001440000000264213173131001016552 0ustar guususers/// @ref gtx_color_encoding /// @file glm/gtx/color_encoding.hpp /// /// @see core (dependence) /// @see gtx_color_encoding (dependence) /// /// @defgroup gtx_color_encoding GLM_GTX_color_encoding /// @ingroup gtx /// /// Include to use the features of this extension. /// /// @brief Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../vec3.hpp" #include #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_color_encoding extension included") #endif namespace glm { /// @addtogroup gtx_color_encoding /// @{ /// Convert a linear sRGB color to D65 YUV. template GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB); /// Convert a linear sRGB color to D50 YUV. template GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB); /// Convert a D65 YUV color to linear sRGB. template GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ); /// Convert a D65 YUV color to D50 YUV. template GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ); /// @} } //namespace glm #include "color_encoding.inl" glm-0.9.9-a2/glm/gtx/norm.inl0000600000175000001440000000443213173131001014533 0ustar guususers/// @ref gtx_norm /// @file glm/gtx/norm.inl #include "../detail/qualifier.hpp" namespace glm{ namespace detail { template struct compute_length2 { GLM_FUNC_QUALIFIER static T call(vec const& v) { return dot(v, v); } }; }//namespace detail template GLM_FUNC_QUALIFIER genType length2(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length2' accepts only floating-point inputs"); return x * x; } template GLM_FUNC_QUALIFIER T length2(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length2' accepts only floating-point inputs"); return detail::compute_length2::value>::call(v); } template GLM_FUNC_QUALIFIER T distance2(T p0, T p1) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance2' accepts only floating-point inputs"); return length2(p1 - p0); } template GLM_FUNC_QUALIFIER T distance2(vec const& p0, vec const& p1) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance2' accepts only floating-point inputs"); return length2(p1 - p0); } template GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b) { return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z); } template GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& v) { return abs(v.x) + abs(v.y) + abs(v.z); } template GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b ) { return length(b - a); } template GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& v) { return length(v); } template GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth) { return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth)); } template GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& v, unsigned int Depth) { return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth)); } }//namespace glm glm-0.9.9-a2/glm/gtx/scalar_relational.hpp0000600000175000001440000000155713173131001017251 0ustar guususers/// @ref gtx_scalar_relational /// @file glm/gtx/scalar_relational.hpp /// /// @see core (dependence) /// /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational /// @ingroup gtx /// /// Include to use the features of this extension. /// /// Extend a position from a source to a position at a defined length. #pragma once // Dependency: #include "../glm.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_extend extension included") #endif namespace glm { /// @addtogroup gtx_scalar_relational /// @{ /// @} }//namespace glm #include "scalar_relational.inl" glm-0.9.9-a2/glm/gtx/vector_query.inl0000600000175000001440000001064513173131001016312 0ustar guususers/// @ref gtx_vector_query /// @file glm/gtx/vector_query.inl #include namespace glm{ namespace detail { template struct compute_areCollinear{}; template struct compute_areCollinear<2, T, Q> { GLM_FUNC_QUALIFIER static bool call(vec<2, T, Q> const& v0, vec<2, T, Q> const& v1, T const& epsilon) { return length(cross(vec<3, T, Q>(v0, static_cast(0)), vec<3, T, Q>(v1, static_cast(0)))) < epsilon; } }; template struct compute_areCollinear<3, T, Q> { GLM_FUNC_QUALIFIER static bool call(vec<3, T, Q> const& v0, vec<3, T, Q> const& v1, T const& epsilon) { return length(cross(v0, v1)) < epsilon; } }; template struct compute_areCollinear<4, T, Q> { GLM_FUNC_QUALIFIER static bool call(vec<4, T, Q> const& v0, vec<4, T, Q> const& v1, T const& epsilon) { return length(cross(vec<3, T, Q>(v0), vec<3, T, Q>(v1))) < epsilon; } }; template struct compute_isCompNull{}; template struct compute_isCompNull<2, T, Q> { GLM_FUNC_QUALIFIER static vec<2, bool, Q> call(vec<2, T, Q> const& v, T const& epsilon) { return vec<2, bool, Q>( (abs(v.x) < epsilon), (abs(v.y) < epsilon)); } }; template struct compute_isCompNull<3, T, Q> { GLM_FUNC_QUALIFIER static vec<3, bool, Q> call(vec<3, T, Q> const& v, T const& epsilon) { return vec<3, bool, Q>( (abs(v.x) < epsilon), (abs(v.y) < epsilon), (abs(v.z) < epsilon)); } }; template struct compute_isCompNull<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, bool, Q> call(vec<4, T, Q> const& v, T const& epsilon) { return vec<4, bool, Q>( (abs(v.x) < epsilon), (abs(v.y) < epsilon), (abs(v.z) < epsilon), (abs(v.w) < epsilon)); } }; }//namespace detail template GLM_FUNC_QUALIFIER bool areCollinear(vec const& v0, vec const& v1, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areCollinear' only accept floating-point inputs"); return detail::compute_areCollinear::call(v0, v1, epsilon); } template GLM_FUNC_QUALIFIER bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areOrthogonal' only accept floating-point inputs"); return abs(dot(v0, v1)) <= max( static_cast(1), length(v0)) * max(static_cast(1), length(v1)) * epsilon; } template GLM_FUNC_QUALIFIER bool isNormalized(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNormalized' only accept floating-point inputs"); return abs(length(v) - static_cast(1)) <= static_cast(2) * epsilon; } template GLM_FUNC_QUALIFIER bool isNull(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNull' only accept floating-point inputs"); return length(v) <= epsilon; } template GLM_FUNC_QUALIFIER vec isCompNull(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isCompNull' only accept floating-point inputs"); return detail::compute_isCompNull::call(v, epsilon); } template GLM_FUNC_QUALIFIER vec<2, bool, Q> isCompNull(vec<2, T, Q> const& v, T const& epsilon) { return vec<2, bool, Q>( abs(v.x) < epsilon, abs(v.y) < epsilon); } template GLM_FUNC_QUALIFIER vec<3, bool, Q> isCompNull(vec<3, T, Q> const& v, T const& epsilon) { return vec<3, bool, Q>( abs(v.x) < epsilon, abs(v.y) < epsilon, abs(v.z) < epsilon); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isCompNull(vec<4, T, Q> const& v, T const& epsilon) { return vec<4, bool, Q>( abs(v.x) < epsilon, abs(v.y) < epsilon, abs(v.z) < epsilon, abs(v.w) < epsilon); } template GLM_FUNC_QUALIFIER bool areOrthonormal(vec const& v0, vec const& v1, T const& epsilon) { return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon); } }//namespace glm glm-0.9.9-a2/glm/gtx/closest_point.inl0000600000175000001440000000220313173131001016437 0ustar guususers/// @ref gtx_closest_point /// @file glm/gtx/closest_point.inl namespace glm { template GLM_FUNC_QUALIFIER vec<3, T, Q> closestPointOnLine ( vec<3, T, Q> const& point, vec<3, T, Q> const& a, vec<3, T, Q> const& b ) { T LineLength = distance(a, b); vec<3, T, Q> Vector = point - a; vec<3, T, Q> LineDirection = (b - a) / LineLength; // Project Vector to LineDirection to get the distance of point from a T Distance = dot(Vector, LineDirection); if(Distance <= T(0)) return a; if(Distance >= LineLength) return b; return a + LineDirection * Distance; } template GLM_FUNC_QUALIFIER vec<2, T, Q> closestPointOnLine ( vec<2, T, Q> const& point, vec<2, T, Q> const& a, vec<2, T, Q> const& b ) { T LineLength = distance(a, b); vec<2, T, Q> Vector = point - a; vec<2, T, Q> LineDirection = (b - a) / LineLength; // Project Vector to LineDirection to get the distance of point from a T Distance = dot(Vector, LineDirection); if(Distance <= T(0)) return a; if(Distance >= LineLength) return b; return a + LineDirection * Distance; } }//namespace glm glm-0.9.9-a2/glm/gtx/io.hpp0000600000175000001440000001576313173131001014205 0ustar guususers/// @ref gtx_io /// @file glm/gtx/io.hpp /// @author Jan P Springer (regnirpsj@gmail.com) /// /// @see core (dependence) /// @see gtc_matrix_access (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtx_io GLM_GTX_io /// @ingroup gtx /// /// Include to use the features of this extension. /// /// std::[w]ostream support for glm types /// /// std::[w]ostream support for glm types + qualifier/width/etc. manipulators /// based on howard hinnant's std::chrono io proposal /// [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html] #pragma once // Dependency: #include "../glm.hpp" #include "../gtx/quaternion.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_io is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_io extension included") #endif #include // std::basic_ostream<> (fwd) #include // std::locale, std::locale::facet, std::locale::id #include // std::pair<> namespace glm { /// @addtogroup gtx_io /// @{ namespace io { enum order_type { column_major, row_major}; template class format_punct : public std::locale::facet { typedef CTy char_type; public: static std::locale::id id; bool formatted; unsigned precision; unsigned width; char_type separator; char_type delim_left; char_type delim_right; char_type space; char_type newline; order_type order; GLM_FUNC_DECL explicit format_punct(size_t a = 0); GLM_FUNC_DECL explicit format_punct(format_punct const&); }; template > class basic_state_saver { public: GLM_FUNC_DECL explicit basic_state_saver(std::basic_ios&); GLM_FUNC_DECL ~basic_state_saver(); private: typedef ::std::basic_ios state_type; typedef typename state_type::char_type char_type; typedef ::std::ios_base::fmtflags flags_type; typedef ::std::streamsize streamsize_type; typedef ::std::locale const locale_type; state_type& state_; flags_type flags_; streamsize_type precision_; streamsize_type width_; char_type fill_; locale_type locale_; GLM_FUNC_DECL basic_state_saver& operator=(basic_state_saver const&); }; typedef basic_state_saver state_saver; typedef basic_state_saver wstate_saver; template > class basic_format_saver { public: GLM_FUNC_DECL explicit basic_format_saver(std::basic_ios&); GLM_FUNC_DECL ~basic_format_saver(); private: basic_state_saver const bss_; GLM_FUNC_DECL basic_format_saver& operator=(basic_format_saver const&); }; typedef basic_format_saver format_saver; typedef basic_format_saver wformat_saver; struct precision { unsigned value; GLM_FUNC_DECL explicit precision(unsigned); }; struct width { unsigned value; GLM_FUNC_DECL explicit width(unsigned); }; template struct delimeter { CTy value[3]; GLM_FUNC_DECL explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ','); }; struct order { order_type value; GLM_FUNC_DECL explicit order(order_type); }; // functions, inlined (inline) template FTy const& get_facet(std::basic_ios&); template std::basic_ios& formatted(std::basic_ios&); template std::basic_ios& unformattet(std::basic_ios&); template std::basic_ostream& operator<<(std::basic_ostream&, precision const&); template std::basic_ostream& operator<<(std::basic_ostream&, width const&); template std::basic_ostream& operator<<(std::basic_ostream&, delimeter const&); template std::basic_ostream& operator<<(std::basic_ostream&, order const&); }//namespace io template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tquat const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<1, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 2, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 3, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 4, T, Q> const&); template GLM_FUNC_DECL std::basic_ostream & operator<<(std::basic_ostream &, std::pair const, mat<4, 4, T, Q> const> const&); /// @} }//namespace glm #include "io.inl" glm-0.9.9-a2/glm/common.hpp0000600000175000001440000006533013173131001014257 0ustar guususers/// @ref core /// @file glm/common.hpp /// /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// /// @defgroup core_func_common Common functions /// @ingroup core /// /// Include to use these core features. /// /// These all operate component-wise. The description is per component. #pragma once #include "detail/setup.hpp" #include "detail/qualifier.hpp" #include "detail/type_int.hpp" #include "detail/_fixes.hpp" namespace glm { /// @addtogroup core_func_common /// @{ /// Returns x if x >= 0; otherwise, it returns -x. /// /// @tparam genType floating-point or signed integer; scalar or vector types. /// /// @see GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// @see qualifier template GLM_FUNC_DECL genType abs(genType x); /// Returns x if x >= 0; otherwise, it returns -x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec abs(vec const& x); /// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL sign man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec sign(vec const& x); /// Returns a value equal to the nearest integer that is less then or equal to x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL floor man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec floor(vec const& x); /// Returns a value equal to the nearest integer to x /// whose absolute value is not larger than the absolute value of x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL trunc man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec trunc(vec const& x); /// Returns a value equal to the nearest integer to x. /// The fraction 0.5 will round in a direction chosen by the /// implementation, presumably the direction that is fastest. /// This includes the possibility that round(x) returns the /// same value as roundEven(x) for all values of x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL round man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec round(vec const& x); /// Returns a value equal to the nearest integer to x. /// A fractional part of 0.5 will round toward the nearest even /// integer. (Both 3.5 and 4.5 for x will return 4.0.) /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL roundEven man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// @see New round to even technique template GLM_FUNC_DECL vec roundEven(vec const& x); /// Returns a value equal to the nearest integer /// that is greater than or equal to x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL ceil man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec ceil(vec const& x); /// Return x - floor(x). /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL fract man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType fract(genType x); /// Return x - floor(x). /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL fract man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec fract(vec const& x); template GLM_FUNC_DECL genType mod(genType x, genType y); template GLM_FUNC_DECL vec mod(vec const& x, T y); /// Modulus. Returns x - y * floor(x / y) /// for each component in x using the floating point value y. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types, include glm/gtc/integer for integer scalar types support /// @tparam Q Value from qualifier enum /// /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec mod(vec const& x, vec const& y); /// Returns the fractional part of x and sets i to the integer /// part (as a whole number floating point value). Both the /// return value and the output parameter will have the same /// sign as x. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL modf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType modf(genType x, genType& i); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType min(genType x, genType y); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec min(vec const& x, T y); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec min(vec const& x, vec const& y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType max(genType x, genType y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec max(vec const& x, T y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec max(vec const& x, vec const& y); /// Returns min(max(x, minVal), maxVal) for each component in x /// using the floating-point values minVal and maxVal. /// /// @tparam genType Floating-point or integer; scalar or vector types. /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x /// using the floating-point values minVal and maxVal. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec clamp(vec const& x, T minVal, T maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x /// using the floating-point values minVal and maxVal. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec clamp(vec const& x, vec const& minVal, vec const& maxVal); /// If genTypeU is a floating scalar or vector: /// Returns x * (1.0 - a) + y * a, i.e., the linear blend of /// x and y using the floating-point value a. /// The value for a is not restricted to the range [0, 1]. /// /// If genTypeU is a boolean scalar or vector: /// Selects which vector each returned component comes /// from. For a component of 'a' that is false, the /// corresponding component of 'x' is returned. For a /// component of 'a' that is true, the corresponding /// component of 'y' is returned. Components of 'x' and 'y' that /// are not selected are allowed to be invalid floating point /// values and will have no effect on the results. Thus, this /// provides different functionality than /// genType mix(genType x, genType y, genType(a)) /// where a is a Boolean vector. /// /// @see GLSL mix man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// /// @param[in] x Value to interpolate. /// @param[in] y Value to interpolate. /// @param[in] a Interpolant. /// /// @tparam genTypeT Floating point scalar or vector. /// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT. /// /// @code /// #include /// ... /// float a; /// bool b; /// glm::dvec3 e; /// glm::dvec3 f; /// glm::vec4 g; /// glm::vec4 h; /// ... /// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors. /// glm::vec4 s = glm::mix(g, h, b); // Returns g or h; /// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second. /// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter. /// @endcode template GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a); template GLM_FUNC_DECL vec mix(vec const& x, vec const& y, vec const& a); template GLM_FUNC_DECL vec mix(vec const& x, vec const& y, U a); /// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType. /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType step(genType edge, genType x); /// Returns 0.0 if x < edge, otherwise it returns 1.0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec step(T edge, vec const& x); /// Returns 0.0 if x < edge, otherwise it returns 1.0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec step(vec const& edge, vec const& x); /// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and /// performs smooth Hermite interpolation between 0 and 1 /// when edge0 < x < edge1. This is useful in cases where /// you would want a threshold function with a smooth /// transition. This is equivalent to: /// genType t; /// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1); /// return t * t * (3 - 2 * t); /// Results are undefined if edge0 >= edge1. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL smoothstep man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x); template GLM_FUNC_DECL vec smoothstep(T edge0, T edge1, vec const& x); template GLM_FUNC_DECL vec smoothstep(vec const& edge0, vec const& edge1, vec const& x); /// Returns true if x holds a NaN (not a number) /// representation in the underlying implementation's set of /// floating point representations. Returns false otherwise, /// including for implementations with no NaN /// representations. /// /// /!\ When using compiler fast math, this function may fail. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL isnan man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec isnan(vec const& x); /// Returns true if x holds a positive infinity or negative /// infinity representation in the underlying implementation's /// set of floating point representations. Returns false /// otherwise, including for implementations with no infinity /// representations. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL isinf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec isinf(vec const& x); /// Returns a signed integer value representing /// the encoding of a floating-point value. The floating-point /// value's bit-level representation is preserved. /// /// @see GLSL floatBitsToInt man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions GLM_FUNC_DECL int floatBitsToInt(float const& v); /// Returns a signed integer value representing /// the encoding of a floating-point value. The floatingpoint /// value's bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL floatBitsToInt man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec floatBitsToInt(vec const& v); /// Returns a unsigned integer value representing /// the encoding of a floating-point value. The floatingpoint /// value's bit-level representation is preserved. /// /// @see GLSL floatBitsToUint man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions GLM_FUNC_DECL uint floatBitsToUint(float const& v); /// Returns a unsigned integer value representing /// the encoding of a floating-point value. The floatingpoint /// value's bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL floatBitsToUint man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec floatBitsToUint(vec const& v); /// Returns a floating-point value corresponding to a signed /// integer encoding of a floating-point value. /// If an inf or NaN is passed in, it will not signal, and the /// resulting floating point value is unspecified. Otherwise, /// the bit-level representation is preserved. /// /// @see GLSL intBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions GLM_FUNC_DECL float intBitsToFloat(int const& v); /// Returns a floating-point value corresponding to a signed /// integer encoding of a floating-point value. /// If an inf or NaN is passed in, it will not signal, and the /// resulting floating point value is unspecified. Otherwise, /// the bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL intBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec intBitsToFloat(vec const& v); /// Returns a floating-point value corresponding to a /// unsigned integer encoding of a floating-point value. /// If an inf or NaN is passed in, it will not signal, and the /// resulting floating point value is unspecified. Otherwise, /// the bit-level representation is preserved. /// /// @see GLSL uintBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions GLM_FUNC_DECL float uintBitsToFloat(uint const& v); /// Returns a floating-point value corresponding to a /// unsigned integer encoding of a floating-point value. /// If an inf or NaN is passed in, it will not signal, and the /// resulting floating point value is unspecified. Otherwise, /// the bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam Q Value from qualifier enum /// /// @see GLSL uintBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL vec uintBitsToFloat(vec const& v); /// Computes and returns a * b + c. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL fma man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType fma(genType const& a, genType const& b, genType const& c); /// Splits x into a floating-point significand in the range /// [0.5, 1.0) and an integral exponent of two, such that: /// x = significand * exp(2, exponent) /// /// The significand is returned by the function and the /// exponent is returned in the parameter exp. For a /// floating-point value of zero, the significant and exponent /// are both zero. For a floating-point value that is an /// infinity or is not a number, the results are undefined. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL frexp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType frexp(genType const& x, genIType& exp); /// Builds a floating-point number from x and the /// corresponding integral exponent of two in exp, returning: /// significand * exp(2, exponent) /// /// If this product is too large to be represented in the /// floating-point type, the result is undefined. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL ldexp man page; /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template GLM_FUNC_DECL genType ldexp(genType const& x, genIType const& exp); /// @} }//namespace glm #include "detail/func_common.inl" glm-0.9.9-a2/glm/exponential.hpp0000600000175000001440000001272213173131001015312 0ustar guususers/// @ref core /// @file glm/exponential.hpp /// /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions /// /// @defgroup core_func_exponential Exponential functions /// @ingroup core /// /// Include to use these core features. /// /// These all operate component-wise. The description is per component. #pragma once #include "detail/type_vec1.hpp" #include "detail/type_vec2.hpp" #include "detail/type_vec3.hpp" #include "detail/type_vec4.hpp" #include namespace glm { /// @addtogroup core_func_exponential /// @{ /// Returns 'base' raised to the power 'exponent'. /// /// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type qualifier. /// @param exponent Floating point value representing the 'exponent'. /// /// @see GLSL pow man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec pow(vec const& base, vec const& exponent); /// Returns the natural exponentiation of x, i.e., e^x. /// /// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL exp man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec exp(vec const& v); /// Returns the natural logarithm of v, i.e., /// returns the value y which satisfies the equation x = e^y. /// Results are undefined if v <= 0. /// /// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL log man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec log(vec const& v); /// Returns 2 raised to the v power. /// /// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL exp2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec exp2(vec const& v); /// Returns the base 2 log of x, i.e., returns the value y, /// which satisfies the equation x = 2 ^ y. /// /// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL log2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec log2(vec const& v); /// Returns the positive square root of v. /// /// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL sqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec sqrt(vec const& v); /// Returns the reciprocal of the positive square root of v. /// /// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL inversesqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template GLM_FUNC_DECL vec inversesqrt(vec const& v); /// @} }//namespace glm #include "detail/func_exponential.inl" glm-0.9.9-a2/glm/mat4x3.hpp0000600000175000001440000000300313173131001014074 0ustar guususers/// @ref core /// @file glm/mat4x3.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat4x3.hpp" namespace glm { /// 4 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, lowp> lowp_mat4x3; /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, mediump> mediump_mat4x3; /// 4 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, highp> highp_mat4x3; }//namespace glm glm-0.9.9-a2/glm/mat2x2.hpp0000600000175000001440000000555213173131001014104 0ustar guususers/// @ref core /// @file glm/mat2x2.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat2x2.hpp" namespace glm { /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2; /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2; /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2; /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2x2; /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2x2; /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2x2; }//namespace glm glm-0.9.9-a2/glm/fwd.hpp0000600000175000001440000023515513173131001013553 0ustar guususers/// @ref core /// @file glm/fwd.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_int.hpp" #include "detail/type_float.hpp" #include "detail/type_vec.hpp" #include "detail/type_mat.hpp" ////////////////////// // GLM_GTC_quaternion namespace glm { template struct tquat; /// Quaternion of low single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat lowp_quat; /// Quaternion of medium single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat mediump_quat; /// Quaternion of high single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat highp_quat; #if(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef highp_quat quat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef mediump_quat quat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_quat quat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) /// Quaternion of default single-qualifier floating-point numbers. typedef highp_quat quat; #endif /// Quaternion of low single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef lowp_quat lowp_fquat; /// Quaternion of medium single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef mediump_quat mediump_fquat; /// Quaternion of high single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef highp_quat highp_fquat; /// Quaternion of default single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef quat fquat; /// Quaternion of low double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat lowp_dquat; /// Quaternion of medium double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat mediump_dquat; /// Quaternion of high double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat highp_dquat; #if(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) typedef highp_dquat dquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) typedef mediump_dquat dquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_dquat dquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) /// Quaternion of default double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef highp_dquat dquat; #endif }//namespace glm ////////////////////// // GLM_GTC_precision namespace glm { /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64; /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8_t; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16_t; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32_t; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64_t; /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_i8; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_i16; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_i32; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_i64; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8_t; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16_t; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32_t; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64_t; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_i8; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_i16; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_i32; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_i64; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16; /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8_t; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16_t; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32_t; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64_t; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_i8; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_i16; /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_i32; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_i64; /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 int8; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 int16; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 int32; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 int64; #if GLM_HAS_EXTENDED_INTEGER_TYPE using std::int8_t; using std::int16_t; using std::int32_t; using std::int64_t; #else /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 int8_t; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 int16_t; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 int32_t; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 int64_t; #endif /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 i8; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 i16; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 i32; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 i64; /// Low qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, lowp> lowp_i8vec1; /// Low qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, lowp> lowp_i8vec2; /// Low qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, lowp> lowp_i8vec3; /// Low qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, lowp> lowp_i8vec4; /// Medium qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, mediump> mediump_i8vec1; /// Medium qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, mediump> mediump_i8vec2; /// Medium qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, mediump> mediump_i8vec3; /// Medium qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, mediump> mediump_i8vec4; /// High qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, highp> highp_i8vec1; /// High qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, highp> highp_i8vec2; /// High qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, highp> highp_i8vec3; /// High qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, highp> highp_i8vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_i8vec1 i8vec1; typedef lowp_i8vec2 i8vec2; typedef lowp_i8vec3 i8vec3; typedef lowp_i8vec4 i8vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_i8vec1 i8vec1; typedef mediump_i8vec2 i8vec2; typedef mediump_i8vec3 i8vec3; typedef mediump_i8vec4 i8vec4; #else /// Default qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i8vec1 i8vec1; /// Default qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i8vec2 i8vec2; /// Default qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i8vec3 i8vec3; /// Default qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i8vec4 i8vec4; #endif /// Low qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, lowp> lowp_i16vec1; /// Low qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, lowp> lowp_i16vec2; /// Low qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, lowp> lowp_i16vec3; /// Low qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, lowp> lowp_i16vec4; /// Medium qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, mediump> mediump_i16vec1; /// Medium qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, mediump> mediump_i16vec2; /// Medium qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, mediump> mediump_i16vec3; /// Medium qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, mediump> mediump_i16vec4; /// High qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, highp> highp_i16vec1; /// High qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, highp> highp_i16vec2; /// High qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, highp> highp_i16vec3; /// High qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, highp> highp_i16vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_i16vec1 i16vec1; typedef lowp_i16vec2 i16vec2; typedef lowp_i16vec3 i16vec3; typedef lowp_i16vec4 i16vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_i16vec1 i16vec1; typedef mediump_i16vec2 i16vec2; typedef mediump_i16vec3 i16vec3; typedef mediump_i16vec4 i16vec4; #else /// Default qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i16vec1 i16vec1; /// Default qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i16vec2 i16vec2; /// Default qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i16vec3 i16vec3; /// Default qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i16vec4 i16vec4; #endif /// Low qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, lowp> lowp_i32vec1; /// Low qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, lowp> lowp_i32vec2; /// Low qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, lowp> lowp_i32vec3; /// Low qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, lowp> lowp_i32vec4; /// Medium qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, mediump> mediump_i32vec1; /// Medium qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, mediump> mediump_i32vec2; /// Medium qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, mediump> mediump_i32vec3; /// Medium qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, mediump> mediump_i32vec4; /// High qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, highp> highp_i32vec1; /// High qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, highp> highp_i32vec2; /// High qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, highp> highp_i32vec3; /// High qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, highp> highp_i32vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_i32vec1 i32vec1; typedef lowp_i32vec2 i32vec2; typedef lowp_i32vec3 i32vec3; typedef lowp_i32vec4 i32vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_i32vec1 i32vec1; typedef mediump_i32vec2 i32vec2; typedef mediump_i32vec3 i32vec3; typedef mediump_i32vec4 i32vec4; #else /// Default qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i32vec1 i32vec1; /// Default qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i32vec2 i32vec2; /// Default qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i32vec3 i32vec3; /// Default qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i32vec4 i32vec4; #endif /// Low qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, lowp> lowp_i32vec1; /// Low qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, lowp> lowp_i32vec2; /// Low qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, lowp> lowp_i32vec3; /// Low qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, lowp> lowp_i32vec4; /// Medium qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, mediump> mediump_i32vec1; /// Medium qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, mediump> mediump_i32vec2; /// Medium qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, mediump> mediump_i32vec3; /// Medium qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, mediump> mediump_i32vec4; /// High qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, highp> highp_i32vec1; /// High qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, highp> highp_i32vec2; /// High qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, highp> highp_i32vec3; /// High qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, highp> highp_i32vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_i32vec1 i32vec1; typedef lowp_i32vec2 i32vec2; typedef lowp_i32vec3 i32vec3; typedef lowp_i32vec4 i32vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_i32vec1 i32vec1; typedef mediump_i32vec2 i32vec2; typedef mediump_i32vec3 i32vec3; typedef mediump_i32vec4 i32vec4; #else /// Default qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i32vec1 i32vec1; /// Default qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i32vec2 i32vec2; /// Default qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i32vec3 i32vec3; /// Default qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i32vec4 i32vec4; #endif /// Low qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, lowp> lowp_i64vec1; /// Low qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, lowp> lowp_i64vec2; /// Low qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, lowp> lowp_i64vec3; /// Low qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, lowp> lowp_i64vec4; /// Medium qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, mediump> mediump_i64vec1; /// Medium qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, mediump> mediump_i64vec2; /// Medium qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, mediump> mediump_i64vec3; /// Medium qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, mediump> mediump_i64vec4; /// High qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, highp> highp_i64vec1; /// High qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, highp> highp_i64vec2; /// High qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, highp> highp_i64vec3; /// High qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, highp> highp_i64vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_i64vec1 i64vec1; typedef lowp_i64vec2 i64vec2; typedef lowp_i64vec3 i64vec3; typedef lowp_i64vec4 i64vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_i64vec1 i64vec1; typedef mediump_i64vec2 i64vec2; typedef mediump_i64vec3 i64vec3; typedef mediump_i64vec4 i64vec4; #else /// Default qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i64vec1 i64vec1; /// Default qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i64vec2 i64vec2; /// Default qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i64vec3 i64vec3; /// Default qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i64vec4 i64vec4; #endif ///////////////////////////// // Unsigned int vector types /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64; /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8_t; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16_t; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32_t; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64_t; /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_u8; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_u16; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_u32; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_u64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8_t; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16_t; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32_t; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64_t; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_u8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_u16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_u32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_u64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8_t; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16_t; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32_t; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64_t; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_u8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_u16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_u32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_u64; /// 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 uint8; /// 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 uint16; /// 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 uint32; /// 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 uint64; #if GLM_HAS_EXTENDED_INTEGER_TYPE using std::uint8_t; using std::uint16_t; using std::uint32_t; using std::uint64_t; #else /// 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 uint8_t; /// 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 uint16_t; /// 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 uint32_t; /// 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 uint64_t; #endif /// 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 u8; /// 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 u16; /// 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 u32; /// 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 u64; /// Low qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, lowp> lowp_u8vec1; /// Low qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, lowp> lowp_u8vec2; /// Low qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, lowp> lowp_u8vec3; /// Low qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, lowp> lowp_u8vec4; /// Medium qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, mediump> mediump_u8vec1; /// Medium qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, mediump> mediump_u8vec2; /// Medium qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, mediump> mediump_u8vec3; /// Medium qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, mediump> mediump_u8vec4; /// High qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, highp> highp_u8vec1; /// High qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, highp> highp_u8vec2; /// High qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, highp> highp_u8vec3; /// High qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, highp> highp_u8vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_u8vec1 u8vec1; typedef lowp_u8vec2 u8vec2; typedef lowp_u8vec3 u8vec3; typedef lowp_u8vec4 u8vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_u8vec1 u8vec1; typedef mediump_u8vec2 u8vec2; typedef mediump_u8vec3 u8vec3; typedef mediump_u8vec4 u8vec4; #else /// Default qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u8vec1 u8vec1; /// Default qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u8vec2 u8vec2; /// Default qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u8vec3 u8vec3; /// Default qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u8vec4 u8vec4; #endif /// Low qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, lowp> lowp_u16vec1; /// Low qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, lowp> lowp_u16vec2; /// Low qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, lowp> lowp_u16vec3; /// Low qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, lowp> lowp_u16vec4; /// Medium qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, mediump> mediump_u16vec1; /// Medium qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, mediump> mediump_u16vec2; /// Medium qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, mediump> mediump_u16vec3; /// Medium qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, mediump> mediump_u16vec4; /// High qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, highp> highp_u16vec1; /// High qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, highp> highp_u16vec2; /// High qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, highp> highp_u16vec3; /// High qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, highp> highp_u16vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_u16vec1 u16vec1; typedef lowp_u16vec2 u16vec2; typedef lowp_u16vec3 u16vec3; typedef lowp_u16vec4 u16vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_u16vec1 u16vec1; typedef mediump_u16vec2 u16vec2; typedef mediump_u16vec3 u16vec3; typedef mediump_u16vec4 u16vec4; #else /// Default qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u16vec1 u16vec1; /// Default qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u16vec2 u16vec2; /// Default qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u16vec3 u16vec3; /// Default qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u16vec4 u16vec4; #endif /// Low qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, lowp> lowp_u32vec1; /// Low qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, lowp> lowp_u32vec2; /// Low qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, lowp> lowp_u32vec3; /// Low qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, lowp> lowp_u32vec4; /// Medium qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, mediump> mediump_u32vec1; /// Medium qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, mediump> mediump_u32vec2; /// Medium qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, mediump> mediump_u32vec3; /// Medium qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, mediump> mediump_u32vec4; /// High qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, highp> highp_u32vec1; /// High qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, highp> highp_u32vec2; /// High qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, highp> highp_u32vec3; /// High qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, highp> highp_u32vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_u32vec1 u32vec1; typedef lowp_u32vec2 u32vec2; typedef lowp_u32vec3 u32vec3; typedef lowp_u32vec4 u32vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_u32vec1 u32vec1; typedef mediump_u32vec2 u32vec2; typedef mediump_u32vec3 u32vec3; typedef mediump_u32vec4 u32vec4; #else /// Default qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u32vec1 u32vec1; /// Default qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u32vec2 u32vec2; /// Default qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u32vec3 u32vec3; /// Default qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u32vec4 u32vec4; #endif /// Low qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, lowp> lowp_u32vec1; /// Low qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, lowp> lowp_u32vec2; /// Low qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, lowp> lowp_u32vec3; /// Low qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, lowp> lowp_u32vec4; /// Medium qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, mediump> mediump_u32vec1; /// Medium qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, mediump> mediump_u32vec2; /// Medium qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, mediump> mediump_u32vec3; /// Medium qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, mediump> mediump_u32vec4; /// High qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, highp> highp_u32vec1; /// High qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, highp> highp_u32vec2; /// High qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, highp> highp_u32vec3; /// High qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, highp> highp_u32vec4; #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_u32vec1 u32vec1; typedef lowp_u32vec2 u32vec2; typedef lowp_u32vec3 u32vec3; typedef lowp_u32vec4 u32vec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_u32vec1 u32vec1; typedef mediump_u32vec2 u32vec2; typedef mediump_u32vec3 u32vec3; typedef mediump_u32vec4 u32vec4; #else /// Default qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u32vec1 u32vec1; /// Default qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u32vec2 u32vec2; /// Default qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u32vec3 u32vec3; /// Default qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u32vec4 u32vec4; #endif /// Low qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, lowp> lowp_u64vec1; /// Low qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, lowp> lowp_u64vec2; /// Low qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, lowp> lowp_u64vec3; /// Low qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, lowp> lowp_u64vec4; /// Medium qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, mediump> mediump_u64vec1; /// Medium qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, mediump> mediump_u64vec2; /// Medium qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, mediump> mediump_u64vec3; /// Medium qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, mediump> mediump_u64vec4; /// High qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, highp> highp_u64vec1; /// High qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, highp> highp_u64vec2; /// High qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, highp> highp_u64vec3; /// High qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, highp> highp_u64vec4; #if(defined(GLM_PRECISION_LOWP_UINT)) typedef lowp_u64vec1 u64vec1; typedef lowp_u64vec2 u64vec2; typedef lowp_u64vec3 u64vec3; typedef lowp_u64vec4 u64vec4; #elif(defined(GLM_PRECISION_MEDIUMP_UINT)) typedef mediump_u64vec1 u64vec1; typedef mediump_u64vec2 u64vec2; typedef mediump_u64vec3 u64vec3; typedef mediump_u64vec4 u64vec4; #else /// Default qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u64vec1 u64vec1; /// Default qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u64vec2 u64vec2; /// Default qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u64vec3 u64vec3; /// Default qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u64vec4 u64vec4; #endif ////////////////////// // Float vector types /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32_t; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64_t; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32_t; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64_t; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32_t; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64_t; /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 mediump_float32; /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 mediump_float64; /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 mediump_float32_t; /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 mediump_float64_t; /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 mediump_f32; /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 mediump_f64; /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 highp_float32; /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 highp_float64; /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 highp_float32_t; /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 highp_float64_t; /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 highp_f32; /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 highp_f64; #if(defined(GLM_PRECISION_LOWP_FLOAT)) /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float32 float32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float64 float64; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float32_t float32_t; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float64_t float64_t; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_f32 f32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_f64 f64; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 float32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 float64; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 float32_t; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 float64_t; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 f32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 f64; #else//(defined(GLM_PRECISION_HIGHP_FLOAT)) /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32 float32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64 float64; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32_t float32_t; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64_t float64_t; /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32_t f32; /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64_t f64; #endif /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, lowp> lowp_vec1; /// Low single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, lowp> lowp_vec2; /// Low single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, lowp> lowp_vec3; /// Low single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, lowp> lowp_vec4; /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, lowp> lowp_fvec1; /// Low single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, lowp> lowp_fvec2; /// Low single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, lowp> lowp_fvec3; /// Low single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, lowp> lowp_fvec4; /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, mediump> mediump_vec1; /// Medium Single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, mediump> mediump_vec2; /// Medium Single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, mediump> mediump_vec3; /// Medium Single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, mediump> mediump_vec4; /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, mediump> mediump_fvec1; /// Medium Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, mediump> mediump_fvec2; /// Medium Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, mediump> mediump_fvec3; /// Medium Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, mediump> mediump_fvec4; /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, highp> highp_vec1; /// High Single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, highp> highp_vec2; /// High Single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, highp> highp_vec3; /// High Single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, highp> highp_vec4; /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, highp> highp_fvec1; /// High Single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, highp> highp_fvec2; /// High Single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, highp> highp_fvec3; /// High Single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, highp> highp_fvec4; /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, lowp> lowp_f32vec1; /// Low single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, f32, lowp> lowp_f32vec2; /// Low single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, f32, lowp> lowp_f32vec3; /// Low single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, f32, lowp> lowp_f32vec4; /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, mediump> mediump_f32vec1; /// Medium single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, f32, mediump> mediump_f32vec2; /// Medium single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, f32, mediump> mediump_f32vec3; /// Medium single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, f32, mediump> mediump_f32vec4; /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, highp> highp_f32vec1; /// High single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f32, highp> highp_f32vec2; /// High single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f32, highp> highp_f32vec3; /// High single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f32, highp> highp_f32vec4; /// Low double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, lowp> lowp_f64vec1; /// Low double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, lowp> lowp_f64vec2; /// Low double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, lowp> lowp_f64vec3; /// Low double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, lowp> lowp_f64vec4; /// Medium double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, mediump> mediump_f64vec1; /// Medium double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, mediump> mediump_f64vec2; /// Medium double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, mediump> mediump_f64vec3; /// Medium double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, mediump> mediump_f64vec4; /// High double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, highp> highp_f64vec1; /// High double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, highp> highp_f64vec2; /// High double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, highp> highp_f64vec3; /// High double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, highp> highp_f64vec4; ////////////////////// // Float matrix types /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_f32 lowp_fmat1x1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, lowp> lowp_fmat2x2; /// Low single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, lowp> lowp_fmat2x3; /// Low single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, lowp> lowp_fmat2x4; /// Low single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, lowp> lowp_fmat3x2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, lowp> lowp_fmat3x3; /// Low single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, lowp> lowp_fmat3x4; /// Low single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, lowp> lowp_fmat4x2; /// Low single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, lowp> lowp_fmat4x3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, lowp> lowp_fmat4x4; /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_fmat1x1 lowp_fmat1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_fmat2x2 lowp_fmat2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_fmat3x3 lowp_fmat3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_fmat4x4 lowp_fmat4; /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_f32 mediump_fmat1x1; /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, mediump> mediump_fmat2x2; /// Medium single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, mediump> mediump_fmat2x3; /// Medium single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, mediump> mediump_fmat2x4; /// Medium single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, mediump> mediump_fmat3x2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, mediump> mediump_fmat3x3; /// Medium single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, mediump> mediump_fmat3x4; /// Medium single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, mediump> mediump_fmat4x2; /// Medium single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, mediump> mediump_fmat4x3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, mediump> mediump_fmat4x4; /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_fmat1x1 mediump_fmat1; /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_fmat2x2 mediump_fmat2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_fmat3x3 mediump_fmat3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_fmat4x4 mediump_fmat4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_f32 highp_fmat1x1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, highp> highp_fmat2x2; /// High single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, highp> highp_fmat2x3; /// High single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, highp> highp_fmat2x4; /// High single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, highp> highp_fmat3x2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, highp> highp_fmat3x3; /// High single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, highp> highp_fmat3x4; /// High single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, highp> highp_fmat4x2; /// High single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, highp> highp_fmat4x3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, highp> highp_fmat4x4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_fmat1x1 highp_fmat1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_fmat2x2 highp_fmat2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_fmat3x3 highp_fmat3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_fmat4x4 highp_fmat4; /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 lowp_f32mat1x1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, lowp> lowp_f32mat2x2; /// Low single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, lowp> lowp_f32mat2x3; /// Low single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, lowp> lowp_f32mat2x4; /// Low single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, lowp> lowp_f32mat3x2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, lowp> lowp_f32mat3x3; /// Low single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, lowp> lowp_f32mat3x4; /// Low single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, lowp> lowp_f32mat4x2; /// Low single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, lowp> lowp_f32mat4x3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, lowp> lowp_f32mat4x4; /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 lowp_f32mat1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_f32mat2x2 lowp_f32mat2; /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_f32mat3x3 lowp_f32mat3; /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_f32mat4x4 lowp_f32mat4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 mediump_f32mat1x1; /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, mediump> mediump_f32mat2x2; /// Medium single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, mediump> mediump_f32mat2x3; /// Medium single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, mediump> mediump_f32mat2x4; /// Medium single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, mediump> mediump_f32mat3x2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, mediump> mediump_f32mat3x3; /// Medium single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, mediump> mediump_f32mat3x4; /// Medium single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, mediump> mediump_f32mat4x2; /// Medium single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, mediump> mediump_f32mat4x3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, mediump> mediump_f32mat4x4; /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_f32mat2x2 mediump_f32mat2; /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_f32mat3x3 mediump_f32mat3; /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_f32mat4x4 mediump_f32mat4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 highp_f32mat1x1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, highp> highp_f32mat2x2; /// High single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, highp> highp_f32mat2x3; /// High single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, highp> highp_f32mat2x4; /// High single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, highp> highp_f32mat3x2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, highp> highp_f32mat3x3; /// High single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, highp> highp_f32mat3x4; /// High single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, highp> highp_f32mat4x2; /// High single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, highp> highp_f32mat4x3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, highp> highp_f32mat4x4; /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f32mat2x2 highp_f32mat2; /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f32mat3x3 highp_f32mat3; /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f32mat4x4 highp_f32mat4; /// Low double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 lowp_f64mat1x1; /// Low double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, lowp> lowp_f64mat2x2; /// Low double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, lowp> lowp_f64mat2x3; /// Low double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, lowp> lowp_f64mat2x4; /// Low double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, lowp> lowp_f64mat3x2; /// Low double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, lowp> lowp_f64mat3x3; /// Low double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, lowp> lowp_f64mat3x4; /// Low double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, lowp> lowp_f64mat4x2; /// Low double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, lowp> lowp_f64mat4x3; /// Low double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, lowp> lowp_f64mat4x4; /// Low double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_f64mat1x1 lowp_f64mat1; /// Low double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_f64mat2x2 lowp_f64mat2; /// Low double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_f64mat3x3 lowp_f64mat3; /// Low double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_f64mat4x4 lowp_f64mat4; /// Medium double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 Highp_f64mat1x1; /// Medium double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, mediump> mediump_f64mat2x2; /// Medium double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, mediump> mediump_f64mat2x3; /// Medium double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, mediump> mediump_f64mat2x4; /// Medium double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, mediump> mediump_f64mat3x2; /// Medium double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, mediump> mediump_f64mat3x3; /// Medium double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, mediump> mediump_f64mat3x4; /// Medium double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, mediump> mediump_f64mat4x2; /// Medium double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, mediump> mediump_f64mat4x3; /// Medium double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, mediump> mediump_f64mat4x4; /// Medium double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_f64mat1x1 mediump_f64mat1; /// Medium double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_f64mat2x2 mediump_f64mat2; /// Medium double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_f64mat3x3 mediump_f64mat3; /// Medium double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_f64mat4x4 mediump_f64mat4; /// High double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 highp_f64mat1x1; /// High double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, highp> highp_f64mat2x2; /// High double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, highp> highp_f64mat2x3; /// High double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, highp> highp_f64mat2x4; /// High double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, highp> highp_f64mat3x2; /// High double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, highp> highp_f64mat3x3; /// High double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, highp> highp_f64mat3x4; /// High double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, highp> highp_f64mat4x2; /// High double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, highp> highp_f64mat4x3; /// High double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, highp> highp_f64mat4x4; /// High double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_f64mat1x1 highp_f64mat1; /// High double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f64mat2x2 highp_f64mat2; /// High double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f64mat3x3 highp_f64mat3; /// High double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f64mat4x4 highp_f64mat4; ////////////////////////// // Quaternion types /// Low single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat lowp_f32quat; /// Low double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat lowp_f64quat; /// Medium single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat mediump_f32quat; /// Medium double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat mediump_f64quat; /// High single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat highp_f32quat; /// High double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat highp_f64quat; #if(defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_f32vec1 fvec1; typedef lowp_f32vec2 fvec2; typedef lowp_f32vec3 fvec3; typedef lowp_f32vec4 fvec4; typedef lowp_f32mat2 fmat2; typedef lowp_f32mat3 fmat3; typedef lowp_f32mat4 fmat4; typedef lowp_f32mat2x2 fmat2x2; typedef lowp_f32mat3x2 fmat3x2; typedef lowp_f32mat4x2 fmat4x2; typedef lowp_f32mat2x3 fmat2x3; typedef lowp_f32mat3x3 fmat3x3; typedef lowp_f32mat4x3 fmat4x3; typedef lowp_f32mat2x4 fmat2x4; typedef lowp_f32mat3x4 fmat3x4; typedef lowp_f32mat4x4 fmat4x4; typedef lowp_f32quat fquat; typedef lowp_f32vec1 f32vec1; typedef lowp_f32vec2 f32vec2; typedef lowp_f32vec3 f32vec3; typedef lowp_f32vec4 f32vec4; typedef lowp_f32mat2 f32mat2; typedef lowp_f32mat3 f32mat3; typedef lowp_f32mat4 f32mat4; typedef lowp_f32mat2x2 f32mat2x2; typedef lowp_f32mat3x2 f32mat3x2; typedef lowp_f32mat4x2 f32mat4x2; typedef lowp_f32mat2x3 f32mat2x3; typedef lowp_f32mat3x3 f32mat3x3; typedef lowp_f32mat4x3 f32mat4x3; typedef lowp_f32mat2x4 f32mat2x4; typedef lowp_f32mat3x4 f32mat3x4; typedef lowp_f32mat4x4 f32mat4x4; typedef lowp_f32quat f32quat; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) typedef mediump_f32vec1 fvec1; typedef mediump_f32vec2 fvec2; typedef mediump_f32vec3 fvec3; typedef mediump_f32vec4 fvec4; typedef mediump_f32mat2 fmat2; typedef mediump_f32mat3 fmat3; typedef mediump_f32mat4 fmat4; typedef mediump_f32mat2x2 fmat2x2; typedef mediump_f32mat3x2 fmat3x2; typedef mediump_f32mat4x2 fmat4x2; typedef mediump_f32mat2x3 fmat2x3; typedef mediump_f32mat3x3 fmat3x3; typedef mediump_f32mat4x3 fmat4x3; typedef mediump_f32mat2x4 fmat2x4; typedef mediump_f32mat3x4 fmat3x4; typedef mediump_f32mat4x4 fmat4x4; typedef mediump_f32quat fquat; typedef mediump_f32vec1 f32vec1; typedef mediump_f32vec2 f32vec2; typedef mediump_f32vec3 f32vec3; typedef mediump_f32vec4 f32vec4; typedef mediump_f32mat2 f32mat2; typedef mediump_f32mat3 f32mat3; typedef mediump_f32mat4 f32mat4; typedef mediump_f32mat2x2 f32mat2x2; typedef mediump_f32mat3x2 f32mat3x2; typedef mediump_f32mat4x2 f32mat4x2; typedef mediump_f32mat2x3 f32mat2x3; typedef mediump_f32mat3x3 f32mat3x3; typedef mediump_f32mat4x3 f32mat4x3; typedef mediump_f32mat2x4 f32mat2x4; typedef mediump_f32mat3x4 f32mat3x4; typedef mediump_f32mat4x4 f32mat4x4; typedef mediump_f32quat f32quat; #else//if(defined(GLM_PRECISION_HIGHP_FLOAT)) /// Default single-qualifier floating-point vector of 1 components. /// @see gtc_type_precision typedef highp_f32vec1 fvec1; /// Default single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef highp_f32vec2 fvec2; /// Default single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef highp_f32vec3 fvec3; /// Default single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef highp_f32vec4 fvec4; /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f32mat2x2 fmat2x2; /// Default single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef highp_f32mat2x3 fmat2x3; /// Default single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef highp_f32mat2x4 fmat2x4; /// Default single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef highp_f32mat3x2 fmat3x2; /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f32mat3x3 fmat3x3; /// Default single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef highp_f32mat3x4 fmat3x4; /// Default single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef highp_f32mat4x2 fmat4x2; /// Default single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef highp_f32mat4x3 fmat4x3; /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f32mat4x4 fmat4x4; /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef fmat2x2 fmat2; /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef fmat3x3 fmat3; /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef fmat4x4 fmat4; /// Default single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef highp_fquat fquat; /// Default single-qualifier floating-point vector of 1 components. /// @see gtc_type_precision typedef highp_f32vec1 f32vec1; /// Default single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef highp_f32vec2 f32vec2; /// Default single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef highp_f32vec3 f32vec3; /// Default single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef highp_f32vec4 f32vec4; /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f32mat2x2 f32mat2x2; /// Default single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef highp_f32mat2x3 f32mat2x3; /// Default single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef highp_f32mat2x4 f32mat2x4; /// Default single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef highp_f32mat3x2 f32mat3x2; /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f32mat3x3 f32mat3x3; /// Default single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef highp_f32mat3x4 f32mat3x4; /// Default single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef highp_f32mat4x2 f32mat4x2; /// Default single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef highp_f32mat4x3 f32mat4x3; /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f32mat4x4 f32mat4x4; /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef f32mat2x2 f32mat2; /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef f32mat3x3 f32mat3; /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef f32mat4x4 f32mat4; /// Default single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef highp_f32quat f32quat; #endif #if(defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_f64vec1 f64vec1; typedef lowp_f64vec2 f64vec2; typedef lowp_f64vec3 f64vec3; typedef lowp_f64vec4 f64vec4; typedef lowp_f64mat2 f64mat2; typedef lowp_f64mat3 f64mat3; typedef lowp_f64mat4 f64mat4; typedef lowp_f64mat2x2 f64mat2x2; typedef lowp_f64mat3x2 f64mat3x2; typedef lowp_f64mat4x2 f64mat4x2; typedef lowp_f64mat2x3 f64mat2x3; typedef lowp_f64mat3x3 f64mat3x3; typedef lowp_f64mat4x3 f64mat4x3; typedef lowp_f64mat2x4 f64mat2x4; typedef lowp_f64mat3x4 f64mat3x4; typedef lowp_f64mat4x4 f64mat4x4; typedef lowp_f64quat f64quat; #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE)) typedef mediump_f64vec1 f64vec1; typedef mediump_f64vec2 f64vec2; typedef mediump_f64vec3 f64vec3; typedef mediump_f64vec4 f64vec4; typedef mediump_f64mat2 f64mat2; typedef mediump_f64mat3 f64mat3; typedef mediump_f64mat4 f64mat4; typedef mediump_f64mat2x2 f64mat2x2; typedef mediump_f64mat3x2 f64mat3x2; typedef mediump_f64mat4x2 f64mat4x2; typedef mediump_f64mat2x3 f64mat2x3; typedef mediump_f64mat3x3 f64mat3x3; typedef mediump_f64mat4x3 f64mat4x3; typedef mediump_f64mat2x4 f64mat2x4; typedef mediump_f64mat3x4 f64mat3x4; typedef mediump_f64mat4x4 f64mat4x4; typedef mediump_f64quat f64quat; #else /// Default double-qualifier floating-point vector of 1 components. /// @see gtc_type_precision typedef highp_f64vec1 f64vec1; /// Default double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef highp_f64vec2 f64vec2; /// Default double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef highp_f64vec3 f64vec3; /// Default double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef highp_f64vec4 f64vec4; /// Default double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f64mat2x2 f64mat2x2; /// Default double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef highp_f64mat2x3 f64mat2x3; /// Default double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef highp_f64mat2x4 f64mat2x4; /// Default double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef highp_f64mat3x2 f64mat3x2; /// Default double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f64mat3x3 f64mat3x3; /// Default double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef highp_f64mat3x4 f64mat3x4; /// Default double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef highp_f64mat4x2 f64mat4x2; /// Default double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef highp_f64mat4x3 f64mat4x3; /// Default double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f64mat4x4 f64mat4x4; /// Default double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef f64mat2x2 f64mat2; /// Default double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef f64mat3x3 f64mat3; /// Default double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef f64mat4x4 f64mat4; /// Default double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef highp_f64quat f64quat; #endif }//namespace glm glm-0.9.9-a2/glm/vec4.hpp0000600000175000001440000000016113173131001013617 0ustar guususers/// @ref core /// @file glm/vec4.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_vec4.hpp" glm-0.9.9-a2/glm/packing.hpp0000600000175000001440000002503113173131001014375 0ustar guususers/// @ref core /// @file glm/packing.hpp /// /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions /// @see gtc_packing /// /// @defgroup core_func_packing Floating-Point Pack and Unpack Functions /// @ingroup core /// /// Include to use these core features. /// /// These functions do not operate component-wise, rather as described in each case. #pragma once #include "detail/type_vec2.hpp" #include "detail/type_vec4.hpp" namespace glm { /// @addtogroup core_func_packing /// @{ /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm2x16: round(clamp(c, 0, +1) * 65535.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packUnorm2x16(vec2 const& v); /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm2x16: round(clamp(v, -1, +1) * 32767.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packSnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packSnorm2x16(vec2 const& v); /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm4x8: round(clamp(c, 0, +1) * 255.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packUnorm4x8(vec4 const& v); /// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm4x8: round(clamp(c, -1, +1) * 127.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packSnorm4x8(vec4 const& v); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm2x16: f / 65535.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackUnorm2x16(uint p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm2x16: clamp(f / 32767.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackSnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackSnorm2x16(uint p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm4x8: f / 255.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackUnorm4x8(uint p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm4x8: clamp(f / 127.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p); /// Returns a double-qualifier value obtained by packing the components of v into a 64-bit value. /// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. /// Otherwise, the bit- level representation of v is preserved. /// The first vector component specifies the 32 least significant bits; /// the second component specifies the 32 most significant bits. /// /// @see GLSL packDouble2x32 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL double packDouble2x32(uvec2 const& v); /// Returns a two-component unsigned integer vector representation of v. /// The bit-level representation of v is preserved. /// The first component of the vector contains the 32 least significant bits of the double; /// the second component consists the 32 most significant bits. /// /// @see GLSL unpackDouble2x32 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uvec2 unpackDouble2x32(double v); /// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification, /// and then packing these two 16- bit integers into a 32-bit unsigned integer. /// The first vector component specifies the 16 least-significant bits of the result; /// the second component specifies the 16 most-significant bits. /// /// @see GLSL packHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint packHalf2x16(vec2 const& v); /// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, /// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, /// and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the second component is obtained from the 16 most-significant bits of v. /// /// @see GLSL unpackHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackHalf2x16(uint v); /// @} }//namespace glm #include "detail/func_packing.inl" glm-0.9.9-a2/glm/geometric.hpp0000600000175000001440000001236513173131001014745 0ustar guususers/// @ref core /// @file glm/geometric.hpp /// /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions /// /// @defgroup core_func_geometric Geometric functions /// @ingroup core /// /// Include to use these core features. /// /// These operate on vectors as vectors, not component-wise. #pragma once #include "detail/type_vec3.hpp" namespace glm { /// @addtogroup core_func_geometric /// @{ /// Returns the length of x, i.e., sqrt(x * x). /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL length man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL T length(vec const& x); /// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1). /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL distance man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL T distance(vec const& p0, vec const& p1); /// Returns the dot product of x and y, i.e., result = x * y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL dot man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL T dot(vec const& x, vec const& y); /// Returns the cross product of x and y. /// /// @tparam T Floating-point scalar types. /// /// @see GLSL cross man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y); /// Returns a vector in the same direction as x but with length of 1. /// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL normalize man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec normalize(vec const& x); /// If dot(Nref, I) < 0.0, return N, otherwise, return -N. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL faceforward man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec faceforward( vec const& N, vec const& I, vec const& Nref); /// For the incident vector I and surface orientation N, /// returns the reflection direction : result = I - 2.0 * dot(N, I) * N. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL reflect man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec reflect( vec const& I, vec const& N); /// For the incident vector I and surface normal N, /// and the ratio of indices of refraction eta, /// return the refraction vector. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL refract man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template GLM_FUNC_DECL vec refract( vec const& I, vec const& N, T eta); /// @} }//namespace glm #include "detail/func_geometric.inl" glm-0.9.9-a2/glm/integer.hpp0000600000175000001440000002434613173131001014426 0ustar guususers/// @ref core /// @file glm/integer.hpp /// /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions /// /// @defgroup core_func_integer Integer functions /// @ingroup core /// /// Include to use these core features. /// /// These all operate component-wise. The description is per component. /// The notation [a, b] means the set of bits from bit-number a through bit-number /// b, inclusive. The lowest-order bit is bit 0. #pragma once #include "detail/setup.hpp" #include "detail/qualifier.hpp" #include "common.hpp" #include "vector_relational.hpp" namespace glm { /// @addtogroup core_func_integer /// @{ /// Adds 32-bit unsigned integer x and y, returning the sum /// modulo pow(2, 32). The value carry is set to 0 if the sum was /// less than pow(2, 32), or to 1 otherwise. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL uaddCarry man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec uaddCarry( vec const& x, vec const& y, vec & carry); /// Subtracts the 32-bit unsigned integer y from x, returning /// the difference if non-negative, or pow(2, 32) plus the difference /// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL usubBorrow man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec usubBorrow( vec const& x, vec const& y, vec & borrow); /// Multiplies 32-bit integers x and y, producing a 64-bit /// result. The 32 least-significant bits are returned in lsb. /// The 32 most-significant bits are returned in msb. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL umulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL void umulExtended( vec const& x, vec const& y, vec & msb, vec & lsb); /// Multiplies 32-bit integers x and y, producing a 64-bit /// result. The 32 least-significant bits are returned in lsb. /// The 32 most-significant bits are returned in msb. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL imulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL void imulExtended( vec const& x, vec const& y, vec & msb, vec & lsb); /// Extracts bits [offset, offset + bits - 1] from value, /// returning them in the least significant bits of the result. /// For unsigned data types, the most significant bits of the /// result will be set to zero. For signed data types, the /// most significant bits will be set to the value of bit offset + base - 1. /// /// If bits is zero, the result will be zero. The result will be /// undefined if offset or bits is negative, or if the sum of /// offset and bits is greater than the number of bits used /// to store the operand. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar types. /// /// @see GLSL bitfieldExtract man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitfieldExtract( vec const& Value, int Offset, int Bits); /// Returns the insertion the bits least-significant bits of insert into base. /// /// The result will have bits [offset, offset + bits - 1] taken /// from bits [0, bits - 1] of insert, and all other bits taken /// directly from the corresponding bits of base. If bits is /// zero, the result will simply be base. The result will be /// undefined if offset or bits is negative, or if the sum of /// offset and bits is greater than the number of bits used to /// store the operand. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitfieldInsert man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitfieldInsert( vec const& Base, vec const& Insert, int Offset, int Bits); /// Returns the reversal of the bits of value. /// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, /// where bits is the total number of bits used to represent value. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitfieldReverse man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitfieldReverse(vec const& v); /// Returns the number of bits set to 1 in the binary representation of value. /// /// @tparam genType Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitCount man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL int bitCount(genType v); /// Returns the number of bits set to 1 in the binary representation of value. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar or vector types. /// /// @see GLSL bitCount man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec bitCount(vec const& v); /// Returns the bit number of the least significant bit set to /// 1 in the binary representation of value. /// If value is zero, -1 will be returned. /// /// @tparam genIUType Signed or unsigned integer scalar types. /// /// @see GLSL findLSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL int findLSB(genIUType x); /// Returns the bit number of the least significant bit set to /// 1 in the binary representation of value. /// If value is zero, -1 will be returned. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar types. /// /// @see GLSL findLSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec findLSB(vec const& v); /// Returns the bit number of the most significant bit in the binary representation of value. /// For positive integers, the result will be the bit number of the most significant bit set to 1. /// For negative integers, the result will be the bit number of the most significant /// bit set to 0. For a value of zero or negative one, -1 will be returned. /// /// @tparam genIUType Signed or unsigned integer scalar types. /// /// @see GLSL findMSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL int findMSB(genIUType x); /// Returns the bit number of the most significant bit in the binary representation of value. /// For positive integers, the result will be the bit number of the most significant bit set to 1. /// For negative integers, the result will be the bit number of the most significant /// bit set to 0. For a value of zero or negative one, -1 will be returned. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Signed or unsigned integer scalar types. /// /// @see GLSL findMSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template GLM_FUNC_DECL vec findMSB(vec const& v); /// @} }//namespace glm #include "detail/func_integer.inl" glm-0.9.9-a2/glm/vec2.hpp0000600000175000001440000000016113173131001013615 0ustar guususers/// @ref core /// @file glm/vec2.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_vec2.hpp" glm-0.9.9-a2/glm/gtc/0000700000175000001440000000000013173131001013022 5ustar guususersglm-0.9.9-a2/glm/gtc/matrix_access.inl0000600000175000001440000000221113173131001016351 0ustar guususers/// @ref gtc_matrix_access /// @file glm/gtc/matrix_access.inl namespace glm { template GLM_FUNC_QUALIFIER genType row ( genType const& m, length_t index, typename genType::row_type const& x ) { assert(index >= 0 && index < m[0].length()); genType Result = m; for(length_t i = 0; i < m.length(); ++i) Result[i][index] = x[i]; return Result; } template GLM_FUNC_QUALIFIER typename genType::row_type row ( genType const& m, length_t index ) { assert(index >= 0 && index < m[0].length()); typename genType::row_type Result(0); for(length_t i = 0; i < m.length(); ++i) Result[i] = m[i][index]; return Result; } template GLM_FUNC_QUALIFIER genType column ( genType const& m, length_t index, typename genType::col_type const& x ) { assert(index >= 0 && index < m.length()); genType Result = m; Result[index] = x; return Result; } template GLM_FUNC_QUALIFIER typename genType::col_type column ( genType const& m, length_t index ) { assert(index >= 0 && index < m.length()); return m[index]; } }//namespace glm glm-0.9.9-a2/glm/gtc/matrix_integer.hpp0000600000175000001440000003426413173131001016567 0ustar guususers/// @ref gtc_matrix_integer /// @file glm/gtc/matrix_integer.hpp /// /// @see core (dependence) /// /// @defgroup gtc_matrix_integer GLM_GTC_matrix_integer /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines a number of matrices with integer types. #pragma once // Dependency: #include "../mat2x2.hpp" #include "../mat2x3.hpp" #include "../mat2x4.hpp" #include "../mat3x2.hpp" #include "../mat3x3.hpp" #include "../mat3x4.hpp" #include "../mat4x2.hpp" #include "../mat4x3.hpp" #include "../mat4x4.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_integer extension included") #endif namespace glm { /// @addtogroup gtc_matrix_integer /// @{ /// High-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, highp> highp_imat2; /// High-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, highp> highp_imat3; /// High-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, highp> highp_imat4; /// High-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, highp> highp_imat2x2; /// High-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, highp> highp_imat2x3; /// High-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, highp> highp_imat2x4; /// High-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, highp> highp_imat3x2; /// High-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, highp> highp_imat3x3; /// High-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, highp> highp_imat3x4; /// High-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, highp> highp_imat4x2; /// High-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, highp> highp_imat4x3; /// High-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, highp> highp_imat4x4; /// Medium-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, mediump> mediump_imat2; /// Medium-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, mediump> mediump_imat3; /// Medium-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, mediump> mediump_imat4; /// Medium-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, mediump> mediump_imat2x2; /// Medium-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, mediump> mediump_imat2x3; /// Medium-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, mediump> mediump_imat2x4; /// Medium-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, mediump> mediump_imat3x2; /// Medium-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, mediump> mediump_imat3x3; /// Medium-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, mediump> mediump_imat3x4; /// Medium-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, mediump> mediump_imat4x2; /// Medium-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, mediump> mediump_imat4x3; /// Medium-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, mediump> mediump_imat4x4; /// Low-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, lowp> lowp_imat2; /// Low-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, lowp> lowp_imat3; /// Low-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, lowp> lowp_imat4; /// Low-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, lowp> lowp_imat2x2; /// Low-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, lowp> lowp_imat2x3; /// Low-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, lowp> lowp_imat2x4; /// Low-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, lowp> lowp_imat3x2; /// Low-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, lowp> lowp_imat3x3; /// Low-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, lowp> lowp_imat3x4; /// Low-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, lowp> lowp_imat4x2; /// Low-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, lowp> lowp_imat4x3; /// Low-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, lowp> lowp_imat4x4; /// High-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, highp> highp_umat2; /// High-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, highp> highp_umat3; /// High-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, highp> highp_umat4; /// High-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, highp> highp_umat2x2; /// High-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, highp> highp_umat2x3; /// High-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, highp> highp_umat2x4; /// High-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, highp> highp_umat3x2; /// High-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, highp> highp_umat3x3; /// High-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, highp> highp_umat3x4; /// High-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, highp> highp_umat4x2; /// High-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, highp> highp_umat4x3; /// High-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, highp> highp_umat4x4; /// Medium-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, mediump> mediump_umat2; /// Medium-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, mediump> mediump_umat3; /// Medium-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, mediump> mediump_umat4; /// Medium-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, mediump> mediump_umat2x2; /// Medium-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, mediump> mediump_umat2x3; /// Medium-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, mediump> mediump_umat2x4; /// Medium-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, mediump> mediump_umat3x2; /// Medium-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, mediump> mediump_umat3x3; /// Medium-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, mediump> mediump_umat3x4; /// Medium-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, mediump> mediump_umat4x2; /// Medium-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, mediump> mediump_umat4x3; /// Medium-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, mediump> mediump_umat4x4; /// Low-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, lowp> lowp_umat2; /// Low-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, lowp> lowp_umat3; /// Low-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, lowp> lowp_umat4; /// Low-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, lowp> lowp_umat2x2; /// Low-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, lowp> lowp_umat2x3; /// Low-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, lowp> lowp_umat2x4; /// Low-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, lowp> lowp_umat3x2; /// Low-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, lowp> lowp_umat3x3; /// Low-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, lowp> lowp_umat3x4; /// Low-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, lowp> lowp_umat4x2; /// Low-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, lowp> lowp_umat4x3; /// Low-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, lowp> lowp_umat4x4; #if(defined(GLM_PRECISION_HIGHP_INT)) typedef highp_imat2 imat2; typedef highp_imat3 imat3; typedef highp_imat4 imat4; typedef highp_imat2x2 imat2x2; typedef highp_imat2x3 imat2x3; typedef highp_imat2x4 imat2x4; typedef highp_imat3x2 imat3x2; typedef highp_imat3x3 imat3x3; typedef highp_imat3x4 imat3x4; typedef highp_imat4x2 imat4x2; typedef highp_imat4x3 imat4x3; typedef highp_imat4x4 imat4x4; #elif(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_imat2 imat2; typedef lowp_imat3 imat3; typedef lowp_imat4 imat4; typedef lowp_imat2x2 imat2x2; typedef lowp_imat2x3 imat2x3; typedef lowp_imat2x4 imat2x4; typedef lowp_imat3x2 imat3x2; typedef lowp_imat3x3 imat3x3; typedef lowp_imat3x4 imat3x4; typedef lowp_imat4x2 imat4x2; typedef lowp_imat4x3 imat4x3; typedef lowp_imat4x4 imat4x4; #else //if(defined(GLM_PRECISION_MEDIUMP_INT)) /// Signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mediump_imat2 imat2; /// Signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mediump_imat3 imat3; /// Signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mediump_imat4 imat4; /// Signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mediump_imat2x2 imat2x2; /// Signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mediump_imat2x3 imat2x3; /// Signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mediump_imat2x4 imat2x4; /// Signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mediump_imat3x2 imat3x2; /// Signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mediump_imat3x3 imat3x3; /// Signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mediump_imat3x4 imat3x4; /// Signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mediump_imat4x2 imat4x2; /// Signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mediump_imat4x3 imat4x3; /// Signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mediump_imat4x4 imat4x4; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_HIGHP_UINT)) typedef highp_umat2 umat2; typedef highp_umat3 umat3; typedef highp_umat4 umat4; typedef highp_umat2x2 umat2x2; typedef highp_umat2x3 umat2x3; typedef highp_umat2x4 umat2x4; typedef highp_umat3x2 umat3x2; typedef highp_umat3x3 umat3x3; typedef highp_umat3x4 umat3x4; typedef highp_umat4x2 umat4x2; typedef highp_umat4x3 umat4x3; typedef highp_umat4x4 umat4x4; #elif(defined(GLM_PRECISION_LOWP_UINT)) typedef lowp_umat2 umat2; typedef lowp_umat3 umat3; typedef lowp_umat4 umat4; typedef lowp_umat2x2 umat2x2; typedef lowp_umat2x3 umat2x3; typedef lowp_umat2x4 umat2x4; typedef lowp_umat3x2 umat3x2; typedef lowp_umat3x3 umat3x3; typedef lowp_umat3x4 umat3x4; typedef lowp_umat4x2 umat4x2; typedef lowp_umat4x3 umat4x3; typedef lowp_umat4x4 umat4x4; #else //if(defined(GLM_PRECISION_MEDIUMP_UINT)) /// Unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mediump_umat2 umat2; /// Unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mediump_umat3 umat3; /// Unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mediump_umat4 umat4; /// Unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mediump_umat2x2 umat2x2; /// Unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mediump_umat2x3 umat2x3; /// Unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mediump_umat2x4 umat2x4; /// Unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mediump_umat3x2 umat3x2; /// Unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mediump_umat3x3 umat3x3; /// Unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mediump_umat3x4 umat3x4; /// Unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mediump_umat4x2 umat4x2; /// Unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mediump_umat4x3 umat4x3; /// Unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mediump_umat4x4 umat4x4; #endif//GLM_PRECISION /// @} }//namespace glm glm-0.9.9-a2/glm/gtc/vec1.inl0000600000175000001440000000005513173131001014366 0ustar guususers/// @ref gtc_vec1 /// @file glm/gtc/vec1.inl glm-0.9.9-a2/glm/gtc/random.hpp0000600000175000001440000000500413173131001015014 0ustar guususers/// @ref gtc_random /// @file glm/gtc/random.hpp /// /// @see core (dependence) /// @see gtx_random (extended) /// /// @defgroup gtc_random GLM_GTC_random /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Generate random number from various distribution methods. #pragma once // Dependency: #include "../vec2.hpp" #include "../vec3.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_random extension included") #endif namespace glm { /// @addtogroup gtc_random /// @{ /// Generate random numbers in the interval [Min, Max], according a linear distribution /// /// @param Min Minimum value included in the sampling /// @param Max Maximum value included in the sampling /// @tparam genType Value type. Currently supported: float or double scalars. /// @see gtc_random template GLM_FUNC_DECL genType linearRand(genType Min, genType Max); /// Generate random numbers in the interval [Min, Max], according a linear distribution /// /// @param Min Minimum value included in the sampling /// @param Max Maximum value included in the sampling /// @tparam T Value type. Currently supported: float or double. /// /// @see gtc_random template GLM_FUNC_DECL vec linearRand(vec const& Min, vec const& Max); /// Generate random numbers in the interval [Min, Max], according a gaussian distribution /// /// @see gtc_random template GLM_FUNC_DECL genType gaussRand(genType Mean, genType Deviation); /// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<2, T, defaultp> circularRand(T Radius); /// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<3, T, defaultp> sphericalRand(T Radius); /// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<2, T, defaultp> diskRand(T Radius); /// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius /// /// @see gtc_random template GLM_FUNC_DECL vec<3, T, defaultp> ballRand(T Radius); /// @} }//namespace glm #include "random.inl" glm-0.9.9-a2/glm/gtc/matrix_transform.hpp0000600000175000001440000013104213173131001017135 0ustar guususers/// @ref gtc_matrix_transform /// @file glm/gtc/matrix_transform.hpp /// /// @see core (dependence) /// @see gtx_transform /// @see gtx_transform2 /// /// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines functions that generate common transformation matrices. /// /// The matrices generated by this extension use standard OpenGL fixed-function /// conventions. For example, the lookAt function generates a transform from world /// space into the specific eye space that the projective matrix functions /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility /// specifications defines the particular layout of this eye space. #pragma once // Dependencies #include "../mat4x4.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../gtc/constants.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_transform extension included") #endif namespace glm { /// @addtogroup gtc_matrix_transform /// @{ /// Builds a translation 4 * 4 matrix created from a vector of 3 components. /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a translation vector. /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @code /// #include /// #include /// ... /// glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f)); /// // m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f /// // m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f /// // m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f /// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f /// @endcode /// @see gtc_matrix_transform /// @see - translate(mat<4, 4, T, Q> const& m, T x, T y, T z) /// @see - translate(vec<3, T, Q> const& v) /// @see glTranslate man page template GLM_FUNC_DECL mat<4, 4, T, Q> translate( mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v); /// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. /// /// @param m Input matrix multiplied by this rotation matrix. /// @param angle Rotation angle expressed in radians. /// @param axis Rotation axis, recommended to be normalized. /// @tparam T Value type used to build the matrix. Supported: half, float or double. /// @see gtc_matrix_transform /// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z) /// @see - rotate(T angle, vec<3, T, Q> const& v) /// @see glRotate man page template GLM_FUNC_DECL mat<4, 4, T, Q> rotate( mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& axis); /// Builds a scale 4 * 4 matrix created from 3 scalars. /// /// @param m Input matrix multiplied by this scale matrix. /// @param v Ratio of scaling for each axis. /// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double. /// @see gtc_matrix_transform /// @see - scale(mat<4, 4, T, Q> const& m, T x, T y, T z) /// @see - scale(vec<3, T, Q> const& v) /// @see glScale man page template GLM_FUNC_DECL mat<4, 4, T, Q> scale( mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v); /// Creates a matrix for projecting two-dimensional coordinates onto the screen. /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top, T const& zNear, T const& zFar) /// @see gluOrtho2D man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho( T left, T right, T bottom, T top); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_ZO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_NO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_ZO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_NO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoZO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoNO( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) template GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see glOrtho man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho( T left, T right, T bottom, T top, T zNear, T zFar); /// Creates a left handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO( T left, T right, T bottom, T top, T near, T far); /// Creates a left handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO( T left, T right, T bottom, T top, T near, T far); /// Creates a right handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO( T left, T right, T bottom, T top, T near, T far); /// Creates a right handed frustum matrix. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO( T left, T right, T bottom, T top, T near, T far); /// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO( T left, T right, T bottom, T top, T near, T far); /// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO( T left, T right, T bottom, T top, T near, T far); /// Creates a left handed frustum matrix. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH( T left, T right, T bottom, T top, T near, T far); /// Creates a right handed frustum matrix. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH( T left, T right, T bottom, T top, T near, T far); /// Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see glFrustum man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum( T left, T right, T bottom, T top, T near, T far); /// Creates a matrix for a right handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO( T fovy, T aspect, T near, T far); /// Creates a matrix for a right handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO( T fovy, T aspect, T near, T far); /// Creates a matrix for a left handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO( T fovy, T aspect, T near, T far); /// Creates a matrix for a left handed, symetric perspective-view frustum. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO( T fovy, T aspect, T near, T far); /// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO( T fovy, T aspect, T near, T far); /// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO( T fovy, T aspect, T near, T far); /// Creates a matrix for a right handed, symetric perspective-view frustum. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH( T fovy, T aspect, T near, T far); /// Creates a matrix for a left handed, symetric perspective-view frustum. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH( T fovy, T aspect, T near, T far); /// Creates a matrix for a symetric perspective-view frustum based on the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param fovy Specifies the field of view angle in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform /// @see gluPerspective man page template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective( T fovy, T aspect, T near, T far); /// Builds a perspective projection matrix based on a field of view using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using right-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO( T fov, T width, T height, T near, T far); /// Builds a right handed perspective projection matrix based on a field of view. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH( T fov, T width, T height, T near, T far); /// Builds a left handed perspective projection matrix based on a field of view. /// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH( T fov, T width, T height, T near, T far); /// Builds a perspective projection matrix based on a field of view and the default handedness and default near and far clip planes definition. /// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param fov Expressed in radians. /// @param width Width of the viewport /// @param height Height of the viewport /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param far Specifies the distance from the viewer to the far clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov( T fov, T width, T height, T near, T far); /// Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH( T fovy, T aspect, T near); /// Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH( T fovy, T aspect, T near); /// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective( T fovy, T aspect, T near); /// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective( T fovy, T aspect, T near); /// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping. /// /// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. /// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). /// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @param ep Epsilon /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. /// @see gtc_matrix_transform template GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective( T fovy, T aspect, T near, T ep); /// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param obj Specify the object coordinates. /// @param model Specifies the current modelview matrix /// @param proj Specifies the current projection matrix /// @param viewport Specifies the current viewport /// @return Return the computed window coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform /// @see gluProject man page template GLM_FUNC_DECL vec<3, T, Q> projectZO( vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param obj Specify the object coordinates. /// @param model Specifies the current modelview matrix /// @param proj Specifies the current projection matrix /// @param viewport Specifies the current viewport /// @return Return the computed window coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform /// @see gluProject man page template GLM_FUNC_DECL vec<3, T, Q> projectNO( vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates using default near and far clip planes definition. /// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param obj Specify the object coordinates. /// @param model Specifies the current modelview matrix /// @param proj Specifies the current projection matrix /// @param viewport Specifies the current viewport /// @return Return the computed window coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform /// @see gluProject man page template GLM_FUNC_DECL vec<3, T, Q> project( vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates. /// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) /// /// @param win Specify the window coordinates to be mapped. /// @param model Specifies the modelview matrix /// @param proj Specifies the projection matrix /// @param viewport Specifies the viewport /// @return Returns the computed object coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform /// @see gluUnProject man page template GLM_FUNC_DECL vec<3, T, Q> unProjectZO( vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates. /// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition) /// /// @param win Specify the window coordinates to be mapped. /// @param model Specifies the modelview matrix /// @param proj Specifies the projection matrix /// @param viewport Specifies the viewport /// @return Returns the computed object coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform /// @see gluUnProject man page template GLM_FUNC_DECL vec<3, T, Q> unProjectNO( vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using default near and far clip planes definition. /// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE. /// /// @param win Specify the window coordinates to be mapped. /// @param model Specifies the modelview matrix /// @param proj Specifies the projection matrix /// @param viewport Specifies the viewport /// @return Returns the computed object coordinates. /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform /// @see gluUnProject man page template GLM_FUNC_DECL vec<3, T, Q> unProject( vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport); /// Define a picking region /// /// @param center Specify the center of a picking region in window coordinates. /// @param delta Specify the width and height, respectively, of the picking region in window coordinates. /// @param viewport Rendering viewport /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform /// @see gluPickMatrix man page template GLM_FUNC_DECL mat<4, 4, T, Q> pickMatrix( vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport); /// Build a right handed look at view matrix. /// /// @param eye Position of the camera /// @param center Position where the camera is looking at /// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @see gtc_matrix_transform /// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) template GLM_FUNC_DECL mat<4, 4, T, Q> lookAtRH( vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up); /// Build a left handed look at view matrix. /// /// @param eye Position of the camera /// @param center Position where the camera is looking at /// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @see gtc_matrix_transform /// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) template GLM_FUNC_DECL mat<4, 4, T, Q> lookAtLH( vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up); /// Build a look at view matrix based on the default handedness. /// /// @param eye Position of the camera /// @param center Position where the camera is looking at /// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @see gtc_matrix_transform /// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) /// @see gluLookAt man page template GLM_FUNC_DECL mat<4, 4, T, Q> lookAt( vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up); /// @} }//namespace glm #include "matrix_transform.inl" glm-0.9.9-a2/glm/gtc/ulp.hpp0000600000175000001440000000352013173131001014335 0ustar guususers/// @ref gtc_ulp /// @file glm/gtc/ulp.hpp /// /// @see core (dependence) /// /// @defgroup gtc_ulp GLM_GTC_ulp /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Allow the measurement of the accuracy of a function against a reference /// implementation. This extension works on floating-point data and provide results /// in ULP. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/type_int.hpp" #include "../detail/compute_vector_relational.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_ulp extension included") #endif namespace glm { /// @addtogroup gtc_ulp /// @{ /// Return the next ULP value(s) after the input value(s). /// @see gtc_ulp template GLM_FUNC_DECL genType next_float(genType const& x); /// Return the previous ULP value(s) before the input value(s). /// @see gtc_ulp template GLM_FUNC_DECL genType prev_float(genType const& x); /// Return the value(s) ULP distance after the input value(s). /// @see gtc_ulp template GLM_FUNC_DECL genType next_float(genType const& x, uint const& Distance); /// Return the value(s) ULP distance before the input value(s). /// @see gtc_ulp template GLM_FUNC_DECL genType prev_float(genType const& x, uint const& Distance); /// Return the distance in the number of ULP between 2 scalars. /// @see gtc_ulp template GLM_FUNC_DECL uint float_distance(T const& x, T const& y); /// Return the distance in the number of ULP between 2 vectors. /// @see gtc_ulp template GLM_FUNC_DECL vec<2, uint, Q> float_distance(vec<2, T, Q> const& x, vec<2, T, Q> const& y); /// @} }// namespace glm #include "ulp.inl" glm-0.9.9-a2/glm/gtc/matrix_transform.inl0000600000175000001440000007070713173131001017142 0ustar guususers/// @ref gtc_matrix_transform /// @file glm/gtc/matrix_transform.inl #include "../geometric.hpp" #include "../trigonometric.hpp" #include "../matrix.hpp" namespace glm { template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v) { mat<4, 4, T, Q> Result(m); Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& v) { T const a = angle; T const c = cos(a); T const s = sin(a); vec<3, T, Q> axis(normalize(v)); vec<3, T, Q> temp((T(1) - c) * axis); mat<4, 4, T, Q> Rotate; Rotate[0][0] = c + temp[0] * axis[0]; Rotate[0][1] = temp[0] * axis[1] + s * axis[2]; Rotate[0][2] = temp[0] * axis[2] - s * axis[1]; Rotate[1][0] = temp[1] * axis[0] - s * axis[2]; Rotate[1][1] = c + temp[1] * axis[1]; Rotate[1][2] = temp[1] * axis[2] + s * axis[0]; Rotate[2][0] = temp[2] * axis[0] + s * axis[1]; Rotate[2][1] = temp[2] * axis[1] - s * axis[0]; Rotate[2][2] = c + temp[2] * axis[2]; mat<4, 4, T, Q> Result; Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; Result[3] = m[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate_slow(mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& v) { T const a = angle; T const c = cos(a); T const s = sin(a); mat<4, 4, T, Q> Result; vec<3, T, Q> axis = normalize(v); Result[0][0] = c + (static_cast(1) - c) * axis.x * axis.x; Result[0][1] = (static_cast(1) - c) * axis.x * axis.y + s * axis.z; Result[0][2] = (static_cast(1) - c) * axis.x * axis.z - s * axis.y; Result[0][3] = static_cast(0); Result[1][0] = (static_cast(1) - c) * axis.y * axis.x - s * axis.z; Result[1][1] = c + (static_cast(1) - c) * axis.y * axis.y; Result[1][2] = (static_cast(1) - c) * axis.y * axis.z + s * axis.x; Result[1][3] = static_cast(0); Result[2][0] = (static_cast(1) - c) * axis.z * axis.x + s * axis.y; Result[2][1] = (static_cast(1) - c) * axis.z * axis.y - s * axis.x; Result[2][2] = c + (static_cast(1) - c) * axis.z * axis.z; Result[2][3] = static_cast(0); Result[3] = vec<4, T, Q>(0, 0, 0, 1); return m * Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v) { mat<4, 4, T, Q> Result; Result[0] = m[0] * v[0]; Result[1] = m[1] * v[1]; Result[2] = m[2] * v[2]; Result[3] = m[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale_slow(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v) { mat<4, 4, T, Q> Result(T(1)); Result[0][0] = v.x; Result[1][1] = v.y; Result[2][2] = v.z; return m * Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top) { mat<4, 4, T, defaultp> Result(static_cast(1)); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_ZO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = static_cast(1) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - zNear / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_NO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = static_cast(2) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - (zFar + zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_ZO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = - static_cast(1) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - zNear / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_NO(T left, T right, T bottom, T top, T zNear, T zFar) { mat<4, 4, T, defaultp> Result(1); Result[0][0] = static_cast(2) / (right - left); Result[1][1] = static_cast(2) / (top - bottom); Result[2][2] = - static_cast(2) / (zFar - zNear); Result[3][0] = - (right + left) / (right - left); Result[3][1] = - (top + bottom) / (top - bottom); Result[3][2] = - (zFar + zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoZO(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return orthoLH_ZO(left, right, bottom, top, zNear, zFar); # else return orthoRH_ZO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoNO(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return orthoLH_NO(left, right, bottom, top, zNear, zFar); # else return orthoRH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return orthoLH_ZO(left, right, bottom, top, zNear, zFar); # else return orthoLH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return orthoRH_ZO(left, right, bottom, top, zNear, zFar); # else return orthoRH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return orthoLH_ZO(left, right, bottom, top, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return orthoLH_NO(left, right, bottom, top, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return orthoRH_ZO(left, right, bottom, top, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return orthoRH_NO(left, right, bottom, top, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = farVal / (farVal - nearVal); Result[2][3] = static_cast(1); Result[3][2] = -(farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_NO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = (farVal + nearVal) / (farVal - nearVal); Result[2][3] = static_cast(1); Result[3][2] = - (static_cast(2) * farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = farVal / (nearVal - farVal); Result[2][3] = static_cast(-1); Result[3][2] = -(farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_NO(T left, T right, T bottom, T top, T nearVal, T farVal) { mat<4, 4, T, defaultp> Result(0); Result[0][0] = (static_cast(2) * nearVal) / (right - left); Result[1][1] = (static_cast(2) * nearVal) / (top - bottom); Result[2][0] = (right + left) / (right - left); Result[2][1] = (top + bottom) / (top - bottom); Result[2][2] = - (farVal + nearVal) / (farVal - nearVal); Result[2][3] = static_cast(-1); Result[3][2] = - (static_cast(2) * farVal * nearVal) / (farVal - nearVal); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumZO(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return frustumLH_ZO(left, right, bottom, top, nearVal, farVal); # else return frustumRH_ZO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumNO(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return frustumLH_NO(left, right, bottom, top, nearVal, farVal); # else return frustumRH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return frustumLH_ZO(left, right, bottom, top, nearVal, farVal); # else return frustumLH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return frustumRH_ZO(left, right, bottom, top, nearVal, farVal); # else return frustumRH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustum(T left, T right, T bottom, T top, T nearVal, T farVal) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return frustumLH_ZO(left, right, bottom, top, nearVal, farVal); # elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return frustumLH_NO(left, right, bottom, top, nearVal, farVal); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return frustumRH_ZO(left, right, bottom, top, nearVal, farVal); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return frustumRH_NO(left, right, bottom, top, nearVal, farVal); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_ZO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = zFar / (zNear - zFar); Result[2][3] = - static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_NO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = - (zFar + zNear) / (zFar - zNear); Result[2][3] = - static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_ZO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = zFar / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_NO(T fovy, T aspect, T zNear, T zFar) { assert(abs(aspect - std::numeric_limits::epsilon()) > static_cast(0)); T const tanHalfFovy = tan(fovy / static_cast(2)); mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = static_cast(1) / (aspect * tanHalfFovy); Result[1][1] = static_cast(1) / (tanHalfFovy); Result[2][2] = (zFar + zNear) / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveZO(T fovy, T aspect, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return perspectiveLH_ZO(fovy, aspect, zNear, zFar); # else return perspectiveRH_ZO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveNO(T fovy, T aspect, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return perspectiveLH_NO(fovy, aspect, zNear, zFar); # else return perspectiveRH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveLH_ZO(fovy, aspect, zNear, zFar); # else return perspectiveLH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveRH_ZO(fovy, aspect, zNear, zFar); # else return perspectiveRH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveLH_ZO(fovy, aspect, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return perspectiveLH_NO(fovy, aspect, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveRH_ZO(fovy, aspect, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return perspectiveRH_NO(fovy, aspect, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_ZO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = zFar / (zNear - zFar); Result[2][3] = - static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_NO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = - (zFar + zNear) / (zFar - zNear); Result[2][3] = - static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_ZO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = zFar / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = -(zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_NO(T fov, T width, T height, T zNear, T zFar) { assert(width > static_cast(0)); assert(height > static_cast(0)); assert(fov > static_cast(0)); T const rad = fov; T const h = glm::cos(static_cast(0.5) * rad) / glm::sin(static_cast(0.5) * rad); T const w = h * height / width; ///todo max(width , Height) / min(width , Height)? mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = w; Result[1][1] = h; Result[2][2] = (zFar + zNear) / (zFar - zNear); Result[2][3] = static_cast(1); Result[3][2] = - (static_cast(2) * zFar * zNear) / (zFar - zNear); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovZO(T fov, T width, T height, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return perspectiveFovLH_ZO(fov, width, height, zNear, zFar); # else return perspectiveFovRH_ZO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovNO(T fov, T width, T height, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return perspectiveFovLH_NO(fov, width, height, zNear, zFar); # else return perspectiveFovRH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveFovLH_ZO(fov, width, height, zNear, zFar); # else return perspectiveFovLH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveFovRH_ZO(fov, width, height, zNear, zFar); # else return perspectiveFovRH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveFovLH_ZO(fov, width, height, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return perspectiveFovLH_NO(fov, width, height, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return perspectiveFovRH_ZO(fov, width, height, zNear, zFar); # elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE return perspectiveFovRH_NO(fov, width, height, zNear, zFar); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveRH(T fovy, T aspect, T zNear) { T const range = tan(fovy / static_cast(2)) * zNear; T const left = -range * aspect; T const right = range * aspect; T const bottom = -range; T const top = range; mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = (static_cast(2) * zNear) / (right - left); Result[1][1] = (static_cast(2) * zNear) / (top - bottom); Result[2][2] = - static_cast(1); Result[2][3] = - static_cast(1); Result[3][2] = - static_cast(2) * zNear; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveLH(T fovy, T aspect, T zNear) { T const range = tan(fovy / static_cast(2)) * zNear; T const left = -range * aspect; T const right = range * aspect; T const bottom = -range; T const top = range; mat<4, 4, T, defaultp> Result(T(0)); Result[0][0] = (static_cast(2) * zNear) / (right - left); Result[1][1] = (static_cast(2) * zNear) / (top - bottom); Result[2][2] = static_cast(1); Result[2][3] = static_cast(1); Result[3][2] = - static_cast(2) * zNear; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspective(T fovy, T aspect, T zNear) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return infinitePerspectiveLH(fovy, aspect, zNear); # else return infinitePerspectiveRH(fovy, aspect, zNear); # endif } // Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep) { T const range = tan(fovy / static_cast(2)) * zNear; T const left = -range * aspect; T const right = range * aspect; T const bottom = -range; T const top = range; mat<4, 4, T, defaultp> Result(static_cast(0)); Result[0][0] = (static_cast(2) * zNear) / (right - left); Result[1][1] = (static_cast(2) * zNear) / (top - bottom); Result[2][2] = ep - static_cast(1); Result[2][3] = static_cast(-1); Result[3][2] = (ep - static_cast(2)) * zNear; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear) { return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon()); } template GLM_FUNC_QUALIFIER vec<3, T, Q> projectZO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast(1)); tmp = model * tmp; tmp = proj * tmp; tmp /= tmp.w; tmp.x = tmp.x * static_cast(0.5) + static_cast(0.5); tmp.y = tmp.y * static_cast(0.5) + static_cast(0.5); tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]); tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]); return vec<3, T, Q>(tmp); } template GLM_FUNC_QUALIFIER vec<3, T, Q> projectNO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast(1)); tmp = model * tmp; tmp = proj * tmp; tmp /= tmp.w; tmp = tmp * static_cast(0.5) + static_cast(0.5); tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]); tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]); return vec<3, T, Q>(tmp); } template GLM_FUNC_QUALIFIER vec<3, T, Q> project(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return projectZO(obj, model, proj, viewport); # else return projectNO(obj, model, proj, viewport); # endif } template GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectZO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { mat<4, 4, T, Q> Inverse = inverse(proj * model); vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1)); tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]); tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]); tmp.x = tmp.x * static_cast(2) - static_cast(1); tmp.y = tmp.y * static_cast(2) - static_cast(1); vec<4, T, Q> obj = Inverse * tmp; obj /= obj.w; return vec<3, T, Q>(obj); } template GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectNO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { mat<4, 4, T, Q> Inverse = inverse(proj * model); vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1)); tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]); tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]); tmp = tmp * static_cast(2) - static_cast(1); vec<4, T, Q> obj = Inverse * tmp; obj /= obj.w; return vec<3, T, Q>(obj); } template GLM_FUNC_QUALIFIER vec<3, T, Q> unProject(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport) { # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE return unProjectZO(win, model, proj, viewport); # else return unProjectNO(win, model, proj, viewport); # endif } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> pickMatrix(vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport) { assert(delta.x > static_cast(0) && delta.y > static_cast(0)); mat<4, 4, T, Q> Result(static_cast(1)); if(!(delta.x > static_cast(0) && delta.y > static_cast(0))) return Result; // Error vec<3, T, Q> Temp( (static_cast(viewport[2]) - static_cast(2) * (center.x - static_cast(viewport[0]))) / delta.x, (static_cast(viewport[3]) - static_cast(2) * (center.y - static_cast(viewport[1]))) / delta.y, static_cast(0)); // Translate and scale the picked region to the entire window Result = translate(Result, Temp); return scale(Result, vec<3, T, Q>(static_cast(viewport[2]) / delta.x, static_cast(viewport[3]) / delta.y, static_cast(1))); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtRH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up) { vec<3, T, Q> const f(normalize(center - eye)); vec<3, T, Q> const s(normalize(cross(f, up))); vec<3, T, Q> const u(cross(s, f)); mat<4, 4, T, Q> Result(1); Result[0][0] = s.x; Result[1][0] = s.y; Result[2][0] = s.z; Result[0][1] = u.x; Result[1][1] = u.y; Result[2][1] = u.z; Result[0][2] =-f.x; Result[1][2] =-f.y; Result[2][2] =-f.z; Result[3][0] =-dot(s, eye); Result[3][1] =-dot(u, eye); Result[3][2] = dot(f, eye); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtLH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up) { vec<3, T, Q> const f(normalize(center - eye)); vec<3, T, Q> const s(normalize(cross(up, f))); vec<3, T, Q> const u(cross(f, s)); mat<4, 4, T, Q> Result(1); Result[0][0] = s.x; Result[1][0] = s.y; Result[2][0] = s.z; Result[0][1] = u.x; Result[1][1] = u.y; Result[2][1] = u.z; Result[0][2] = f.x; Result[1][2] = f.y; Result[2][2] = f.z; Result[3][0] = -dot(s, eye); Result[3][1] = -dot(u, eye); Result[3][2] = -dot(f, eye); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAt(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED return lookAtLH(eye, center, up); # else return lookAtRH(eye, center, up); # endif } }//namespace glm glm-0.9.9-a2/glm/gtc/reciprocal.hpp0000600000175000001440000000660213173131001015664 0ustar guususers/// @ref gtc_reciprocal /// @file glm/gtc/reciprocal.hpp /// /// @see core (dependence) /// /// @defgroup gtc_reciprocal GLM_GTC_reciprocal /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Define secant, cosecant and cotangent functions. #pragma once // Dependencies #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_reciprocal extension included") #endif namespace glm { /// @addtogroup gtc_reciprocal /// @{ /// Secant function. /// hypotenuse / adjacent or 1 / cos(x) /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType sec(genType angle); /// Cosecant function. /// hypotenuse / opposite or 1 / sin(x) /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType csc(genType angle); /// Cotangent function. /// adjacent / opposite or 1 / tan(x) /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType cot(genType angle); /// Inverse secant function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType asec(genType x); /// Inverse cosecant function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acsc(genType x); /// Inverse cotangent function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acot(genType x); /// Secant hyperbolic function. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType sech(genType angle); /// Cosecant hyperbolic function. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType csch(genType angle); /// Cotangent hyperbolic function. /// /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType coth(genType angle); /// Inverse secant hyperbolic function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType asech(genType x); /// Inverse cosecant hyperbolic function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acsch(genType x); /// Inverse cotangent hyperbolic function. /// /// @return Return an angle expressed in radians. /// @tparam genType Floating-point scalar or vector types. /// /// @see gtc_reciprocal template GLM_FUNC_DECL genType acoth(genType x); /// @} }//namespace glm #include "reciprocal.inl" glm-0.9.9-a2/glm/gtc/matrix_inverse.inl0000600000175000001440000001163613173131001016576 0ustar guususers/// @ref gtc_matrix_inverse /// @file glm/gtc/matrix_inverse.inl namespace glm { template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> affineInverse(mat<3, 3, T, Q> const& m) { mat<2, 2, T, Q> const Inv(inverse(mat<2, 2, T, Q>(m))); return mat<3, 3, T, Q>( vec<3, T, Q>(Inv[0], static_cast(0)), vec<3, T, Q>(Inv[1], static_cast(0)), vec<3, T, Q>(-Inv * vec<2, T, Q>(m[2]), static_cast(1))); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> affineInverse(mat<4, 4, T, Q> const& m) { mat<3, 3, T, Q> const Inv(inverse(mat<3, 3, T, Q>(m))); return mat<4, 4, T, Q>( vec<4, T, Q>(Inv[0], static_cast(0)), vec<4, T, Q>(Inv[1], static_cast(0)), vec<4, T, Q>(Inv[2], static_cast(0)), vec<4, T, Q>(-Inv * vec<3, T, Q>(m[3]), static_cast(1))); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> inverseTranspose(mat<2, 2, T, Q> const& m) { T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1]; mat<2, 2, T, Q> Inverse( + m[1][1] / Determinant, - m[0][1] / Determinant, - m[1][0] / Determinant, + m[0][0] / Determinant); return Inverse; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> inverseTranspose(mat<3, 3, T, Q> const& m) { T Determinant = + m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]); mat<3, 3, T, Q> Inverse; Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]); Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]); Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]); Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]); Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]); Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]); Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]); Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]); Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]); Inverse /= Determinant; return Inverse; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> inverseTranspose(mat<4, 4, T, Q> const& m) { T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; T SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; T SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; T SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; T SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; T SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; T SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; T SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; T SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; T SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; T SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; T SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; T SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; T SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; mat<4, 4, T, Q> Inverse; Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02); Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04); Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05); Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05); Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02); Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04); Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05); Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05); Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08); Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10); Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12); Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12); Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15); Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17); Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18); Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18); T Determinant = + m[0][0] * Inverse[0][0] + m[0][1] * Inverse[0][1] + m[0][2] * Inverse[0][2] + m[0][3] * Inverse[0][3]; Inverse /= Determinant; return Inverse; } }//namespace glm glm-0.9.9-a2/glm/gtc/ulp.inl0000600000175000001440000002044313173131001014333 0ustar guususers/// @ref gtc_ulp /// @file glm/gtc/ulp.inl /// /// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. /// /// Developed at SunPro, a Sun Microsystems, Inc. business. /// Permission to use, copy, modify, and distribute this /// software is freely granted, provided that this notice /// is preserved. #include "../detail/type_int.hpp" #include "epsilon.hpp" #include #include #include #if(GLM_COMPILER & GLM_COMPILER_VC) # pragma warning(push) # pragma warning(disable : 4127) #endif typedef union { float value; /* FIXME: Assumes 32 bit int. */ unsigned int word; } ieee_float_shape_type; typedef union { double value; struct { glm::detail::int32 lsw; glm::detail::int32 msw; } parts; } ieee_double_shape_type; #define GLM_EXTRACT_WORDS(ix0,ix1,d) \ do { \ ieee_double_shape_type ew_u; \ ew_u.value = (d); \ (ix0) = ew_u.parts.msw; \ (ix1) = ew_u.parts.lsw; \ } while (0) #define GLM_GET_FLOAT_WORD(i,d) \ do { \ ieee_float_shape_type gf_u; \ gf_u.value = (d); \ (i) = gf_u.word; \ } while (0) #define GLM_SET_FLOAT_WORD(d,i) \ do { \ ieee_float_shape_type sf_u; \ sf_u.word = (i); \ (d) = sf_u.value; \ } while (0) #define GLM_INSERT_WORDS(d,ix0,ix1) \ do { \ ieee_double_shape_type iw_u; \ iw_u.parts.msw = (ix0); \ iw_u.parts.lsw = (ix1); \ (d) = iw_u.value; \ } while (0) namespace glm{ namespace detail { GLM_FUNC_QUALIFIER float nextafterf(float x, float y) { volatile float t; glm::detail::int32 hx, hy, ix, iy; GLM_GET_FLOAT_WORD(hx, x); GLM_GET_FLOAT_WORD(hy, y); ix = hx&0x7fffffff; // |x| iy = hy&0x7fffffff; // |y| if((ix>0x7f800000) || // x is nan (iy>0x7f800000)) // y is nan return x+y; if(compute_equal::call(x, y)) return y; // x=y, return y if(ix==0) { // x == 0 GLM_SET_FLOAT_WORD(x,(hy&0x80000000)|1);// return +-minsubnormal t = x*x; if(detail::compute_equal::call(t, x)) return t; else return x; // raise underflow flag } if(hx>=0) { // x > 0 if(hx>hy) // x > y, x -= ulp hx -= 1; else // x < y, x += ulp hx += 1; } else { // x < 0 if(hy>=0||hx>hy) // x < y, x -= ulp hx -= 1; else // x > y, x += ulp hx += 1; } hy = hx&0x7f800000; if(hy>=0x7f800000) return x+x; // overflow if(hy<0x00800000) // underflow { t = x*x; if(!detail::compute_equal::call(t, x)) { // raise underflow flag GLM_SET_FLOAT_WORD(y,hx); return y; } } GLM_SET_FLOAT_WORD(x,hx); return x; } GLM_FUNC_QUALIFIER double nextafter(double x, double y) { volatile double t; glm::detail::int32 hx, hy, ix, iy; glm::detail::uint32 lx, ly; GLM_EXTRACT_WORDS(hx, lx, x); GLM_EXTRACT_WORDS(hy, ly, y); ix = hx & 0x7fffffff; // |x| iy = hy & 0x7fffffff; // |y| if(((ix>=0x7ff00000)&&((ix-0x7ff00000)|lx)!=0) || // x is nan ((iy>=0x7ff00000)&&((iy-0x7ff00000)|ly)!=0)) // y is nan return x+y; if(detail::compute_equal::call(x, y)) return y; // x=y, return y if((ix|lx)==0) { // x == 0 GLM_INSERT_WORDS(x, hy & 0x80000000, 1); // return +-minsubnormal t = x*x; if(detail::compute_equal::call(t, x)) return t; else return x; // raise underflow flag } if(hx>=0) { // x > 0 if(hx>hy||((hx==hy)&&(lx>ly))) { // x > y, x -= ulp if(lx==0) hx -= 1; lx -= 1; } else { // x < y, x += ulp lx += 1; if(lx==0) hx += 1; } } else { // x < 0 if(hy>=0||hx>hy||((hx==hy)&&(lx>ly))){// x < y, x -= ulp if(lx==0) hx -= 1; lx -= 1; } else { // x > y, x += ulp lx += 1; if(lx==0) hx += 1; } } hy = hx&0x7ff00000; if(hy>=0x7ff00000) return x+x; // overflow if(hy<0x00100000) { // underflow t = x*x; if(!detail::compute_equal::call(t, x)) { // raise underflow flag GLM_INSERT_WORDS(y,hx,lx); return y; } } GLM_INSERT_WORDS(x,hx,lx); return x; } }//namespace detail }//namespace glm #if(GLM_COMPILER & GLM_COMPILER_VC) # pragma warning(pop) #endif namespace glm { template<> GLM_FUNC_QUALIFIER float next_float(float const& x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::max()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafterf(x, FLT_MAX); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafterf(x, FLT_MAX); # else return nextafterf(x, FLT_MAX); # endif } template<> GLM_FUNC_QUALIFIER double next_float(double const& x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::max()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafter(x, std::numeric_limits::max()); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafter(x, FLT_MAX); # else return nextafter(x, DBL_MAX); # endif } template GLM_FUNC_QUALIFIER vec next_float(vec const& x) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = next_float(x[i]); return Result; } GLM_FUNC_QUALIFIER float prev_float(float const& x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::min()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return detail::nextafterf(x, FLT_MIN); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafterf(x, FLT_MIN); # else return nextafterf(x, FLT_MIN); # endif } GLM_FUNC_QUALIFIER double prev_float(double const& x) { # if GLM_HAS_CXX11_STL return std::nextafter(x, std::numeric_limits::min()); # elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))) return _nextafter(x, DBL_MIN); # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return __builtin_nextafter(x, DBL_MIN); # else return nextafter(x, DBL_MIN); # endif } template GLM_FUNC_QUALIFIER vec prev_float(vec const& x) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prev_float(x[i]); return Result; } template GLM_FUNC_QUALIFIER T next_float(T const& x, uint const& ulps) { T temp = x; for(uint i = 0; i < ulps; ++i) temp = next_float(temp); return temp; } template GLM_FUNC_QUALIFIER vec next_float(vec const& x, vec const& ulps) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = next_float(x[i], ulps[i]); return Result; } template GLM_FUNC_QUALIFIER T prev_float(T const& x, uint const& ulps) { T temp = x; for(uint i = 0; i < ulps; ++i) temp = prev_float(temp); return temp; } template GLM_FUNC_QUALIFIER vec prev_float(vec const& x, vec const& ulps) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prev_float(x[i], ulps[i]); return Result; } template GLM_FUNC_QUALIFIER uint float_distance(T const& x, T const& y) { uint ulp = 0; if(x < y) { T temp = x; while(glm::epsilonNotEqual(temp, y, glm::epsilon()))// && ulp < std::numeric_limits::max()) { ++ulp; temp = next_float(temp); } } else if(y < x) { T temp = y; while(glm::epsilonNotEqual(temp, x, glm::epsilon()))// && ulp < std::numeric_limits::max()) { ++ulp; temp = next_float(temp); } } else // == { } return ulp; } template GLM_FUNC_QUALIFIER vec float_distance(vec const& x, vec const& y) { vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = float_distance(x[i], y[i]); return Result; } }//namespace glm glm-0.9.9-a2/glm/gtc/type_precision.hpp0000600000175000001440000006002513173131001016574 0ustar guususers/// @ref gtc_type_precision /// @file glm/gtc/type_precision.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtc_type_precision GLM_GTC_type_precision /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines specific C++-based qualifier types. /// /// @ref core_precision defines types based on GLSL's qualifier qualifiers. This /// extension defines types based on explicitly-sized C++ data types. #pragma once // Dependency: #include "../gtc/quaternion.hpp" #include "../gtc/vec1.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../mat2x2.hpp" #include "../mat2x3.hpp" #include "../mat2x4.hpp" #include "../mat3x2.hpp" #include "../mat3x3.hpp" #include "../mat3x4.hpp" #include "../mat4x2.hpp" #include "../mat4x3.hpp" #include "../mat4x4.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_type_precision extension included") #endif namespace glm { /////////////////////////// // Signed int vector types /// @addtogroup gtc_type_precision /// @{ /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64; /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8_t; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16_t; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32_t; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64_t; /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_i8; /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_i16; /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_i32; /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_i64; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8_t; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16_t; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32_t; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64_t; /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_i8; /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_i16; /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_i32; /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_i64; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16; /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8_t; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16_t; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32_t; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64_t; /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_i8; /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_i16; /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_i32; /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_i64; /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 int8; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 int16; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 int32; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 int64; #if GLM_HAS_EXTENDED_INTEGER_TYPE using std::int8_t; using std::int16_t; using std::int32_t; using std::int64_t; #else /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 int8_t; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 int16_t; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 int32_t; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 int64_t; #endif /// 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 i8; /// 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 i16; /// 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 i32; /// 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 i64; /// 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, defaultp> i8vec1; /// 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, defaultp> i8vec2; /// 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, defaultp> i8vec3; /// 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, defaultp> i8vec4; /// 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, defaultp> i16vec1; /// 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, defaultp> i16vec2; /// 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, defaultp> i16vec3; /// 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, defaultp> i16vec4; /// 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, defaultp> i32vec1; /// 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, defaultp> i32vec2; /// 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, defaultp> i32vec3; /// 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, defaultp> i32vec4; /// 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, defaultp> i64vec1; /// 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, defaultp> i64vec2; /// 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, defaultp> i64vec3; /// 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, defaultp> i64vec4; ///////////////////////////// // Unsigned int vector types /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64; /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8_t; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16_t; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32_t; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64_t; /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_u8; /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_u16; /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_u32; /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_u64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8_t; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16_t; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32_t; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64_t; /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_u8; /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_u16; /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_u32; /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_u64; /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8; /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16; /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32; /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64; /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8_t; /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16_t; /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32_t; /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64_t; /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_u8; /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_u16; /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_u32; /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_u64; /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 uint8; /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 uint16; /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 uint32; /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 uint64; #if GLM_HAS_EXTENDED_INTEGER_TYPE using std::uint8_t; using std::uint16_t; using std::uint32_t; using std::uint64_t; #else /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 uint8_t; /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 uint16_t; /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 uint32_t; /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 uint64_t; #endif /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 u8; /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 u16; /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 u32; /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 u64; /// Default qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, defaultp> u8vec1; /// Default qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, defaultp> u8vec2; /// Default qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, defaultp> u8vec3; /// Default qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, defaultp> u8vec4; /// Default qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, defaultp> u16vec1; /// Default qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, defaultp> u16vec2; /// Default qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, defaultp> u16vec3; /// Default qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, defaultp> u16vec4; /// Default qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, defaultp> u32vec1; /// Default qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, defaultp> u32vec2; /// Default qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, defaultp> u32vec3; /// Default qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, defaultp> u32vec4; /// Default qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, defaultp> u64vec1; /// Default qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, defaultp> u64vec2; /// Default qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, defaultp> u64vec3; /// Default qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, defaultp> u64vec4; ////////////////////// // Float vector types /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 float32; /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 float32_t; /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 f32; # ifndef GLM_FORCE_SINGLE_ONLY /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 float64; /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 float64_t; /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 f64; # endif//GLM_FORCE_SINGLE_ONLY /// Single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, defaultp> fvec1; /// Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, defaultp> fvec2; /// Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, defaultp> fvec3; /// Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, defaultp> fvec4; /// Single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, defaultp> f32vec1; /// Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f32, defaultp> f32vec2; /// Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f32, defaultp> f32vec3; /// Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f32, defaultp> f32vec4; # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, defaultp> f64vec1; /// Double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, defaultp> f64vec2; /// Double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, defaultp> f64vec3; /// Double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, defaultp> f64vec4; # endif//GLM_FORCE_SINGLE_ONLY ////////////////////// // Float matrix types /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 fmat1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> fmat2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> fmat3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> fmat4; /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 fmat1x1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> fmat2x2; /// Single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, defaultp> fmat2x3; /// Single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, defaultp> fmat2x4; /// Single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, defaultp> fmat3x2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> fmat3x3; /// Single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, defaultp> fmat3x4; /// Single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, defaultp> fmat4x2; /// Single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, defaultp> fmat4x3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> fmat4x4; /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> f32mat2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> f32mat3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> f32mat4; /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 f32mat1x1; /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> f32mat2x2; /// Single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, defaultp> f32mat2x3; /// Single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, defaultp> f32mat2x4; /// Single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, defaultp> f32mat3x2; /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> f32mat3x3; /// Single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, defaultp> f32mat3x4; /// Single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, defaultp> f32mat4x2; /// Single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, defaultp> f32mat4x3; /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> f32mat4x4; # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f64mat1; /// Double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, defaultp> f64mat2; /// Double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, defaultp> f64mat3; /// Double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, defaultp> f64mat4; /// Double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 f64mat1x1; /// Double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, defaultp> f64mat2x2; /// Double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, defaultp> f64mat2x3; /// Double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, defaultp> f64mat2x4; /// Double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, defaultp> f64mat3x2; /// Double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, defaultp> f64mat3x3; /// Double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, defaultp> f64mat3x4; /// Double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, defaultp> f64mat4x2; /// Double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, defaultp> f64mat4x3; /// Double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, defaultp> f64mat4x4; # endif//GLM_FORCE_SINGLE_ONLY ////////////////////////// // Quaternion types /// Single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat f32quat; # ifndef GLM_FORCE_SINGLE_ONLY /// Double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat f64quat; # endif//GLM_FORCE_SINGLE_ONLY /// @} }//namespace glm #include "type_precision.inl" glm-0.9.9-a2/glm/gtc/epsilon.hpp0000600000175000001440000000336413173131001015214 0ustar guususers/// @ref gtc_epsilon /// @file glm/gtc/epsilon.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtc_epsilon GLM_GTC_epsilon /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Comparison functions for a user defined epsilon values. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_epsilon extension included") #endif namespace glm { /// @addtogroup gtc_epsilon /// @{ /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL vec epsilonEqual(vec const& x, vec const& y, T const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL bool epsilonEqual(genType const& x, genType const& y, genType const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is not satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. /// True if this expression is not satisfied. /// /// @see gtc_epsilon template GLM_FUNC_DECL bool epsilonNotEqual(genType const& x, genType const& y, genType const& epsilon); /// @} }//namespace glm #include "epsilon.inl" glm-0.9.9-a2/glm/gtc/packing.hpp0000600000175000001440000010642113173131001015155 0ustar guususers/// @ref gtc_packing /// @file glm/gtc/packing.hpp /// /// @see core (dependence) /// /// @defgroup gtc_packing GLM_GTC_packing /// @ingroup gtc /// /// Include to use the features of this extension. /// /// This extension provides a set of function to convert vertors to packed /// formats. #pragma once // Dependency: #include "type_precision.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_packing extension included") #endif namespace glm { /// @addtogroup gtc_packing /// @{ /// First, converts the normalized floating-point value v into a 8-bit integer value. /// Then, the results are packed into the returned 8-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm1x8: round(clamp(c, 0, +1) * 255.0) /// /// @see gtc_packing /// @see uint16 packUnorm2x8(vec2 const& v) /// @see uint32 packUnorm4x8(vec4 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint8 packUnorm1x8(float v); /// Convert a single 8-bit integer to a normalized floating-point value. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm4x8: f / 255.0 /// /// @see gtc_packing /// @see vec2 unpackUnorm2x8(uint16 p) /// @see vec4 unpackUnorm4x8(uint32 p) /// @see GLSL unpackUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackUnorm1x8(uint8 p); /// First, converts each component of the normalized floating-point value v into 8-bit integer values. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm2x8: round(clamp(c, 0, +1) * 255.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint8 packUnorm1x8(float const& v) /// @see uint32 packUnorm4x8(vec4 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const& v); /// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm4x8: f / 255.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackUnorm1x8(uint8 v) /// @see vec4 unpackUnorm4x8(uint32 p) /// @see GLSL unpackUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p); /// First, converts the normalized floating-point value v into 8-bit integer value. /// Then, the results are packed into the returned 8-bit unsigned integer. /// /// The conversion to fixed point is done as follows: /// packSnorm1x8: round(clamp(s, -1, +1) * 127.0) /// /// @see gtc_packing /// @see uint16 packSnorm2x8(vec2 const& v) /// @see uint32 packSnorm4x8(vec4 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint8 packSnorm1x8(float s); /// First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers. /// Then, the value is converted to a normalized floating-point value to generate the returned scalar. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm1x8: clamp(f / 127.0, -1, +1) /// /// @see gtc_packing /// @see vec2 unpackSnorm2x8(uint16 p) /// @see vec4 unpackSnorm4x8(uint32 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackSnorm1x8(uint8 p); /// First, converts each component of the normalized floating-point value v into 8-bit integer values. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm2x8: round(clamp(c, -1, +1) * 127.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint8 packSnorm1x8(float const& v) /// @see uint32 packSnorm4x8(vec4 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const& v); /// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm2x8: clamp(f / 127.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackSnorm1x8(uint8 p) /// @see vec4 unpackSnorm4x8(uint32 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p); /// First, converts the normalized floating-point value v into a 16-bit integer value. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm1x16: round(clamp(c, 0, +1) * 65535.0) /// /// @see gtc_packing /// @see uint16 packSnorm1x16(float const& v) /// @see uint64 packSnorm4x16(vec4 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packUnorm1x16(float v); /// First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers. /// Then, the value is converted to a normalized floating-point value to generate the returned scalar. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnorm1x16: f / 65535.0 /// /// @see gtc_packing /// @see vec2 unpackUnorm2x16(uint32 p) /// @see vec4 unpackUnorm4x16(uint64 p) /// @see GLSL unpackUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackUnorm1x16(uint16 p); /// First, converts each component of the normalized floating-point value v into 16-bit integer values. /// Then, the results are packed into the returned 64-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm4x16: round(clamp(c, 0, +1) * 65535.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint16 packUnorm1x16(float const& v) /// @see uint32 packUnorm2x16(vec2 const& v) /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const& v); /// First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackUnormx4x16: f / 65535.0 /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackUnorm1x16(uint16 p) /// @see vec2 unpackUnorm2x16(uint32 p) /// @see GLSL unpackUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p); /// First, converts the normalized floating-point value v into 16-bit integer value. /// Then, the results are packed into the returned 16-bit unsigned integer. /// /// The conversion to fixed point is done as follows: /// packSnorm1x8: round(clamp(s, -1, +1) * 32767.0) /// /// @see gtc_packing /// @see uint32 packSnorm2x16(vec2 const& v) /// @see uint64 packSnorm4x16(vec4 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packSnorm1x16(float v); /// First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned scalar. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm1x16: clamp(f / 32767.0, -1, +1) /// /// @see gtc_packing /// @see vec2 unpackSnorm2x16(uint32 p) /// @see vec4 unpackSnorm4x16(uint64 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackSnorm1x16(uint16 p); /// First, converts each component of the normalized floating-point value v into 16-bit integer values. /// Then, the results are packed into the returned 64-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm2x8: round(clamp(c, -1, +1) * 32767.0) /// /// The first component of the vector will be written to the least significant bits of the output; /// the last component will be written to the most significant bits. /// /// @see gtc_packing /// @see uint16 packSnorm1x16(float const& v) /// @see uint32 packSnorm2x16(vec2 const& v) /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const& v); /// First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm4x16: clamp(f / 32767.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see float unpackSnorm1x16(uint16 p) /// @see vec2 unpackSnorm2x16(uint32 p) /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p); /// Returns an unsigned integer obtained by converting the components of a floating-point scalar /// to the 16-bit floating-point representation found in the OpenGL Specification, /// and then packing this 16-bit value into a 16-bit unsigned integer. /// /// @see gtc_packing /// @see uint32 packHalf2x16(vec2 const& v) /// @see uint64 packHalf4x16(vec4 const& v) /// @see GLSL packHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint16 packHalf1x16(float v); /// Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value, /// interpreted as a 16-bit floating-point number according to the OpenGL Specification, /// and converting it to 32-bit floating-point values. /// /// @see gtc_packing /// @see vec2 unpackHalf2x16(uint32 const& v) /// @see vec4 unpackHalf4x16(uint64 const& v) /// @see GLSL unpackHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL float unpackHalf1x16(uint16 v); /// Returns an unsigned integer obtained by converting the components of a four-component floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification, /// and then packing these four 16-bit values into a 64-bit unsigned integer. /// The first vector component specifies the 16 least-significant bits of the result; /// the forth component specifies the 16 most-significant bits. /// /// @see gtc_packing /// @see uint16 packHalf1x16(float const& v) /// @see uint32 packHalf2x16(vec2 const& v) /// @see GLSL packHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL uint64 packHalf4x16(vec4 const& v); /// Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values, /// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, /// and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the forth component is obtained from the 16 most-significant bits of v. /// /// @see gtc_packing /// @see float unpackHalf1x16(uint16 const& v) /// @see vec2 unpackHalf2x16(uint32 const& v) /// @see GLSL unpackHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p); /// Returns an unsigned integer obtained by converting the components of a four-component signed integer vector /// to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification, /// and then packing these four values into a 32-bit unsigned integer. /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see uint32 packI3x10_1x2(uvec4 const& v) /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see ivec4 unpackI3x10_1x2(uint32 const& p) GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const& v); /// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see vec4 unpackSnorm3x10_1x2(uint32 const& p); /// @see uvec4 unpackI3x10_1x2(uint32 const& p); GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p); /// Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector /// to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification, /// and then packing these four values into a 32-bit unsigned integer. /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see uint32 packI3x10_1x2(ivec4 const& v) /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see ivec4 unpackU3x10_1x2(uint32 const& p) GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const& v); /// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see vec4 unpackSnorm3x10_1x2(uint32 const& p); /// @see uvec4 unpackI3x10_1x2(uint32 const& p); GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p); /// First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values. /// Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packSnorm3x10_1x2(xyz): round(clamp(c, -1, +1) * 511.0) /// packSnorm3x10_1x2(w): round(clamp(c, -1, +1) * 1.0) /// /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see vec4 unpackSnorm3x10_1x2(uint32 const& p) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see uint32 packI3x10_1x2(ivec4 const& v) GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const& v); /// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm3x10_1x2(xyz): clamp(f / 511.0, -1, +1) /// unpackSnorm3x10_1x2(w): clamp(f / 511.0, -1, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see vec4 unpackUnorm3x10_1x2(uint32 const& p)) /// @see uvec4 unpackI3x10_1x2(uint32 const& p) /// @see uvec4 unpackU3x10_1x2(uint32 const& p) GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p); /// First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values. /// Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The conversion for component c of v to fixed point is done as follows: /// packUnorm3x10_1x2(xyz): round(clamp(c, 0, +1) * 1023.0) /// packUnorm3x10_1x2(w): round(clamp(c, 0, +1) * 3.0) /// /// The first vector component specifies the 10 least-significant bits of the result; /// the forth component specifies the 2 most-significant bits. /// /// @see gtc_packing /// @see vec4 unpackUnorm3x10_1x2(uint32 const& p) /// @see uint32 packUnorm3x10_1x2(vec4 const& v) /// @see uint32 packU3x10_1x2(uvec4 const& v) /// @see uint32 packI3x10_1x2(ivec4 const& v) GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const& v); /// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector. /// /// The conversion for unpacked fixed-point value f to floating point is done as follows: /// unpackSnorm3x10_1x2(xyz): clamp(f / 1023.0, 0, +1) /// unpackSnorm3x10_1x2(w): clamp(f / 3.0, 0, +1) /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packSnorm3x10_1x2(vec4 const& v) /// @see vec4 unpackInorm3x10_1x2(uint32 const& p)) /// @see uvec4 unpackI3x10_1x2(uint32 const& p) /// @see uvec4 unpackU3x10_1x2(uint32 const& p) GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p); /// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values. /// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The first vector component specifies the 11 least-significant bits of the result; /// the last component specifies the 10 most-significant bits. /// /// @see gtc_packing /// @see vec3 unpackF2x11_1x10(uint32 const& p) GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const& v); /// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value . /// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// @see gtc_packing /// @see uint32 packF2x11_1x10(vec3 const& v) GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p); /// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values. /// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value. /// Then, the results are packed into the returned 32-bit unsigned integer. /// /// The first vector component specifies the 11 least-significant bits of the result; /// the last component specifies the 10 most-significant bits. /// /// packF3x9_E1x5 allows encoding into RGBE / RGB9E5 format /// /// @see gtc_packing /// @see vec3 unpackF3x9_E1x5(uint32 const& p) GLM_FUNC_DECL uint32 packF3x9_E1x5(vec3 const& v); /// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value . /// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector. /// /// The first component of the returned vector will be extracted from the least significant bits of the input; /// the last component will be extracted from the most significant bits. /// /// unpackF3x9_E1x5 allows decoding RGBE / RGB9E5 data /// /// @see gtc_packing /// @see uint32 packF3x9_E1x5(vec3 const& v) GLM_FUNC_DECL vec3 unpackF3x9_E1x5(uint32 p); /// Returns an unsigned integer vector obtained by converting the components of a floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification. /// The first vector component specifies the 16 least-significant bits of the result; /// the forth component specifies the 16 most-significant bits. /// /// @see gtc_packing /// @see vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& p) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec<4, T, Q> packRGBM(vec<3, T, Q> const& rgb); /// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the forth component is obtained from the 16 most-significant bits of v. /// /// @see gtc_packing /// @see vec<4, T, Q> packRGBM(vec<3, float, Q> const& v) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm); /// Returns an unsigned integer vector obtained by converting the components of a floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification. /// The first vector component specifies the 16 least-significant bits of the result; /// the forth component specifies the 16 most-significant bits. /// /// @see gtc_packing /// @see vec unpackHalf(vec const& p) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec packHalf(vec const& v); /// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the forth component is obtained from the 16 most-significant bits of v. /// /// @see gtc_packing /// @see vec packHalf(vec const& v) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template GLM_FUNC_DECL vec unpackHalf(vec const& p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec unpackUnorm(vec const& p); template GLM_FUNC_DECL vec packUnorm(vec const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see vec packUnorm(vec const& v) template GLM_FUNC_DECL vec unpackUnorm(vec const& v); /// Convert each component of the normalized floating-point vector into signed integer values. /// /// @see gtc_packing /// @see vec unpackSnorm(vec const& p); template GLM_FUNC_DECL vec packSnorm(vec const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see vec packSnorm(vec const& v) template GLM_FUNC_DECL vec unpackSnorm(vec const& v); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec2 unpackUnorm2x4(uint8 p) GLM_FUNC_DECL uint8 packUnorm2x4(vec2 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint8 packUnorm2x4(vec2 const& v) GLM_FUNC_DECL vec2 unpackUnorm2x4(uint8 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec4 unpackUnorm4x4(uint16 p) GLM_FUNC_DECL uint16 packUnorm4x4(vec4 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint16 packUnorm4x4(vec4 const& v) GLM_FUNC_DECL vec4 unpackUnorm4x4(uint16 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec3 unpackUnorm1x5_1x6_1x5(uint16 p) GLM_FUNC_DECL uint16 packUnorm1x5_1x6_1x5(vec3 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint16 packUnorm1x5_1x6_1x5(vec3 const& v) GLM_FUNC_DECL vec3 unpackUnorm1x5_1x6_1x5(uint16 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec4 unpackUnorm3x5_1x1(uint16 p) GLM_FUNC_DECL uint16 packUnorm3x5_1x1(vec4 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint16 packUnorm3x5_1x1(vec4 const& v) GLM_FUNC_DECL vec4 unpackUnorm3x5_1x1(uint16 p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing /// @see vec3 unpackUnorm2x3_1x2(uint8 p) GLM_FUNC_DECL uint8 packUnorm2x3_1x2(vec3 const& v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing /// @see uint8 packUnorm2x3_1x2(vec3 const& v) GLM_FUNC_DECL vec3 unpackUnorm2x3_1x2(uint8 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see i8vec2 unpackInt2x8(int16 p) GLM_FUNC_DECL int16 packInt2x8(i8vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int16 packInt2x8(i8vec2 const& v) GLM_FUNC_DECL i8vec2 unpackInt2x8(int16 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u8vec2 unpackInt2x8(uint16 p) GLM_FUNC_DECL uint16 packUint2x8(u8vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint16 packInt2x8(u8vec2 const& v) GLM_FUNC_DECL u8vec2 unpackUint2x8(uint16 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see i8vec4 unpackInt4x8(int32 p) GLM_FUNC_DECL int32 packInt4x8(i8vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int32 packInt2x8(i8vec4 const& v) GLM_FUNC_DECL i8vec4 unpackInt4x8(int32 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u8vec4 unpackUint4x8(uint32 p) GLM_FUNC_DECL uint32 packUint4x8(u8vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint32 packUint4x8(u8vec2 const& v) GLM_FUNC_DECL u8vec4 unpackUint4x8(uint32 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see i16vec2 unpackInt2x16(int p) GLM_FUNC_DECL int packInt2x16(i16vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int packInt2x16(i16vec2 const& v) GLM_FUNC_DECL i16vec2 unpackInt2x16(int p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see i16vec4 unpackInt4x16(int64 p) GLM_FUNC_DECL int64 packInt4x16(i16vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int64 packInt4x16(i16vec4 const& v) GLM_FUNC_DECL i16vec4 unpackInt4x16(int64 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u16vec2 unpackUint2x16(uint p) GLM_FUNC_DECL uint packUint2x16(u16vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint packUint2x16(u16vec2 const& v) GLM_FUNC_DECL u16vec2 unpackUint2x16(uint p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u16vec4 unpackUint4x16(uint64 p) GLM_FUNC_DECL uint64 packUint4x16(u16vec4 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see uint64 packUint4x16(u16vec4 const& v) GLM_FUNC_DECL u16vec4 unpackUint4x16(uint64 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see i32vec2 unpackInt2x32(int p) GLM_FUNC_DECL int64 packInt2x32(i32vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int packInt2x16(i32vec2 const& v) GLM_FUNC_DECL i32vec2 unpackInt2x32(int64 p); /// Convert each component from an integer vector into a packed unsigned integer. /// /// @see gtc_packing /// @see u32vec2 unpackUint2x32(int p) GLM_FUNC_DECL uint64 packUint2x32(u32vec2 const& v); /// Convert a packed integer into an integer vector. /// /// @see gtc_packing /// @see int packUint2x16(u32vec2 const& v) GLM_FUNC_DECL u32vec2 unpackUint2x32(uint64 p); /// @} }// namespace glm #include "packing.inl" glm-0.9.9-a2/glm/gtc/packing.inl0000600000175000001440000006037113173131001015153 0ustar guususers/// @ref gtc_packing /// @file glm/gtc/packing.inl #include "../common.hpp" #include "../vector_relational.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../detail/type_half.hpp" #include #include namespace glm{ namespace detail { GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x00007c00 => 00000000 00000000 01111100 00000000 // 0x000003ff => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((f >> 16) & 0x8000) | // sign ((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) | // exponential ((f >> 13) & 0x03ff); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 f) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x000007c0 => 00000000 00000000 00000111 11000000 // 0x00007c00 => 00000000 00000000 01111100 00000000 // 0x000003ff => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((f & 0x7f800000) - 0x38000000) >> 17) & 0x07c0) | // exponential ((f >> 17) & 0x003f); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 p) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x000007c0 => 00000000 00000000 00000111 11000000 // 0x00007c00 => 00000000 00000000 01111100 00000000 // 0x000003ff => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((p & 0x07c0) << 17) + 0x38000000) & 0x7f800000) | // exponential ((p & 0x003f) << 17); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 f) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x0000001F => 00000000 00000000 00000000 00011111 // 0x0000003F => 00000000 00000000 00000000 00111111 // 0x000003E0 => 00000000 00000000 00000011 11100000 // 0x000007C0 => 00000000 00000000 00000111 11000000 // 0x00007C00 => 00000000 00000000 01111100 00000000 // 0x000003FF => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((f & 0x7f800000) - 0x38000000) >> 18) & 0x03E0) | // exponential ((f >> 18) & 0x001f); // Mantissa } GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 p) { // 10 bits => EE EEEFFFFF // 11 bits => EEE EEFFFFFF // Half bits => SEEEEEFF FFFFFFFF // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF // 0x0000001F => 00000000 00000000 00000000 00011111 // 0x0000003F => 00000000 00000000 00000000 00111111 // 0x000003E0 => 00000000 00000000 00000011 11100000 // 0x000007C0 => 00000000 00000000 00000111 11000000 // 0x00007C00 => 00000000 00000000 01111100 00000000 // 0x000003FF => 00000000 00000000 00000011 11111111 // 0x38000000 => 00111000 00000000 00000000 00000000 // 0x7f800000 => 01111111 10000000 00000000 00000000 // 0x00008000 => 00000000 00000000 10000000 00000000 return ((((p & 0x03E0) << 18) + 0x38000000) & 0x7f800000) | // exponential ((p & 0x001f) << 18); // Mantissa } GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h) { return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13); } GLM_FUNC_QUALIFIER glm::uint floatTo11bit(float x) { if(x == 0.0f) return 0u; else if(glm::isnan(x)) return ~0u; else if(glm::isinf(x)) return 0x1Fu << 6u; uint Pack = 0u; memcpy(&Pack, &x, sizeof(Pack)); return float2packed11(Pack); } GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x) { if(x == 0) return 0.0f; else if(x == ((1 << 11) - 1)) return ~0;//NaN else if(x == (0x1f << 6)) return ~0;//Inf uint Result = packed11ToFloat(x); float Temp = 0; memcpy(&Temp, &Result, sizeof(Temp)); return Temp; } GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x) { if(x == 0.0f) return 0u; else if(glm::isnan(x)) return ~0u; else if(glm::isinf(x)) return 0x1Fu << 5u; uint Pack = 0; memcpy(&Pack, &x, sizeof(Pack)); return float2packed10(Pack); } GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x) { if(x == 0) return 0.0f; else if(x == ((1 << 10) - 1)) return ~0;//NaN else if(x == (0x1f << 5)) return ~0;//Inf uint Result = packed10ToFloat(x); float Temp = 0; memcpy(&Temp, &Result, sizeof(Temp)); return Temp; } // GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z) // { // return ((floatTo11bit(x) & ((1 << 11) - 1)) << 0) | ((floatTo11bit(y) & ((1 << 11) - 1)) << 11) | ((floatTo10bit(z) & ((1 << 10) - 1)) << 22); // } union u3u3u2 { struct { uint x : 3; uint y : 3; uint z : 2; } data; uint8 pack; }; union u4u4 { struct { uint x : 4; uint y : 4; } data; uint8 pack; }; union u4u4u4u4 { struct { uint x : 4; uint y : 4; uint z : 4; uint w : 4; } data; uint16 pack; }; union u5u6u5 { struct { uint x : 5; uint y : 6; uint z : 5; } data; uint16 pack; }; union u5u5u5u1 { struct { uint x : 5; uint y : 5; uint z : 5; uint w : 1; } data; uint16 pack; }; union u10u10u10u2 { struct { uint x : 10; uint y : 10; uint z : 10; uint w : 2; } data; uint32 pack; }; union i10i10i10i2 { struct { int x : 10; int y : 10; int z : 10; int w : 2; } data; uint32 pack; }; union u9u9u9e5 { struct { uint x : 9; uint y : 9; uint z : 9; uint w : 5; } data; uint32 pack; }; template struct compute_half {}; template struct compute_half<1, Q> { GLM_FUNC_QUALIFIER static vec<1, uint16, Q> pack(vec<1, float, Q> const& v) { int16 const Unpack(detail::toFloat16(v.x)); u16vec1 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<1, float, Q> unpack(vec<1, uint16, Q> const& v) { i16vec1 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<1, float, Q>(detail::toFloat32(v.x)); } }; template struct compute_half<2, Q> { GLM_FUNC_QUALIFIER static vec<2, uint16, Q> pack(vec<2, float, Q> const& v) { vec<2, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y)); u16vec2 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<2, float, Q> unpack(vec<2, uint16, Q> const& v) { i16vec2 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<2, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y)); } }; template struct compute_half<3, Q> { GLM_FUNC_QUALIFIER static vec<3, uint16, Q> pack(vec<3, float, Q> const& v) { vec<3, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z)); u16vec3 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<3, float, Q> unpack(vec<3, uint16, Q> const& v) { i16vec3 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<3, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z)); } }; template struct compute_half<4, Q> { GLM_FUNC_QUALIFIER static vec<4, uint16, Q> pack(vec<4, float, Q> const& v) { vec<4, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w)); u16vec4 Packed; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER static vec<4, float, Q> unpack(vec<4, uint16, Q> const& v) { i16vec4 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec<4, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w)); } }; }//namespace detail GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float v) { return static_cast(round(clamp(v, 0.0f, 1.0f) * 255.0f)); } GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 p) { float const Unpack(p); return Unpack * static_cast(0.0039215686274509803921568627451); // 1 / 255 } GLM_FUNC_QUALIFIER uint16 packUnorm2x8(vec2 const& v) { u8vec2 const Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f)); uint16 Unpack = 0; memcpy(&Unpack, &Topack, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 p) { u8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return vec2(Unpack) * float(0.0039215686274509803921568627451); // 1 / 255 } GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float v) { int8 const Topack(static_cast(round(clamp(v ,-1.0f, 1.0f) * 127.0f))); uint8 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 p) { int8 Unpack = 0; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( static_cast(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint16 packSnorm2x8(vec2 const& v) { i8vec2 const Topack(round(clamp(v, -1.0f, 1.0f) * 127.0f)); uint16 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 p) { i8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( vec2(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float s) { return static_cast(round(clamp(s, 0.0f, 1.0f) * 65535.0f)); } GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 p) { float const Unpack(p); return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 } GLM_FUNC_QUALIFIER uint64 packUnorm4x16(vec4 const& v) { u16vec4 const Topack(round(clamp(v , 0.0f, 1.0f) * 65535.0f)); uint64 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 p) { u16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return vec4(Unpack) * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 } GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float v) { int16 const Topack = static_cast(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); uint16 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 p) { int16 Unpack = 0; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( static_cast(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint64 packSnorm4x16(vec4 const& v) { i16vec4 const Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); uint64 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 p) { i16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return clamp( vec4(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint16 packHalf1x16(float v) { int16 const Topack(detail::toFloat16(v)); uint16 Packed = 0; memcpy(&Packed, &Topack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 v) { int16 Unpack = 0; memcpy(&Unpack, &v, sizeof(Unpack)); return detail::toFloat32(Unpack); } GLM_FUNC_QUALIFIER uint64 packHalf4x16(glm::vec4 const& v) { i16vec4 const Unpack( detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w)); uint64 Packed = 0; memcpy(&Packed, &Unpack, sizeof(Packed)); return Packed; } GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 v) { i16vec4 Unpack; memcpy(&Unpack, &v, sizeof(Unpack)); return vec4( detail::toFloat32(Unpack.x), detail::toFloat32(Unpack.y), detail::toFloat32(Unpack.z), detail::toFloat32(Unpack.w)); } GLM_FUNC_QUALIFIER uint32 packI3x10_1x2(ivec4 const& v) { detail::i10i10i10i2 Result; Result.data.x = v.x; Result.data.y = v.y; Result.data.z = v.z; Result.data.w = v.w; return Result.pack; } GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 v) { detail::i10i10i10i2 Unpack; Unpack.pack = v; return ivec4( Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); } GLM_FUNC_QUALIFIER uint32 packU3x10_1x2(uvec4 const& v) { detail::u10u10u10u2 Result; Result.data.x = v.x; Result.data.y = v.y; Result.data.z = v.z; Result.data.w = v.w; return Result.pack; } GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 v) { detail::u10u10u10u2 Unpack; Unpack.pack = v; return uvec4( Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); } GLM_FUNC_QUALIFIER uint32 packSnorm3x10_1x2(vec4 const& v) { ivec4 const Pack(round(clamp(v,-1.0f, 1.0f) * vec4(511.f, 511.f, 511.f, 1.f))); detail::i10i10i10i2 Result; Result.data.x = Pack.x; Result.data.y = Pack.y; Result.data.z = Pack.z; Result.data.w = Pack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 v) { detail::i10i10i10i2 Unpack; Unpack.pack = v; vec4 const Result(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w); return clamp(Result * vec4(1.f / 511.f, 1.f / 511.f, 1.f / 511.f, 1.f), -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint32 packUnorm3x10_1x2(vec4 const& v) { uvec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(1023.f, 1023.f, 1023.f, 3.f))); detail::u10u10u10u2 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; Result.data.w = Unpack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 v) { vec4 const ScaleFactors(1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 3.f); detail::u10u10u10u2 Unpack; Unpack.pack = v; return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactors; } GLM_FUNC_QUALIFIER uint32 packF2x11_1x10(vec3 const& v) { return ((detail::floatTo11bit(v.x) & ((1 << 11) - 1)) << 0) | ((detail::floatTo11bit(v.y) & ((1 << 11) - 1)) << 11) | ((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22); } GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 v) { return vec3( detail::packed11bitToFloat(v >> 0), detail::packed11bitToFloat(v >> 11), detail::packed10bitToFloat(v >> 22)); } GLM_FUNC_QUALIFIER uint32 packF3x9_E1x5(vec3 const& v) { float const SharedExpMax = (pow(2.0f, 9.0f - 1.0f) / pow(2.0f, 9.0f)) * pow(2.0f, 31.f - 15.f); vec3 const Color = clamp(v, 0.0f, SharedExpMax); float const MaxColor = max(Color.x, max(Color.y, Color.z)); float const ExpSharedP = max(-15.f - 1.f, floor(log2(MaxColor))) + 1.0f + 15.f; float const MaxShared = floor(MaxColor / pow(2.0f, (ExpSharedP - 15.f - 9.f)) + 0.5f); float const ExpShared = detail::compute_equal::call(MaxShared, pow(2.0f, 9.0f)) ? ExpSharedP + 1.0f : ExpSharedP; uvec3 const ColorComp(floor(Color / pow(2.f, (ExpShared - 15.f - 9.f)) + 0.5f)); detail::u9u9u9e5 Unpack; Unpack.data.x = ColorComp.x; Unpack.data.y = ColorComp.y; Unpack.data.z = ColorComp.z; Unpack.data.w = uint(ExpShared); return Unpack.pack; } GLM_FUNC_QUALIFIER vec3 unpackF3x9_E1x5(uint32 v) { detail::u9u9u9e5 Unpack; Unpack.pack = v; return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * pow(2.0f, Unpack.data.w - 15.f - 9.f); } // Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html template GLM_FUNC_QUALIFIER vec<4, T, Q> packRGBM(vec<3, T, Q> const& rgb) { vec<3, T, Q> const Color(rgb * static_cast(1.0 / 6.0)); T Alpha = clamp(max(max(Color.x, Color.y), max(Color.z, static_cast(1e-6))), static_cast(0), static_cast(1)); Alpha = ceil(Alpha * static_cast(255.0)) / static_cast(255.0); return vec<4, T, Q>(Color / Alpha, Alpha); } template GLM_FUNC_QUALIFIER vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm) { return vec<3, T, Q>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast(6); } template GLM_FUNC_QUALIFIER vec packHalf(vec const& v) { return detail::compute_half::pack(v); } template GLM_FUNC_QUALIFIER vec unpackHalf(vec const& v) { return detail::compute_half::unpack(v); } template GLM_FUNC_QUALIFIER vec packUnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(round(clamp(v, static_cast(0), static_cast(1)) * static_cast(std::numeric_limits::max()))); } template GLM_FUNC_QUALIFIER vec unpackUnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(v) * (static_cast(1) / static_cast(std::numeric_limits::max())); } template GLM_FUNC_QUALIFIER vec packSnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(round(clamp(v , static_cast(-1), static_cast(1)) * static_cast(std::numeric_limits::max()))); } template GLM_FUNC_QUALIFIER vec unpackSnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return clamp(vec(v) * (static_cast(1) / static_cast(std::numeric_limits::max())), static_cast(-1), static_cast(1)); } GLM_FUNC_QUALIFIER uint8 packUnorm2x4(vec2 const& v) { u32vec2 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f)); detail::u4u4 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; return Result.pack; } GLM_FUNC_QUALIFIER vec2 unpackUnorm2x4(uint8 v) { float const ScaleFactor(1.f / 15.f); detail::u4u4 Unpack; Unpack.pack = v; return vec2(Unpack.data.x, Unpack.data.y) * ScaleFactor; } GLM_FUNC_QUALIFIER uint16 packUnorm4x4(vec4 const& v) { u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f)); detail::u4u4u4u4 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; Result.data.w = Unpack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackUnorm4x4(uint16 v) { float const ScaleFactor(1.f / 15.f); detail::u4u4u4u4 Unpack; Unpack.pack = v; return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor; } GLM_FUNC_QUALIFIER uint16 packUnorm1x5_1x6_1x5(vec3 const& v) { u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(31.f, 63.f, 31.f))); detail::u5u6u5 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; return Result.pack; } GLM_FUNC_QUALIFIER vec3 unpackUnorm1x5_1x6_1x5(uint16 v) { vec3 const ScaleFactor(1.f / 31.f, 1.f / 63.f, 1.f / 31.f); detail::u5u6u5 Unpack; Unpack.pack = v; return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor; } GLM_FUNC_QUALIFIER uint16 packUnorm3x5_1x1(vec4 const& v) { u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(31.f, 31.f, 31.f, 1.f))); detail::u5u5u5u1 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; Result.data.w = Unpack.w; return Result.pack; } GLM_FUNC_QUALIFIER vec4 unpackUnorm3x5_1x1(uint16 v) { vec4 const ScaleFactor(1.f / 31.f, 1.f / 31.f, 1.f / 31.f, 1.f); detail::u5u5u5u1 Unpack; Unpack.pack = v; return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor; } GLM_FUNC_QUALIFIER uint8 packUnorm2x3_1x2(vec3 const& v) { u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(7.f, 7.f, 3.f))); detail::u3u3u2 Result; Result.data.x = Unpack.x; Result.data.y = Unpack.y; Result.data.z = Unpack.z; return Result.pack; } GLM_FUNC_QUALIFIER vec3 unpackUnorm2x3_1x2(uint8 v) { vec3 const ScaleFactor(1.f / 7.f, 1.f / 7.f, 1.f / 3.f); detail::u3u3u2 Unpack; Unpack.pack = v; return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor; } GLM_FUNC_QUALIFIER int16 packInt2x8(i8vec2 const& v) { int16 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i8vec2 unpackInt2x8(int16 p) { i8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint16 packUint2x8(u8vec2 const& v) { uint16 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u8vec2 unpackUint2x8(uint16 p) { u8vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int32 packInt4x8(i8vec4 const& v) { int32 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i8vec4 unpackInt4x8(int32 p) { i8vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint32 packUint4x8(u8vec4 const& v) { uint32 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u8vec4 unpackUint4x8(uint32 p) { u8vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int packInt2x16(i16vec2 const& v) { int Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i16vec2 unpackInt2x16(int p) { i16vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int64 packInt4x16(i16vec4 const& v) { int64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i16vec4 unpackInt4x16(int64 p) { i16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint packUint2x16(u16vec2 const& v) { uint Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u16vec2 unpackUint2x16(uint p) { u16vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint64 packUint4x16(u16vec4 const& v) { uint64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u16vec4 unpackUint4x16(uint64 p) { u16vec4 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER int64 packInt2x32(i32vec2 const& v) { int64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER i32vec2 unpackInt2x32(int64 p) { i32vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } GLM_FUNC_QUALIFIER uint64 packUint2x32(u32vec2 const& v) { uint64 Pack = 0; memcpy(&Pack, &v, sizeof(Pack)); return Pack; } GLM_FUNC_QUALIFIER u32vec2 unpackUint2x32(uint64 p) { u32vec2 Unpack; memcpy(&Unpack, &p, sizeof(Unpack)); return Unpack; } }//namespace glm glm-0.9.9-a2/glm/gtc/integer.hpp0000600000175000001440000000401313173131001015170 0ustar guususers/// @ref gtc_integer /// @file glm/gtc/integer.hpp /// /// @see core (dependence) /// @see gtc_integer (dependence) /// /// @defgroup gtc_integer GLM_GTC_integer /// @ingroup gtc /// /// Include to use the features of this extension. /// /// @brief Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../common.hpp" #include "../integer.hpp" #include "../exponential.hpp" #include #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_integer extension included") #endif namespace glm { /// @addtogroup gtc_integer /// @{ /// Returns the log2 of x for integer values. Can be reliably using to compute mipmap count from the texture size. /// @see gtc_integer template GLM_FUNC_DECL genIUType log2(genIUType x); /// Returns a value equal to the nearest integer to x. /// The fraction 0.5 will round in a direction chosen by the /// implementation, presumably the direction that is fastest. /// /// @param x The values of the argument must be greater or equal to zero. /// @tparam T floating point scalar types. /// /// @see GLSL round man page /// @see gtc_integer template GLM_FUNC_DECL vec iround(vec const& x); /// Returns a value equal to the nearest integer to x. /// The fraction 0.5 will round in a direction chosen by the /// implementation, presumably the direction that is fastest. /// /// @param x The values of the argument must be greater or equal to zero. /// @tparam T floating point scalar types. /// /// @see GLSL round man page /// @see gtc_integer template GLM_FUNC_DECL vec uround(vec const& x); /// @} } //namespace glm #include "integer.inl" glm-0.9.9-a2/glm/gtc/round.hpp0000600000175000001440000001526513173131001014675 0ustar guususers/// @ref gtc_round /// @file glm/gtc/round.hpp /// /// @see core (dependence) /// @see gtc_round (dependence) /// /// @defgroup gtc_round GLM_GTC_round /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Rounding value to specific boundings #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/_vectorize.hpp" #include "../vector_relational.hpp" #include "../common.hpp" #include #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_integer extension included") #endif namespace glm { /// @addtogroup gtc_round /// @{ /// Return true if the value is a power of two number. /// /// @see gtc_round template GLM_FUNC_DECL bool isPowerOfTwo(genIUType v); /// Return true if the value is a power of two number. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec isPowerOfTwo(vec const& v); /// Return the power of two number which value is just higher the input value, /// round up to a power of two. /// /// @see gtc_round template GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType v); /// Return the power of two number which value is just higher the input value, /// round up to a power of two. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec ceilPowerOfTwo(vec const& v); /// Return the power of two number which value is just lower the input value, /// round down to a power of two. /// /// @see gtc_round template GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType v); /// Return the power of two number which value is just lower the input value, /// round down to a power of two. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec floorPowerOfTwo(vec const& v); /// Return the power of two number which value is the closet to the input value. /// /// @see gtc_round template GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType v); /// Return the power of two number which value is the closet to the input value. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec roundPowerOfTwo(vec const& v); /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @see gtc_round template GLM_FUNC_DECL bool isMultiple(genIUType v, genIUType Multiple); /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec isMultiple(vec const& v, T Multiple); /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_round template GLM_FUNC_DECL vec isMultiple(vec const& v, vec const& Multiple); /// Higher multiple number of Source. /// /// @tparam genType Floating-point or integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL genType ceilMultiple(genType v, genType Multiple); /// Higher multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL vec ceilMultiple(vec const& v, vec const& Multiple); /// Lower multiple number of Source. /// /// @tparam genType Floating-point or integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL genType floorMultiple(genType v, genType Multiple); /// Lower multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL vec floorMultiple(vec const& v, vec const& Multiple); /// Lower multiple number of Source. /// /// @tparam genType Floating-point or integer scalar or vector types. /// /// @param v Source value to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL genType roundMultiple(genType v, genType Multiple); /// Lower multiple number of Source. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @param v Source values to which is applied the function /// @param Multiple Must be a null or positive value /// /// @see gtc_round template GLM_FUNC_DECL vec roundMultiple(vec const& v, vec const& Multiple); /// @} } //namespace glm #include "round.inl" glm-0.9.9-a2/glm/gtc/epsilon.inl0000600000175000001440000000436613173131001015212 0ustar guususers/// @ref gtc_epsilon /// @file glm/gtc/epsilon.inl // Dependency: #include "quaternion.hpp" #include "../vector_relational.hpp" #include "../common.hpp" #include "../detail/type_vec.hpp" namespace glm { template<> GLM_FUNC_QUALIFIER bool epsilonEqual ( float const& x, float const& y, float const& epsilon ) { return abs(x - y) < epsilon; } template<> GLM_FUNC_QUALIFIER bool epsilonEqual ( double const& x, double const& y, double const& epsilon ) { return abs(x - y) < epsilon; } template GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, T const& epsilon) { return lessThan(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, vec const& epsilon) { return lessThan(abs(x - y), vec(epsilon)); } template<> GLM_FUNC_QUALIFIER bool epsilonNotEqual(float const& x, float const& y, float const& epsilon) { return abs(x - y) >= epsilon; } template<> GLM_FUNC_QUALIFIER bool epsilonNotEqual(double const& x, double const& y, double const& epsilon) { return abs(x - y) >= epsilon; } template GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon) { return greaterThanEqual(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, vec const& epsilon) { return greaterThanEqual(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonEqual(tquat const& x, tquat const& y, T const& epsilon) { vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); return lessThan(abs(v), vec<4, T, Q>(epsilon)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonNotEqual(tquat const& x, tquat const& y, T const& epsilon) { vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon)); } }//namespace glm glm-0.9.9-a2/glm/gtc/type_aligned.hpp0000600000175000001440000006643713173131001016221 0ustar guususers/// @ref gtc_type_aligned /// @file glm/gtc/type_aligned.hpp /// /// @see core (dependence) /// /// @defgroup gtc_type_aligned GLM_GTC_type_aligned /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Aligned types allowing SIMD optimizations of vectors and matrices types #pragma once #if !GLM_HAS_ALIGNED_TYPE # error "GLM: Aligned types are not supported on this platform" #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_type_aligned extension included") #endif #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../gtc/vec1.hpp" namespace glm { /// @addtogroup gtc_type_aligned /// @{ // -- *vec1 -- /// 1 component vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, float, aligned_highp> aligned_highp_vec1; /// 1 component vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, float, aligned_mediump> aligned_mediump_vec1; /// 1 component vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, float, aligned_lowp> aligned_lowp_vec1; /// 1 component vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, double, aligned_highp> aligned_highp_dvec1; /// 1 component vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, double, aligned_mediump> aligned_mediump_dvec1; /// 1 component vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, double, aligned_lowp> aligned_lowp_dvec1; /// 1 component vector aligned in memory of signed integer numbers. typedef vec<1, int, aligned_highp> aligned_highp_ivec1; /// 1 component vector aligned in memory of signed integer numbers. typedef vec<1, int, aligned_mediump> aligned_mediump_ivec1; /// 1 component vector aligned in memory of signed integer numbers. typedef vec<1, int, aligned_lowp> aligned_lowp_ivec1; /// 1 component vector aligned in memory of unsigned integer numbers. typedef vec<1, uint, aligned_highp> aligned_highp_uvec1; /// 1 component vector aligned in memory of unsigned integer numbers. typedef vec<1, uint, aligned_mediump> aligned_mediump_uvec1; /// 1 component vector aligned in memory of unsigned integer numbers. typedef vec<1, uint, aligned_lowp> aligned_lowp_uvec1; /// 1 component vector aligned in memory of bool values. typedef vec<1, bool, aligned_highp> aligned_highp_bvec1; /// 1 component vector aligned in memory of bool values. typedef vec<1, bool, aligned_mediump> aligned_mediump_bvec1; /// 1 component vector aligned in memory of bool values. typedef vec<1, bool, aligned_lowp> aligned_lowp_bvec1; /// 1 component vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, float, packed_highp> packed_highp_vec1; /// 1 component vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, float, packed_mediump> packed_mediump_vec1; /// 1 component vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, float, packed_lowp> packed_lowp_vec1; /// 1 component vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<1, double, packed_highp> packed_highp_dvec1; /// 1 component vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<1, double, packed_mediump> packed_mediump_dvec1; /// 1 component vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<1, double, packed_lowp> packed_lowp_dvec1; /// 1 component vector tightly packed in memory of signed integer numbers. typedef vec<1, int, packed_highp> packed_highp_ivec1; /// 1 component vector tightly packed in memory of signed integer numbers. typedef vec<1, int, packed_mediump> packed_mediump_ivec1; /// 1 component vector tightly packed in memory of signed integer numbers. typedef vec<1, int, packed_lowp> packed_lowp_ivec1; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef vec<1, uint, packed_highp> packed_highp_uvec1; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef vec<1, uint, packed_mediump> packed_mediump_uvec1; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef vec<1, uint, packed_lowp> packed_lowp_uvec1; /// 1 component vector tightly packed in memory of bool values. typedef vec<1, bool, packed_highp> packed_highp_bvec1; /// 1 component vector tightly packed in memory of bool values. typedef vec<1, bool, packed_mediump> packed_mediump_bvec1; /// 1 component vector tightly packed in memory of bool values. typedef vec<1, bool, packed_lowp> packed_lowp_bvec1; // -- *vec2 -- /// 2 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, float, aligned_highp> aligned_highp_vec2; /// 2 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, float, aligned_mediump> aligned_mediump_vec2; /// 2 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, float, aligned_lowp> aligned_lowp_vec2; /// 2 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, double, aligned_highp> aligned_highp_dvec2; /// 2 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, double, aligned_mediump> aligned_mediump_dvec2; /// 2 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, double, aligned_lowp> aligned_lowp_dvec2; /// 2 components vector aligned in memory of signed integer numbers. typedef vec<2, int, aligned_highp> aligned_highp_ivec2; /// 2 components vector aligned in memory of signed integer numbers. typedef vec<2, int, aligned_mediump> aligned_mediump_ivec2; /// 2 components vector aligned in memory of signed integer numbers. typedef vec<2, int, aligned_lowp> aligned_lowp_ivec2; /// 2 components vector aligned in memory of unsigned integer numbers. typedef vec<2, uint, aligned_highp> aligned_highp_uvec2; /// 2 components vector aligned in memory of unsigned integer numbers. typedef vec<2, uint, aligned_mediump> aligned_mediump_uvec2; /// 2 components vector aligned in memory of unsigned integer numbers. typedef vec<2, uint, aligned_lowp> aligned_lowp_uvec2; /// 2 components vector aligned in memory of bool values. typedef vec<2, bool, aligned_highp> aligned_highp_bvec2; /// 2 components vector aligned in memory of bool values. typedef vec<2, bool, aligned_mediump> aligned_mediump_bvec2; /// 2 components vector aligned in memory of bool values. typedef vec<2, bool, aligned_lowp> aligned_lowp_bvec2; /// 2 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, float, packed_highp> packed_highp_vec2; /// 2 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, float, packed_mediump> packed_mediump_vec2; /// 2 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, float, packed_lowp> packed_lowp_vec2; /// 2 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<2, double, packed_highp> packed_highp_dvec2; /// 2 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<2, double, packed_mediump> packed_mediump_dvec2; /// 2 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<2, double, packed_lowp> packed_lowp_dvec2; /// 2 components vector tightly packed in memory of signed integer numbers. typedef vec<2, int, packed_highp> packed_highp_ivec2; /// 2 components vector tightly packed in memory of signed integer numbers. typedef vec<2, int, packed_mediump> packed_mediump_ivec2; /// 2 components vector tightly packed in memory of signed integer numbers. typedef vec<2, int, packed_lowp> packed_lowp_ivec2; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef vec<2, uint, packed_highp> packed_highp_uvec2; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef vec<2, uint, packed_mediump> packed_mediump_uvec2; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef vec<2, uint, packed_lowp> packed_lowp_uvec2; /// 2 components vector tightly packed in memory of bool values. typedef vec<2, bool, packed_highp> packed_highp_bvec2; /// 2 components vector tightly packed in memory of bool values. typedef vec<2, bool, packed_mediump> packed_mediump_bvec2; /// 2 components vector tightly packed in memory of bool values. typedef vec<2, bool, packed_lowp> packed_lowp_bvec2; // -- *vec3 -- /// 3 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, float, aligned_highp> aligned_highp_vec3; /// 3 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, float, aligned_mediump> aligned_mediump_vec3; /// 3 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, float, aligned_lowp> aligned_lowp_vec3; /// 3 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, double, aligned_highp> aligned_highp_dvec3; /// 3 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, double, aligned_mediump> aligned_mediump_dvec3; /// 3 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, double, aligned_lowp> aligned_lowp_dvec3; /// 3 components vector aligned in memory of signed integer numbers. typedef vec<3, int, aligned_highp> aligned_highp_ivec3; /// 3 components vector aligned in memory of signed integer numbers. typedef vec<3, int, aligned_mediump> aligned_mediump_ivec3; /// 3 components vector aligned in memory of signed integer numbers. typedef vec<3, int, aligned_lowp> aligned_lowp_ivec3; /// 3 components vector aligned in memory of unsigned integer numbers. typedef vec<3, uint, aligned_highp> aligned_highp_uvec3; /// 3 components vector aligned in memory of unsigned integer numbers. typedef vec<3, uint, aligned_mediump> aligned_mediump_uvec3; /// 3 components vector aligned in memory of unsigned integer numbers. typedef vec<3, uint, aligned_lowp> aligned_lowp_uvec3; /// 3 components vector aligned in memory of bool values. typedef vec<3, bool, aligned_highp> aligned_highp_bvec3; /// 3 components vector aligned in memory of bool values. typedef vec<3, bool, aligned_mediump> aligned_mediump_bvec3; /// 3 components vector aligned in memory of bool values. typedef vec<3, bool, aligned_lowp> aligned_lowp_bvec3; /// 3 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, float, packed_highp> packed_highp_vec3; /// 3 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, float, packed_mediump> packed_mediump_vec3; /// 3 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, float, packed_lowp> packed_lowp_vec3; /// 3 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<3, double, packed_highp> packed_highp_dvec3; /// 3 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<3, double, packed_mediump> packed_mediump_dvec3; /// 3 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<3, double, packed_lowp> packed_lowp_dvec3; /// 3 components vector tightly packed in memory of signed integer numbers. typedef vec<3, int, packed_highp> packed_highp_ivec3; /// 3 components vector tightly packed in memory of signed integer numbers. typedef vec<3, int, packed_mediump> packed_mediump_ivec3; /// 3 components vector tightly packed in memory of signed integer numbers. typedef vec<3, int, packed_lowp> packed_lowp_ivec3; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef vec<3, uint, packed_highp> packed_highp_uvec3; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef vec<3, uint, packed_mediump> packed_mediump_uvec3; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef vec<3, uint, packed_lowp> packed_lowp_uvec3; /// 3 components vector tightly packed in memory of bool values. typedef vec<3, bool, packed_highp> packed_highp_bvec3; /// 3 components vector tightly packed in memory of bool values. typedef vec<3, bool, packed_mediump> packed_mediump_bvec3; /// 3 components vector tightly packed in memory of bool values. typedef vec<3, bool, packed_lowp> packed_lowp_bvec3; // -- *vec4 -- /// 4 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, float, aligned_highp> aligned_highp_vec4; /// 4 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, float, aligned_mediump> aligned_mediump_vec4; /// 4 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, float, aligned_lowp> aligned_lowp_vec4; /// 4 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, double, aligned_highp> aligned_highp_dvec4; /// 4 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, double, aligned_mediump> aligned_mediump_dvec4; /// 4 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, double, aligned_lowp> aligned_lowp_dvec4; /// 4 components vector aligned in memory of signed integer numbers. typedef vec<4, int, aligned_highp> aligned_highp_ivec4; /// 4 components vector aligned in memory of signed integer numbers. typedef vec<4, int, aligned_mediump> aligned_mediump_ivec4; /// 4 components vector aligned in memory of signed integer numbers. typedef vec<4, int, aligned_lowp> aligned_lowp_ivec4; /// 4 components vector aligned in memory of unsigned integer numbers. typedef vec<4, uint, aligned_highp> aligned_highp_uvec4; /// 4 components vector aligned in memory of unsigned integer numbers. typedef vec<4, uint, aligned_mediump> aligned_mediump_uvec4; /// 4 components vector aligned in memory of unsigned integer numbers. typedef vec<4, uint, aligned_lowp> aligned_lowp_uvec4; /// 4 components vector aligned in memory of bool values. typedef vec<4, bool, aligned_highp> aligned_highp_bvec4; /// 4 components vector aligned in memory of bool values. typedef vec<4, bool, aligned_mediump> aligned_mediump_bvec4; /// 4 components vector aligned in memory of bool values. typedef vec<4, bool, aligned_lowp> aligned_lowp_bvec4; /// 4 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, float, packed_highp> packed_highp_vec4; /// 4 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, float, packed_mediump> packed_mediump_vec4; /// 4 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, float, packed_lowp> packed_lowp_vec4; /// 4 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs. typedef vec<4, double, packed_highp> packed_highp_dvec4; /// 4 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. typedef vec<4, double, packed_mediump> packed_mediump_dvec4; /// 4 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs. typedef vec<4, double, packed_lowp> packed_lowp_dvec4; /// 4 components vector tightly packed in memory of signed integer numbers. typedef vec<4, int, packed_highp> packed_highp_ivec4; /// 4 components vector tightly packed in memory of signed integer numbers. typedef vec<4, int, packed_mediump> packed_mediump_ivec4; /// 4 components vector tightly packed in memory of signed integer numbers. typedef vec<4, int, packed_lowp> packed_lowp_ivec4; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef vec<4, uint, packed_highp> packed_highp_uvec4; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef vec<4, uint, packed_mediump> packed_mediump_uvec4; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef vec<4, uint, packed_lowp> packed_lowp_uvec4; /// 4 components vector tightly packed in memory of bool values. typedef vec<4, bool, packed_highp> packed_highp_bvec4; /// 4 components vector tightly packed in memory of bool values. typedef vec<4, bool, packed_mediump> packed_mediump_bvec4; /// 4 components vector tightly packed in memory of bool values. typedef vec<4, bool, packed_lowp> packed_lowp_bvec4; // -- default -- #if(defined(GLM_PRECISION_LOWP_FLOAT)) typedef aligned_lowp_vec1 aligned_vec1; typedef aligned_lowp_vec2 aligned_vec2; typedef aligned_lowp_vec3 aligned_vec3; typedef aligned_lowp_vec4 aligned_vec4; typedef packed_lowp_vec1 packed_vec1; typedef packed_lowp_vec2 packed_vec2; typedef packed_lowp_vec3 packed_vec3; typedef packed_lowp_vec4 packed_vec4; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) typedef aligned_mediump_vec1 aligned_vec1; typedef aligned_mediump_vec2 aligned_vec2; typedef aligned_mediump_vec3 aligned_vec3; typedef aligned_mediump_vec4 aligned_vec4; typedef packed_mediump_vec1 packed_vec1; typedef packed_mediump_vec2 packed_vec2; typedef packed_mediump_vec3 packed_vec3; typedef packed_mediump_vec4 packed_vec4; #else //defined(GLM_PRECISION_HIGHP_FLOAT) /// 1 component vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec1 aligned_vec1; /// 2 components vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec2 aligned_vec2; /// 3 components vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec3 aligned_vec3; /// 4 components vector aligned in memory of single-precision floating-point numbers. typedef aligned_highp_vec4 aligned_vec4; /// 1 component vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec1 packed_vec1; /// 2 components vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec2 packed_vec2; /// 3 components vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec3 packed_vec3; /// 4 components vector tightly packed in memory of single-precision floating-point numbers. typedef packed_highp_vec4 packed_vec4; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_LOWP_DOUBLE)) typedef aligned_lowp_dvec1 aligned_dvec1; typedef aligned_lowp_dvec2 aligned_dvec2; typedef aligned_lowp_dvec3 aligned_dvec3; typedef aligned_lowp_dvec4 aligned_dvec4; typedef packed_lowp_dvec1 packed_dvec1; typedef packed_lowp_dvec2 packed_dvec2; typedef packed_lowp_dvec3 packed_dvec3; typedef packed_lowp_dvec4 packed_dvec4; #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE)) typedef aligned_mediump_dvec1 aligned_dvec1; typedef aligned_mediump_dvec2 aligned_dvec2; typedef aligned_mediump_dvec3 aligned_dvec3; typedef aligned_mediump_dvec4 aligned_dvec4; typedef packed_mediump_dvec1 packed_dvec1; typedef packed_mediump_dvec2 packed_dvec2; typedef packed_mediump_dvec3 packed_dvec3; typedef packed_mediump_dvec4 packed_dvec4; #else //defined(GLM_PRECISION_HIGHP_DOUBLE) /// 1 component vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec1 aligned_dvec1; /// 2 components vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec2 aligned_dvec2; /// 3 components vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec3 aligned_dvec3; /// 4 components vector aligned in memory of double-precision floating-point numbers. typedef aligned_highp_dvec4 aligned_dvec4; /// 1 component vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec1 packed_dvec1; /// 2 components vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec2 packed_dvec2; /// 3 components vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec3 packed_dvec3; /// 4 components vector tightly packed in memory of double-precision floating-point numbers. typedef packed_highp_dvec4 packed_dvec4; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_LOWP_INT)) typedef aligned_lowp_ivec1 aligned_ivec1; typedef aligned_lowp_ivec2 aligned_ivec2; typedef aligned_lowp_ivec3 aligned_ivec3; typedef aligned_lowp_ivec4 aligned_ivec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef aligned_mediump_ivec1 aligned_ivec1; typedef aligned_mediump_ivec2 aligned_ivec2; typedef aligned_mediump_ivec3 aligned_ivec3; typedef aligned_mediump_ivec4 aligned_ivec4; #else //defined(GLM_PRECISION_HIGHP_INT) /// 1 component vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec1 aligned_ivec1; /// 2 components vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec2 aligned_ivec2; /// 3 components vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec3 aligned_ivec3; /// 4 components vector aligned in memory of signed integer numbers. typedef aligned_highp_ivec4 aligned_ivec4; /// 1 component vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec1 packed_ivec1; /// 2 components vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec2 packed_ivec2; /// 3 components vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec3 packed_ivec3; /// 4 components vector tightly packed in memory of signed integer numbers. typedef packed_highp_ivec4 packed_ivec4; #endif//GLM_PRECISION // -- Unsigned integer definition -- #if(defined(GLM_PRECISION_LOWP_UINT)) typedef aligned_lowp_uvec1 aligned_uvec1; typedef aligned_lowp_uvec2 aligned_uvec2; typedef aligned_lowp_uvec3 aligned_uvec3; typedef aligned_lowp_uvec4 aligned_uvec4; #elif(defined(GLM_PRECISION_MEDIUMP_UINT)) typedef aligned_mediump_uvec1 aligned_uvec1; typedef aligned_mediump_uvec2 aligned_uvec2; typedef aligned_mediump_uvec3 aligned_uvec3; typedef aligned_mediump_uvec4 aligned_uvec4; #else //defined(GLM_PRECISION_HIGHP_UINT) /// 1 component vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec1 aligned_uvec1; /// 2 components vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec2 aligned_uvec2; /// 3 components vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec3 aligned_uvec3; /// 4 components vector aligned in memory of unsigned integer numbers. typedef aligned_highp_uvec4 aligned_uvec4; /// 1 component vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec1 packed_uvec1; /// 2 components vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec2 packed_uvec2; /// 3 components vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec3 packed_uvec3; /// 4 components vector tightly packed in memory of unsigned integer numbers. typedef packed_highp_uvec4 packed_uvec4; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_LOWP_BOOL)) typedef aligned_lowp_bvec1 aligned_bvec1; typedef aligned_lowp_bvec2 aligned_bvec2; typedef aligned_lowp_bvec3 aligned_bvec3; typedef aligned_lowp_bvec4 aligned_bvec4; #elif(defined(GLM_PRECISION_MEDIUMP_BOOL)) typedef aligned_mediump_bvec1 aligned_bvec1; typedef aligned_mediump_bvec2 aligned_bvec2; typedef aligned_mediump_bvec3 aligned_bvec3; typedef aligned_mediump_bvec4 aligned_bvec4; #else //defined(GLM_PRECISION_HIGHP_BOOL) /// 1 component vector aligned in memory of bool values. typedef aligned_highp_bvec1 aligned_bvec1; /// 2 components vector aligned in memory of bool values. typedef aligned_highp_bvec2 aligned_bvec2; /// 3 components vector aligned in memory of bool values. typedef aligned_highp_bvec3 aligned_bvec3; /// 4 components vector aligned in memory of bool values. typedef aligned_highp_bvec4 aligned_bvec4; /// 1 components vector tightly packed in memory of bool values. typedef packed_highp_bvec1 packed_bvec1; /// 2 components vector tightly packed in memory of bool values. typedef packed_highp_bvec2 packed_bvec2; /// 3 components vector tightly packed in memory of bool values. typedef packed_highp_bvec3 packed_bvec3; /// 4 components vector tightly packed in memory of bool values. typedef packed_highp_bvec4 packed_bvec4; #endif//GLM_PRECISION /// @} }//namespace glm glm-0.9.9-a2/glm/gtc/integer.inl0000600000175000001440000000437413173131001015175 0ustar guususers/// @ref gtc_integer /// @file glm/gtc/integer.inl namespace glm{ namespace detail { template struct compute_log2 { GLM_FUNC_QUALIFIER static vec call(vec const& v) { //Equivalent to return findMSB(vec); but save one function call in ASM with VC //return findMSB(vec); return vec(detail::compute_findMSB_vec::call(v)); } }; # if GLM_HAS_BITSCAN_WINDOWS template struct compute_log2<4, int, Q, false, Aligned> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) { vec<4, int, Q> Result; _BitScanReverse(reinterpret_cast(&Result.x), v.x); _BitScanReverse(reinterpret_cast(&Result.y), v.y); _BitScanReverse(reinterpret_cast(&Result.z), v.z); _BitScanReverse(reinterpret_cast(&Result.w), v.w); return Result; } }; # endif//GLM_HAS_BITSCAN_WINDOWS }//namespace detail template GLM_FUNC_QUALIFIER int iround(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); assert(static_cast(0.0) <= x); return static_cast(x + static_cast(0.5)); } template GLM_FUNC_QUALIFIER vec iround(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); assert(all(lessThanEqual(vec(0), x))); return vec(x + static_cast(0.5)); } template GLM_FUNC_QUALIFIER uint uround(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); assert(static_cast(0.0) <= x); return static_cast(x + static_cast(0.5)); } template GLM_FUNC_QUALIFIER vec uround(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); assert(all(lessThanEqual(vec(0), x))); return vec(x + static_cast(0.5)); } }//namespace glm glm-0.9.9-a2/glm/gtc/bitfield.hpp0000600000175000001440000002067613173131001015332 0ustar guususers/// @ref gtc_bitfield /// @file glm/gtc/bitfield.hpp /// /// @see core (dependence) /// @see gtc_bitfield (dependence) /// /// @defgroup gtc_bitfield GLM_GTC_bitfield /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Allow to perform bit operations on integer values #include "../detail/setup.hpp" #pragma once // Dependencies #include "../detail/qualifier.hpp" #include "../detail/type_int.hpp" #include "../detail/_vectorize.hpp" #include #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_bitfield extension included") #endif namespace glm { /// @addtogroup gtc_bitfield /// @{ /// Build a mask of 'count' bits /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType mask(genIUType Bits); /// Build a mask of 'count' bits /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec mask(vec const& v); /// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift); /// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldRotateRight(vec const& In, int Shift); /// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift); /// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldRotateLeft(vec const& In, int Shift); /// Set to 1 a range of bits. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount); /// Set to 1 a range of bits. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldFillOne(vec const& Value, int FirstBit, int BitCount); /// Set to 0 a range of bits. /// /// @see gtc_bitfield template GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount); /// Set to 0 a range of bits. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Signed and unsigned integer scalar types /// @tparam Q Value from qualifier enum /// /// @see gtc_bitfield template GLM_FUNC_DECL vec bitfieldFillZero(vec const& Value, int FirstBit, int BitCount); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z); /// Interleaves the bits of x, y and z. /// The first bit is the first bit of x followed by the first bit of y and the first bit of z. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w); /// Interleaves the bits of x, y, z and w. /// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w. /// The other bits are interleaved following the previous sequence. /// /// @see gtc_bitfield GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w); /// @} } //namespace glm #include "bitfield.inl" glm-0.9.9-a2/glm/gtc/type_ptr.hpp0000600000175000001440000001537713173131001015420 0ustar guususers/// @ref gtc_type_ptr /// @file glm/gtc/type_ptr.hpp /// /// @see core (dependence) /// @see gtc_quaternion (dependence) /// /// @defgroup gtc_type_ptr GLM_GTC_type_ptr /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Handles the interaction between pointers and vector, matrix types. /// /// This extension defines an overloaded function, glm::value_ptr, which /// takes any of the \ref core_template "core template types". It returns /// a pointer to the memory layout of the object. Matrix types store their values /// in column-major order. /// /// This is useful for uploading data to matrices or copying data to buffer objects. /// /// Example: /// @code /// #include /// #include /// /// glm::vec3 aVector(3); /// glm::mat4 someMatrix(1.0); /// /// glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector)); /// glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix)); /// @endcode /// /// need to be included to use the features of this extension. #pragma once // Dependency: #include "../gtc/quaternion.hpp" #include "../gtc/vec1.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../mat2x2.hpp" #include "../mat2x3.hpp" #include "../mat2x4.hpp" #include "../mat3x2.hpp" #include "../mat3x3.hpp" #include "../mat3x4.hpp" #include "../mat4x2.hpp" #include "../mat4x3.hpp" #include "../mat4x4.hpp" #include #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_type_ptr extension included") #endif namespace glm { /// @addtogroup gtc_type_ptr /// @{ /// Return the constant address to the data of the input parameter. /// @see gtc_type_ptr template GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<1, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<2, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<3, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<4, T, Q> const& v); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<2, T, defaultp> make_vec2(T const * const ptr); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<3, T, defaultp> make_vec3(T const * const ptr); /// Build a vector from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL vec<4, T, defaultp> make_vec4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2x2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 3, T, defaultp> make_mat2x3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 4, T, defaultp> make_mat2x4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 2, T, defaultp> make_mat3x2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3x3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 4, T, defaultp> make_mat3x4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 2, T, defaultp> make_mat4x2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 3, T, defaultp> make_mat4x3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4x4(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3(T const * const ptr); /// Build a matrix from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4(T const * const ptr); /// Build a quaternion from a pointer. /// @see gtc_type_ptr template GLM_FUNC_DECL tquat make_quat(T const * const ptr); /// @} }//namespace glm #include "type_ptr.inl" glm-0.9.9-a2/glm/gtc/matrix_access.hpp0000600000175000001440000000261213173131001016363 0ustar guususers/// @ref gtc_matrix_access /// @file glm/gtc/matrix_access.hpp /// /// @see core (dependence) /// /// @defgroup gtc_matrix_access GLM_GTC_matrix_access /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines functions to access rows or columns of a matrix easily. #pragma once // Dependency: #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_access extension included") #endif namespace glm { /// @addtogroup gtc_matrix_access /// @{ /// Get a specific row of a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL typename genType::row_type row( genType const& m, length_t index); /// Set a specific row to a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL genType row( genType const& m, length_t index, typename genType::row_type const& x); /// Get a specific column of a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL typename genType::col_type column( genType const& m, length_t index); /// Set a specific column to a matrix. /// @see gtc_matrix_access template GLM_FUNC_DECL genType column( genType const& m, length_t index, typename genType::col_type const& x); /// @} }//namespace glm #include "matrix_access.inl" glm-0.9.9-a2/glm/gtc/constants.inl0000600000175000001440000001011613173131001015543 0ustar guususers/// @ref gtc_constants /// @file glm/gtc/constants.inl #include namespace glm { template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() { return std::numeric_limits::epsilon(); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType zero() { return genType(0); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one() { return genType(1); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() { return genType(3.14159265358979323846264338327950288); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_pi() { return genType(6.28318530717958647692528676655900576); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_pi() { return genType(1.772453850905516027); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType half_pi() { return genType(1.57079632679489661923132169163975144); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType three_over_two_pi() { return genType(4.71238898038468985769396507491925432); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType quarter_pi() { return genType(0.785398163397448309615660845819875721); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_pi() { return genType(0.318309886183790671537767526745028724); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_two_pi() { return genType(0.159154943091895335768883763372514362); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_pi() { return genType(0.636619772367581343075535053490057448); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType four_over_pi() { return genType(1.273239544735162686151070106980114898); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_root_pi() { return genType(1.12837916709551257389615890312154517); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_root_two() { return genType(0.707106781186547524400844362104849039); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_half_pi() { return genType(1.253314137315500251); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two_pi() { return genType(2.506628274631000502); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_ln_four() { return genType(1.17741002251547469); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType e() { return genType(2.71828182845904523536); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType euler() { return genType(0.577215664901532860606); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two() { return genType(1.41421356237309504880168872420969808); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_three() { return genType(1.73205080756887729352744634150587236); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_five() { return genType(2.23606797749978969640917366873127623); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_two() { return genType(0.693147180559945309417232121458176568); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ten() { return genType(2.30258509299404568401799145468436421); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ln_two() { return genType(-0.3665129205816643); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType third() { return genType(0.3333333333333333333333333333333333333333); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_thirds() { return genType(0.666666666666666666666666666666666666667); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType golden_ratio() { return genType(1.61803398874989484820458683436563811); } } //namespace glm glm-0.9.9-a2/glm/gtc/bitfield.inl0000600000175000001440000003776113173131001015330 0ustar guususers/// @ref gtc_bitfield /// @file glm/gtc/bitfield.inl #include "../simd/integer.h" namespace glm{ namespace detail { template GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y); template GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z); template GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w); template<> GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y) { glm::uint16 REG1(x); glm::uint16 REG2(y); REG1 = ((REG1 << 4) | REG1) & static_cast(0x0F0F); REG2 = ((REG2 << 4) | REG2) & static_cast(0x0F0F); REG1 = ((REG1 << 2) | REG1) & static_cast(0x3333); REG2 = ((REG2 << 2) | REG2) & static_cast(0x3333); REG1 = ((REG1 << 1) | REG1) & static_cast(0x5555); REG2 = ((REG2 << 1) | REG2) & static_cast(0x5555); return REG1 | static_cast(REG2 << 1); } template<> GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y) { glm::uint32 REG1(x); glm::uint32 REG2(y); REG1 = ((REG1 << 8) | REG1) & static_cast(0x00FF00FF); REG2 = ((REG2 << 8) | REG2) & static_cast(0x00FF00FF); REG1 = ((REG1 << 4) | REG1) & static_cast(0x0F0F0F0F); REG2 = ((REG2 << 4) | REG2) & static_cast(0x0F0F0F0F); REG1 = ((REG1 << 2) | REG1) & static_cast(0x33333333); REG2 = ((REG2 << 2) | REG2) & static_cast(0x33333333); REG1 = ((REG1 << 1) | REG1) & static_cast(0x55555555); REG2 = ((REG2 << 1) | REG2) & static_cast(0x55555555); return REG1 | (REG2 << 1); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y) { glm::uint64 REG1(x); glm::uint64 REG2(y); REG1 = ((REG1 << 16) | REG1) & static_cast(0x0000FFFF0000FFFFull); REG2 = ((REG2 << 16) | REG2) & static_cast(0x0000FFFF0000FFFFull); REG1 = ((REG1 << 8) | REG1) & static_cast(0x00FF00FF00FF00FFull); REG2 = ((REG2 << 8) | REG2) & static_cast(0x00FF00FF00FF00FFull); REG1 = ((REG1 << 4) | REG1) & static_cast(0x0F0F0F0F0F0F0F0Full); REG2 = ((REG2 << 4) | REG2) & static_cast(0x0F0F0F0F0F0F0F0Full); REG1 = ((REG1 << 2) | REG1) & static_cast(0x3333333333333333ull); REG2 = ((REG2 << 2) | REG2) & static_cast(0x3333333333333333ull); REG1 = ((REG1 << 1) | REG1) & static_cast(0x5555555555555555ull); REG2 = ((REG2 << 1) | REG2) & static_cast(0x5555555555555555ull); return REG1 | (REG2 << 1); } template<> GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z) { glm::uint32 REG1(x); glm::uint32 REG2(y); glm::uint32 REG3(z); REG1 = ((REG1 << 16) | REG1) & static_cast(0xFF0000FFu); REG2 = ((REG2 << 16) | REG2) & static_cast(0xFF0000FFu); REG3 = ((REG3 << 16) | REG3) & static_cast(0xFF0000FFu); REG1 = ((REG1 << 8) | REG1) & static_cast(0x0F00F00Fu); REG2 = ((REG2 << 8) | REG2) & static_cast(0x0F00F00Fu); REG3 = ((REG3 << 8) | REG3) & static_cast(0x0F00F00Fu); REG1 = ((REG1 << 4) | REG1) & static_cast(0xC30C30C3u); REG2 = ((REG2 << 4) | REG2) & static_cast(0xC30C30C3u); REG3 = ((REG3 << 4) | REG3) & static_cast(0xC30C30C3u); REG1 = ((REG1 << 2) | REG1) & static_cast(0x49249249u); REG2 = ((REG2 << 2) | REG2) & static_cast(0x49249249u); REG3 = ((REG3 << 2) | REG3) & static_cast(0x49249249u); return REG1 | (REG2 << 1) | (REG3 << 2); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z) { glm::uint64 REG1(x); glm::uint64 REG2(y); glm::uint64 REG3(z); REG1 = ((REG1 << 32) | REG1) & static_cast(0xFFFF00000000FFFFull); REG2 = ((REG2 << 32) | REG2) & static_cast(0xFFFF00000000FFFFull); REG3 = ((REG3 << 32) | REG3) & static_cast(0xFFFF00000000FFFFull); REG1 = ((REG1 << 16) | REG1) & static_cast(0x00FF0000FF0000FFull); REG2 = ((REG2 << 16) | REG2) & static_cast(0x00FF0000FF0000FFull); REG3 = ((REG3 << 16) | REG3) & static_cast(0x00FF0000FF0000FFull); REG1 = ((REG1 << 8) | REG1) & static_cast(0xF00F00F00F00F00Full); REG2 = ((REG2 << 8) | REG2) & static_cast(0xF00F00F00F00F00Full); REG3 = ((REG3 << 8) | REG3) & static_cast(0xF00F00F00F00F00Full); REG1 = ((REG1 << 4) | REG1) & static_cast(0x30C30C30C30C30C3ull); REG2 = ((REG2 << 4) | REG2) & static_cast(0x30C30C30C30C30C3ull); REG3 = ((REG3 << 4) | REG3) & static_cast(0x30C30C30C30C30C3ull); REG1 = ((REG1 << 2) | REG1) & static_cast(0x9249249249249249ull); REG2 = ((REG2 << 2) | REG2) & static_cast(0x9249249249249249ull); REG3 = ((REG3 << 2) | REG3) & static_cast(0x9249249249249249ull); return REG1 | (REG2 << 1) | (REG3 << 2); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z) { glm::uint64 REG1(x); glm::uint64 REG2(y); glm::uint64 REG3(z); REG1 = ((REG1 << 32) | REG1) & static_cast(0xFFFF00000000FFFFull); REG2 = ((REG2 << 32) | REG2) & static_cast(0xFFFF00000000FFFFull); REG3 = ((REG3 << 32) | REG3) & static_cast(0xFFFF00000000FFFFull); REG1 = ((REG1 << 16) | REG1) & static_cast(0x00FF0000FF0000FFull); REG2 = ((REG2 << 16) | REG2) & static_cast(0x00FF0000FF0000FFull); REG3 = ((REG3 << 16) | REG3) & static_cast(0x00FF0000FF0000FFull); REG1 = ((REG1 << 8) | REG1) & static_cast(0xF00F00F00F00F00Full); REG2 = ((REG2 << 8) | REG2) & static_cast(0xF00F00F00F00F00Full); REG3 = ((REG3 << 8) | REG3) & static_cast(0xF00F00F00F00F00Full); REG1 = ((REG1 << 4) | REG1) & static_cast(0x30C30C30C30C30C3ull); REG2 = ((REG2 << 4) | REG2) & static_cast(0x30C30C30C30C30C3ull); REG3 = ((REG3 << 4) | REG3) & static_cast(0x30C30C30C30C30C3ull); REG1 = ((REG1 << 2) | REG1) & static_cast(0x9249249249249249ull); REG2 = ((REG2 << 2) | REG2) & static_cast(0x9249249249249249ull); REG3 = ((REG3 << 2) | REG3) & static_cast(0x9249249249249249ull); return REG1 | (REG2 << 1) | (REG3 << 2); } template<> GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w) { glm::uint32 REG1(x); glm::uint32 REG2(y); glm::uint32 REG3(z); glm::uint32 REG4(w); REG1 = ((REG1 << 12) | REG1) & static_cast(0x000F000Fu); REG2 = ((REG2 << 12) | REG2) & static_cast(0x000F000Fu); REG3 = ((REG3 << 12) | REG3) & static_cast(0x000F000Fu); REG4 = ((REG4 << 12) | REG4) & static_cast(0x000F000Fu); REG1 = ((REG1 << 6) | REG1) & static_cast(0x03030303u); REG2 = ((REG2 << 6) | REG2) & static_cast(0x03030303u); REG3 = ((REG3 << 6) | REG3) & static_cast(0x03030303u); REG4 = ((REG4 << 6) | REG4) & static_cast(0x03030303u); REG1 = ((REG1 << 3) | REG1) & static_cast(0x11111111u); REG2 = ((REG2 << 3) | REG2) & static_cast(0x11111111u); REG3 = ((REG3 << 3) | REG3) & static_cast(0x11111111u); REG4 = ((REG4 << 3) | REG4) & static_cast(0x11111111u); return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3); } template<> GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w) { glm::uint64 REG1(x); glm::uint64 REG2(y); glm::uint64 REG3(z); glm::uint64 REG4(w); REG1 = ((REG1 << 24) | REG1) & static_cast(0x000000FF000000FFull); REG2 = ((REG2 << 24) | REG2) & static_cast(0x000000FF000000FFull); REG3 = ((REG3 << 24) | REG3) & static_cast(0x000000FF000000FFull); REG4 = ((REG4 << 24) | REG4) & static_cast(0x000000FF000000FFull); REG1 = ((REG1 << 12) | REG1) & static_cast(0x000F000F000F000Full); REG2 = ((REG2 << 12) | REG2) & static_cast(0x000F000F000F000Full); REG3 = ((REG3 << 12) | REG3) & static_cast(0x000F000F000F000Full); REG4 = ((REG4 << 12) | REG4) & static_cast(0x000F000F000F000Full); REG1 = ((REG1 << 6) | REG1) & static_cast(0x0303030303030303ull); REG2 = ((REG2 << 6) | REG2) & static_cast(0x0303030303030303ull); REG3 = ((REG3 << 6) | REG3) & static_cast(0x0303030303030303ull); REG4 = ((REG4 << 6) | REG4) & static_cast(0x0303030303030303ull); REG1 = ((REG1 << 3) | REG1) & static_cast(0x1111111111111111ull); REG2 = ((REG2 << 3) | REG2) & static_cast(0x1111111111111111ull); REG3 = ((REG3 << 3) | REG3) & static_cast(0x1111111111111111ull); REG4 = ((REG4 << 3) | REG4) & static_cast(0x1111111111111111ull); return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3); } }//namespace detail template GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'mask' accepts only integer values"); return Bits >= sizeof(genIUType) * 8 ? ~static_cast(0) : (static_cast(1) << Bits) - static_cast(1); } template GLM_FUNC_QUALIFIER vec mask(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'mask' accepts only integer values"); return detail::functor1::call(mask, v); } template GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); int const BitSize = static_cast(sizeof(genIType) * 8); return (In << static_cast(Shift)) | (In >> static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER vec bitfieldRotateRight(vec const& In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); int const BitSize = static_cast(sizeof(T) * 8); return (In << static_cast(Shift)) | (In >> static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); int const BitSize = static_cast(sizeof(genIType) * 8); return (In >> static_cast(Shift)) | (In << static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER vec bitfieldRotateLeft(vec const& In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); int const BitSize = static_cast(sizeof(T) * 8); return (In >> static_cast(Shift)) | (In << static_cast(BitSize - Shift)); } template GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount) { return Value | static_cast(mask(BitCount) << FirstBit); } template GLM_FUNC_QUALIFIER vec bitfieldFillOne(vec const& Value, int FirstBit, int BitCount) { return Value | static_cast(mask(BitCount) << FirstBit); } template GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount) { return Value & static_cast(~(mask(BitCount) << FirstBit)); } template GLM_FUNC_QUALIFIER vec bitfieldFillZero(vec const& Value, int FirstBit, int BitCount) { return Value & static_cast(~(mask(BitCount) << FirstBit)); } GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y) { union sign8 { int8 i; uint8 u; } sign_x, sign_y; union sign16 { int16 i; uint16 u; } result; sign_x.i = x; sign_y.i = y; result.u = bitfieldInterleave(sign_x.u, sign_y.u); return result.i; } GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y) { return detail::bitfieldInterleave(x, y); } GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y) { union sign16 { int16 i; uint16 u; } sign_x, sign_y; union sign32 { int32 i; uint32 u; } result; sign_x.i = x; sign_y.i = y; result.u = bitfieldInterleave(sign_x.u, sign_y.u); return result.i; } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y) { return detail::bitfieldInterleave(x, y); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y) { union sign32 { int32 i; uint32 u; } sign_x, sign_y; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; result.u = bitfieldInterleave(sign_x.u, sign_y.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y) { return detail::bitfieldInterleave(x, y); } GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z) { union sign8 { int8 i; uint8 u; } sign_x, sign_y, sign_z; union sign32 { int32 i; uint32 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u); return result.i; } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z) { return detail::bitfieldInterleave(x, y, z); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z) { union sign16 { int16 i; uint16 u; } sign_x, sign_y, sign_z; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z) { return detail::bitfieldInterleave(x, y, z); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z) { union sign16 { int32 i; uint32 u; } sign_x, sign_y, sign_z; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z) { return detail::bitfieldInterleave(x, y, z); } GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w) { union sign8 { int8 i; uint8 u; } sign_x, sign_y, sign_z, sign_w; union sign32 { int32 i; uint32 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; sign_w.i = w; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u); return result.i; } GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w) { return detail::bitfieldInterleave(x, y, z, w); } GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w) { union sign16 { int16 i; uint16 u; } sign_x, sign_y, sign_z, sign_w; union sign64 { int64 i; uint64 u; } result; sign_x.i = x; sign_y.i = y; sign_z.i = z; sign_w.i = w; result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u); return result.i; } GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w) { return detail::bitfieldInterleave(x, y, z, w); } }//namespace glm glm-0.9.9-a2/glm/gtc/type_ptr.inl0000600000175000001440000002061613173131001015403 0ustar guususers/// @ref gtc_type_ptr /// @file glm/gtc/type_ptr.inl #include namespace glm { /// @addtogroup gtc_type_ptr /// @{ template GLM_FUNC_QUALIFIER T const* value_ptr(vec<2, T, Q> const& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T* value_ptr(vec<2, T, Q>& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T const * value_ptr(vec<3, T, Q> const& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T* value_ptr(vec<3, T, Q>& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T const* value_ptr(vec<4, T, Q> const& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T* value_ptr(vec<4, T, Q>& v) { return &(v.x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 2, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 2, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 3, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 3, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 4, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 4, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 3, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 3, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 2, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 2, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 4, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 4, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 2, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 2, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 4, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 4, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 3, T, Q> const& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T * value_ptr(mat<4, 3, T, Q>& m) { return &(m[0].x); } template GLM_FUNC_QUALIFIER T const * value_ptr(tquat const& q) { return &(q[0]); } template GLM_FUNC_QUALIFIER T* value_ptr(tquat& q) { return &(q[0]); } template inline vec<1, T, Q> make_vec1(vec<1, T, Q> const& v) { return v; } template inline vec<1, T, Q> make_vec1(vec<2, T, Q> const& v) { return vec<1, T, Q>(v); } template inline vec<1, T, Q> make_vec1(vec<3, T, Q> const& v) { return vec<1, T, Q>(v); } template inline vec<1, T, Q> make_vec1(vec<4, T, Q> const& v) { return vec<1, T, Q>(v); } template inline vec<2, T, Q> make_vec2(vec<1, T, Q> const& v) { return vec<2, T, Q>(v.x, static_cast(0)); } template inline vec<2, T, Q> make_vec2(vec<2, T, Q> const& v) { return v; } template inline vec<2, T, Q> make_vec2(vec<3, T, Q> const& v) { return vec<2, T, Q>(v); } template inline vec<2, T, Q> make_vec2(vec<4, T, Q> const& v) { return vec<2, T, Q>(v); } template inline vec<3, T, Q> make_vec3(vec<1, T, Q> const& v) { return vec<3, T, Q>(v.x, static_cast(0), static_cast(0)); } template inline vec<3, T, Q> make_vec3(vec<2, T, Q> const& v) { return vec<3, T, Q>(v.x, v.y, static_cast(0)); } template inline vec<3, T, Q> make_vec3(vec<3, T, Q> const& v) { return v; } template inline vec<3, T, Q> make_vec3(vec<4, T, Q> const& v) { return vec<3, T, Q>(v); } template inline vec<4, T, Q> make_vec4(vec<1, T, Q> const& v) { return vec<4, T, Q>(v.x, static_cast(0), static_cast(0), static_cast(1)); } template inline vec<4, T, Q> make_vec4(vec<2, T, Q> const& v) { return vec<4, T, Q>(v.x, v.y, static_cast(0), static_cast(1)); } template inline vec<4, T, Q> make_vec4(vec<3, T, Q> const& v) { return vec<4, T, Q>(v.x, v.y, v.z, static_cast(1)); } template inline vec<4, T, Q> make_vec4(vec<4, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER vec<2, T, defaultp> make_vec2(T const *const ptr) { vec<2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(vec<2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER vec<3, T, defaultp> make_vec3(T const *const ptr) { vec<3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(vec<3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER vec<4, T, defaultp> make_vec4(T const *const ptr) { vec<4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(vec<4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2x2(T const *const ptr) { mat<2, 2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<2, 2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, defaultp> make_mat2x3(T const *const ptr) { mat<2, 3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<2, 3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, defaultp> make_mat2x4(T const *const ptr) { mat<2, 4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<2, 4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, defaultp> make_mat3x2(T const *const ptr) { mat<3, 2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<3, 2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3x3(T const *const ptr) { mat<3, 3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<3, 3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<3, 4, T, defaultp> make_mat3x4(T const *const ptr) { mat<3, 4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<3, 4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<4, 2, T, defaultp> make_mat4x2(T const *const ptr) { mat<4, 2, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<4, 2, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, defaultp> make_mat4x3(T const *const ptr) { mat<4, 3, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<4, 3, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4x4(T const *const ptr) { mat<4, 4, T, defaultp> Result; memcpy(value_ptr(Result), ptr, sizeof(mat<4, 4, T, defaultp>)); return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2(T const *const ptr) { return make_mat2x2(ptr); } template GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3(T const *const ptr) { return make_mat3x3(ptr); } template GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4(T const *const ptr) { return make_mat4x4(ptr); } template GLM_FUNC_QUALIFIER tquat make_quat(T const *const ptr) { tquat Result; memcpy(value_ptr(Result), ptr, sizeof(tquat)); return Result; } /// @} }//namespace glm glm-0.9.9-a2/glm/gtc/color_space.inl0000600000175000001440000000565413173131001016033 0ustar guususers/// @ref gtc_color_space /// @file glm/gtc/color_space.inl namespace glm{ namespace detail { template struct compute_rgbToSrgb { GLM_FUNC_QUALIFIER static vec call(vec const& ColorRGB, T GammaCorrection) { vec const ClampedColor(clamp(ColorRGB, static_cast(0), static_cast(1))); return mix( pow(ClampedColor, vec(GammaCorrection)) * static_cast(1.055) - static_cast(0.055), ClampedColor * static_cast(12.92), lessThan(ClampedColor, vec(static_cast(0.0031308)))); } }; template struct compute_rgbToSrgb<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& ColorRGB, T GammaCorrection) { return vec<4, T, Q>(compute_rgbToSrgb<3, T, Q>::call(vec<3, T, Q>(ColorRGB), GammaCorrection), ColorRGB.w); } }; template struct compute_srgbToRgb { GLM_FUNC_QUALIFIER static vec call(vec const& ColorSRGB, T Gamma) { return mix( pow((ColorSRGB + static_cast(0.055)) * static_cast(0.94786729857819905213270142180095), vec(Gamma)), ColorSRGB * static_cast(0.07739938080495356037151702786378), lessThanEqual(ColorSRGB, vec(static_cast(0.04045)))); } }; template struct compute_srgbToRgb<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& ColorSRGB, T Gamma) { return vec<4, T, Q>(compute_srgbToRgb<3, T, Q>::call(vec<3, T, Q>(ColorSRGB), Gamma), ColorSRGB.w); } }; }//namespace detail template GLM_FUNC_QUALIFIER vec convertLinearToSRGB(vec const& ColorLinear) { return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(0.41666)); } // Based on Ian Taylor http://chilliant.blogspot.fr/2012/08/srgb-approximations-for-hlsl.html template<> GLM_FUNC_QUALIFIER vec<3, float, lowp> convertLinearToSRGB(vec<3, float, lowp> const& ColorLinear) { vec<3, float, lowp> S1 = sqrt(ColorLinear); vec<3, float, lowp> S2 = sqrt(S1); vec<3, float, lowp> S3 = sqrt(S2); return 0.662002687f * S1 + 0.684122060f * S2 - 0.323583601f * S3 - 0.0225411470f * ColorLinear; } template GLM_FUNC_QUALIFIER vec convertLinearToSRGB(vec const& ColorLinear, T Gamma) { return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(1) / Gamma); } template GLM_FUNC_QUALIFIER vec convertSRGBToLinear(vec const& ColorSRGB) { return detail::compute_srgbToRgb::call(ColorSRGB, static_cast(2.4)); } template GLM_FUNC_QUALIFIER vec convertSRGBToLinear(vec const& ColorSRGB, T Gamma) { return detail::compute_srgbToRgb::call(ColorSRGB, Gamma); } }//namespace glm glm-0.9.9-a2/glm/gtc/round.inl0000600000175000001440000002212113173131001014655 0ustar guususers/// @ref gtc_round /// @file glm/gtc/round.inl #include "../integer.hpp" namespace glm{ namespace detail { template struct compute_ceilShift { GLM_FUNC_QUALIFIER static vec call(vec const& v, T) { return v; } }; template struct compute_ceilShift { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Shift) { return v | (v >> Shift); } }; template struct compute_ceilPowerOfTwo { GLM_FUNC_QUALIFIER static vec call(vec const& x) { GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); vec const Sign(sign(x)); vec v(abs(x)); v = v - static_cast(1); v = v | (v >> static_cast(1)); v = v | (v >> static_cast(2)); v = v | (v >> static_cast(4)); v = compute_ceilShift= 2>::call(v, 8); v = compute_ceilShift= 4>::call(v, 16); v = compute_ceilShift= 8>::call(v, 32); return (v + static_cast(1)) * Sign; } }; template struct compute_ceilPowerOfTwo { GLM_FUNC_QUALIFIER static vec call(vec const& x) { GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); vec v(x); v = v - static_cast(1); v = v | (v >> static_cast(1)); v = v | (v >> static_cast(2)); v = v | (v >> static_cast(4)); v = compute_ceilShift= 2>::call(v, 8); v = compute_ceilShift= 4>::call(v, 16); v = compute_ceilShift= 8>::call(v, 32); return v + static_cast(1); } }; template struct compute_ceilMultiple{}; template<> struct compute_ceilMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source > genType(0)) return Source + (Multiple - std::fmod(Source, Multiple)); else return Source + std::fmod(-Source, Multiple); } }; template<> struct compute_ceilMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { genType Tmp = Source - genType(1); return Tmp + (Multiple - (Tmp % Multiple)); } }; template<> struct compute_ceilMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source > genType(0)) { genType Tmp = Source - genType(1); return Tmp + (Multiple - (Tmp % Multiple)); } else return Source + (-Source % Multiple); } }; template struct compute_floorMultiple{}; template<> struct compute_floorMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - std::fmod(Source, Multiple); else return Source - std::fmod(Source, Multiple) - Multiple; } }; template<> struct compute_floorMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; template<> struct compute_floorMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; template struct compute_roundMultiple{}; template<> struct compute_roundMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - std::fmod(Source, Multiple); else { genType Tmp = Source + genType(1); return Tmp - std::fmod(Tmp, Multiple) - Multiple; } } }; template<> struct compute_roundMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; template<> struct compute_roundMultiple { template GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) { if(Source >= genType(0)) return Source - Source % Multiple; else { genType Tmp = Source + genType(1); return Tmp - Tmp % Multiple - Multiple; } } }; }//namespace detail //////////////// // isPowerOfTwo template GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value) { genType const Result = glm::abs(Value); return !(Result & (Result - 1)); } template GLM_FUNC_QUALIFIER vec isPowerOfTwo(vec const& Value) { vec const Result(abs(Value)); return equal(Result & (Result - 1), vec(0)); } ////////////////// // ceilPowerOfTwo template GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value) { return detail::compute_ceilPowerOfTwo<1, genType, defaultp, std::numeric_limits::is_signed>::call(vec<1, genType, defaultp>(value)).x; } template GLM_FUNC_QUALIFIER vec ceilPowerOfTwo(vec const& v) { return detail::compute_ceilPowerOfTwo::is_signed>::call(v); } /////////////////// // floorPowerOfTwo template GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value) { return isPowerOfTwo(value) ? value : static_cast(1) << findMSB(value); } template GLM_FUNC_QUALIFIER vec floorPowerOfTwo(vec const& v) { return detail::functor1::call(floorPowerOfTwo, v); } /////////////////// // roundPowerOfTwo template GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value) { if(isPowerOfTwo(value)) return value; genIUType const prev = static_cast(1) << findMSB(value); genIUType const next = prev << static_cast(1); return (next - value) < (value - prev) ? next : prev; } template GLM_FUNC_QUALIFIER vec roundPowerOfTwo(vec const& v) { return detail::functor1::call(roundPowerOfTwo, v); } //////////////// // isMultiple template GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple) { return isMultiple(vec<1, genType>(Value), vec<1, genType>(Multiple)).x; } template GLM_FUNC_QUALIFIER vec isMultiple(vec const& Value, T Multiple) { return (Value % Multiple) == vec(0); } template GLM_FUNC_QUALIFIER vec isMultiple(vec const& Value, vec const& Multiple) { return (Value % Multiple) == vec(0); } ////////////////////// // ceilMultiple template GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple) { return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER vec ceilMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(ceilMultiple, Source, Multiple); } ////////////////////// // floorMultiple template GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple) { return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER vec floorMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(floorMultiple, Source, Multiple); } ////////////////////// // roundMultiple template GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple) { return detail::compute_roundMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template GLM_FUNC_QUALIFIER vec roundMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(roundMultiple, Source, Multiple); } }//namespace glm glm-0.9.9-a2/glm/gtc/random.inl0000600000175000001440000002500713173131001015014 0ustar guususers/// @ref gtc_random /// @file glm/gtc/random.inl #include "../geometric.hpp" #include "../exponential.hpp" #include "../trigonometric.hpp" #include "../ext/vec1.hpp" #include #include #include #include namespace glm{ namespace detail { template struct compute_rand { GLM_FUNC_QUALIFIER static vec call(); }; template struct compute_rand<1, uint8, P> { GLM_FUNC_QUALIFIER static vec<1, uint8, P> call() { return vec<1, uint8, P>( std::rand() % std::numeric_limits::max()); } }; template struct compute_rand<2, uint8, P> { GLM_FUNC_QUALIFIER static vec<2, uint8, P> call() { return vec<2, uint8, P>( std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max()); } }; template struct compute_rand<3, uint8, P> { GLM_FUNC_QUALIFIER static vec<3, uint8, P> call() { return vec<3, uint8, P>( std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max()); } }; template struct compute_rand<4, uint8, P> { GLM_FUNC_QUALIFIER static vec<4, uint8, P> call() { return vec<4, uint8, P>( std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max(), std::rand() % std::numeric_limits::max()); } }; template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() { return (vec(compute_rand::call()) << static_cast(8)) | (vec(compute_rand::call()) << static_cast(0)); } }; template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() { return (vec(compute_rand::call()) << static_cast(16)) | (vec(compute_rand::call()) << static_cast(0)); } }; template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() { return (vec(compute_rand::call()) << static_cast(32)) | (vec(compute_rand::call()) << static_cast(0)); } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max); }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (vec(compute_rand::call() % vec(Max + static_cast(1) - Min))) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return (compute_rand::call() % (Max + static_cast(1) - Min)) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) { return vec(compute_rand::call()) / static_cast(std::numeric_limits::max()) * (Max - Min) + Min; } }; }//namespace detail template GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max) { return detail::compute_linearRand<1, genType, highp>::call( vec<1, genType, highp>(Min), vec<1, genType, highp>(Max)).x; } template GLM_FUNC_QUALIFIER vec linearRand(vec const& Min, vec const& Max) { return detail::compute_linearRand::call(Min, Max); } template GLM_FUNC_QUALIFIER genType gaussRand(genType Mean, genType Deviation) { genType w, x1, x2; do { x1 = linearRand(genType(-1), genType(1)); x2 = linearRand(genType(-1), genType(1)); w = x1 * x1 + x2 * x2; } while(w > genType(1)); return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean; } template GLM_FUNC_QUALIFIER vec gaussRand(vec const& Mean, vec const& Deviation) { return detail::functor2::call(gaussRand, Mean, Deviation); } template GLM_FUNC_QUALIFIER vec<2, T, defaultp> diskRand(T Radius) { vec<2, T, defaultp> Result(T(0)); T LenRadius(T(0)); do { Result = linearRand( vec<2, T, defaultp>(-Radius), vec<2, T, defaultp>(Radius)); LenRadius = length(Result); } while(LenRadius > Radius); return Result; } template GLM_FUNC_QUALIFIER vec<3, T, defaultp> ballRand(T Radius) { vec<3, T, defaultp> Result(T(0)); T LenRadius(T(0)); do { Result = linearRand( vec<3, T, defaultp>(-Radius), vec<3, T, defaultp>(Radius)); LenRadius = length(Result); } while(LenRadius > Radius); return Result; } template GLM_FUNC_QUALIFIER vec<2, T, defaultp> circularRand(T Radius) { T a = linearRand(T(0), static_cast(6.283185307179586476925286766559)); return vec<2, T, defaultp>(glm::cos(a), glm::sin(a)) * Radius; } template GLM_FUNC_QUALIFIER vec<3, T, defaultp> sphericalRand(T Radius) { T z = linearRand(T(-1), T(1)); T a = linearRand(T(0), T(6.283185307179586476925286766559f)); T r = sqrt(T(1) - z * z); T x = r * std::cos(a); T y = r * std::sin(a); return vec<3, T, defaultp>(x, y, z) * Radius; } }//namespace glm glm-0.9.9-a2/glm/gtc/noise.hpp0000600000175000001440000000274413173131001014661 0ustar guususers/// @ref gtc_noise /// @file glm/gtc/noise.hpp /// /// @see core (dependence) /// /// @defgroup gtc_noise GLM_GTC_noise /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines 2D, 3D and 4D procedural noise functions /// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": /// https://github.com/ashima/webgl-noise /// Following Stefan Gustavson's paper "Simplex noise demystified": /// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../detail/_noise.hpp" #include "../geometric.hpp" #include "../common.hpp" #include "../vector_relational.hpp" #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_noise extension included") #endif namespace glm { /// @addtogroup gtc_noise /// @{ /// Classic perlin noise. /// @see gtc_noise template GLM_FUNC_DECL T perlin( vec const& p); /// Periodic perlin noise. /// @see gtc_noise template GLM_FUNC_DECL T perlin( vec const& p, vec const& rep); /// Simplex noise. /// @see gtc_noise template GLM_FUNC_DECL T simplex( vec const& p); /// @} }//namespace glm #include "noise.inl" glm-0.9.9-a2/glm/gtc/quaternion_simd.inl0000600000175000001440000001424613173131001016740 0ustar guususers/// @ref core /// @file glm/gtc/quaternion_simd.inl #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { /* template struct compute_quat_mul { static tquat call(tquat const& q1, tquat const& q2) { // SSE2 STATS: 11 shuffle, 8 mul, 8 add // SSE4 STATS: 3 shuffle, 4 mul, 4 dpps __m128 const mul0 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(0, 1, 2, 3))); __m128 const mul1 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(1, 0, 3, 2))); __m128 const mul2 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(2, 3, 0, 1))); __m128 const mul3 = _mm_mul_ps(q1.Data, q2.Data); # if GLM_ARCH & GLM_ARCH_SSE41_BIT __m128 const add0 = _mm_dp_ps(mul0, _mm_set_ps(1.0f, -1.0f, 1.0f, 1.0f), 0xff); __m128 const add1 = _mm_dp_ps(mul1, _mm_set_ps(1.0f, 1.0f, 1.0f, -1.0f), 0xff); __m128 const add2 = _mm_dp_ps(mul2, _mm_set_ps(1.0f, 1.0f, -1.0f, 1.0f), 0xff); __m128 const add3 = _mm_dp_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f), 0xff); # else __m128 const mul4 = _mm_mul_ps(mul0, _mm_set_ps(1.0f, -1.0f, 1.0f, 1.0f)); __m128 const add0 = _mm_add_ps(mul0, _mm_movehl_ps(mul4, mul4)); __m128 const add4 = _mm_add_ss(add0, _mm_shuffle_ps(add0, add0, 1)); __m128 const mul5 = _mm_mul_ps(mul1, _mm_set_ps(1.0f, 1.0f, 1.0f, -1.0f)); __m128 const add1 = _mm_add_ps(mul1, _mm_movehl_ps(mul5, mul5)); __m128 const add5 = _mm_add_ss(add1, _mm_shuffle_ps(add1, add1, 1)); __m128 const mul6 = _mm_mul_ps(mul2, _mm_set_ps(1.0f, 1.0f, -1.0f, 1.0f)); __m128 const add2 = _mm_add_ps(mul6, _mm_movehl_ps(mul6, mul6)); __m128 const add6 = _mm_add_ss(add2, _mm_shuffle_ps(add2, add2, 1)); __m128 const mul7 = _mm_mul_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f)); __m128 const add3 = _mm_add_ps(mul3, _mm_movehl_ps(mul7, mul7)); __m128 const add7 = _mm_add_ss(add3, _mm_shuffle_ps(add3, add3, 1)); #endif // This SIMD code is a politically correct way of doing this, but in every test I've tried it has been slower than // the final code below. I'll keep this here for reference - maybe somebody else can do something better... // //__m128 xxyy = _mm_shuffle_ps(add4, add5, _MM_SHUFFLE(0, 0, 0, 0)); //__m128 zzww = _mm_shuffle_ps(add6, add7, _MM_SHUFFLE(0, 0, 0, 0)); // //return _mm_shuffle_ps(xxyy, zzww, _MM_SHUFFLE(2, 0, 2, 0)); tquat Result; _mm_store_ss(&Result.x, add4); _mm_store_ss(&Result.y, add5); _mm_store_ss(&Result.z, add6); _mm_store_ss(&Result.w, add7); return Result; } }; */ template struct compute_dot, float, true> { static GLM_FUNC_QUALIFIER float call(tquat const& x, tquat const& y) { return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); } }; template struct compute_quat_add { static tquat call(tquat const& q, tquat const& p) { tquat Result; Result.data = _mm_add_ps(q.data, p.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_add { static tquat call(tquat const& a, tquat const& b) { tquat Result; Result.data = _mm256_add_pd(a.data, b.data); return Result; } }; # endif template struct compute_quat_sub { static tquat call(tquat const& q, tquat const& p) { vec<4, float, Q> Result; Result.data = _mm_sub_ps(q.data, p.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_sub { static tquat call(tquat const& a, tquat const& b) { tquat Result; Result.data = _mm256_sub_pd(a.data, b.data); return Result; } }; # endif template struct compute_quat_mul_scalar { static tquat call(tquat const& q, float s) { vec<4, float, Q> Result; Result.data = _mm_mul_ps(q.data, _mm_set_ps1(s)); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_mul_scalar { static tquat call(tquat const& q, double s) { tquat Result; Result.data = _mm256_mul_pd(q.data, _mm_set_ps1(s)); return Result; } }; # endif template struct compute_quat_div_scalar { static tquat call(tquat const& q, float s) { vec<4, float, Q> Result; Result.data = _mm_div_ps(q.data, _mm_set_ps1(s)); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_quat_div_scalar { static tquat call(tquat const& q, double s) { tquat Result; Result.data = _mm256_div_pd(q.data, _mm_set_ps1(s)); return Result; } }; # endif template struct compute_quat_mul_vec4 { static vec<4, float, Q> call(tquat const& q, vec<4, float, Q> const& v) { __m128 const q_wwww = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 3, 3, 3)); __m128 const q_swp0 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 0, 2, 1)); __m128 const q_swp1 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 1, 0, 2)); __m128 const v_swp0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 0, 2, 1)); __m128 const v_swp1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 1, 0, 2)); __m128 uv = _mm_sub_ps(_mm_mul_ps(q_swp0, v_swp1), _mm_mul_ps(q_swp1, v_swp0)); __m128 uv_swp0 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 0, 2, 1)); __m128 uv_swp1 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 1, 0, 2)); __m128 uuv = _mm_sub_ps(_mm_mul_ps(q_swp0, uv_swp1), _mm_mul_ps(q_swp1, uv_swp0)); __m128 const two = _mm_set1_ps(2.0f); uv = _mm_mul_ps(uv, _mm_mul_ps(q_wwww, two)); uuv = _mm_mul_ps(uuv, two); vec<4, float, Q> Result; Result.data = _mm_add_ps(v.Data, _mm_add_ps(uv, uuv)); return Result; } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/gtc/quaternion.hpp0000600000175000001440000003245013173131001015726 0ustar guususers/// @ref gtc_quaternion /// @file glm/gtc/quaternion.hpp /// /// @see core (dependence) /// @see gtc_constants (dependence) /// /// @defgroup gtc_quaternion GLM_GTC_quaternion /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines a templated quaternion type and several quaternion operations. #pragma once // Dependency: #include "../mat3x3.hpp" #include "../mat4x4.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../gtc/constants.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_quaternion extension included") #endif namespace glm { /// @addtogroup gtc_quaternion /// @{ template struct tquat { // -- Implementation detail -- typedef tquat type; typedef T value_type; // -- Data -- # if GLM_HAS_ALIGNED_TYPE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # endif # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # endif union { struct { T x, y, z, w;}; typename detail::storage::value>::type data; }; # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # endif # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # endif # else T x, y, z, w; # endif // -- Component accesses -- typedef length_t length_type; /// Return the count of components of a quaternion GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;} GLM_FUNC_DECL T & operator[](length_type i); GLM_FUNC_DECL T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR tquat() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat const& q) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat const& q); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR tquat(T s, vec<3, T, Q> const& v); GLM_FUNC_DECL GLM_CONSTEXPR tquat(T w, T x, T y, T z); // -- Conversion constructors -- template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tquat(tquat const& q); /// Explicit conversion operators # if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS GLM_FUNC_DECL explicit operator mat<3, 3, T, Q>(); GLM_FUNC_DECL explicit operator mat<4, 4, T, Q>(); # endif /// Create a quaternion from two normalized axis /// /// @param u A first normalized axis /// @param v A second normalized axis /// @see gtc_quaternion /// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors GLM_FUNC_DECL tquat(vec<3, T, Q> const& u, vec<3, T, Q> const& v); /// Build a quaternion from euler angles (pitch, yaw, roll), in radians. GLM_FUNC_DECL GLM_EXPLICIT tquat(vec<3, T, Q> const& eulerAngles); GLM_FUNC_DECL GLM_EXPLICIT tquat(mat<3, 3, T, Q> const& q); GLM_FUNC_DECL GLM_EXPLICIT tquat(mat<4, 4, T, Q> const& q); // -- Unary arithmetic operators -- GLM_FUNC_DECL tquat & operator=(tquat const& q) GLM_DEFAULT; template GLM_FUNC_DECL tquat & operator=(tquat const& q); template GLM_FUNC_DECL tquat & operator+=(tquat const& q); template GLM_FUNC_DECL tquat & operator-=(tquat const& q); template GLM_FUNC_DECL tquat & operator*=(tquat const& q); template GLM_FUNC_DECL tquat & operator*=(U s); template GLM_FUNC_DECL tquat & operator/=(U s); }; // -- Unary bit operators -- template GLM_FUNC_DECL tquat operator+(tquat const& q); template GLM_FUNC_DECL tquat operator-(tquat const& q); // -- Binary operators -- template GLM_FUNC_DECL tquat operator+(tquat const& q, tquat const& p); template GLM_FUNC_DECL tquat operator*(tquat const& q, tquat const& p); template GLM_FUNC_DECL vec<3, T, Q> operator*(tquat const& q, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v, tquat const& q); template GLM_FUNC_DECL vec<4, T, Q> operator*(tquat const& q, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v, tquat const& q); template GLM_FUNC_DECL tquat operator*(tquat const& q, T const& s); template GLM_FUNC_DECL tquat operator*(T const& s, tquat const& q); template GLM_FUNC_DECL tquat operator/(tquat const& q, T const& s); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(tquat const& q1, tquat const& q2); template GLM_FUNC_DECL bool operator!=(tquat const& q1, tquat const& q2); /// Returns the length of the quaternion. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T length(tquat const& q); /// Returns the normalized quaternion. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat normalize(tquat const& q); /// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T dot(tquat const& x, tquat const& y); /// Spherical linear interpolation of two quaternions. /// The interpolation is oriented and the rotation is performed at constant speed. /// For short path spherical linear interpolation, use the slerp function. /// /// @param x A quaternion /// @param y A quaternion /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// @tparam T Floating-point scalar types. /// /// @see - slerp(tquat const& x, tquat const& y, T const& a) /// @see gtc_quaternion template GLM_FUNC_DECL tquat mix(tquat const& x, tquat const& y, T a); /// Linear interpolation of two quaternions. /// The interpolation is oriented. /// /// @param x A quaternion /// @param y A quaternion /// @param a Interpolation factor. The interpolation is defined in the range [0, 1]. /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat lerp(tquat const& x, tquat const& y, T a); /// Spherical linear interpolation of two quaternions. /// The interpolation always take the short path and the rotation is performed at constant speed. /// /// @param x A quaternion /// @param y A quaternion /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat slerp(tquat const& x, tquat const& y, T a); /// Returns the q conjugate. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat conjugate(tquat const& q); /// Returns the q inverse. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat inverse(tquat const& q); /// Rotates a quaternion from a vector of 3 components axis and an angle. /// /// @param q Source orientation /// @param angle Angle expressed in radians. /// @param axis Axis of the rotation /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat rotate(tquat const& q, T const& angle, vec<3, T, Q> const& axis); /// Returns euler angles, pitch as x, yaw as y, roll as z. /// The result is expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<3, T, Q> eulerAngles(tquat const& x); /// Returns roll value of euler angles expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T roll(tquat const& x); /// Returns pitch value of euler angles expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T pitch(tquat const& x); /// Returns yaw value of euler angles expressed in radians. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T yaw(tquat const& x); /// Converts a quaternion to a 3 * 3 matrix. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL mat<3, 3, T, Q> mat3_cast(tquat const& x); /// Converts a quaternion to a 4 * 4 matrix. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL mat<4, 4, T, Q> mat4_cast(tquat const& x); /// Converts a 3 * 3 matrix to a quaternion. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat quat_cast(mat<3, 3, T, Q> const& x); /// Converts a 4 * 4 matrix to a quaternion. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat quat_cast(mat<4, 4, T, Q> const& x); /// Returns the quaternion rotation angle. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL T angle(tquat const& x); /// Returns the q rotation axis. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<3, T, Q> axis(tquat const& x); /// Build a quaternion from an angle and a normalized axis. /// /// @param angle Angle expressed in radians. /// @param axis Axis of the quaternion, must be normalized. /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL tquat angleAxis(T const& angle, vec<3, T, Q> const& axis); /// Returns the component-wise comparison result of x < y. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> lessThan(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x <= y. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> lessThanEqual(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x > y. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> greaterThan(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x >= y. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> greaterThanEqual(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x == y. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> equal(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x != y. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> notEqual(tquat const& x, tquat const& y); /// Returns true if x holds a NaN (not a number) /// representation in the underlying implementation's set of /// floating point representations. Returns false otherwise, /// including for implementations with no NaN /// representations. /// /// /!\ When using compiler fast math, this function may fail. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> isnan(tquat const& x); /// Returns true if x holds a positive infinity or negative /// infinity representation in the underlying implementation's /// set of floating point representations. Returns false /// otherwise, including for implementations with no infinity /// representations. /// /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion template GLM_FUNC_DECL vec<4, bool, Q> isinf(tquat const& x); /// @} } //namespace glm #include "quaternion.inl" glm-0.9.9-a2/glm/gtc/constants.hpp0000600000175000001440000001031613173131001015552 0ustar guususers/// @ref gtc_constants /// @file glm/gtc/constants.hpp /// /// @see core (dependence) /// /// @defgroup gtc_constants GLM_GTC_constants /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Provide a list of constants and precomputed useful values. #pragma once // Dependencies #include "../detail/setup.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_constants extension included") #endif namespace glm { /// @addtogroup gtc_constants /// @{ /// Return the epsilon constant for floating point types. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon(); /// Return 0. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType zero(); /// Return 1. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one(); /// Return the pi constant. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType pi(); /// Return pi * 2. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi(); /// Return square root of pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi(); /// Return pi / 2. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi(); /// Return pi / 2 * 3. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi(); /// Return pi / 4. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi(); /// Return 1 / pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi(); /// Return 1 / (pi * 2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi(); /// Return 2 / pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi(); /// Return 4 / pi. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi(); /// Return 2 / sqrt(pi). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi(); /// Return 1 / sqrt(2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two(); /// Return sqrt(pi / 2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi(); /// Return sqrt(2 * pi). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi(); /// Return sqrt(ln(4)). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four(); /// Return e constant. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType e(); /// Return Euler's constant. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType euler(); /// Return sqrt(2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_two(); /// Return sqrt(3). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_three(); /// Return sqrt(5). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType root_five(); /// Return ln(2). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two(); /// Return ln(10). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten(); /// Return ln(ln(2)). /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two(); /// Return 1 / 3. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType third(); /// Return 2 / 3. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds(); /// Return the golden ratio constant. /// @see gtc_constants template GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio(); /// @} } //namespace glm #include "constants.inl" glm-0.9.9-a2/glm/gtc/color_space.hpp0000600000175000001440000000366613173131001016041 0ustar guususers/// @ref gtc_color_space /// @file glm/gtc/color_space.hpp /// /// @see core (dependence) /// @see gtc_color_space (dependence) /// /// @defgroup gtc_color_space GLM_GTC_color_space /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Allow to perform bit operations on integer values #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #include "../exponential.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_color_space extension included") #endif namespace glm { /// @addtogroup gtc_color_space /// @{ /// Convert a linear color to sRGB color using a standard gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear); /// Convert a linear color to sRGB color using a custom gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear, T Gamma); /// Convert a sRGB color to linear color using a standard gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB); /// Convert a sRGB color to linear color using a custom gamma correction. // IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb template GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB, T Gamma); /// @} } //namespace glm #include "color_space.inl" glm-0.9.9-a2/glm/gtc/reciprocal.inl0000600000175000001440000001424613173131001015662 0ustar guususers/// @ref gtc_reciprocal /// @file glm/gtc/reciprocal.inl #include "../trigonometric.hpp" #include namespace glm { // sec template GLM_FUNC_QUALIFIER genType sec(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sec' only accept floating-point values"); return genType(1) / glm::cos(angle); } template GLM_FUNC_QUALIFIER vec sec(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sec' only accept floating-point inputs"); return detail::functor1::call(sec, x); } // csc template GLM_FUNC_QUALIFIER genType csc(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csc' only accept floating-point values"); return genType(1) / glm::sin(angle); } template GLM_FUNC_QUALIFIER vec csc(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csc' only accept floating-point inputs"); return detail::functor1::call(csc, x); } // cot template GLM_FUNC_QUALIFIER genType cot(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cot' only accept floating-point values"); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); return glm::tan(pi_over_2 - angle); } template GLM_FUNC_QUALIFIER vec cot(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cot' only accept floating-point inputs"); return detail::functor1::call(cot, x); } // asec template GLM_FUNC_QUALIFIER genType asec(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asec' only accept floating-point values"); return acos(genType(1) / x); } template GLM_FUNC_QUALIFIER vec asec(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asec' only accept floating-point inputs"); return detail::functor1::call(asec, x); } // acsc template GLM_FUNC_QUALIFIER genType acsc(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsc' only accept floating-point values"); return asin(genType(1) / x); } template GLM_FUNC_QUALIFIER vec acsc(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsc' only accept floating-point inputs"); return detail::functor1::call(acsc, x); } // acot template GLM_FUNC_QUALIFIER genType acot(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acot' only accept floating-point values"); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); return pi_over_2 - atan(x); } template GLM_FUNC_QUALIFIER vec acot(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acot' only accept floating-point inputs"); return detail::functor1::call(acot, x); } // sech template GLM_FUNC_QUALIFIER genType sech(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sech' only accept floating-point values"); return genType(1) / glm::cosh(angle); } template GLM_FUNC_QUALIFIER vec sech(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sech' only accept floating-point inputs"); return detail::functor1::call(sech, x); } // csch template GLM_FUNC_QUALIFIER genType csch(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csch' only accept floating-point values"); return genType(1) / glm::sinh(angle); } template GLM_FUNC_QUALIFIER vec csch(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csch' only accept floating-point inputs"); return detail::functor1::call(csch, x); } // coth template GLM_FUNC_QUALIFIER genType coth(genType angle) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'coth' only accept floating-point values"); return glm::cosh(angle) / glm::sinh(angle); } template GLM_FUNC_QUALIFIER vec coth(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'coth' only accept floating-point inputs"); return detail::functor1::call(coth, x); } // asech template GLM_FUNC_QUALIFIER genType asech(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asech' only accept floating-point values"); return acosh(genType(1) / x); } template GLM_FUNC_QUALIFIER vec asech(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asech' only accept floating-point inputs"); return detail::functor1::call(asech, x); } // acsch template GLM_FUNC_QUALIFIER genType acsch(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsch' only accept floating-point values"); return acsch(genType(1) / x); } template GLM_FUNC_QUALIFIER vec acsch(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsch' only accept floating-point inputs"); return detail::functor1::call(acsch, x); } // acoth template GLM_FUNC_QUALIFIER genType acoth(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acoth' only accept floating-point values"); return atanh(genType(1) / x); } template GLM_FUNC_QUALIFIER vec acoth(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acoth' only accept floating-point inputs"); return detail::functor1::call(acoth, x); } }//namespace glm glm-0.9.9-a2/glm/gtc/matrix_inverse.hpp0000600000175000001440000000271013173131001016574 0ustar guususers/// @ref gtc_matrix_inverse /// @file glm/gtc/matrix_inverse.hpp /// /// @see core (dependence) /// /// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Defines additional matrix inverting functions. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../matrix.hpp" #include "../mat2x2.hpp" #include "../mat3x3.hpp" #include "../mat4x4.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_matrix_inverse extension included") #endif namespace glm { /// @addtogroup gtc_matrix_inverse /// @{ /// Fast matrix inverse for affine matrix. /// /// @param m Input matrix to invert. /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. /// @see gtc_matrix_inverse template GLM_FUNC_DECL genType affineInverse(genType const& m); /// Compute the inverse transpose of a matrix. /// /// @param m Input matrix to invert transpose. /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. /// @see gtc_matrix_inverse template GLM_FUNC_DECL genType inverseTranspose(genType const& m); /// @} }//namespace glm #include "matrix_inverse.inl" glm-0.9.9-a2/glm/gtc/type_precision.inl0000600000175000001440000000010713173131001016562 0ustar guususers/// @ref gtc_swizzle /// @file glm/gtc/swizzle.inl namespace glm { } glm-0.9.9-a2/glm/gtc/quaternion.inl0000600000175000001440000005357613173131001015735 0ustar guususers/// @ref gtc_quaternion /// @file glm/gtc/quaternion.inl #include "../trigonometric.hpp" #include "../geometric.hpp" #include "../exponential.hpp" #include "../detail/compute_vector_relational.hpp" #include "epsilon.hpp" #include namespace glm{ namespace detail { template struct compute_dot, T, Aligned> { static GLM_FUNC_QUALIFIER T call(tquat const& a, tquat const& b) { vec<4, T, Q> tmp(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); return (tmp.x + tmp.y) + (tmp.z + tmp.w); } }; template struct compute_quat_add { static tquat call(tquat const& q, tquat const& p) { return tquat(q.w + p.w, q.x + p.x, q.y + p.y, q.z + p.z); } }; template struct compute_quat_sub { static tquat call(tquat const& q, tquat const& p) { return tquat(q.w - p.w, q.x - p.x, q.y - p.y, q.z - p.z); } }; template struct compute_quat_mul_scalar { static tquat call(tquat const& q, T s) { return tquat(q.w * s, q.x * s, q.y * s, q.z * s); } }; template struct compute_quat_div_scalar { static tquat call(tquat const& q, T s) { return tquat(q.w / s, q.x / s, q.y / s, q.z / s); } }; template struct compute_quat_mul_vec4 { static vec<4, T, Q> call(tquat const& q, vec<4, T, Q> const& v) { return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w); } }; }//namespace detail // -- Component accesses -- template GLM_FUNC_QUALIFIER T & tquat::operator[](typename tquat::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } template GLM_FUNC_QUALIFIER T const& tquat::operator[](typename tquat::length_type i) const { assert(i >= 0 && i < this->length()); return (&x)[i]; } // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(tquat const& q) : x(q.x), y(q.y), z(q.z), w(q.w) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(tquat const& q) : x(q.x), y(q.y), z(q.z), w(q.w) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(T s, vec<3, T, Q> const& v) : x(v.x), y(v.y), z(v.z), w(s) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(T _w, T _x, T _y, T _z) : x(_x), y(_y), z(_z), w(_w) {} // -- Conversion constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(tquat const& q) : x(static_cast(q.x)) , y(static_cast(q.y)) , z(static_cast(q.z)) , w(static_cast(q.w)) {} //template //GLM_FUNC_QUALIFIER tquat::tquat //( // valType const& pitch, // valType const& yaw, // valType const& roll //) //{ // vec<3, valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5)); // vec<3, valType> c = glm::cos(eulerAngle * valType(0.5)); // vec<3, valType> s = glm::sin(eulerAngle * valType(0.5)); // // this->w = c.x * c.y * c.z + s.x * s.y * s.z; // this->x = s.x * c.y * c.z - c.x * s.y * s.z; // this->y = c.x * s.y * c.z + s.x * c.y * s.z; // this->z = c.x * c.y * s.z - s.x * s.y * c.z; //} template GLM_FUNC_QUALIFIER tquat::tquat(vec<3, T, Q> const& u, vec<3, T, Q> const& v) { T norm_u_norm_v = sqrt(dot(u, u) * dot(v, v)); T real_part = norm_u_norm_v + dot(u, v); vec<3, T, Q> t; if(real_part < static_cast(1.e-6f) * norm_u_norm_v) { // If u and v are exactly opposite, rotate 180 degrees // around an arbitrary orthogonal axis. Axis normalisation // can happen later, when we normalise the quaternion. real_part = static_cast(0); t = abs(u.x) > abs(u.z) ? vec<3, T, Q>(-u.y, u.x, static_cast(0)) : vec<3, T, Q>(static_cast(0), -u.z, u.y); } else { // Otherwise, build quaternion the standard way. t = cross(u, v); } *this = normalize(tquat(real_part, t.x, t.y, t.z)); } template GLM_FUNC_QUALIFIER tquat::tquat(vec<3, T, Q> const& eulerAngle) { vec<3, T, Q> c = glm::cos(eulerAngle * T(0.5)); vec<3, T, Q> s = glm::sin(eulerAngle * T(0.5)); this->w = c.x * c.y * c.z + s.x * s.y * s.z; this->x = s.x * c.y * c.z - c.x * s.y * s.z; this->y = c.x * s.y * c.z + s.x * c.y * s.z; this->z = c.x * c.y * s.z - s.x * s.y * c.z; } template GLM_FUNC_QUALIFIER tquat::tquat(mat<3, 3, T, Q> const& m) { *this = quat_cast(m); } template GLM_FUNC_QUALIFIER tquat::tquat(mat<4, 4, T, Q> const& m) { *this = quat_cast(m); } # if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS template GLM_FUNC_QUALIFIER tquat::operator mat<3, 3, T, Q>() { return mat3_cast(*this); } template GLM_FUNC_QUALIFIER tquat::operator mat<4, 4, T, Q>() { return mat4_cast(*this); } # endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS template GLM_FUNC_QUALIFIER tquat conjugate(tquat const& q) { return tquat(q.w, -q.x, -q.y, -q.z); } template GLM_FUNC_QUALIFIER tquat inverse(tquat const& q) { return conjugate(q) / dot(q, q); } // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER tquat & tquat::operator=(tquat const& q) { this->w = q.w; this->x = q.x; this->y = q.y; this->z = q.z; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER tquat & tquat::operator=(tquat const& q) { this->w = static_cast(q.w); this->x = static_cast(q.x); this->y = static_cast(q.y); this->z = static_cast(q.z); return *this; } template template GLM_FUNC_QUALIFIER tquat & tquat::operator+=(tquat const& q) { return (*this = detail::compute_quat_add::value>::call(*this, tquat(q))); } template template GLM_FUNC_QUALIFIER tquat & tquat::operator-=(tquat const& q) { return (*this = detail::compute_quat_sub::value>::call(*this, tquat(q))); } template template GLM_FUNC_QUALIFIER tquat & tquat::operator*=(tquat const& r) { tquat const p(*this); tquat const q(r); this->w = p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z; this->x = p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y; this->y = p.w * q.y + p.y * q.w + p.z * q.x - p.x * q.z; this->z = p.w * q.z + p.z * q.w + p.x * q.y - p.y * q.x; return *this; } template template GLM_FUNC_QUALIFIER tquat & tquat::operator*=(U s) { return (*this = detail::compute_quat_mul_scalar::value>::call(*this, static_cast(s))); } template template GLM_FUNC_QUALIFIER tquat & tquat::operator/=(U s) { return (*this = detail::compute_quat_div_scalar::value>::call(*this, static_cast(s))); } // -- Unary bit operators -- template GLM_FUNC_QUALIFIER tquat operator+(tquat const& q) { return q; } template GLM_FUNC_QUALIFIER tquat operator-(tquat const& q) { return tquat(-q.w, -q.x, -q.y, -q.z); } // -- Binary operators -- template GLM_FUNC_QUALIFIER tquat operator+(tquat const& q, tquat const& p) { return tquat(q) += p; } template GLM_FUNC_QUALIFIER tquat operator*(tquat const& q, tquat const& p) { return tquat(q) *= p; } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(tquat const& q, vec<3, T, Q> const& v) { vec<3, T, Q> const QuatVector(q.x, q.y, q.z); vec<3, T, Q> const uv(glm::cross(QuatVector, v)); vec<3, T, Q> const uuv(glm::cross(QuatVector, uv)); return v + ((uv * q.w) + uuv) * static_cast(2); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v, tquat const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(tquat const& q, vec<4, T, Q> const& v) { return detail::compute_quat_mul_vec4::value>::call(q, v); } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v, tquat const& q) { return glm::inverse(q) * v; } template GLM_FUNC_QUALIFIER tquat operator*(tquat const& q, T const& s) { return tquat( q.w * s, q.x * s, q.y * s, q.z * s); } template GLM_FUNC_QUALIFIER tquat operator*(T const& s, tquat const& q) { return q * s; } template GLM_FUNC_QUALIFIER tquat operator/(tquat const& q, T const& s) { return tquat( q.w / s, q.x / s, q.y / s, q.z / s); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(tquat const& q1, tquat const& q2) { return all(epsilonEqual(q1, q2, epsilon())); } template GLM_FUNC_QUALIFIER bool operator!=(tquat const& q1, tquat const& q2) { return any(epsilonNotEqual(q1, q2, epsilon())); } // -- Operations -- template GLM_FUNC_QUALIFIER T dot(tquat const& x, tquat const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); } template GLM_FUNC_QUALIFIER T length(tquat const& q) { return glm::sqrt(dot(q, q)); } template GLM_FUNC_QUALIFIER tquat normalize(tquat const& q) { T len = length(q); if(len <= T(0)) // Problem return tquat(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); T oneOverLen = T(1) / len; return tquat(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen); } template GLM_FUNC_QUALIFIER tquat cross(tquat const& q1, tquat const& q2) { return tquat( q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z, q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y, q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z, q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x); } /* // (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle)) template GLM_FUNC_QUALIFIER tquat mix(tquat const& x, tquat const& y, T const& a) { if(a <= T(0)) return x; if(a >= T(1)) return y; float fCos = dot(x, y); tquat y2(y); //BUG!!! tquat y2; if(fCos < T(0)) { y2 = -y; fCos = -fCos; } //if(fCos > 1.0f) // problem float k0, k1; if(fCos > T(0.9999)) { k0 = T(1) - a; k1 = T(0) + a; //BUG!!! 1.0f + a; } else { T fSin = sqrt(T(1) - fCos * fCos); T fAngle = atan(fSin, fCos); T fOneOverSin = static_cast(1) / fSin; k0 = sin((T(1) - a) * fAngle) * fOneOverSin; k1 = sin((T(0) + a) * fAngle) * fOneOverSin; } return tquat( k0 * x.w + k1 * y2.w, k0 * x.x + k1 * y2.x, k0 * x.y + k1 * y2.y, k0 * x.z + k1 * y2.z); } template GLM_FUNC_QUALIFIER tquat mix2 ( tquat const& x, tquat const& y, T const& a ) { bool flip = false; if(a <= static_cast(0)) return x; if(a >= static_cast(1)) return y; T cos_t = dot(x, y); if(cos_t < T(0)) { cos_t = -cos_t; flip = true; } T alpha(0), beta(0); if(T(1) - cos_t < 1e-7) beta = static_cast(1) - alpha; else { T theta = acos(cos_t); T sin_t = sin(theta); beta = sin(theta * (T(1) - alpha)) / sin_t; alpha = sin(alpha * theta) / sin_t; } if(flip) alpha = -alpha; return normalize(beta * x + alpha * y); } */ template GLM_FUNC_QUALIFIER tquat mix(tquat const& x, tquat const& y, T a) { T cosTheta = dot(x, y); // Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator if(cosTheta > T(1) - epsilon()) { // Linear interpolation return tquat( mix(x.w, y.w, a), mix(x.x, y.x, a), mix(x.y, y.y, a), mix(x.z, y.z, a)); } else { // Essential Mathematics, page 467 T angle = acos(cosTheta); return (sin((T(1) - a) * angle) * x + sin(a * angle) * y) / sin(angle); } } template GLM_FUNC_QUALIFIER tquat lerp(tquat const& x, tquat const& y, T a) { // Lerp is only defined in [0, 1] assert(a >= static_cast(0)); assert(a <= static_cast(1)); return x * (T(1) - a) + (y * a); } template GLM_FUNC_QUALIFIER tquat slerp(tquat const& x, tquat const& y, T a) { tquat z = y; T cosTheta = dot(x, y); // If cosTheta < 0, the interpolation will take the long way around the sphere. // To fix this, one quat must be negated. if (cosTheta < T(0)) { z = -y; cosTheta = -cosTheta; } // Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator if(cosTheta > T(1) - epsilon()) { // Linear interpolation return tquat( mix(x.w, z.w, a), mix(x.x, z.x, a), mix(x.y, z.y, a), mix(x.z, z.z, a)); } else { // Essential Mathematics, page 467 T angle = acos(cosTheta); return (sin((T(1) - a) * angle) * x + sin(a * angle) * z) / sin(angle); } } template GLM_FUNC_QUALIFIER tquat rotate(tquat const& q, T const& angle, vec<3, T, Q> const& v) { vec<3, T, Q> Tmp = v; // Axis of rotation must be normalised T len = glm::length(Tmp); if(abs(len - T(1)) > T(0.001)) { T oneOverLen = static_cast(1) / len; Tmp.x *= oneOverLen; Tmp.y *= oneOverLen; Tmp.z *= oneOverLen; } T const AngleRad(angle); T const Sin = sin(AngleRad * T(0.5)); return q * tquat(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); //return gtc::quaternion::cross(q, tquat(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> eulerAngles(tquat const& x) { return vec<3, T, Q>(pitch(x), yaw(x), roll(x)); } template GLM_FUNC_QUALIFIER T roll(tquat const& q) { return static_cast(atan(static_cast(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z)); } template GLM_FUNC_QUALIFIER T pitch(tquat const& q) { //return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z)); const T y = static_cast(2) * (q.y * q.z + q.w * q.x); const T x = q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z; if(detail::compute_equal::call(y, static_cast(0)) && detail::compute_equal::call(x, static_cast(0))) //avoid atan2(0,0) - handle singularity - Matiis return static_cast(static_cast(2) * atan(q.x,q.w)); return static_cast(atan(y,x)); } template GLM_FUNC_QUALIFIER T yaw(tquat const& q) { return asin(clamp(static_cast(-2) * (q.x * q.z - q.w * q.y), static_cast(-1), static_cast(1))); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat3_cast(tquat const& q) { mat<3, 3, T, Q> Result(T(1)); T qxx(q.x * q.x); T qyy(q.y * q.y); T qzz(q.z * q.z); T qxz(q.x * q.z); T qxy(q.x * q.y); T qyz(q.y * q.z); T qwx(q.w * q.x); T qwy(q.w * q.y); T qwz(q.w * q.z); Result[0][0] = T(1) - T(2) * (qyy + qzz); Result[0][1] = T(2) * (qxy + qwz); Result[0][2] = T(2) * (qxz - qwy); Result[1][0] = T(2) * (qxy - qwz); Result[1][1] = T(1) - T(2) * (qxx + qzz); Result[1][2] = T(2) * (qyz + qwx); Result[2][0] = T(2) * (qxz + qwy); Result[2][1] = T(2) * (qyz - qwx); Result[2][2] = T(1) - T(2) * (qxx + qyy); return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat4_cast(tquat const& q) { return mat<4, 4, T, Q>(mat3_cast(q)); } template GLM_FUNC_QUALIFIER tquat quat_cast(mat<3, 3, T, Q> const& m) { T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2]; T fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2]; T fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1]; T fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2]; int biggestIndex = 0; T fourBiggestSquaredMinus1 = fourWSquaredMinus1; if(fourXSquaredMinus1 > fourBiggestSquaredMinus1) { fourBiggestSquaredMinus1 = fourXSquaredMinus1; biggestIndex = 1; } if(fourYSquaredMinus1 > fourBiggestSquaredMinus1) { fourBiggestSquaredMinus1 = fourYSquaredMinus1; biggestIndex = 2; } if(fourZSquaredMinus1 > fourBiggestSquaredMinus1) { fourBiggestSquaredMinus1 = fourZSquaredMinus1; biggestIndex = 3; } T biggestVal = sqrt(fourBiggestSquaredMinus1 + static_cast(1)) * static_cast(0.5); T mult = static_cast(0.25) / biggestVal; switch(biggestIndex) { case 0: return tquat(biggestVal, (m[1][2] - m[2][1]) * mult, (m[2][0] - m[0][2]) * mult, (m[0][1] - m[1][0]) * mult); case 1: return tquat((m[1][2] - m[2][1]) * mult, biggestVal, (m[0][1] + m[1][0]) * mult, (m[2][0] + m[0][2]) * mult); case 2: return tquat((m[2][0] - m[0][2]) * mult, (m[0][1] + m[1][0]) * mult, biggestVal, (m[1][2] + m[2][1]) * mult); case 3: return tquat((m[0][1] - m[1][0]) * mult, (m[2][0] + m[0][2]) * mult, (m[1][2] + m[2][1]) * mult, biggestVal); default: // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity. assert(false); return tquat(1, 0, 0, 0); } } template GLM_FUNC_QUALIFIER tquat quat_cast(mat<4, 4, T, Q> const& m4) { return quat_cast(mat<3, 3, T, Q>(m4)); } template GLM_FUNC_QUALIFIER T angle(tquat const& x) { return acos(x.w) * static_cast(2); } template GLM_FUNC_QUALIFIER vec<3, T, Q> axis(tquat const& x) { T tmp1 = static_cast(1) - x.w * x.w; if(tmp1 <= static_cast(0)) return vec<3, T, Q>(0, 0, 1); T tmp2 = static_cast(1) / sqrt(tmp1); return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); } template GLM_FUNC_QUALIFIER tquat angleAxis(T const& angle, vec<3, T, Q> const& v) { tquat Result; T const a(angle); T const s = glm::sin(a * static_cast(0.5)); Result.w = glm::cos(a * static_cast(0.5)); Result.x = v.x * s; Result.y = v.y * s; Result.z = v.z * s; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThan(tquat const& x, tquat const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] < y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThanEqual(tquat const& x, tquat const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] <= y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThan(tquat const& x, tquat const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] > y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThanEqual(tquat const& x, tquat const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] >= y[i]; return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(tquat const& x, tquat const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = detail::compute_equal::call(x[i], y[i]); return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(tquat const& x, tquat const& y) { vec<4, bool, Q> Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = !detail::compute_equal::call(x[i], y[i]); return Result; } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isnan(tquat const& q) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); return vec<4, bool, Q>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w)); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> isinf(tquat const& q) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isinf' only accept floating-point inputs"); return vec<4, bool, Q>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w)); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_ALIGNED_TYPE # include "quaternion_simd.inl" #endif glm-0.9.9-a2/glm/gtc/vec1.hpp0000600000175000001440000000441113173131001014373 0ustar guususers/// @ref gtc_vec1 /// @file glm/gtc/vec1.hpp /// /// @see core (dependence) /// /// @defgroup gtc_vec1 GLM_GTC_vec1 /// @ingroup gtc /// /// Include to use the features of this extension. /// /// Add vec1, ivec1, uvec1 and bvec1 types. #pragma once // Dependency: #include "../ext/vec1.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_vec1 extension included") #endif namespace glm { ////////////////////////// // vec1 definition #if(defined(GLM_PRECISION_HIGHP_BOOL)) typedef highp_bvec1 bvec1; #elif(defined(GLM_PRECISION_MEDIUMP_BOOL)) typedef mediump_bvec1 bvec1; #elif(defined(GLM_PRECISION_LOWP_BOOL)) typedef lowp_bvec1 bvec1; #else /// 1 component vector of boolean. /// @see gtc_vec1 extension. typedef highp_bvec1 bvec1; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_HIGHP_FLOAT)) typedef highp_vec1 vec1; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) typedef mediump_vec1 vec1; #elif(defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_vec1 vec1; #else /// 1 component vector of floating-point numbers. /// @see gtc_vec1 extension. typedef highp_vec1 vec1; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_HIGHP_DOUBLE)) typedef highp_dvec1 dvec1; #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE)) typedef mediump_dvec1 dvec1; #elif(defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_dvec1 dvec1; #else /// 1 component vector of floating-point numbers. /// @see gtc_vec1 extension. typedef highp_dvec1 dvec1; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_HIGHP_INT)) typedef highp_ivec1 ivec1; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_ivec1 ivec1; #elif(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_ivec1 ivec1; #else /// 1 component vector of signed integer numbers. /// @see gtc_vec1 extension. typedef highp_ivec1 ivec1; #endif//GLM_PRECISION #if(defined(GLM_PRECISION_HIGHP_UINT)) typedef highp_uvec1 uvec1; #elif(defined(GLM_PRECISION_MEDIUMP_UINT)) typedef mediump_uvec1 uvec1; #elif(defined(GLM_PRECISION_LOWP_UINT)) typedef lowp_uvec1 uvec1; #else /// 1 component vector of unsigned integer numbers. /// @see gtc_vec1 extension. typedef highp_uvec1 uvec1; #endif//GLM_PRECISION }// namespace glm #include "vec1.inl" glm-0.9.9-a2/glm/gtc/noise.inl0000600000175000001440000010065313173131001014652 0ustar guususers/// @ref gtc_noise /// @file glm/gtc/noise.inl /// // Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": // https://github.com/ashima/webgl-noise // Following Stefan Gustavson's paper "Simplex noise demystified": // http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf namespace glm{ namespace gtc { template GLM_FUNC_QUALIFIER vec<4, T, Q> grad4(T const& j, vec<4, T, Q> const& ip) { vec<3, T, Q> pXYZ = floor(fract(vec<3, T, Q>(j) * vec<3, T, Q>(ip)) * T(7)) * ip[2] - T(1); T pW = static_cast(1.5) - dot(abs(pXYZ), vec<3, T, Q>(1)); vec<4, T, Q> s = vec<4, T, Q>(lessThan(vec<4, T, Q>(pXYZ, pW), vec<4, T, Q>(0.0))); pXYZ = pXYZ + (vec<3, T, Q>(s) * T(2) - T(1)) * s.w; return vec<4, T, Q>(pXYZ, pW); } }//namespace gtc // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position) { vec<4, T, Q> Pi = glm::floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); vec<4, T, Q> Pf = glm::fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z); vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w); vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z); vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w); vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> gx = static_cast(2) * glm::fract(i / T(41)) - T(1); vec<4, T, Q> gy = glm::abs(gx) - T(0.5); vec<4, T, Q> tx = glm::floor(gx + T(0.5)); gx = gx - tx; vec<2, T, Q> g00(gx.x, gy.x); vec<2, T, Q> g10(gx.y, gy.y); vec<2, T, Q> g01(gx.z, gy.z); vec<2, T, Q> g11(gx.w, gy.w); vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11))); g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w; T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x)); T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y)); T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z)); T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w)); vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y)); vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x); T n_xy = mix(n_x.x, n_x.y, fade_xy.y); return T(2.3) * n_xy; } // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position) { vec<3, T, Q> Pi0 = floor(Position); // Integer part for indexing vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1 Pi0 = detail::mod289(Pi0); Pi1 = detail::mod289(Pi1); vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy = vec<4, T, Q>(vec<2, T, Q>(Pi0.y), vec<2, T, Q>(Pi1.y)); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> gx0 = ixy0 * T(1.0 / 7.0); vec<4, T, Q> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5); gx0 = fract(gx0); vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0); vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0)); gx0 -= sz0 * (step(T(0), gx0) - T(0.5)); gy0 -= sz0 * (step(T(0), gy0) - T(0.5)); vec<4, T, Q> gx1 = ixy1 * T(1.0 / 7.0); vec<4, T, Q> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5); gx1 = fract(gx1); vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1); vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0)); gx1 -= sz1 * (step(T(0), gx1) - T(0.5)); gy1 -= sz1 * (step(T(0), gy1) - T(0.5)); vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x); vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y); vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z); vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w); vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x); vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y); vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z); vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w); vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110))); g000 *= norm0.x; g010 *= norm0.y; g100 *= norm0.z; g110 *= norm0.w; vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111))); g001 *= norm1.x; g011 *= norm1.y; g101 *= norm1.z; g111 *= norm1.w; T n000 = dot(g000, Pf0); T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z)); T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z)); T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z)); T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z)); T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z)); T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z)); T n111 = dot(g111, Pf1); vec<3, T, Q> fade_xyz = detail::fade(Pf0); vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z); vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y); T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); return T(2.2) * n_xyz; } /* // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& P) { vec<3, T, Q> Pi0 = floor(P); // Integer part for indexing vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1 Pi0 = mod(Pi0, T(289)); Pi1 = mod(Pi1, T(289)); vec<3, T, Q> Pf0 = fract(P); // Fractional part for interpolation vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> ixy = permute(permute(ix) + iy); vec<4, T, Q> ixy0 = permute(ixy + iz0); vec<4, T, Q> ixy1 = permute(ixy + iz1); vec<4, T, Q> gx0 = ixy0 / T(7); vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5); gx0 = fract(gx0); vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0); vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0)); gx0 -= sz0 * (step(0.0, gx0) - T(0.5)); gy0 -= sz0 * (step(0.0, gy0) - T(0.5)); vec<4, T, Q> gx1 = ixy1 / T(7); vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5); gx1 = fract(gx1); vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1); vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0)); gx1 -= sz1 * (step(T(0), gx1) - T(0.5)); gy1 -= sz1 * (step(T(0), gy1) - T(0.5)); vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x); vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y); vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z); vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w); vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x); vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y); vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z); vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w); vec<4, T, Q> norm0 = taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110))); g000 *= norm0.x; g010 *= norm0.y; g100 *= norm0.z; g110 *= norm0.w; vec<4, T, Q> norm1 = taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111))); g001 *= norm1.x; g011 *= norm1.y; g101 *= norm1.z; g111 *= norm1.w; T n000 = dot(g000, Pf0); T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z)); T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z)); T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z)); T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z)); T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z)); T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z)); T n111 = dot(g111, Pf1); vec<3, T, Q> fade_xyz = fade(Pf0); vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z); vec<2, T, Q> n_yz = mix( vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y); T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); return T(2.2) * n_xyz; } */ // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position) { vec<4, T, Q> Pi0 = floor(Position); // Integer part for indexing vec<4, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1 Pi0 = mod(Pi0, vec<4, T, Q>(289)); Pi1 = mod(Pi1, vec<4, T, Q>(289)); vec<4, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<4, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> iw0(Pi0.w); vec<4, T, Q> iw1(Pi1.w); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0); vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1); vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0); vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1); vec<4, T, Q> gx00 = ixy00 / T(7); vec<4, T, Q> gy00 = floor(gx00) / T(7); vec<4, T, Q> gz00 = floor(gy00) / T(6); gx00 = fract(gx00) - T(0.5); gy00 = fract(gy00) - T(0.5); gz00 = fract(gz00) - T(0.5); vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00); vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0.0)); gx00 -= sw00 * (step(T(0), gx00) - T(0.5)); gy00 -= sw00 * (step(T(0), gy00) - T(0.5)); vec<4, T, Q> gx01 = ixy01 / T(7); vec<4, T, Q> gy01 = floor(gx01) / T(7); vec<4, T, Q> gz01 = floor(gy01) / T(6); gx01 = fract(gx01) - T(0.5); gy01 = fract(gy01) - T(0.5); gz01 = fract(gz01) - T(0.5); vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01); vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0)); gx01 -= sw01 * (step(T(0), gx01) - T(0.5)); gy01 -= sw01 * (step(T(0), gy01) - T(0.5)); vec<4, T, Q> gx10 = ixy10 / T(7); vec<4, T, Q> gy10 = floor(gx10) / T(7); vec<4, T, Q> gz10 = floor(gy10) / T(6); gx10 = fract(gx10) - T(0.5); gy10 = fract(gy10) - T(0.5); gz10 = fract(gz10) - T(0.5); vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10); vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0)); gx10 -= sw10 * (step(T(0), gx10) - T(0.5)); gy10 -= sw10 * (step(T(0), gy10) - T(0.5)); vec<4, T, Q> gx11 = ixy11 / T(7); vec<4, T, Q> gy11 = floor(gx11) / T(7); vec<4, T, Q> gz11 = floor(gy11) / T(6); gx11 = fract(gx11) - T(0.5); gy11 = fract(gy11) - T(0.5); gz11 = fract(gz11) - T(0.5); vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11); vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(0.0)); gx11 -= sw11 * (step(T(0), gx11) - T(0.5)); gy11 -= sw11 * (step(T(0), gy11) - T(0.5)); vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x); vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y); vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z); vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w); vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x); vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y); vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z); vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w); vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x); vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y); vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z); vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w); vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x); vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y); vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z); vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w); vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100))); g0000 *= norm00.x; g0100 *= norm00.y; g1000 *= norm00.z; g1100 *= norm00.w; vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101))); g0001 *= norm01.x; g0101 *= norm01.y; g1001 *= norm01.z; g1101 *= norm01.w; vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110))); g0010 *= norm10.x; g0110 *= norm10.y; g1010 *= norm10.z; g1110 *= norm10.w; vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111))); g0011 *= norm11.x; g0111 *= norm11.y; g1011 *= norm11.z; g1111 *= norm11.w; T n0000 = dot(g0000, Pf0); T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w)); T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w)); T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w)); T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w)); T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w)); T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w)); T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w)); T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w)); T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w)); T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w)); T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w)); T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w)); T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w)); T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w)); T n1111 = dot(g1111, Pf1); vec<4, T, Q> fade_xyzw = detail::fade(Pf0); vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w); vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w); vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z); vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y); T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x); return T(2.2) * n_xyzw; } // Classic Perlin noise, periodic variant template GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position, vec<2, T, Q> const& rep) { vec<4, T, Q> Pi = floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); vec<4, T, Q> Pf = fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0); Pi = mod(Pi, vec<4, T, Q>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z); vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w); vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z); vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w); vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> gx = static_cast(2) * fract(i / T(41)) - T(1); vec<4, T, Q> gy = abs(gx) - T(0.5); vec<4, T, Q> tx = floor(gx + T(0.5)); gx = gx - tx; vec<2, T, Q> g00(gx.x, gy.x); vec<2, T, Q> g10(gx.y, gy.y); vec<2, T, Q> g01(gx.z, gy.z); vec<2, T, Q> g11(gx.w, gy.w); vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11))); g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w; T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x)); T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y)); T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z)); T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w)); vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y)); vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x); T n_xy = mix(n_x.x, n_x.y, fade_xy.y); return T(2.3) * n_xy; } // Classic Perlin noise, periodic variant template GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position, vec<3, T, Q> const& rep) { vec<3, T, Q> Pi0 = mod(floor(Position), rep); // Integer part, modulo period vec<3, T, Q> Pi1 = mod(Pi0 + vec<3, T, Q>(T(1)), rep); // Integer part + 1, mod period Pi0 = mod(Pi0, vec<3, T, Q>(289)); Pi1 = mod(Pi1, vec<3, T, Q>(289)); vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<3, T, Q> Pf1 = Pf0 - vec<3, T, Q>(T(1)); // Fractional part - 1.0 vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> gx0 = ixy0 / T(7); vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5); gx0 = fract(gx0); vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0); vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0)); gx0 -= sz0 * (step(T(0), gx0) - T(0.5)); gy0 -= sz0 * (step(T(0), gy0) - T(0.5)); vec<4, T, Q> gx1 = ixy1 / T(7); vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5); gx1 = fract(gx1); vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1); vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(T(0))); gx1 -= sz1 * (step(T(0), gx1) - T(0.5)); gy1 -= sz1 * (step(T(0), gy1) - T(0.5)); vec<3, T, Q> g000 = vec<3, T, Q>(gx0.x, gy0.x, gz0.x); vec<3, T, Q> g100 = vec<3, T, Q>(gx0.y, gy0.y, gz0.y); vec<3, T, Q> g010 = vec<3, T, Q>(gx0.z, gy0.z, gz0.z); vec<3, T, Q> g110 = vec<3, T, Q>(gx0.w, gy0.w, gz0.w); vec<3, T, Q> g001 = vec<3, T, Q>(gx1.x, gy1.x, gz1.x); vec<3, T, Q> g101 = vec<3, T, Q>(gx1.y, gy1.y, gz1.y); vec<3, T, Q> g011 = vec<3, T, Q>(gx1.z, gy1.z, gz1.z); vec<3, T, Q> g111 = vec<3, T, Q>(gx1.w, gy1.w, gz1.w); vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110))); g000 *= norm0.x; g010 *= norm0.y; g100 *= norm0.z; g110 *= norm0.w; vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111))); g001 *= norm1.x; g011 *= norm1.y; g101 *= norm1.z; g111 *= norm1.w; T n000 = dot(g000, Pf0); T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z)); T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z)); T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z)); T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z)); T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z)); T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z)); T n111 = dot(g111, Pf1); vec<3, T, Q> fade_xyz = detail::fade(Pf0); vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z); vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y); T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); return T(2.2) * n_xyz; } // Classic Perlin noise, periodic version template GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position, vec<4, T, Q> const& rep) { vec<4, T, Q> Pi0 = mod(floor(Position), rep); // Integer part modulo rep vec<4, T, Q> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep vec<4, T, Q> Pf0 = fract(Position); // Fractional part for interpolation vec<4, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0 vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x); vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y); vec<4, T, Q> iz0(Pi0.z); vec<4, T, Q> iz1(Pi1.z); vec<4, T, Q> iw0(Pi0.w); vec<4, T, Q> iw1(Pi1.w); vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy); vec<4, T, Q> ixy0 = detail::permute(ixy + iz0); vec<4, T, Q> ixy1 = detail::permute(ixy + iz1); vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0); vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1); vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0); vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1); vec<4, T, Q> gx00 = ixy00 / T(7); vec<4, T, Q> gy00 = floor(gx00) / T(7); vec<4, T, Q> gz00 = floor(gy00) / T(6); gx00 = fract(gx00) - T(0.5); gy00 = fract(gy00) - T(0.5); gz00 = fract(gz00) - T(0.5); vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00); vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0)); gx00 -= sw00 * (step(T(0), gx00) - T(0.5)); gy00 -= sw00 * (step(T(0), gy00) - T(0.5)); vec<4, T, Q> gx01 = ixy01 / T(7); vec<4, T, Q> gy01 = floor(gx01) / T(7); vec<4, T, Q> gz01 = floor(gy01) / T(6); gx01 = fract(gx01) - T(0.5); gy01 = fract(gy01) - T(0.5); gz01 = fract(gz01) - T(0.5); vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01); vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0)); gx01 -= sw01 * (step(T(0), gx01) - T(0.5)); gy01 -= sw01 * (step(T(0), gy01) - T(0.5)); vec<4, T, Q> gx10 = ixy10 / T(7); vec<4, T, Q> gy10 = floor(gx10) / T(7); vec<4, T, Q> gz10 = floor(gy10) / T(6); gx10 = fract(gx10) - T(0.5); gy10 = fract(gy10) - T(0.5); gz10 = fract(gz10) - T(0.5); vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10); vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0.0)); gx10 -= sw10 * (step(T(0), gx10) - T(0.5)); gy10 -= sw10 * (step(T(0), gy10) - T(0.5)); vec<4, T, Q> gx11 = ixy11 / T(7); vec<4, T, Q> gy11 = floor(gx11) / T(7); vec<4, T, Q> gz11 = floor(gy11) / T(6); gx11 = fract(gx11) - T(0.5); gy11 = fract(gy11) - T(0.5); gz11 = fract(gz11) - T(0.5); vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11); vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(T(0))); gx11 -= sw11 * (step(T(0), gx11) - T(0.5)); gy11 -= sw11 * (step(T(0), gy11) - T(0.5)); vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x); vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y); vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z); vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w); vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x); vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y); vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z); vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w); vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x); vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y); vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z); vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w); vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x); vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y); vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z); vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w); vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100))); g0000 *= norm00.x; g0100 *= norm00.y; g1000 *= norm00.z; g1100 *= norm00.w; vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101))); g0001 *= norm01.x; g0101 *= norm01.y; g1001 *= norm01.z; g1101 *= norm01.w; vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110))); g0010 *= norm10.x; g0110 *= norm10.y; g1010 *= norm10.z; g1110 *= norm10.w; vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111))); g0011 *= norm11.x; g0111 *= norm11.y; g1011 *= norm11.z; g1111 *= norm11.w; T n0000 = dot(g0000, Pf0); T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w)); T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w)); T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w)); T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w)); T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w)); T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w)); T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w)); T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w)); T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w)); T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w)); T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w)); T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w)); T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w)); T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w)); T n1111 = dot(g1111, Pf1); vec<4, T, Q> fade_xyzw = detail::fade(Pf0); vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w); vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w); vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z); vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y); T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x); return T(2.2) * n_xyzw; } template GLM_FUNC_QUALIFIER T simplex(glm::vec<2, T, Q> const& v) { vec<4, T, Q> const C = vec<4, T, Q>( T( 0.211324865405187), // (3.0 - sqrt(3.0)) / 6.0 T( 0.366025403784439), // 0.5 * (sqrt(3.0) - 1.0) T(-0.577350269189626), // -1.0 + 2.0 * C.x T( 0.024390243902439)); // 1.0 / 41.0 // First corner vec<2, T, Q> i = floor(v + dot(v, vec<2, T, Q>(C[1]))); vec<2, T, Q> x0 = v - i + dot(i, vec<2, T, Q>(C[0])); // Other corners //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0 //i1.y = 1.0 - i1.x; vec<2, T, Q> i1 = (x0.x > x0.y) ? vec<2, T, Q>(1, 0) : vec<2, T, Q>(0, 1); // x0 = x0 - 0.0 + 0.0 * C.xx ; // x1 = x0 - i1 + 1.0 * C.xx ; // x2 = x0 - 1.0 + 2.0 * C.xx ; vec<4, T, Q> x12 = vec<4, T, Q>(x0.x, x0.y, x0.x, x0.y) + vec<4, T, Q>(C.x, C.x, C.z, C.z); x12 = vec<4, T, Q>(vec<2, T, Q>(x12) - i1, x12.z, x12.w); // Permutations i = mod(i, vec<2, T, Q>(289)); // Avoid truncation effects in permutation vec<3, T, Q> p = detail::permute( detail::permute(i.y + vec<3, T, Q>(T(0), i1.y, T(1))) + i.x + vec<3, T, Q>(T(0), i1.x, T(1))); vec<3, T, Q> m = max(vec<3, T, Q>(0.5) - vec<3, T, Q>( dot(x0, x0), dot(vec<2, T, Q>(x12.x, x12.y), vec<2, T, Q>(x12.x, x12.y)), dot(vec<2, T, Q>(x12.z, x12.w), vec<2, T, Q>(x12.z, x12.w))), vec<3, T, Q>(0)); m = m * m ; m = m * m ; // Gradients: 41 points uniformly over a line, mapped onto a diamond. // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287) vec<3, T, Q> x = static_cast(2) * fract(p * C.w) - T(1); vec<3, T, Q> h = abs(x) - T(0.5); vec<3, T, Q> ox = floor(x + T(0.5)); vec<3, T, Q> a0 = x - ox; // Normalise gradients implicitly by scaling m // Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h ); m *= static_cast(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h); // Compute final noise value at P vec<3, T, Q> g; g.x = a0.x * x0.x + h.x * x0.y; //g.yz = a0.yz * x12.xz + h.yz * x12.yw; g.y = a0.y * x12.x + h.y * x12.y; g.z = a0.z * x12.z + h.z * x12.w; return T(130) * dot(m, g); } template GLM_FUNC_QUALIFIER T simplex(vec<3, T, Q> const& v) { vec<2, T, Q> const C(1.0 / 6.0, 1.0 / 3.0); vec<4, T, Q> const D(0.0, 0.5, 1.0, 2.0); // First corner vec<3, T, Q> i(floor(v + dot(v, vec<3, T, Q>(C.y)))); vec<3, T, Q> x0(v - i + dot(i, vec<3, T, Q>(C.x))); // Other corners vec<3, T, Q> g(step(vec<3, T, Q>(x0.y, x0.z, x0.x), x0)); vec<3, T, Q> l(T(1) - g); vec<3, T, Q> i1(min(g, vec<3, T, Q>(l.z, l.x, l.y))); vec<3, T, Q> i2(max(g, vec<3, T, Q>(l.z, l.x, l.y))); // x0 = x0 - 0.0 + 0.0 * C.xxx; // x1 = x0 - i1 + 1.0 * C.xxx; // x2 = x0 - i2 + 2.0 * C.xxx; // x3 = x0 - 1.0 + 3.0 * C.xxx; vec<3, T, Q> x1(x0 - i1 + C.x); vec<3, T, Q> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y vec<3, T, Q> x3(x0 - D.y); // -1.0+3.0*C.x = -0.5 = -D.y // Permutations i = detail::mod289(i); vec<4, T, Q> p(detail::permute(detail::permute(detail::permute( i.z + vec<4, T, Q>(T(0), i1.z, i2.z, T(1))) + i.y + vec<4, T, Q>(T(0), i1.y, i2.y, T(1))) + i.x + vec<4, T, Q>(T(0), i1.x, i2.x, T(1)))); // Gradients: 7x7 points over a square, mapped onto an octahedron. // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294) T n_ = static_cast(0.142857142857); // 1.0/7.0 vec<3, T, Q> ns(n_ * vec<3, T, Q>(D.w, D.y, D.z) - vec<3, T, Q>(D.x, D.z, D.x)); vec<4, T, Q> j(p - T(49) * floor(p * ns.z * ns.z)); // mod(p,7*7) vec<4, T, Q> x_(floor(j * ns.z)); vec<4, T, Q> y_(floor(j - T(7) * x_)); // mod(j,N) vec<4, T, Q> x(x_ * ns.x + ns.y); vec<4, T, Q> y(y_ * ns.x + ns.y); vec<4, T, Q> h(T(1) - abs(x) - abs(y)); vec<4, T, Q> b0(x.x, x.y, y.x, y.y); vec<4, T, Q> b1(x.z, x.w, y.z, y.w); // vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0; // vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0; vec<4, T, Q> s0(floor(b0) * T(2) + T(1)); vec<4, T, Q> s1(floor(b1) * T(2) + T(1)); vec<4, T, Q> sh(-step(h, vec<4, T, Q>(0.0))); vec<4, T, Q> a0 = vec<4, T, Q>(b0.x, b0.z, b0.y, b0.w) + vec<4, T, Q>(s0.x, s0.z, s0.y, s0.w) * vec<4, T, Q>(sh.x, sh.x, sh.y, sh.y); vec<4, T, Q> a1 = vec<4, T, Q>(b1.x, b1.z, b1.y, b1.w) + vec<4, T, Q>(s1.x, s1.z, s1.y, s1.w) * vec<4, T, Q>(sh.z, sh.z, sh.w, sh.w); vec<3, T, Q> p0(a0.x, a0.y, h.x); vec<3, T, Q> p1(a0.z, a0.w, h.y); vec<3, T, Q> p2(a1.x, a1.y, h.z); vec<3, T, Q> p3(a1.z, a1.w, h.w); // Normalise gradients vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3))); p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w; // Mix final noise value vec<4, T, Q> m = max(T(0.6) - vec<4, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), vec<4, T, Q>(0)); m = m * m; return T(42) * dot(m * m, vec<4, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))); } template GLM_FUNC_QUALIFIER T simplex(vec<4, T, Q> const& v) { vec<4, T, Q> const C( 0.138196601125011, // (5 - sqrt(5))/20 G4 0.276393202250021, // 2 * G4 0.414589803375032, // 3 * G4 -0.447213595499958); // -1 + 4 * G4 // (sqrt(5) - 1)/4 = F4, used once below T const F4 = static_cast(0.309016994374947451); // First corner vec<4, T, Q> i = floor(v + dot(v, vec4(F4))); vec<4, T, Q> x0 = v - i + dot(i, vec4(C.x)); // Other corners // Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI) vec<4, T, Q> i0; vec<3, T, Q> isX = step(vec<3, T, Q>(x0.y, x0.z, x0.w), vec<3, T, Q>(x0.x)); vec<3, T, Q> isYZ = step(vec<3, T, Q>(x0.z, x0.w, x0.w), vec<3, T, Q>(x0.y, x0.y, x0.z)); // i0.x = dot(isX, vec3(1.0)); //i0.x = isX.x + isX.y + isX.z; //i0.yzw = static_cast(1) - isX; i0 = vec<4, T, Q>(isX.x + isX.y + isX.z, T(1) - isX); // i0.y += dot(isYZ.xy, vec2(1.0)); i0.y += isYZ.x + isYZ.y; //i0.zw += 1.0 - vec<2, T, Q>(isYZ.x, isYZ.y); i0.z += static_cast(1) - isYZ.x; i0.w += static_cast(1) - isYZ.y; i0.z += isYZ.z; i0.w += static_cast(1) - isYZ.z; // i0 now contains the unique values 0,1,2,3 in each channel vec<4, T, Q> i3 = clamp(i0, T(0), T(1)); vec<4, T, Q> i2 = clamp(i0 - T(1), T(0), T(1)); vec<4, T, Q> i1 = clamp(i0 - T(2), T(0), T(1)); // x0 = x0 - 0.0 + 0.0 * C.xxxx // x1 = x0 - i1 + 0.0 * C.xxxx // x2 = x0 - i2 + 0.0 * C.xxxx // x3 = x0 - i3 + 0.0 * C.xxxx // x4 = x0 - 1.0 + 4.0 * C.xxxx vec<4, T, Q> x1 = x0 - i1 + C.x; vec<4, T, Q> x2 = x0 - i2 + C.y; vec<4, T, Q> x3 = x0 - i3 + C.z; vec<4, T, Q> x4 = x0 + C.w; // Permutations i = mod(i, vec<4, T, Q>(289)); T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x); vec<4, T, Q> j1 = detail::permute(detail::permute(detail::permute(detail::permute( i.w + vec<4, T, Q>(i1.w, i2.w, i3.w, T(1))) + i.z + vec<4, T, Q>(i1.z, i2.z, i3.z, T(1))) + i.y + vec<4, T, Q>(i1.y, i2.y, i3.y, T(1))) + i.x + vec<4, T, Q>(i1.x, i2.x, i3.x, T(1))); // Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope // 7*7*6 = 294, which is close to the ring size 17*17 = 289. vec<4, T, Q> ip = vec<4, T, Q>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0)); vec<4, T, Q> p0 = gtc::grad4(j0, ip); vec<4, T, Q> p1 = gtc::grad4(j1.x, ip); vec<4, T, Q> p2 = gtc::grad4(j1.y, ip); vec<4, T, Q> p3 = gtc::grad4(j1.z, ip); vec<4, T, Q> p4 = gtc::grad4(j1.w, ip); // Normalise gradients vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3))); p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w; p4 *= detail::taylorInvSqrt(dot(p4, p4)); // Mix contributions from the five corners vec<3, T, Q> m0 = max(T(0.6) - vec<3, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), vec<3, T, Q>(0)); vec<2, T, Q> m1 = max(T(0.6) - vec<2, T, Q>(dot(x3, x3), dot(x4, x4) ), vec<2, T, Q>(0)); m0 = m0 * m0; m1 = m1 * m1; return T(49) * (dot(m0 * m0, vec<3, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + dot(m1 * m1, vec<2, T, Q>(dot(p3, x3), dot(p4, x4)))); } }//namespace glm glm-0.9.9-a2/glm/simd/0000700000175000001440000000000013173131001013201 5ustar guususersglm-0.9.9-a2/glm/simd/matrix.h0000600000175000001440000011602613173131001014666 0ustar guususers/// @ref simd /// @file glm/simd/matrix.h #pragma once #include "geometric.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER void glm_mat4_matrixCompMult(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { out[0] = _mm_mul_ps(in1[0], in2[0]); out[1] = _mm_mul_ps(in1[1], in2[1]); out[2] = _mm_mul_ps(in1[2], in2[2]); out[3] = _mm_mul_ps(in1[3], in2[3]); } GLM_FUNC_QUALIFIER void glm_mat4_add(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { out[0] = _mm_add_ps(in1[0], in2[0]); out[1] = _mm_add_ps(in1[1], in2[1]); out[2] = _mm_add_ps(in1[2], in2[2]); out[3] = _mm_add_ps(in1[3], in2[3]); } GLM_FUNC_QUALIFIER void glm_mat4_sub(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { out[0] = _mm_sub_ps(in1[0], in2[0]); out[1] = _mm_sub_ps(in1[1], in2[1]); out[2] = _mm_sub_ps(in1[2], in2[2]); out[3] = _mm_sub_ps(in1[3], in2[3]); } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_mul_vec4(glm_vec4 const m[4], glm_vec4 v) { __m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0)); __m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1)); __m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2)); __m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(m[0], v0); __m128 m1 = _mm_mul_ps(m[1], v1); __m128 m2 = _mm_mul_ps(m[2], v2); __m128 m3 = _mm_mul_ps(m[3], v3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); return a2; } GLM_FUNC_QUALIFIER __m128 glm_vec4_mul_mat4(glm_vec4 v, glm_vec4 const m[4]) { __m128 i0 = m[0]; __m128 i1 = m[1]; __m128 i2 = m[2]; __m128 i3 = m[3]; __m128 m0 = _mm_mul_ps(v, i0); __m128 m1 = _mm_mul_ps(v, i1); __m128 m2 = _mm_mul_ps(v, i2); __m128 m3 = _mm_mul_ps(v, i3); __m128 u0 = _mm_unpacklo_ps(m0, m1); __m128 u1 = _mm_unpackhi_ps(m0, m1); __m128 a0 = _mm_add_ps(u0, u1); __m128 u2 = _mm_unpacklo_ps(m2, m3); __m128 u3 = _mm_unpackhi_ps(m2, m3); __m128 a1 = _mm_add_ps(u2, u3); __m128 f0 = _mm_movelh_ps(a0, a1); __m128 f1 = _mm_movehl_ps(a1, a0); __m128 f2 = _mm_add_ps(f0, f1); return f2; } GLM_FUNC_QUALIFIER void glm_mat4_mul(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4]) { { __m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[0] = a2; } { __m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[1] = a2; } { __m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[2] = a2; } { //(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3)) __m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0)); __m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1)); __m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2)); __m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(in1[0], e0); __m128 m1 = _mm_mul_ps(in1[1], e1); __m128 m2 = _mm_mul_ps(in1[2], e2); __m128 m3 = _mm_mul_ps(in1[3], e3); __m128 a0 = _mm_add_ps(m0, m1); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); out[3] = a2; } } GLM_FUNC_QUALIFIER void glm_mat4_transpose(glm_vec4 const in[4], glm_vec4 out[4]) { __m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44); __m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE); __m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44); __m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE); out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88); out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD); out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88); out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD); } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_highp(glm_vec4 const in[4]) { __m128 Fac0; { // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; // valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac0 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac1; { // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; // valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac1 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac2; { // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; // valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac2 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac3; { // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; // valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac3 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac4; { // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; // valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac4 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac5; { // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; // valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac5 = _mm_sub_ps(Mul00, Mul01); } __m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f); __m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f); // m[1][0] // m[0][0] // m[0][0] // m[0][0] __m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][1] // m[0][1] // m[0][1] // m[0][1] __m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][2] // m[0][2] // m[0][2] // m[0][2] __m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][3] // m[0][3] // m[0][3] // m[0][3] __m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0)); // col0 // + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]), // - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]), // + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]), // - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]), __m128 Mul00 = _mm_mul_ps(Vec1, Fac0); __m128 Mul01 = _mm_mul_ps(Vec2, Fac1); __m128 Mul02 = _mm_mul_ps(Vec3, Fac2); __m128 Sub00 = _mm_sub_ps(Mul00, Mul01); __m128 Add00 = _mm_add_ps(Sub00, Mul02); __m128 Inv0 = _mm_mul_ps(SignB, Add00); // col1 // - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]), // + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]), // - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]), // + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]), __m128 Mul03 = _mm_mul_ps(Vec0, Fac0); __m128 Mul04 = _mm_mul_ps(Vec2, Fac3); __m128 Mul05 = _mm_mul_ps(Vec3, Fac4); __m128 Sub01 = _mm_sub_ps(Mul03, Mul04); __m128 Add01 = _mm_add_ps(Sub01, Mul05); __m128 Inv1 = _mm_mul_ps(SignA, Add01); // col2 // + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]), // - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]), // + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]), // - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]), __m128 Mul06 = _mm_mul_ps(Vec0, Fac1); __m128 Mul07 = _mm_mul_ps(Vec1, Fac3); __m128 Mul08 = _mm_mul_ps(Vec3, Fac5); __m128 Sub02 = _mm_sub_ps(Mul06, Mul07); __m128 Add02 = _mm_add_ps(Sub02, Mul08); __m128 Inv2 = _mm_mul_ps(SignB, Add02); // col3 // - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]), // + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]), // - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]), // + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3])); __m128 Mul09 = _mm_mul_ps(Vec0, Fac2); __m128 Mul10 = _mm_mul_ps(Vec1, Fac4); __m128 Mul11 = _mm_mul_ps(Vec2, Fac5); __m128 Sub03 = _mm_sub_ps(Mul09, Mul10); __m128 Add03 = _mm_add_ps(Sub03, Mul11); __m128 Inv3 = _mm_mul_ps(SignA, Add03); __m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0)); // valType Determinant = m[0][0] * Inverse[0][0] // + m[0][1] * Inverse[1][0] // + m[0][2] * Inverse[2][0] // + m[0][3] * Inverse[3][0]; __m128 Det0 = glm_vec4_dot(in[0], Row2); return Det0; } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_lowp(glm_vec4 const m[4]) { // _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128( //T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; //T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; //T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; //T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; //T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; //T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // First 2 columns __m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2))); __m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3))); __m128 MulA = _mm_mul_ps(Swp2A, Swp3A); // Second 2 columns __m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3))); __m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2))); __m128 MulB = _mm_mul_ps(Swp2B, Swp3B); // Columns subtraction __m128 SubE = _mm_sub_ps(MulA, MulB); // Last 2 rows __m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2))); __m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0))); __m128 MulC = _mm_mul_ps(Swp2C, Swp3C); __m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC); //vec<4, T, Q> DetCof( // + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02), // - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04), // + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05), // - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05)); __m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0))); __m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1))); __m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA); __m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1)); __m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1]; __m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2))); __m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB); __m128 SubRes = _mm_sub_ps(MulFacA, MulFacB); __m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2)); __m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0))); __m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3))); __m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC); __m128 AddRes = _mm_add_ps(SubRes, MulFacC); __m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f)); //return m[0][0] * DetCof[0] // + m[0][1] * DetCof[1] // + m[0][2] * DetCof[2] // + m[0][3] * DetCof[3]; return glm_vec4_dot(m[0], DetCof); } GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant(glm_vec4 const m[4]) { // _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add) //T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; //T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; //T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; //T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; //T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; //T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // First 2 columns __m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2)); __m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3)); __m128 MulA = _mm_mul_ps(Swp2A, Swp3A); // Second 2 columns __m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3)); __m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2)); __m128 MulB = _mm_mul_ps(Swp2B, Swp3B); // Columns subtraction __m128 SubE = _mm_sub_ps(MulA, MulB); // Last 2 rows __m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2)); __m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0)); __m128 MulC = _mm_mul_ps(Swp2C, Swp3C); __m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC); //vec<4, T, Q> DetCof( // + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02), // - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04), // + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05), // - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05)); __m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0)); __m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1)); __m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA); __m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1)); __m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1]; __m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2)); __m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB); __m128 SubRes = _mm_sub_ps(MulFacA, MulFacB); __m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2)); __m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0)); __m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3)); __m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC); __m128 AddRes = _mm_add_ps(SubRes, MulFacC); __m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f)); //return m[0][0] * DetCof[0] // + m[0][1] * DetCof[1] // + m[0][2] * DetCof[2] // + m[0][3] * DetCof[3]; return glm_vec4_dot(m[0], DetCof); } GLM_FUNC_QUALIFIER void glm_mat4_inverse(glm_vec4 const in[4], glm_vec4 out[4]) { __m128 Fac0; { // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; // valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac0 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac1; { // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; // valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac1 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac2; { // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; // valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac2 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac3; { // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; // valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac3 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac4; { // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; // valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac4 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac5; { // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; // valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac5 = _mm_sub_ps(Mul00, Mul01); } __m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f); __m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f); // m[1][0] // m[0][0] // m[0][0] // m[0][0] __m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][1] // m[0][1] // m[0][1] // m[0][1] __m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][2] // m[0][2] // m[0][2] // m[0][2] __m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][3] // m[0][3] // m[0][3] // m[0][3] __m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0)); // col0 // + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]), // - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]), // + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]), // - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]), __m128 Mul00 = _mm_mul_ps(Vec1, Fac0); __m128 Mul01 = _mm_mul_ps(Vec2, Fac1); __m128 Mul02 = _mm_mul_ps(Vec3, Fac2); __m128 Sub00 = _mm_sub_ps(Mul00, Mul01); __m128 Add00 = _mm_add_ps(Sub00, Mul02); __m128 Inv0 = _mm_mul_ps(SignB, Add00); // col1 // - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]), // + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]), // - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]), // + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]), __m128 Mul03 = _mm_mul_ps(Vec0, Fac0); __m128 Mul04 = _mm_mul_ps(Vec2, Fac3); __m128 Mul05 = _mm_mul_ps(Vec3, Fac4); __m128 Sub01 = _mm_sub_ps(Mul03, Mul04); __m128 Add01 = _mm_add_ps(Sub01, Mul05); __m128 Inv1 = _mm_mul_ps(SignA, Add01); // col2 // + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]), // - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]), // + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]), // - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]), __m128 Mul06 = _mm_mul_ps(Vec0, Fac1); __m128 Mul07 = _mm_mul_ps(Vec1, Fac3); __m128 Mul08 = _mm_mul_ps(Vec3, Fac5); __m128 Sub02 = _mm_sub_ps(Mul06, Mul07); __m128 Add02 = _mm_add_ps(Sub02, Mul08); __m128 Inv2 = _mm_mul_ps(SignB, Add02); // col3 // - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]), // + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]), // - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]), // + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3])); __m128 Mul09 = _mm_mul_ps(Vec0, Fac2); __m128 Mul10 = _mm_mul_ps(Vec1, Fac4); __m128 Mul11 = _mm_mul_ps(Vec2, Fac5); __m128 Sub03 = _mm_sub_ps(Mul09, Mul10); __m128 Add03 = _mm_add_ps(Sub03, Mul11); __m128 Inv3 = _mm_mul_ps(SignA, Add03); __m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0)); // valType Determinant = m[0][0] * Inverse[0][0] // + m[0][1] * Inverse[1][0] // + m[0][2] * Inverse[2][0] // + m[0][3] * Inverse[3][0]; __m128 Det0 = glm_vec4_dot(in[0], Row2); __m128 Rcp0 = _mm_div_ps(_mm_set1_ps(1.0f), Det0); //__m128 Rcp0 = _mm_rcp_ps(Det0); // Inverse /= Determinant; out[0] = _mm_mul_ps(Inv0, Rcp0); out[1] = _mm_mul_ps(Inv1, Rcp0); out[2] = _mm_mul_ps(Inv2, Rcp0); out[3] = _mm_mul_ps(Inv3, Rcp0); } GLM_FUNC_QUALIFIER void glm_mat4_inverse_lowp(glm_vec4 const in[4], glm_vec4 out[4]) { __m128 Fac0; { // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; // valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; // valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac0 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac1; { // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; // valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; // valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac1 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac2; { // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; // valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; // valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac2 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac3; { // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; // valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; // valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac3 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac4; { // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; // valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; // valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac4 = _mm_sub_ps(Mul00, Mul01); } __m128 Fac5; { // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; // valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; // valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; __m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0)); __m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Mul00 = _mm_mul_ps(Swp00, Swp01); __m128 Mul01 = _mm_mul_ps(Swp02, Swp03); Fac5 = _mm_sub_ps(Mul00, Mul01); } __m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f); __m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f); // m[1][0] // m[0][0] // m[0][0] // m[0][0] __m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0)); __m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][1] // m[0][1] // m[0][1] // m[0][1] __m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1)); __m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][2] // m[0][2] // m[0][2] // m[0][2] __m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2)); __m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0)); // m[1][3] // m[0][3] // m[0][3] // m[0][3] __m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3)); __m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0)); // col0 // + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]), // - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]), // + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]), // - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]), __m128 Mul00 = _mm_mul_ps(Vec1, Fac0); __m128 Mul01 = _mm_mul_ps(Vec2, Fac1); __m128 Mul02 = _mm_mul_ps(Vec3, Fac2); __m128 Sub00 = _mm_sub_ps(Mul00, Mul01); __m128 Add00 = _mm_add_ps(Sub00, Mul02); __m128 Inv0 = _mm_mul_ps(SignB, Add00); // col1 // - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]), // + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]), // - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]), // + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]), __m128 Mul03 = _mm_mul_ps(Vec0, Fac0); __m128 Mul04 = _mm_mul_ps(Vec2, Fac3); __m128 Mul05 = _mm_mul_ps(Vec3, Fac4); __m128 Sub01 = _mm_sub_ps(Mul03, Mul04); __m128 Add01 = _mm_add_ps(Sub01, Mul05); __m128 Inv1 = _mm_mul_ps(SignA, Add01); // col2 // + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]), // - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]), // + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]), // - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]), __m128 Mul06 = _mm_mul_ps(Vec0, Fac1); __m128 Mul07 = _mm_mul_ps(Vec1, Fac3); __m128 Mul08 = _mm_mul_ps(Vec3, Fac5); __m128 Sub02 = _mm_sub_ps(Mul06, Mul07); __m128 Add02 = _mm_add_ps(Sub02, Mul08); __m128 Inv2 = _mm_mul_ps(SignB, Add02); // col3 // - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]), // + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]), // - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]), // + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3])); __m128 Mul09 = _mm_mul_ps(Vec0, Fac2); __m128 Mul10 = _mm_mul_ps(Vec1, Fac4); __m128 Mul11 = _mm_mul_ps(Vec2, Fac5); __m128 Sub03 = _mm_sub_ps(Mul09, Mul10); __m128 Add03 = _mm_add_ps(Sub03, Mul11); __m128 Inv3 = _mm_mul_ps(SignA, Add03); __m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0)); // valType Determinant = m[0][0] * Inverse[0][0] // + m[0][1] * Inverse[1][0] // + m[0][2] * Inverse[2][0] // + m[0][3] * Inverse[3][0]; __m128 Det0 = glm_vec4_dot(in[0], Row2); __m128 Rcp0 = _mm_rcp_ps(Det0); //__m128 Rcp0 = _mm_div_ps(one, Det0); // Inverse /= Determinant; out[0] = _mm_mul_ps(Inv0, Rcp0); out[1] = _mm_mul_ps(Inv1, Rcp0); out[2] = _mm_mul_ps(Inv2, Rcp0); out[3] = _mm_mul_ps(Inv3, Rcp0); } /* GLM_FUNC_QUALIFIER void glm_mat4_rotate(__m128 const in[4], float Angle, float const v[3], __m128 out[4]) { float a = glm::radians(Angle); float c = cos(a); float s = sin(a); glm::vec4 AxisA(v[0], v[1], v[2], float(0)); __m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x); __m128 AxisC = detail::sse_nrm_ps(AxisB); __m128 Cos0 = _mm_set_ss(c); __m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0)); __m128 Sin0 = _mm_set_ss(s); __m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0)); // vec<3, T, Q> temp = (valType(1) - c) * axis; __m128 Temp0 = _mm_sub_ps(one, CosA); __m128 Temp1 = _mm_mul_ps(Temp0, AxisC); //Rotate[0][0] = c + temp[0] * axis[0]; //Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; //Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; __m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0)); __m128 TmpA0 = _mm_mul_ps(Axis0, AxisC); __m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0)); __m128 TmpA1 = _mm_add_ps(CosA0, TmpA0); __m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f); __m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3)); __m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2); __m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3); //Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; //Rotate[1][1] = c + temp[1] * axis[1]; //Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; __m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1)); __m128 TmpB0 = _mm_mul_ps(Axis1, AxisC); __m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1)); __m128 TmpB1 = _mm_add_ps(CosA1, TmpB0); __m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f); __m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2)); __m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2); __m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3); //Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; //Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; //Rotate[2][2] = c + temp[2] * axis[2]; __m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2)); __m128 TmpC0 = _mm_mul_ps(Axis2, AxisC); __m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1)); __m128 TmpC1 = _mm_add_ps(CosA2, TmpC0); __m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f); __m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1)); __m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2); __m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3); __m128 Result[4]; Result[0] = TmpA4; Result[1] = TmpB4; Result[2] = TmpC4; Result[3] = _mm_set_ps(1, 0, 0, 0); //mat<4, 4, valType> Result; //Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; //Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; //Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; //Result[3] = m[3]; //return Result; sse_mul_ps(in, Result, out); } */ GLM_FUNC_QUALIFIER void glm_mat4_outerProduct(__m128 const& c, __m128 const& r, __m128 out[4]) { out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0))); out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1))); out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2))); out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3))); } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/simd/platform.h0000600000175000001440000003200013173131001015173 0ustar guususers/// @ref simd /// @file glm/simd/platform.h #pragma once /////////////////////////////////////////////////////////////////////////////////// // Platform #define GLM_PLATFORM_UNKNOWN 0x00000000 #define GLM_PLATFORM_WINDOWS 0x00010000 #define GLM_PLATFORM_LINUX 0x00020000 #define GLM_PLATFORM_APPLE 0x00040000 //#define GLM_PLATFORM_IOS 0x00080000 #define GLM_PLATFORM_ANDROID 0x00100000 #define GLM_PLATFORM_CHROME_NACL 0x00200000 #define GLM_PLATFORM_UNIX 0x00400000 #define GLM_PLATFORM_QNXNTO 0x00800000 #define GLM_PLATFORM_WINCE 0x01000000 #define GLM_PLATFORM_CYGWIN 0x02000000 #ifdef GLM_FORCE_PLATFORM_UNKNOWN # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN #elif defined(__CYGWIN__) # define GLM_PLATFORM GLM_PLATFORM_CYGWIN #elif defined(__QNXNTO__) # define GLM_PLATFORM GLM_PLATFORM_QNXNTO #elif defined(__APPLE__) # define GLM_PLATFORM GLM_PLATFORM_APPLE #elif defined(WINCE) # define GLM_PLATFORM GLM_PLATFORM_WINCE #elif defined(_WIN32) # define GLM_PLATFORM GLM_PLATFORM_WINDOWS #elif defined(__native_client__) # define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL #elif defined(__ANDROID__) # define GLM_PLATFORM GLM_PLATFORM_ANDROID #elif defined(__linux) # define GLM_PLATFORM GLM_PLATFORM_LINUX #elif defined(__unix) # define GLM_PLATFORM GLM_PLATFORM_UNIX #else # define GLM_PLATFORM GLM_PLATFORM_UNKNOWN #endif// // Report platform detection #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED) # define GLM_MESSAGE_PLATFORM_DISPLAYED # if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO) # pragma message("GLM: QNX platform detected") //# elif(GLM_PLATFORM & GLM_PLATFORM_IOS) //# pragma message("GLM: iOS platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_APPLE) # pragma message("GLM: Apple platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_WINCE) # pragma message("GLM: WinCE platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS) # pragma message("GLM: Windows platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL) # pragma message("GLM: Native Client detected") # elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) # pragma message("GLM: Android platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_LINUX) # pragma message("GLM: Linux platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_UNIX) # pragma message("GLM: UNIX platform detected") # elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN) # pragma message("GLM: platform unknown") # else # pragma message("GLM: platform not detected") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Compiler #define GLM_COMPILER_UNKNOWN 0x00000000 // Intel #define GLM_COMPILER_INTEL 0x00100000 #define GLM_COMPILER_INTEL14 0x00100040 #define GLM_COMPILER_INTEL15 0x00100050 #define GLM_COMPILER_INTEL16 0x00100060 #define GLM_COMPILER_INTEL17 0x00100070 // Visual C++ defines #define GLM_COMPILER_VC 0x01000000 #define GLM_COMPILER_VC12 0x010000B0 #define GLM_COMPILER_VC14 0x010000C0 #define GLM_COMPILER_VC15 0x010000D0 #define GLM_COMPILER_VC16 0x010000E0 // GCC defines #define GLM_COMPILER_GCC 0x02000000 #define GLM_COMPILER_GCC46 0x020000D0 #define GLM_COMPILER_GCC47 0x020000E0 #define GLM_COMPILER_GCC48 0x020000F0 #define GLM_COMPILER_GCC49 0x02000100 #define GLM_COMPILER_GCC5 0x02000200 #define GLM_COMPILER_GCC6 0x02000300 #define GLM_COMPILER_GCC7 0x02000400 #define GLM_COMPILER_GCC8 0x02000500 // CUDA #define GLM_COMPILER_CUDA 0x10000000 #define GLM_COMPILER_CUDA70 0x100000A0 #define GLM_COMPILER_CUDA75 0x100000B0 #define GLM_COMPILER_CUDA80 0x100000C0 // Clang #define GLM_COMPILER_CLANG 0x20000000 #define GLM_COMPILER_CLANG34 0x20000050 #define GLM_COMPILER_CLANG35 0x20000060 #define GLM_COMPILER_CLANG36 0x20000070 #define GLM_COMPILER_CLANG37 0x20000080 #define GLM_COMPILER_CLANG38 0x20000090 #define GLM_COMPILER_CLANG39 0x200000A0 #define GLM_COMPILER_CLANG40 0x200000B0 #define GLM_COMPILER_CLANG41 0x200000C0 #define GLM_COMPILER_CLANG42 0x200000D0 // Build model #define GLM_MODEL_32 0x00000010 #define GLM_MODEL_64 0x00000020 // Force generic C++ compiler #ifdef GLM_FORCE_COMPILER_UNKNOWN # define GLM_COMPILER GLM_COMPILER_UNKNOWN #elif defined(__INTEL_COMPILER) # if (__INTEL_COMPILER < 1400) # error "GLM requires ICC 2013 SP1 or newer" # elif __INTEL_COMPILER == 1400 # define GLM_COMPILER GLM_COMPILER_INTEL14 # elif __INTEL_COMPILER == 1500 # define GLM_COMPILER GLM_COMPILER_INTEL15 # elif __INTEL_COMPILER == 1600 # define GLM_COMPILER GLM_COMPILER_INTEL16 # elif __INTEL_COMPILER >= 1700 # define GLM_COMPILER GLM_COMPILER_INTEL17 # endif // CUDA #elif defined(__CUDACC__) # if !defined(CUDA_VERSION) && !defined(GLM_FORCE_CUDA) # include // make sure version is defined since nvcc does not define it itself! # endif # if CUDA_VERSION < 7000 # error "GLM requires CUDA 7.0 or higher" # elif (CUDA_VERSION >= 7000 && CUDA_VERSION < 7500) # define GLM_COMPILER GLM_COMPILER_CUDA70 # elif (CUDA_VERSION >= 7500 && CUDA_VERSION < 8000) # define GLM_COMPILER GLM_COMPILER_CUDA75 # elif (CUDA_VERSION >= 8000) # define GLM_COMPILER GLM_COMPILER_CUDA80 # endif // Clang #elif defined(__clang__) # if defined(__apple_build_version__) # if (__clang_major__ < 6) # error "GLM requires Clang 3.4 / Apple Clang 6.0 or higher" # elif __clang_major__ == 6 && __clang_minor__ == 0 # define GLM_COMPILER GLM_COMPILER_CLANG35 # elif __clang_major__ == 6 && __clang_minor__ >= 1 # define GLM_COMPILER GLM_COMPILER_CLANG36 # elif __clang_major__ >= 7 # define GLM_COMPILER GLM_COMPILER_CLANG37 # endif # else # if ((__clang_major__ == 3) && (__clang_minor__ < 4)) || (__clang_major__ < 3) # error "GLM requires Clang 3.4 or higher" # elif __clang_major__ == 3 && __clang_minor__ == 4 # define GLM_COMPILER GLM_COMPILER_CLANG34 # elif __clang_major__ == 3 && __clang_minor__ == 5 # define GLM_COMPILER GLM_COMPILER_CLANG35 # elif __clang_major__ == 3 && __clang_minor__ == 6 # define GLM_COMPILER GLM_COMPILER_CLANG36 # elif __clang_major__ == 3 && __clang_minor__ == 7 # define GLM_COMPILER GLM_COMPILER_CLANG37 # elif __clang_major__ == 3 && __clang_minor__ == 8 # define GLM_COMPILER GLM_COMPILER_CLANG38 # elif __clang_major__ == 3 && __clang_minor__ >= 9 # define GLM_COMPILER GLM_COMPILER_CLANG39 # elif __clang_major__ == 4 && __clang_minor__ == 0 # define GLM_COMPILER GLM_COMPILER_CLANG40 # elif __clang_major__ == 4 && __clang_minor__ == 1 # define GLM_COMPILER GLM_COMPILER_CLANG41 # elif __clang_major__ == 4 && __clang_minor__ >= 2 # define GLM_COMPILER GLM_COMPILER_CLANG42 # elif __clang_major__ >= 4 # define GLM_COMPILER GLM_COMPILER_CLANG42 # endif # endif // Visual C++ #elif defined(_MSC_VER) # if _MSC_VER < 1800 # error "GLM requires Visual C++ 12 - 2013 or higher" # elif _MSC_VER == 1800 # define GLM_COMPILER GLM_COMPILER_VC12 # elif _MSC_VER == 1900 # define GLM_COMPILER GLM_COMPILER_VC14 # elif _MSC_VER >= 1910 # define GLM_COMPILER GLM_COMPILER_VC15 # endif//_MSC_VER // G++ #elif defined(__GNUC__) || defined(__MINGW32__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ < 6)) || (__GNUC__ < 4) # error "GLM requires GCC 4.7 or higher" # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6) # define GLM_COMPILER (GLM_COMPILER_GCC46) # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7) # define GLM_COMPILER (GLM_COMPILER_GCC47) # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) # define GLM_COMPILER (GLM_COMPILER_GCC48) # elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9) # define GLM_COMPILER (GLM_COMPILER_GCC49) # elif (__GNUC__ == 5) # define GLM_COMPILER (GLM_COMPILER_GCC5) # elif (__GNUC__ == 6) # define GLM_COMPILER (GLM_COMPILER_GCC6) # elif (__GNUC__ == 7) # define GLM_COMPILER (GLM_COMPILER_GCC7) # elif (__GNUC__ >= 8) # define GLM_COMPILER (GLM_COMPILER_GCC8) # endif #else # define GLM_COMPILER GLM_COMPILER_UNKNOWN #endif #ifndef GLM_COMPILER # error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message." #endif//GLM_COMPILER /////////////////////////////////////////////////////////////////////////////////// // Instruction sets // User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_SSE3 GLM_FORCE_AVX GLM_FORCE_AVX2 GLM_FORCE_AVX2 #define GLM_ARCH_X86_BIT 0x00000001 #define GLM_ARCH_SSE2_BIT 0x00000002 #define GLM_ARCH_SSE3_BIT 0x00000004 #define GLM_ARCH_SSSE3_BIT 0x00000008 #define GLM_ARCH_SSE41_BIT 0x00000010 #define GLM_ARCH_SSE42_BIT 0x00000020 #define GLM_ARCH_AVX_BIT 0x00000040 #define GLM_ARCH_AVX2_BIT 0x00000080 #define GLM_ARCH_AVX512_BIT 0x00000200 // Skylake subset #define GLM_ARCH_ARM_BIT 0x00000400 #define GLM_ARCH_NEON_BIT 0x00000800 #define GLM_ARCH_MIPS_BIT 0x00010000 #define GLM_ARCH_PPC_BIT 0x01000000 #define GLM_ARCH_PURE (0x00000000) #define GLM_ARCH_X86 (GLM_ARCH_X86_BIT) #define GLM_ARCH_SSE2 (GLM_ARCH_SSE2_BIT | GLM_ARCH_X86) #define GLM_ARCH_SSE3 (GLM_ARCH_SSE3_BIT | GLM_ARCH_SSE2) #define GLM_ARCH_SSSE3 (GLM_ARCH_SSSE3_BIT | GLM_ARCH_SSE3) #define GLM_ARCH_SSE41 (GLM_ARCH_SSE41_BIT | GLM_ARCH_SSSE3) #define GLM_ARCH_SSE42 (GLM_ARCH_SSE42_BIT | GLM_ARCH_SSE41) #define GLM_ARCH_AVX (GLM_ARCH_AVX_BIT | GLM_ARCH_SSE42) #define GLM_ARCH_AVX2 (GLM_ARCH_AVX2_BIT | GLM_ARCH_AVX) #define GLM_ARCH_AVX512 (GLM_ARCH_AVX512_BIT | GLM_ARCH_AVX2) // Skylake subset #define GLM_ARCH_ARM (GLM_ARCH_ARM_BIT) #define GLM_ARCH_NEON (GLM_ARCH_NEON_BIT | GLM_ARCH_ARM) #define GLM_ARCH_MIPS (GLM_ARCH_MIPS_BIT) #define GLM_ARCH_PPC (GLM_ARCH_PPC_BIT) #if defined(GLM_FORCE_PURE) # define GLM_ARCH GLM_ARCH_PURE #elif defined(GLM_FORCE_MIPS) # define GLM_ARCH (GLM_ARCH_MIPS) #elif defined(GLM_FORCE_PPC) # define GLM_ARCH (GLM_ARCH_PPC) #elif defined(GLM_FORCE_NEON) # define GLM_ARCH (GLM_ARCH_NEON) #elif defined(GLM_FORCE_AVX512) # define GLM_ARCH (GLM_ARCH_AVX512) #elif defined(GLM_FORCE_AVX2) # define GLM_ARCH (GLM_ARCH_AVX2) #elif defined(GLM_FORCE_AVX) # define GLM_ARCH (GLM_ARCH_AVX) #elif defined(GLM_FORCE_SSE42) # define GLM_ARCH (GLM_ARCH_SSE42) #elif defined(GLM_FORCE_SSE41) # define GLM_ARCH (GLM_ARCH_SSE41) #elif defined(GLM_FORCE_SSSE3) # define GLM_ARCH (GLM_ARCH_SSSE3) #elif defined(GLM_FORCE_SSE3) # define GLM_ARCH (GLM_ARCH_SSE3) #elif defined(GLM_FORCE_SSE2) # define GLM_ARCH (GLM_ARCH_SSE2) #elif (GLM_COMPILER & (GLM_COMPILER_CLANG | GLM_COMPILER_GCC)) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_LINUX)) // This is Skylake set of instruction set # if defined(__AVX512BW__) && defined(__AVX512F__) && defined(__AVX512CD__) && defined(__AVX512VL__) && defined(__AVX512DQ__) # define GLM_ARCH (GLM_ARCH_AVX512) # elif defined(__AVX2__) # define GLM_ARCH (GLM_ARCH_AVX2) # elif defined(__AVX__) # define GLM_ARCH (GLM_ARCH_AVX) # elif defined(__SSE4_2__) # define GLM_ARCH (GLM_ARCH_SSE42) # elif defined(__SSE4_1__) # define GLM_ARCH (GLM_ARCH_SSE41) # elif defined(__SSSE3__) # define GLM_ARCH (GLM_ARCH_SSSE3) # elif defined(__SSE3__) # define GLM_ARCH (GLM_ARCH_SSE3) # elif defined(__SSE2__) # define GLM_ARCH (GLM_ARCH_SSE2) # elif defined(__i386__) || defined(__x86_64__) # define GLM_ARCH (GLM_ARCH_X86) # elif defined(__ARM_NEON) # define GLM_ARCH (GLM_ARCH_ARM | GLM_ARCH_NEON) # elif defined(__arm__ ) # define GLM_ARCH (GLM_ARCH_ARM) # elif defined(__mips__ ) # define GLM_ARCH (GLM_ARCH_MIPS) # elif defined(__powerpc__ ) # define GLM_ARCH (GLM_ARCH_PPC) # else # define GLM_ARCH (GLM_ARCH_PURE) # endif #elif (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)) # if defined(_M_ARM) # define GLM_ARCH (GLM_ARCH_ARM) # elif defined(__AVX2__) # define GLM_ARCH (GLM_ARCH_AVX2) # elif defined(__AVX__) # define GLM_ARCH (GLM_ARCH_AVX) # elif defined(_M_X64) # define GLM_ARCH (GLM_ARCH_SSE2) # elif defined(_M_IX86_FP) # if _M_IX86_FP >= 2 # define GLM_ARCH (GLM_ARCH_SSE2) # else # define GLM_ARCH (GLM_ARCH_PURE) # endif # elif defined(_M_PPC) # define GLM_ARCH (GLM_ARCH_PPC) # else # define GLM_ARCH (GLM_ARCH_PURE) # endif #else # define GLM_ARCH GLM_ARCH_PURE #endif // With MinGW-W64, including intrinsic headers before intrin.h will produce some errors. The problem is // that windows.h (and maybe other headers) will silently include intrin.h, which of course causes problems. // To fix, we just explicitly include intrin.h here. #if defined(__MINGW64__) && (GLM_ARCH != GLM_ARCH_PURE) # include #endif #if GLM_ARCH & GLM_ARCH_AVX2_BIT # include #elif GLM_ARCH & GLM_ARCH_AVX_BIT # include #elif GLM_ARCH & GLM_ARCH_SSE42_BIT # if GLM_COMPILER & GLM_COMPILER_CLANG # include # endif # include #elif GLM_ARCH & GLM_ARCH_SSE41_BIT # include #elif GLM_ARCH & GLM_ARCH_SSSE3_BIT # include #elif GLM_ARCH & GLM_ARCH_SSE3_BIT # include #elif GLM_ARCH & GLM_ARCH_SSE2_BIT # include #endif//GLM_ARCH #if GLM_ARCH & GLM_ARCH_SSE2_BIT typedef __m128 glm_vec4; typedef __m128i glm_ivec4; typedef __m128i glm_uvec4; #endif #if GLM_ARCH & GLM_ARCH_AVX_BIT typedef __m256d glm_dvec4; #endif #if GLM_ARCH & GLM_ARCH_AVX2_BIT typedef __m256i glm_i64vec4; typedef __m256i glm_u64vec4; #endif glm-0.9.9-a2/glm/simd/vector_relational.h0000600000175000001440000000021313173131001017064 0ustar guususers/// @ref simd /// @file glm/simd/vector_relational.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/simd/exponential.h0000600000175000001440000000055513173131001015707 0ustar guususers/// @ref simd /// @file glm/simd/experimental.h #pragma once #include "platform.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_sqrt_lowp(glm_vec4 x) { return _mm_mul_ss(_mm_rsqrt_ss(x), x); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sqrt_lowp(glm_vec4 x) { return _mm_mul_ps(_mm_rsqrt_ps(x), x); } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/simd/integer.h0000600000175000001440000000715213173131001015016 0ustar guususers/// @ref simd /// @file glm/simd/integer.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave(glm_uvec4 x) { glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF); glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF); glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F); glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333); glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555); glm_uvec4 Reg1; glm_uvec4 Reg2; // REG1 = x; // REG2 = y; //Reg1 = _mm_unpacklo_epi64(x, y); Reg1 = x; //REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); //REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); Reg2 = _mm_slli_si128(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask4); //REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); //REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); Reg2 = _mm_slli_si128(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask3); //REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); //REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); Reg2 = _mm_slli_epi32(Reg1, 4); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask2); //REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); //REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); Reg2 = _mm_slli_epi32(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask1); //REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); //REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); Reg2 = _mm_slli_epi32(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask0); //return REG1 | (REG2 << 1); Reg2 = _mm_slli_epi32(Reg1, 1); Reg2 = _mm_srli_si128(Reg2, 8); Reg1 = _mm_or_si128(Reg1, Reg2); return Reg1; } GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave2(glm_uvec4 x, glm_uvec4 y) { glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF); glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF); glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F); glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333); glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555); glm_uvec4 Reg1; glm_uvec4 Reg2; // REG1 = x; // REG2 = y; Reg1 = _mm_unpacklo_epi64(x, y); //REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF); //REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF); Reg2 = _mm_slli_si128(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask4); //REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF); //REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF); Reg2 = _mm_slli_si128(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask3); //REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F); //REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F); Reg2 = _mm_slli_epi32(Reg1, 4); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask2); //REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333); //REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333); Reg2 = _mm_slli_epi32(Reg1, 2); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask1); //REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555); //REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555); Reg2 = _mm_slli_epi32(Reg1, 1); Reg1 = _mm_or_si128(Reg2, Reg1); Reg1 = _mm_and_si128(Reg1, Mask0); //return REG1 | (REG2 << 1); Reg2 = _mm_slli_epi32(Reg1, 1); Reg2 = _mm_srli_si128(Reg2, 8); Reg1 = _mm_or_si128(Reg1, Reg2); return Reg1; } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/simd/geometric.h0000600000175000001440000000752313173131001015341 0ustar guususers/// @ref simd /// @file glm/simd/geometric.h #pragma once #include "common.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_DECL glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2); GLM_FUNC_DECL glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2); GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_length(glm_vec4 x) { glm_vec4 const dot0 = glm_vec4_dot(x, x); glm_vec4 const sqt0 = _mm_sqrt_ps(dot0); return sqt0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_distance(glm_vec4 p0, glm_vec4 p1) { glm_vec4 const sub0 = _mm_sub_ps(p0, p1); glm_vec4 const len0 = glm_vec4_length(sub0); return len0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2) { # if GLM_ARCH & GLM_ARCH_AVX_BIT return _mm_dp_ps(v1, v2, 0xff); # elif GLM_ARCH & GLM_ARCH_SSE3_BIT glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const hadd0 = _mm_hadd_ps(mul0, mul0); glm_vec4 const hadd1 = _mm_hadd_ps(hadd0, hadd0); return hadd1; # else glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1)); glm_vec4 const add0 = _mm_add_ps(mul0, swp0); glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3)); glm_vec4 const add1 = _mm_add_ps(add0, swp1); return add1; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2) { # if GLM_ARCH & GLM_ARCH_AVX_BIT return _mm_dp_ps(v1, v2, 0xff); # elif GLM_ARCH & GLM_ARCH_SSE3_BIT glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const had0 = _mm_hadd_ps(mul0, mul0); glm_vec4 const had1 = _mm_hadd_ps(had0, had0); return had1; # else glm_vec4 const mul0 = _mm_mul_ps(v1, v2); glm_vec4 const mov0 = _mm_movehl_ps(mul0, mul0); glm_vec4 const add0 = _mm_add_ps(mov0, mul0); glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, 1); glm_vec4 const add1 = _mm_add_ss(add0, swp1); return add1; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_cross(glm_vec4 v1, glm_vec4 v2) { glm_vec4 const swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1)); glm_vec4 const swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2)); glm_vec4 const swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1)); glm_vec4 const swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2)); glm_vec4 const mul0 = _mm_mul_ps(swp0, swp3); glm_vec4 const mul1 = _mm_mul_ps(swp1, swp2); glm_vec4 const sub0 = _mm_sub_ps(mul0, mul1); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_normalize(glm_vec4 v) { glm_vec4 const dot0 = glm_vec4_dot(v, v); glm_vec4 const isr0 = _mm_rsqrt_ps(dot0); glm_vec4 const mul0 = _mm_mul_ps(v, isr0); return mul0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_faceforward(glm_vec4 N, glm_vec4 I, glm_vec4 Nref) { glm_vec4 const dot0 = glm_vec4_dot(Nref, I); glm_vec4 const sgn0 = glm_vec4_sign(dot0); glm_vec4 const mul0 = _mm_mul_ps(sgn0, _mm_set1_ps(-1.0f)); glm_vec4 const mul1 = _mm_mul_ps(N, mul0); return mul1; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_reflect(glm_vec4 I, glm_vec4 N) { glm_vec4 const dot0 = glm_vec4_dot(N, I); glm_vec4 const mul0 = _mm_mul_ps(N, dot0); glm_vec4 const mul1 = _mm_mul_ps(mul0, _mm_set1_ps(2.0f)); glm_vec4 const sub0 = _mm_sub_ps(I, mul1); return sub0; } GLM_FUNC_QUALIFIER __m128 glm_vec4_refract(glm_vec4 I, glm_vec4 N, glm_vec4 eta) { glm_vec4 const dot0 = glm_vec4_dot(N, I); glm_vec4 const mul0 = _mm_mul_ps(eta, eta); glm_vec4 const mul1 = _mm_mul_ps(dot0, dot0); glm_vec4 const sub0 = _mm_sub_ps(_mm_set1_ps(1.0f), mul0); glm_vec4 const sub1 = _mm_sub_ps(_mm_set1_ps(1.0f), mul1); glm_vec4 const mul2 = _mm_mul_ps(sub0, sub1); if(_mm_movemask_ps(_mm_cmplt_ss(mul2, _mm_set1_ps(0.0f))) == 0) return _mm_set1_ps(0.0f); glm_vec4 const sqt0 = _mm_sqrt_ps(mul2); glm_vec4 const mad0 = glm_vec4_fma(eta, dot0, sqt0); glm_vec4 const mul4 = _mm_mul_ps(mad0, N); glm_vec4 const mul5 = _mm_mul_ps(eta, I); glm_vec4 const sub2 = _mm_sub_ps(mul5, mul4); return sub2; } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/simd/trigonometric.h0000600000175000001440000000021013173131001016232 0ustar guususers/// @ref simd /// @file glm/simd/trigonometric.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/simd/common.h0000600000175000001440000001534613173131001014655 0ustar guususers/// @ref simd /// @file glm/simd/common.h #pragma once #include "platform.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_add(glm_vec4 a, glm_vec4 b) { return _mm_add_ps(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_add(glm_vec4 a, glm_vec4 b) { return _mm_add_ss(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sub(glm_vec4 a, glm_vec4 b) { return _mm_sub_ps(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_sub(glm_vec4 a, glm_vec4 b) { return _mm_sub_ss(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mul(glm_vec4 a, glm_vec4 b) { return _mm_mul_ps(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_mul(glm_vec4 a, glm_vec4 b) { return _mm_mul_ss(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_div(glm_vec4 a, glm_vec4 b) { return _mm_div_ps(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_div(glm_vec4 a, glm_vec4 b) { return _mm_div_ss(a, b); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_div_lowp(glm_vec4 a, glm_vec4 b) { return glm_vec4_mul(a, _mm_rcp_ps(b)); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_swizzle_xyzw(glm_vec4 a) { # if GLM_ARCH & GLM_ARCH_AVX2_BIT return _mm_permute_ps(a, _MM_SHUFFLE(3, 2, 1, 0)); # else return _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 2, 1, 0)); # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_fma(glm_vec4 a, glm_vec4 b, glm_vec4 c) { # if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG) return _mm_fmadd_ss(a, b, c); # else return _mm_add_ss(_mm_mul_ss(a, b), c); # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_fma(glm_vec4 a, glm_vec4 b, glm_vec4 c) { # if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG) return _mm_fmadd_ps(a, b, c); # else return glm_vec4_add(glm_vec4_mul(a, b), c); # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_abs(glm_vec4 x) { return _mm_and_ps(x, _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF))); } GLM_FUNC_QUALIFIER glm_ivec4 glm_ivec4_abs(glm_ivec4 x) { # if GLM_ARCH & GLM_ARCH_SSSE3_BIT return _mm_sign_epi32(x, x); # else glm_ivec4 const sgn0 = _mm_srai_epi32(x, 31); glm_ivec4 const inv0 = _mm_xor_si128(x, sgn0); glm_ivec4 const sub0 = _mm_sub_epi32(inv0, sgn0); return sub0; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sign(glm_vec4 x) { glm_vec4 const zro0 = _mm_setzero_ps(); glm_vec4 const cmp0 = _mm_cmplt_ps(x, zro0); glm_vec4 const cmp1 = _mm_cmpgt_ps(x, zro0); glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(-1.0f)); glm_vec4 const and1 = _mm_and_ps(cmp1, _mm_set1_ps(1.0f)); glm_vec4 const or0 = _mm_or_ps(and0, and1);; return or0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_round(glm_vec4 x) { # if GLM_ARCH & GLM_ARCH_SSE41_BIT return _mm_round_ps(x, _MM_FROUND_TO_NEAREST_INT); # else glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000))); glm_vec4 const and0 = _mm_and_ps(sgn0, x); glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f)); glm_vec4 const add0 = glm_vec4_add(x, or0); glm_vec4 const sub0 = glm_vec4_sub(add0, or0); return sub0; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_floor(glm_vec4 x) { # if GLM_ARCH & GLM_ARCH_SSE41_BIT return _mm_floor_ps(x); # else glm_vec4 const rnd0 = glm_vec4_round(x); glm_vec4 const cmp0 = _mm_cmplt_ps(x, rnd0); glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f)); glm_vec4 const sub0 = glm_vec4_sub(rnd0, and0); return sub0; # endif } /* trunc TODO GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_trunc(glm_vec4 x) { return glm_vec4(); } */ //roundEven GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_roundEven(glm_vec4 x) { glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000))); glm_vec4 const and0 = _mm_and_ps(sgn0, x); glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f)); glm_vec4 const add0 = glm_vec4_add(x, or0); glm_vec4 const sub0 = glm_vec4_sub(add0, or0); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_ceil(glm_vec4 x) { # if GLM_ARCH & GLM_ARCH_SSE41_BIT return _mm_ceil_ps(x); # else glm_vec4 const rnd0 = glm_vec4_round(x); glm_vec4 const cmp0 = _mm_cmpgt_ps(x, rnd0); glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f)); glm_vec4 const add0 = glm_vec4_add(rnd0, and0); return add0; # endif } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_fract(glm_vec4 x) { glm_vec4 const flr0 = glm_vec4_floor(x); glm_vec4 const sub0 = glm_vec4_sub(x, flr0); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mod(glm_vec4 x, glm_vec4 y) { glm_vec4 const div0 = glm_vec4_div(x, y); glm_vec4 const flr0 = glm_vec4_floor(div0); glm_vec4 const mul0 = glm_vec4_mul(y, flr0); glm_vec4 const sub0 = glm_vec4_sub(x, mul0); return sub0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_clamp(glm_vec4 v, glm_vec4 minVal, glm_vec4 maxVal) { glm_vec4 const min0 = _mm_min_ps(v, maxVal); glm_vec4 const max0 = _mm_max_ps(min0, minVal); return max0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mix(glm_vec4 v1, glm_vec4 v2, glm_vec4 a) { glm_vec4 const sub0 = glm_vec4_sub(_mm_set1_ps(1.0f), a); glm_vec4 const mul0 = glm_vec4_mul(v1, sub0); glm_vec4 const mad0 = glm_vec4_fma(v2, a, mul0); return mad0; } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_step(glm_vec4 edge, glm_vec4 x) { glm_vec4 const cmp = _mm_cmple_ps(x, edge); return _mm_movemask_ps(cmp) == 0 ? _mm_set1_ps(1.0f) : _mm_setzero_ps(); } GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_smoothstep(glm_vec4 edge0, glm_vec4 edge1, glm_vec4 x) { glm_vec4 const sub0 = glm_vec4_sub(x, edge0); glm_vec4 const sub1 = glm_vec4_sub(edge1, edge0); glm_vec4 const div0 = glm_vec4_sub(sub0, sub1); glm_vec4 const clp0 = glm_vec4_clamp(div0, _mm_setzero_ps(), _mm_set1_ps(1.0f)); glm_vec4 const mul0 = glm_vec4_mul(_mm_set1_ps(2.0f), clp0); glm_vec4 const sub2 = glm_vec4_sub(_mm_set1_ps(3.0f), mul0); glm_vec4 const mul1 = glm_vec4_mul(clp0, clp0); glm_vec4 const mul2 = glm_vec4_mul(mul1, sub2); return mul2; } // Agner Fog method GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_nan(glm_vec4 x) { glm_ivec4 const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit glm_ivec4 const t3 = _mm_set1_epi32(int(0xFF000000)); // exponent mask glm_ivec4 const t4 = _mm_and_si128(t2, t3); // exponent glm_ivec4 const t5 = _mm_andnot_si128(t3, t2); // fraction glm_ivec4 const Equal = _mm_cmpeq_epi32(t3, t4); glm_ivec4 const Nequal = _mm_cmpeq_epi32(t5, _mm_setzero_si128()); glm_ivec4 const And = _mm_and_si128(Equal, Nequal); return _mm_castsi128_ps(And); // exponent = all 1s and fraction != 0 } // Agner Fog method GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_inf(glm_vec4 x) { glm_ivec4 const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit return _mm_castsi128_ps(_mm_cmpeq_epi32(t2, _mm_set1_epi32(int(0xFF000000)))); // exponent is all 1s, fraction is 0 } #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/simd/packing.h0000600000175000001440000000020113173131001014761 0ustar guususers/// @ref simd /// @file glm/simd/packing.h #pragma once #if GLM_ARCH & GLM_ARCH_SSE2_BIT #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/matrix.hpp0000600000175000001440000001365113173131001014272 0ustar guususers/// @ref core /// @file glm/matrix.hpp /// /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions /// /// @defgroup core_func_matrix Matrix functions /// @ingroup core /// /// Include to use these core features. /// /// For each of the following built-in matrix functions, there is both a /// single-qualifier floating point version, where all arguments and return values /// are single qualifier, and a double-qualifier floating version, where all /// arguments and return values are double qualifier. Only the single-qualifier /// floating point version is shown. #pragma once // Dependencies #include "detail/qualifier.hpp" #include "detail/setup.hpp" #include "detail/type_mat.hpp" #include "vec2.hpp" #include "vec3.hpp" #include "vec4.hpp" #include "mat2x2.hpp" #include "mat2x3.hpp" #include "mat2x4.hpp" #include "mat3x2.hpp" #include "mat3x3.hpp" #include "mat3x4.hpp" #include "mat4x2.hpp" #include "mat4x3.hpp" #include "mat4x4.hpp" namespace glm { namespace detail { template struct outerProduct_trait<2, 2, T, Q> { typedef mat<2, 2, T, Q> type; }; template struct outerProduct_trait<2, 3, T, Q> { typedef mat<3, 2, T, Q> type; }; template struct outerProduct_trait<2, 4, T, Q> { typedef mat<4, 2, T, Q> type; }; template struct outerProduct_trait<3, 2, T, Q> { typedef mat<2, 3, T, Q> type; }; template struct outerProduct_trait<3, 3, T, Q> { typedef mat<3, 3, T, Q> type; }; template struct outerProduct_trait<3, 4, T, Q> { typedef mat<4, 3, T, Q> type; }; template struct outerProduct_trait<4, 2, T, Q> { typedef mat<2, 4, T, Q> type; }; template struct outerProduct_trait<4, 3, T, Q> { typedef mat<3, 4, T, Q> type; }; template struct outerProduct_trait<4, 4, T, Q> { typedef mat<4, 4, T, Q> type; }; }//namespace detail /// @addtogroup core_func_matrix /// @{ /// Multiply matrix x by matrix y component-wise, i.e., /// result[i][j] is the scalar product of x[i][j] and y[i][j]. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL matrixCompMult man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL mat matrixCompMult(mat const& x, mat const& y); /// Treats the first parameter c as a column vector /// and the second parameter r as a row vector /// and does a linear algebraic matrix multiply c * r. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL outerProduct man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL typename detail::outerProduct_trait::type outerProduct(vec const& c, vec const& r); /// Returns the transposed matrix of x /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL transpose man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL typename mat::transpose_type transpose(mat const& x); /// Return the determinant of a squared matrix. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL determinant man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL T determinant(mat const& m); /// Return the inverse of a squared matrix. /// /// @tparam C Integer between 1 and 4 included that qualify the number a column /// @tparam R Integer between 1 and 4 included that qualify the number a row /// @tparam T Floating-point or signed integer scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL inverse man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template GLM_FUNC_DECL mat inverse(mat const& m); /// @} }//namespace glm #include "detail/func_matrix.inl" glm-0.9.9-a2/glm/vector_relational.hpp0000600000175000001440000001406313173131001016500 0ustar guususers/// @ref core /// @file glm/vector_relational.hpp /// /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions /// /// @defgroup core_func_vector_relational Vector Relational Functions /// @ingroup core /// /// Include to use these core features. /// /// Relational and equality operators (<, <=, >, >=, ==, !=) are defined to /// operate on scalars and produce scalar Boolean results. For vector results, /// use the following built-in functions. /// /// In all cases, the sizes of all the input and return vectors for any particular /// call must match. #pragma once #include "detail/qualifier.hpp" #include "detail/setup.hpp" namespace glm { /// @addtogroup core_func_vector_relational /// @{ /// Returns the component-wise comparison result of x < y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL lessThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL vec lessThan(vec const& x, vec const& y); /// Returns the component-wise comparison of result x <= y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL lessThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL vec lessThanEqual(vec const& x, vec const& y); /// Returns the component-wise comparison of result x > y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL greaterThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL vec greaterThan(vec const& x, vec const& y); /// Returns the component-wise comparison of result x >= y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point or integer scalar type. /// /// @see GLSL greaterThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL vec greaterThanEqual(vec const& x, vec const& y); /// Returns the component-wise comparison of result x == y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point, integer or bool scalar type. /// /// @see GLSL equal man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL vec equal(vec const& x, vec const& y); /// Returns the component-wise comparison of result x != y. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T A floating-point, integer or bool scalar type. /// /// @see GLSL notEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL vec notEqual(vec const& x, vec const& y); /// Returns true if any component of x is true. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL any man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL bool any(vec const& v); /// Returns true if all components of x are true. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL all man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL bool all(vec const& v); /// Returns the component-wise logical complement of x. /// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead. /// /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// /// @see GLSL not man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template GLM_FUNC_DECL vec not_(vec const& v); /// @} }//namespace glm #include "detail/func_vector_relational.inl" glm-0.9.9-a2/glm/ext.hpp0000600000175000001440000000563613173131001013572 0ustar guususers/// @file glm/ext.hpp /// /// @ref core (Dependence) #include "detail/setup.hpp" #pragma once #include "glm.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED) # define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED # pragma message("GLM: All extensions included (not recommanded)") #endif//GLM_MESSAGES #include "./ext/vector_relational.hpp" #include "./gtc/bitfield.hpp" #include "./gtc/color_space.hpp" #include "./gtc/constants.hpp" #include "./gtc/epsilon.hpp" #include "./gtc/integer.hpp" #include "./gtc/matrix_access.hpp" #include "./gtc/matrix_integer.hpp" #include "./gtc/matrix_inverse.hpp" #include "./gtc/matrix_transform.hpp" #include "./gtc/noise.hpp" #include "./gtc/packing.hpp" #include "./gtc/quaternion.hpp" #include "./gtc/random.hpp" #include "./gtc/reciprocal.hpp" #include "./gtc/round.hpp" //#include "./gtc/type_aligned.hpp" #include "./gtc/type_precision.hpp" #include "./gtc/type_ptr.hpp" #include "./gtc/ulp.hpp" #include "./gtc/vec1.hpp" #if GLM_HAS_ALIGNED_TYPE # include "./gtc/type_aligned.hpp" #endif #ifdef GLM_ENABLE_EXPERIMENTAL #include "./gtx/associated_min_max.hpp" #include "./gtx/bit.hpp" #include "./gtx/closest_point.hpp" #include "./gtx/color_encoding.hpp" #include "./gtx/color_space.hpp" #include "./gtx/color_space_YCoCg.hpp" #include "./gtx/compatibility.hpp" #include "./gtx/component_wise.hpp" #include "./gtx/dual_quaternion.hpp" #include "./gtx/euler_angles.hpp" #include "./gtx/extend.hpp" #include "./gtx/extended_min_max.hpp" #include "./gtx/fast_exponential.hpp" #include "./gtx/fast_square_root.hpp" #include "./gtx/fast_trigonometry.hpp" #include "./gtx/functions.hpp" #include "./gtx/gradient_paint.hpp" #include "./gtx/handed_coordinate_space.hpp" #include "./gtx/integer.hpp" #include "./gtx/intersect.hpp" #include "./gtx/log_base.hpp" #include "./gtx/matrix_cross_product.hpp" #include "./gtx/matrix_interpolation.hpp" #include "./gtx/matrix_major_storage.hpp" #include "./gtx/matrix_operation.hpp" #include "./gtx/matrix_query.hpp" #include "./gtx/mixed_product.hpp" #include "./gtx/norm.hpp" #include "./gtx/normal.hpp" #include "./gtx/normalize_dot.hpp" #include "./gtx/number_precision.hpp" #include "./gtx/optimum_pow.hpp" #include "./gtx/orthonormalize.hpp" #include "./gtx/perpendicular.hpp" #include "./gtx/polar_coordinates.hpp" #include "./gtx/projection.hpp" #include "./gtx/quaternion.hpp" #include "./gtx/raw_data.hpp" #include "./gtx/rotate_vector.hpp" #include "./gtx/spline.hpp" #include "./gtx/std_based_type.hpp" #if !(GLM_COMPILER & GLM_COMPILER_CUDA) # include "./gtx/string_cast.hpp" #endif #include "./gtx/transform.hpp" #include "./gtx/transform2.hpp" #include "./gtx/vec_swizzle.hpp" #include "./gtx/vector_angle.hpp" #include "./gtx/vector_query.hpp" #include "./gtx/wrap.hpp" #if GLM_HAS_TEMPLATE_ALIASES # include "./gtx/scalar_multiplication.hpp" #endif #if GLM_HAS_RANGE_FOR # include "./gtx/range.hpp" #endif #endif//GLM_ENABLE_EXPERIMENTAL glm-0.9.9-a2/glm/trigonometric.hpp0000600000175000001440000002465013173131001015654 0ustar guususers/// @ref core /// @file glm/trigonometric.hpp /// /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions /// /// @defgroup core_func_trigonometric Angle and Trigonometry Functions /// @ingroup core /// /// Include to use these core features. /// /// Function parameters specified as angle are assumed to be in units of radians. /// In no case will any of these functions result in a divide by zero error. If /// the divisor of a ratio is 0, then results will be undefined. /// /// These all operate component-wise. The description is per component. #pragma once #include "detail/setup.hpp" #include "detail/qualifier.hpp" namespace glm { /// @addtogroup core_func_trigonometric /// @{ /// Converts degrees to radians and returns the result. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL radians man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec radians(vec const& degrees); /// Converts radians to degrees and returns the result. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL degrees man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL GLM_CONSTEXPR vec degrees(vec const& radians); /// The standard trigonometric sine function. /// The values returned by this function will range from [-1, 1]. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL sin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec sin(vec const& angle); /// The standard trigonometric cosine function. /// The values returned by this function will range from [-1, 1]. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL cos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec cos(vec const& angle); /// The standard trigonometric tangent function. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL tan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec tan(vec const& angle); /// Arc sine. Returns an angle whose sine is x. /// The range of values returned by this function is [-PI/2, PI/2]. /// Results are undefined if |x| > 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL asin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec asin(vec const& x); /// Arc cosine. Returns an angle whose sine is x. /// The range of values returned by this function is [0, PI]. /// Results are undefined if |x| > 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL acos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec acos(vec const& x); /// Arc tangent. Returns an angle whose tangent is y/x. /// The signs of x and y are used to determine what /// quadrant the angle is in. The range of values returned /// by this function is [-PI, PI]. Results are undefined /// if x and y are both 0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec atan(vec const& y, vec const& x); /// Arc tangent. Returns an angle whose tangent is y_over_x. /// The range of values returned by this function is [-PI/2, PI/2]. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec atan(vec const& y_over_x); /// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2 /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL sinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec sinh(vec const& angle); /// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2 /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL cosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec cosh(vec const& angle); /// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle) /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL tanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec tanh(vec const& angle); /// Arc hyperbolic sine; returns the inverse of sinh. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL asinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec asinh(vec const& x); /// Arc hyperbolic cosine; returns the non-negative inverse /// of cosh. Results are undefined if x < 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL acosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec acosh(vec const& x); /// Arc hyperbolic tangent; returns the inverse of tanh. /// Results are undefined if abs(x) >= 1. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types /// @tparam Q Value from qualifier enum /// /// @see GLSL atanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template GLM_FUNC_DECL vec atanh(vec const& x); /// @} }//namespace glm #include "detail/func_trigonometric.inl" glm-0.9.9-a2/glm/mat2x3.hpp0000600000175000001440000000300213173131001014071 0ustar guususers/// @ref core /// @file glm/mat2x3.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat2x3.hpp" namespace glm { /// 2 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, lowp> lowp_mat2x3; /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, mediump> mediump_mat2x3; /// 2 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, highp> highp_mat2x3; }//namespace glm glm-0.9.9-a2/glm/mat3x4.hpp0000600000175000001440000000300313173131001014074 0ustar guususers/// @ref core /// @file glm/mat3x4.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat3x4.hpp" namespace glm { /// 3 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, lowp> lowp_mat3x4; /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, mediump> mediump_mat3x4; /// 3 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, highp> highp_mat3x4; }//namespace glm glm-0.9.9-a2/glm/mat4x4.hpp0000600000175000001440000000555213173131001014110 0ustar guususers/// @ref core /// @file glm/mat4x4.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat4x4.hpp" namespace glm { /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4; /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4; /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4; /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4x4; /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4x4; /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4x4; }//namespace glm glm-0.9.9-a2/glm/ext/0000700000175000001440000000000013173131001013045 5ustar guususersglm-0.9.9-a2/glm/ext/vec1.inl0000600000175000001440000000000013173131001014377 0ustar guususersglm-0.9.9-a2/glm/ext/vector_relational.hpp0000600000175000001440000001051513173131001017276 0ustar guususers/// @ref ext_vector_relational /// @file glm/ext/vector_relational.hpp /// /// @see core (dependence) /// /// @defgroup ext_vector_relational GLM_EXT_vector_relational /// @ingroup ext /// /// Include to use the features of this extension. /// /// Comparison functions for a user defined epsilon values. #pragma once // Dependencies #include "../detail/setup.hpp" #include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vector_relational extension included") #endif namespace glm { /// @addtogroup ext_vector_relational /// @{ /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec equal(vec const& x, vec const& y, T const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec equal(vec const& x, vec const& y, vec const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is satisfied. /// /// @tparam genType Floating-point or integer scalar types /// /// @see ext_vector_relational template GLM_FUNC_DECL bool equal(genType const& x, genType const& y, genType const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is not satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec notEqual(vec const& x, vec const& y, T const& epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. /// True if this expression is not satisfied. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec notEqual(vec const& x, vec const& y, vec const& epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. /// True if this expression is not satisfied. /// /// @tparam genType Floating-point or integer scalar types /// /// @see ext_vector_relational template GLM_FUNC_DECL bool notEqual(genType const& x, genType const& y, genType const& epsilon); /// Returns whether vector components values are within an interval. A open interval excludes its endpoints, and is denoted with square brackets. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec openBounded(vec const& Value, vec const& Min, vec const& Max); /// Returns whether vector components values are within an interval. A closed interval includes its endpoints, and is denoted with square brackets. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types /// @tparam Q Value from qualifier enum /// /// @see ext_vector_relational template GLM_FUNC_DECL vec closeBounded(vec const& Value, vec const& Min, vec const& Max); /// @} }//namespace glm #include "vector_relational.inl" glm-0.9.9-a2/glm/ext/vec1.hpp0000600000175000001440000003055113173131001014422 0ustar guususers/// @ref ext_vec1 /// @file glm/ext/vec1.hpp /// /// @see core (dependence) /// /// @defgroup ext_vec1 GLM_EXT_vec1 /// @ingroup ext /// /// Include to use the features of this extension. /// /// Add vec1, ivec1, uvec1 and bvec1 types. #pragma once #include "../fwd.hpp" #include "../detail/type_vec.hpp" #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED # if GLM_HAS_UNRESTRICTED_UNIONS # include "../detail/_swizzle.hpp" # else # include "../detail/_swizzle_func.hpp" # endif #endif //GLM_SWIZZLE #include #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_EXT_vec1 extension included") #endif namespace glm { /// @addtogroup ext_vec1 /// @{ template struct vec<1, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec type; typedef vec<1, bool, Q> bool_type; // -- Data -- # if GLM_HAS_ONLY_XYZW T x; # elif GLM_HAS_ALIGNED_TYPE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # endif # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # endif union { T x; T r; T s; /* # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED _GLM_SWIZZLE1_2_MEMBERS(T, Q, tvec2, x) _GLM_SWIZZLE1_2_MEMBERS(T, Q, tvec2, r) _GLM_SWIZZLE1_2_MEMBERS(T, Q, tvec2, s) _GLM_SWIZZLE1_3_MEMBERS(T, Q, tvec3, x) _GLM_SWIZZLE1_3_MEMBERS(T, Q, tvec3, r) _GLM_SWIZZLE1_3_MEMBERS(T, Q, tvec3, s) _GLM_SWIZZLE1_4_MEMBERS(T, Q, tvec4, x) _GLM_SWIZZLE1_4_MEMBERS(T, Q, tvec4, r) _GLM_SWIZZLE1_4_MEMBERS(T, Q, tvec4, s) # endif//GLM_SWIZZLE*/ }; # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # endif # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # endif # else union {T x, r, s;}; /* # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, P, tvec2, tvec2, tvec3, tvec4) # endif//GLM_SWIZZLE*/ # endif // -- Component accesses -- /// Return the count of components of the vector typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 1;} GLM_FUNC_DECL T & operator[](length_type i); GLM_FUNC_DECL T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(T scalar); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<2, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<1, U, P> const& v); // -- Swizzle constructors -- /* # if(GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)) template GLM_FUNC_DECL tvec(detail::_swizzle<1, T, Q, tvec1, E0, -1,-2,-3> const& that) { *this = that(); } # endif//(GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)) */ // -- Unary arithmetic operators -- GLM_FUNC_DECL vec & operator=(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL vec & operator=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator+=(U scalar); template GLM_FUNC_DECL vec & operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator-=(U scalar); template GLM_FUNC_DECL vec & operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator*=(U scalar); template GLM_FUNC_DECL vec & operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator/=(U scalar); template GLM_FUNC_DECL vec & operator/=(vec<1, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL vec & operator++(); GLM_FUNC_DECL vec & operator--(); GLM_FUNC_DECL vec operator++(int); GLM_FUNC_DECL vec operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL vec & operator%=(U scalar); template GLM_FUNC_DECL vec & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator&=(U scalar); template GLM_FUNC_DECL vec & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator|=(U scalar); template GLM_FUNC_DECL vec & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator^=(U scalar); template GLM_FUNC_DECL vec & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator<<=(U scalar); template GLM_FUNC_DECL vec & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator>>=(U scalar); template GLM_FUNC_DECL vec & operator>>=(vec<1, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL vec<1, T, Q> operator+(vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator-(vec<1, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v); template GLM_FUNC_DECL vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, T, Q> operator~(vec<1, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2); template GLM_FUNC_DECL vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2); /// 1 component vector of single-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see ext_vec1 typedef vec<1, float, highp> highp_vec1; /// 1 component vector of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see ext_vec1 typedef vec<1, float, mediump> mediump_vec1; /// 1 component vector of single-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see ext_vec1 typedef vec<1, float, lowp> lowp_vec1; /// 1 component vector of double-precision floating-point numbers using high precision arithmetic in term of ULPs. /// /// @see ext_vec1 typedef vec<1, double, highp> highp_dvec1; /// 1 component vector of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. /// /// @see ext_vec1 typedef vec<1, double, mediump> mediump_dvec1; /// 1 component vector of double-precision floating-point numbers using low precision arithmetic in term of ULPs. /// /// @see ext_vec1 typedef vec<1, double, lowp> lowp_dvec1; /// 1 component vector of signed integer numbers. /// /// @see ext_vec1 typedef vec<1, int, highp> highp_ivec1; /// 1 component vector of signed integer numbers. /// /// @see ext_vec1 typedef vec<1, int, mediump> mediump_ivec1; /// 1 component vector of signed integer numbers. /// /// @see ext_vec1 typedef vec<1, int, lowp> lowp_ivec1; /// 1 component vector of unsigned integer numbers. /// /// @see ext_vec1 typedef vec<1, uint, highp> highp_uvec1; /// 1 component vector of unsigned integer numbers. /// /// @see ext_vec1 typedef vec<1, uint, mediump> mediump_uvec1; /// 1 component vector of unsigned integer numbers. /// /// @see ext_vec1 typedef vec<1, uint, lowp> lowp_uvec1; /// 1 component vector of bool values. /// /// @see ext_vec1 typedef vec<1, bool, highp> highp_bvec1; /// 1 component vector of bool values. /// /// @see ext_vec1 typedef vec<1, bool, mediump> mediump_bvec1; /// 1 component vector of bool values. /// /// @see ext_vec1 typedef vec<1, bool, lowp> lowp_bvec1; #if GLM_HAS_TEMPLATE_ALIASES template using tvec1 = vec<1, T, Q>; #endif//GLM_HAS_TEMPLATE_ALIASES /// @} }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "../detail/type_vec1.inl" #endif//GLM_EXTERNAL_TEMPLATE glm-0.9.9-a2/glm/ext/vector_relational.inl0000600000175000001440000000354413173131001017275 0ustar guususers/// @ref ext_vector_relational /// @file glm/ext/vector_relational.inl // Dependency: #include "../vector_relational.hpp" #include "../common.hpp" #include "../detail/type_vec.hpp" namespace glm { template GLM_FUNC_QUALIFIER bool equal(genType const& x, genType const& y, genType const& epsilon) { return abs(x - y) < epsilon; } template GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y, T const& epsilon) { return lessThan(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y, vec const& epsilon) { return lessThan(abs(x - y), epsilon); } template GLM_FUNC_QUALIFIER bool notEqual(genType const& x, genType const& y, genType const& epsilon) { return abs(x - y) >= epsilon; } template GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y, T const& epsilon) { return greaterThanEqual(abs(x - y), vec(epsilon)); } template GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y, vec const& epsilon) { return greaterThanEqual(abs(x - y), epsilon); } template GLM_FUNC_QUALIFIER vec openBounded(vec const& Value, vec const& Min, vec const& Max) { return greaterThan(Value, Min) && lessThan(Value, Max); } template GLM_FUNC_QUALIFIER vec closeBounded(vec const& Value, vec const& Min, vec const& Max) { return greaterThanEqual(Value, Min) && lessThanEqual(Value, Max); } }//namespace glm glm-0.9.9-a2/glm/CMakeLists.txt0000600000175000001440000000606613173131001015017 0ustar guususersfile(GLOB ROOT_SOURCE *.cpp) file(GLOB ROOT_INLINE *.inl) file(GLOB ROOT_HEADER *.hpp) file(GLOB ROOT_TEXT ../*.txt) file(GLOB ROOT_MD ../*.md) file(GLOB ROOT_NAT ../util/glm.natvis) file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp) file(GLOB_RECURSE CORE_INLINE ./detail/*.inl) file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp) file(GLOB_RECURSE EXT_SOURCE ./ext/*.cpp) file(GLOB_RECURSE EXT_INLINE ./ext/*.inl) file(GLOB_RECURSE EXT_HEADER ./ext/*.hpp) file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp) file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl) file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp) file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp) file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl) file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp) file(GLOB_RECURSE SIMD_SOURCE ./simd/*.cpp) file(GLOB_RECURSE SIMD_INLINE ./simd/*.inl) file(GLOB_RECURSE SIMD_HEADER ./simd/*.h) source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD}) source_group("Core Files" FILES ${CORE_SOURCE}) source_group("Core Files" FILES ${CORE_INLINE}) source_group("Core Files" FILES ${CORE_HEADER}) source_group("EXT Files" FILES ${EXT_SOURCE}) source_group("EXT Files" FILES ${EXT_INLINE}) source_group("EXT Files" FILES ${EXT_HEADER}) source_group("GTC Files" FILES ${GTC_SOURCE}) source_group("GTC Files" FILES ${GTC_INLINE}) source_group("GTC Files" FILES ${GTC_HEADER}) source_group("GTX Files" FILES ${GTX_SOURCE}) source_group("GTX Files" FILES ${GTX_INLINE}) source_group("GTX Files" FILES ${GTX_HEADER}) source_group("SIMD Files" FILES ${SIMD_SOURCE}) source_group("SIMD Files" FILES ${SIMD_INLINE}) source_group("SIMD Files" FILES ${SIMD_HEADER}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..) if(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE) if(GLM_STATIC_LIBRARY_ENABLE) add_library(glm_static STATIC ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT} ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} ${EXT_SOURCE} ${EXT_INLINE} ${EXT_HEADER} ${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER} ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER} ${SIMD_SOURCE} ${SIMD_INLINE} ${SIMD_HEADER}) endif(GLM_STATIC_LIBRARY_ENABLE) if(GLM_DYNAMIC_LIBRARY_ENABLE) add_library(glm_shared SHARED ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT} ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} ${EXT_SOURCE} ${EXT_INLINE} ${EXT_HEADER} ${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER} ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER} ${SIMD_SOURCE} ${SIMD_INLINE} ${SIMD_HEADER}) endif(GLM_DYNAMIC_LIBRARY_ENABLE) else(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE) add_executable(glm_dummy ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT} ${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} ${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} ${EXT_SOURCE} ${EXT_INLINE} ${EXT_HEADER} ${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER} ${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER} ${SIMD_SOURCE} ${SIMD_INLINE} ${SIMD_HEADER}) endif(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE) glm-0.9.9-a2/glm/glm.hpp0000600000175000001440000000777713173131001013561 0ustar guususers/// @ref core /// @file glm/glm.hpp /// /// @defgroup core Core features /// /// @brief Features that implement in C++ the GLSL specification as closely as possible. /// /// The GLM core consists of @ref core_types "C++ types that mirror GLSL types" and /// C++ functions that mirror the GLSL functions. It also includes /// @ref core_precision "a set of qualifier-based types" that can be used in the appropriate /// functions. The C++ types are all based on a basic set of @ref core_template "template types". /// /// The best documentation for GLM Core is the current GLSL specification, /// version 4.2 /// (pdf file). /// /// GLM core functionalities require to be included to be used. /// /// @defgroup core_types Types /// /// @brief The standard types defined by the specification. /// /// These types are all typedefs of more generalized, template types. To see the definition /// of these template types, go to @ref core_template. /// /// @ingroup core /// /// @defgroup core_precision Precision types /// /// @brief Non-GLSL types that are used to define qualifier-based types. /// /// The GLSL language allows the user to define the qualifier of a particular variable. /// In OpenGL's GLSL, these qualifier qualifiers have no effect; they are there for compatibility /// with OpenGL ES's qualifier qualifiers, where they @em do have an effect. /// /// C++ has no language equivalent to qualifier qualifiers. So GLM provides the next-best thing: /// a number of typedefs of the @ref core_template that use a particular qualifier. /// /// None of these types make any guarantees about the actual qualifier used. /// /// @ingroup core /// /// @defgroup core_template Template types /// /// @brief The generic template types used as the basis for the core types. /// /// These types are all templates used to define the actual @ref core_types. /// These templetes are implementation details of GLM types and should not be used explicitly. /// /// @ingroup core /// /// @defgroup gtc Stable extensions /// /// @brief Additional features not specified by GLSL specification. /// /// GTC extensions aim to be stable. /// /// Even if it's highly unrecommended, it's possible to include all the extensions at once by /// including . Otherwise, each extension needs to be included a specific file. /// /// @defgroup gtx Experimental extensions /// /// @brief Experimental features not specified by GLSL specification. /// /// Experimental extensions are useful functions and types, but the development of /// their API and functionality is not necessarily stable. They can change /// substantially between versions. Backwards compatibility is not much of an issue /// for them. /// /// Even if it's highly unrecommended, it's possible to include all the extensions /// at once by including . Otherwise, each extension needs to be /// included a specific file. /// /// @mainpage OpenGL Mathematics (GLM) /// - Website: glm.g-truc.net /// - GLM API documentation /// - GLM Manual #include "detail/_fixes.hpp" #include "detail/setup.hpp" #pragma once #include #include #include #include #include #include "fwd.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED) # define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED # pragma message("GLM: Core library included") #endif//GLM_MESSAGES #include "vec2.hpp" #include "vec3.hpp" #include "vec4.hpp" #include "mat2x2.hpp" #include "mat2x3.hpp" #include "mat2x4.hpp" #include "mat3x2.hpp" #include "mat3x3.hpp" #include "mat3x4.hpp" #include "mat4x2.hpp" #include "mat4x3.hpp" #include "mat4x4.hpp" #include "trigonometric.hpp" #include "exponential.hpp" #include "common.hpp" #include "packing.hpp" #include "geometric.hpp" #include "matrix.hpp" #include "vector_relational.hpp" #include "integer.hpp" glm-0.9.9-a2/glm/mat4x2.hpp0000600000175000001440000000300313173131001014073 0ustar guususers/// @ref core /// @file glm/mat4x2.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat4x2.hpp" namespace glm { /// 4 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, lowp> lowp_mat4x2; /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, mediump> mediump_mat4x2; /// 4 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, highp> highp_mat4x2; }//namespace glm glm-0.9.9-a2/glm/mat3x3.hpp0000600000175000001440000000555213173131001014106 0ustar guususers/// @ref core /// @file glm/mat3x3.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat3x3.hpp" namespace glm { /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3; /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3; /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3; /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3x3; /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3x3; /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3x3; }//namespace glm glm-0.9.9-a2/glm/mat3x2.hpp0000600000175000001440000000277713173131001014113 0ustar guususers/// @ref core /// @file glm/mat3x2.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_mat3x2.hpp" namespace glm { /// 3 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, lowp> lowp_mat3x2; /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, mediump> mediump_mat3x2; /// 3 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, highp> highp_mat3x2; }//namespace glm-0.9.9-a2/glm/vec3.hpp0000600000175000001440000000016113173131001013616 0ustar guususers/// @ref core /// @file glm/vec3.hpp #include "detail/setup.hpp" #pragma once #include "detail/type_vec3.hpp" glm-0.9.9-a2/glm/detail/0000700000175000001440000000000013173131001013507 5ustar guususersglm-0.9.9-a2/glm/detail/type_mat2x3.inl0000600000175000001440000002651713173131001016407 0ustar guususers/// @ref core /// @file glm/detail/type_mat2x3.inl namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<2, 3, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(T scalar) { this->value[0] = col_type(scalar, 0, 0); this->value[1] = col_type(0, scalar, 0); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat ( T x0, T y0, T z0, T x1, T y1, T z1 ) { this->value[0] = col_type(x0, y0, z0); this->value[1] = col_type(x1, y1, z1); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(col_type const& v0, col_type const& v1) { this->value[0] = v0; this->value[1] = v1; } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat ( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2 ) { this->value[0] = col_type(static_cast(x1), value_type(y1), value_type(z1)); this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2)); } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<2, 3, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type & mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type const& mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator=(mat<2, 3, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator=(mat<2, 3, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator+=(mat<2, 3, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(mat<2, 3, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator--() { --this->value[0]; --this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator++(int) { mat<2, 3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator--(int) { mat<2, 3, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m) { return mat<2, 3, T, Q>( -m[0], -m[1]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0] + m2[0], m1[1] + m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] - scalar, m[1] - scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0] - m2[0], m1[1] - m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m) { return mat<2, 3, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type operator* ( mat<2, 3, T, Q> const& m, typename mat<2, 3, T, Q>::row_type const& v) { return typename mat<2, 3, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y, m[0][1] * v.x + m[1][1] * v.y, m[0][2] * v.x + m[1][2] * v.y); } template GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::row_type operator* ( typename mat<2, 3, T, Q>::col_type const& v, mat<2, 3, T, Q> const& m) { return typename mat<2, 3, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { T SrcA00 = m1[0][0]; T SrcA01 = m1[0][1]; T SrcA02 = m1[0][2]; T SrcA10 = m1[1][0]; T SrcA11 = m1[1][1]; T SrcA12 = m1[1][2]; T SrcB00 = m2[0][0]; T SrcB01 = m2[0][1]; T SrcB10 = m2[1][0]; T SrcB11 = m2[1][1]; T SrcB20 = m2[2][0]; T SrcB21 = m2[2][1]; mat<3, 3, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1], m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar) { return mat<2, 3, T, Q>( m[0] / scalar, m[1] / scalar); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m) { return mat<2, 3, T, Q>( scalar / m[0], scalar / m[1]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); } } //namespace glm glm-0.9.9-a2/glm/detail/type_mat4x2.hpp0000600000175000001440000001252013173131001016402 0ustar guususers/// @ref core /// @file glm/detail/type_mat4x2.hpp #pragma once #include "../fwd.hpp" #include "type_vec2.hpp" #include "type_vec4.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<4, 2, T, Q> { typedef vec<2, T, Q> col_type; typedef vec<4, T, Q> row_type; typedef mat<4, 2, T, Q> type; typedef mat<2, 4, T, Q> transpose_type; typedef T value_type; private: col_type value[4]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<4, 2, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<4, 2, T, P> const& m); GLM_FUNC_DECL explicit mat(T scalar); GLM_FUNC_DECL mat( T x0, T y0, T x1, T y1, T x2, T y2, T x3, T y3); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3); // -- Conversions -- template< typename X1, typename Y1, typename X2, typename Y2, typename X3, typename Y3, typename X4, typename Y4> GLM_FUNC_DECL mat( X1 x1, Y1 y1, X2 x2, Y2 y2, X3 x3, Y3 y3, X4 x4, Y4 y4); template GLM_FUNC_DECL mat( vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3, vec<2, V4, Q> const& v4); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<4, 2, T, Q> & operator=(mat<4, 2, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<4, 2, T, Q> & operator=(mat<4, 2, U, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(mat<4, 2, U, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(mat<4, 2, U, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<4, 2, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<4, 2, T, Q> & operator++ (); GLM_FUNC_DECL mat<4, 2, T, Q> & operator-- (); GLM_FUNC_DECL mat<4, 2, T, Q> operator++(int); GLM_FUNC_DECL mat<4, 2, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m); template GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat4x2.inl" #endif glm-0.9.9-a2/glm/detail/_swizzle.hpp0000600000175000001440000013742013173131001016077 0ustar guususers/// @ref core /// @file glm/detail/_swizzle.hpp #pragma once namespace glm{ namespace detail { // Internal class for implementing swizzle operators template struct _swizzle_base0 { protected: GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast(_buffer))[i]; } GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterpret_cast(_buffer))[i]; } // Use an opaque buffer to *ensure* the compiler doesn't call a constructor. // The size 1 buffer is assumed to aligned to the actual members so that the // elem() char _buffer[1]; }; template struct _swizzle_base1 : public _swizzle_base0 { }; template struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()() const { return vec<2, T, Q>(this->elem(E0), this->elem(E1)); } }; template struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()() const { return vec<3, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2)); } }; template struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, T, Q> operator ()() const { return vec<4, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } }; // Internal class for implementing swizzle operators /* Template parameters: T = type of scalar values (e.g. float, double) N = number of components in the vector (e.g. 3) E0...3 = what index the n-th element of this swizzle refers to in the unswizzled vec DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles containing duplicate elements so that they cannot be used as r-values). */ template struct _swizzle_base2 : public _swizzle_base1::value> { GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t) { for (int i = 0; i < N; ++i) (*this)[i] = t; return *this; } GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec const& that) { struct op { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e = t; } }; _apply_op(that, op()); return *this; } GLM_FUNC_QUALIFIER void operator -= (vec const& that) { struct op { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e -= t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER void operator += (vec const& that) { struct op { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e += t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER void operator *= (vec const& that) { struct op { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e *= t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER void operator /= (vec const& that) { struct op { GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e /= t; } }; _apply_op(that, op()); } GLM_FUNC_QUALIFIER T& operator[](size_t i) { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } GLM_FUNC_QUALIFIER T operator[](size_t i) const { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } protected: template GLM_FUNC_QUALIFIER void _apply_op(vec const& that, U op) { // Make a copy of the data in this == &that. // The copier should optimize out the copy in cases where the function is // properly inlined and the copy is not necessary. T t[N]; for (int i = 0; i < N; ++i) t[i] = that[i]; for (int i = 0; i < N; ++i) op( (*this)[i], t[i] ); } }; // Specialization for swizzles containing duplicate elements. These cannot be modified. template struct _swizzle_base2 : public _swizzle_base1::value> { struct Stub {}; GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { return *this; } GLM_FUNC_QUALIFIER T operator[] (size_t i) const { const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } }; template struct _swizzle : public _swizzle_base2 { typedef _swizzle_base2 base_type; using base_type::operator=; GLM_FUNC_QUALIFIER operator vec () const { return (*this)(); } }; // // To prevent the C++ syntax from getting entirely overwhelming, define some alias macros // #define GLM_SWIZZLE_TEMPLATE1 template #define GLM_SWIZZLE_TEMPLATE2 template #define GLM_SWIZZLE_TYPE1 _swizzle #define GLM_SWIZZLE_TYPE2 _swizzle // // Wrapper for a binary operator (e.g. u.yy + v.zy) // #define GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ GLM_SWIZZLE_TEMPLATE2 \ GLM_FUNC_QUALIFIER vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \ { \ return a() OPERAND b(); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const vec& b) \ { \ return a() OPERAND b; \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER vec operator OPERAND ( const vec& a, const GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } // // Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz) // #define GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b) \ { \ return a() OPERAND b; \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER vec operator OPERAND ( const T& a, const GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } // // Macro for wrapping a function taking one argument (e.g. abs()) // #define GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a) \ { \ return FUNCTION(a()); \ } // // Macro for wrapping a function taking two vector arguments (e.g. dot()). // #define GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \ GLM_SWIZZLE_TEMPLATE2 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \ { \ return FUNCTION(a(), b()); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a(), b()); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename V& b) \ { \ return FUNCTION(a(), b); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a, b()); \ } // // Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()). // #define GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \ GLM_SWIZZLE_TEMPLATE2 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b, const T& c) \ { \ return FUNCTION(a(), b(), c); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b, const T& c) \ { \ return FUNCTION(a(), b(), c); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\ { \ return FUNCTION(a(), b, c); \ } \ GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const GLM_SWIZZLE_TYPE1& b, const T& c) \ { \ return FUNCTION(a, b(), c); \ } }//namespace detail }//namespace glm namespace glm { namespace detail { GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-) GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*) GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+) GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-) GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*) GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/) } // // Swizzles are distinct types from the unswizzled type. The below macros will // provide template specializations for the swizzle types for the given functions // so that the compiler does not have any ambiguity to choosing how to handle // the function. // // The alternative is to use the operator()() when calling the function in order // to explicitly convert the swizzled type to the unswizzled type. // //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, abs); //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acos); //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acosh); //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, all); //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, any); //GLM_SWIZZLE_FUNCTION_2_ARGS(value_type, dot); //GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, cross); //GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, step); //GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix); } #define GLM_SWIZZLE2_2_MEMBERS(T, Q, E0,E1) \ struct { detail::_swizzle<2, T, Q, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2, T, Q, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2, T, Q, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2, T, Q, 1,1,-1,-2> E1 ## E1; }; #define GLM_SWIZZLE2_3_MEMBERS(T, Q, E0,E1) \ struct { detail::_swizzle<3,T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3,T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3,T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3,T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; #define GLM_SWIZZLE2_4_MEMBERS(T, Q, E0,E1) \ struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; #define GLM_SWIZZLE3_2_MEMBERS(T, Q, E0,E1,E2) \ struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; #define GLM_SWIZZLE3_3_MEMBERS(T, Q ,E0,E1,E2) \ struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; #define GLM_SWIZZLE3_4_MEMBERS(T, Q, E0,E1,E2) \ struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4,T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4,T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4,T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; #define GLM_SWIZZLE4_2_MEMBERS(T, Q, E0,E1,E2,E3) \ struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 0,3,-1,-2> E0 ## E3; }; \ struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 1,3,-1,-2> E1 ## E3; }; \ struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 2,3,-1,-2> E2 ## E3; }; \ struct { detail::_swizzle<2,T, Q, 3,0,-1,-2> E3 ## E0; }; \ struct { detail::_swizzle<2,T, Q, 3,1,-1,-2> E3 ## E1; }; \ struct { detail::_swizzle<2,T, Q, 3,2,-1,-2> E3 ## E2; }; \ struct { detail::_swizzle<2,T, Q, 3,3,-1,-2> E3 ## E3; }; #define GLM_SWIZZLE4_3_MEMBERS(T, Q, E0,E1,E2,E3) \ struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,0,3,-1> E0 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,1,3,-1> E0 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,2,3,-1> E0 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 0,3,0,-1> E0 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 0,3,1,-1> E0 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 0,3,2,-1> E0 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 0,3,3,-1> E0 ## E3 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,0,3,-1> E1 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,1,3,-1> E1 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,2,3,-1> E1 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 1,3,0,-1> E1 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 1,3,1,-1> E1 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 1,3,2,-1> E1 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 1,3,3,-1> E1 ## E3 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,0,3,-1> E2 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,1,3,-1> E2 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,2,3,-1> E2 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 2,3,0,-1> E2 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 2,3,1,-1> E2 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 2,3,2,-1> E2 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 2,3,3,-1> E2 ## E3 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,0,0,-1> E3 ## E0 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,0,1,-1> E3 ## E0 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,0,2,-1> E3 ## E0 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,0,3,-1> E3 ## E0 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,1,0,-1> E3 ## E1 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,1,1,-1> E3 ## E1 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,1,2,-1> E3 ## E1 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,1,3,-1> E3 ## E1 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,2,0,-1> E3 ## E2 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,2,1,-1> E3 ## E2 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,2,2,-1> E3 ## E2 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,2,3,-1> E3 ## E2 ## E3; }; \ struct { detail::_swizzle<3, T, Q, 3,3,0,-1> E3 ## E3 ## E0; }; \ struct { detail::_swizzle<3, T, Q, 3,3,1,-1> E3 ## E3 ## E1; }; \ struct { detail::_swizzle<3, T, Q, 3,3,2,-1> E3 ## E3 ## E2; }; \ struct { detail::_swizzle<3, T, Q, 3,3,3,-1> E3 ## E3 ## E3; }; #define GLM_SWIZZLE4_4_MEMBERS(T, Q, E0,E1,E2,E3) \ struct { detail::_swizzle<4, T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \ struct { detail::_swizzle<4, T, Q, 3,3,3,3> E3 ## E3 ## E3 ## E3; }; glm-0.9.9-a2/glm/detail/type_mat3x4.hpp0000600000175000001440000001255513173131001016413 0ustar guususers/// @ref core /// @file glm/detail/type_mat3x4.hpp #pragma once #include "../fwd.hpp" #include "type_vec3.hpp" #include "type_vec4.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<3, 4, T, Q> { typedef vec<4, T, Q> col_type; typedef vec<3, T, Q> row_type; typedef mat<3, 4, T, Q> type; typedef mat<4, 3, T, Q> transpose_type; typedef T value_type; private: col_type value[3]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<3, 4, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<3, 4, T, P> const& m); GLM_FUNC_DECL explicit mat(T scalar); GLM_FUNC_DECL mat( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1, T x2, T y2, T z2, T w2); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1, col_type const& v2); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, typename X3, typename Y3, typename Z3, typename W3> GLM_FUNC_DECL mat( X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2, X3 x3, Y3 y3, Z3 z3, W3 w3); template GLM_FUNC_DECL mat( vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<3, 4, T, Q> & operator=(mat<3, 4, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<3, 4, T, Q> & operator=(mat<3, 4, U, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(mat<3, 4, U, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(mat<3, 4, U, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<3, 4, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<3, 4, T, Q> & operator++(); GLM_FUNC_DECL mat<3, 4, T, Q> & operator--(); GLM_FUNC_DECL mat<3, 4, T, Q> operator++(int); GLM_FUNC_DECL mat<3, 4, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m); template GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 4, T, Q>::col_type operator*(mat<3, 4, T, Q> const& m, typename mat<3, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 4, T, Q>::row_type operator*(typename mat<3, 4, T, Q>::col_type const& v, mat<3, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat3x4.inl" #endif glm-0.9.9-a2/glm/detail/func_matrix.inl0000600000175000001440000003075013173131001016541 0ustar guususers/// @ref core /// @file glm/detail/func_matrix.inl #include "../geometric.hpp" #include namespace glm{ namespace detail { template struct compute_matrixCompMult { GLM_FUNC_QUALIFIER static mat call(mat const& x, mat const& y) { mat Result; for(length_t i = 0; i < Result.length(); ++i) Result[i] = x[i] * y[i]; return Result; } }; template struct compute_transpose{}; template struct compute_transpose<2, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m) { mat<2, 2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; return Result; } }; template struct compute_transpose<2, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 2, T, Q> call(mat<2, 3, T, Q> const& m) { mat<3,2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; return Result; } }; template struct compute_transpose<2, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 2, T, Q> call(mat<2, 4, T, Q> const& m) { mat<4, 2, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; return Result; } }; template struct compute_transpose<3, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 3, T, Q> call(mat<3, 2, T, Q> const& m) { mat<2, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; return Result; } }; template struct compute_transpose<3, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m) { mat<3, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; return Result; } }; template struct compute_transpose<3, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 3, T, Q> call(mat<3, 4, T, Q> const& m) { mat<4, 3, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; Result[3][2] = m[2][3]; return Result; } }; template struct compute_transpose<4, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 4, T, Q> call(mat<4, 2, T, Q> const& m) { mat<2, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; return Result; } }; template struct compute_transpose<4, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 4, T, Q> call(mat<4, 3, T, Q> const& m) { mat<3, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[2][3] = m[3][2]; return Result; } }; template struct compute_transpose<4, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m) { mat<4, 4, T, Q> Result; Result[0][0] = m[0][0]; Result[0][1] = m[1][0]; Result[0][2] = m[2][0]; Result[0][3] = m[3][0]; Result[1][0] = m[0][1]; Result[1][1] = m[1][1]; Result[1][2] = m[2][1]; Result[1][3] = m[3][1]; Result[2][0] = m[0][2]; Result[2][1] = m[1][2]; Result[2][2] = m[2][2]; Result[2][3] = m[3][2]; Result[3][0] = m[0][3]; Result[3][1] = m[1][3]; Result[3][2] = m[2][3]; Result[3][3] = m[3][3]; return Result; } }; template struct compute_determinant{}; template struct compute_determinant<2, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, Q> const& m) { return m[0][0] * m[1][1] - m[1][0] * m[0][1]; } }; template struct compute_determinant<3, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, Q> const& m) { return + m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]) - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2]) + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]); } }; template struct compute_determinant<4, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, Q> const& m) { T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; vec<4, T, Q> DetCof( + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02), - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04), + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05), - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05)); return m[0][0] * DetCof[0] + m[0][1] * DetCof[1] + m[0][2] * DetCof[2] + m[0][3] * DetCof[3]; } }; template struct compute_inverse{}; template struct compute_inverse<2, 2, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m) { T OneOverDeterminant = static_cast(1) / ( + m[0][0] * m[1][1] - m[1][0] * m[0][1]); mat<2, 2, T, Q> Inverse( + m[1][1] * OneOverDeterminant, - m[0][1] * OneOverDeterminant, - m[1][0] * OneOverDeterminant, + m[0][0] * OneOverDeterminant); return Inverse; } }; template struct compute_inverse<3, 3, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m) { T OneOverDeterminant = static_cast(1) / ( + m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]) - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2]) + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2])); mat<3, 3, T, Q> Inverse; Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant; Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant; Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant; Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant; Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant; Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant; Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant; Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant; Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant; return Inverse; } }; template struct compute_inverse<4, 4, T, Q, Aligned> { GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m) { T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; vec<4, T, Q> Fac0(Coef00, Coef00, Coef02, Coef03); vec<4, T, Q> Fac1(Coef04, Coef04, Coef06, Coef07); vec<4, T, Q> Fac2(Coef08, Coef08, Coef10, Coef11); vec<4, T, Q> Fac3(Coef12, Coef12, Coef14, Coef15); vec<4, T, Q> Fac4(Coef16, Coef16, Coef18, Coef19); vec<4, T, Q> Fac5(Coef20, Coef20, Coef22, Coef23); vec<4, T, Q> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]); vec<4, T, Q> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]); vec<4, T, Q> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]); vec<4, T, Q> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]); vec<4, T, Q> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2); vec<4, T, Q> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4); vec<4, T, Q> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5); vec<4, T, Q> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5); vec<4, T, Q> SignA(+1, -1, +1, -1); vec<4, T, Q> SignB(-1, +1, -1, +1); mat<4, 4, T, Q> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB); vec<4, T, Q> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]); vec<4, T, Q> Dot0(m[0] * Row0); T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w); T OneOverDeterminant = static_cast(1) / Dot1; return Inverse * OneOverDeterminant; } }; }//namespace detail template GLM_FUNC_QUALIFIER mat matrixCompMult(mat const& x, mat const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs"); return detail::compute_matrixCompMult::value>::call(x, y); } template GLM_FUNC_QUALIFIER typename detail::outerProduct_trait::type outerProduct(vec const& c, vec const& r) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs"); typename detail::outerProduct_trait::type m; for(length_t i = 0; i < m.length(); ++i) m[i] = c * r[i]; return m; } template GLM_FUNC_QUALIFIER typename mat::transpose_type transpose(mat const& m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs"); return detail::compute_transpose::value>::call(m); } template GLM_FUNC_QUALIFIER T determinant(mat const& m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs"); return detail::compute_determinant::value>::call(m); } template GLM_FUNC_QUALIFIER mat inverse(mat const& m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs"); return detail::compute_inverse::value>::call(m); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_matrix_simd.inl" #endif glm-0.9.9-a2/glm/detail/type_vec1.hpp0000600000175000001440000000000013173131001016107 0ustar guususersglm-0.9.9-a2/glm/detail/type_mat2x4.inl0000600000175000001440000003011213173131001016372 0ustar guususers/// @ref core /// @file glm/detail/type_mat2x4.inl namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<2, 4, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(T scalar) { value_type const Zero(0); this->value[0] = col_type(scalar, Zero, Zero, Zero); this->value[1] = col_type(Zero, scalar, Zero, Zero); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat ( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1 ) { this->value[0] = col_type(x0, y0, z0, w0); this->value[1] = col_type(x1, y1, z1, w1); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(col_type const& v0, col_type const& v1) { this->value[0] = v0; this->value[1] = v1; } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2> GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat ( X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2 ) { this->value[0] = col_type(static_cast(x1), value_type(y1), value_type(z1), value_type(w1)); this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2), value_type(w2)); } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<2, 4, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type & mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type const& mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator=(mat<2, 4, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator=(mat<2, 4, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(mat<2, 4, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(mat<2, 4, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> & mat<2, 4, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator--() { --this->value[0]; --this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator++(int) { mat<2, 4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator--(int) { mat<2, 4, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m) { return mat<2, 4, T, Q>( -m[0], -m[1]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0] + m2[0], m1[1] + m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] - scalar, m[1] - scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0] - m2[0], m1[1] - m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m) { return mat<2, 4, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v) { return typename mat<2, 4, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y, m[0][1] * v.x + m[1][1] * v.y, m[0][2] * v.x + m[1][2] * v.y, m[0][3] * v.x + m[1][3] * v.y); } template GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m) { return typename mat<2, 4, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { T SrcA00 = m1[0][0]; T SrcA01 = m1[0][1]; T SrcA02 = m1[0][2]; T SrcA03 = m1[0][3]; T SrcA10 = m1[1][0]; T SrcA11 = m1[1][1]; T SrcA12 = m1[1][2]; T SrcA13 = m1[1][3]; T SrcB00 = m2[0][0]; T SrcB01 = m2[0][1]; T SrcB10 = m2[1][0]; T SrcB11 = m2[1][1]; T SrcB20 = m2[2][0]; T SrcB21 = m2[2][1]; T SrcB30 = m2[3][0]; T SrcB31 = m2[3][1]; mat<4, 4, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01; Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11; Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21; Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21; Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31; Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31; Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31; Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1], m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar) { return mat<2, 4, T, Q>( m[0] / scalar, m[1] / scalar); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m) { return mat<2, 4, T, Q>( scalar / m[0], scalar / m[1]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); } } //namespace glm glm-0.9.9-a2/glm/detail/_noise.hpp0000600000175000001440000000420513173131001015477 0ustar guususers/// @ref core /// @file glm/detail/_noise.hpp #pragma once #include "../vec2.hpp" #include "../vec3.hpp" #include "../vec4.hpp" #include "../common.hpp" namespace glm{ namespace detail { template GLM_FUNC_QUALIFIER T mod289(T const& x) { return x - floor(x * (static_cast(1.0) / static_cast(289.0))) * static_cast(289.0); } template GLM_FUNC_QUALIFIER T permute(T const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } template GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r) { return T(1.79284291400159) - T(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r) { return T(1.79284291400159) - T(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r) { return T(1.79284291400159) - T(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r) { return T(1.79284291400159) - T(0.85373472095314) * r; } template GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } template GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } }//namespace detail }//namespace glm glm-0.9.9-a2/glm/detail/_features.hpp0000600000175000001440000002630513173131001016205 0ustar guususers/// @ref core /// @file glm/detail/_features.hpp #pragma once // #define GLM_CXX98_EXCEPTIONS // #define GLM_CXX98_RTTI // #define GLM_CXX11_RVALUE_REFERENCES // Rvalue references - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html // GLM_CXX11_TRAILING_RETURN // Rvalue references for *this - GCC not supported // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm // GLM_CXX11_NONSTATIC_MEMBER_INIT // Initialization of class objects by rvalues - GCC any // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html // GLM_CXX11_NONSTATIC_MEMBER_INIT // Non-static data member initializers - GCC 4.7 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm // #define GLM_CXX11_VARIADIC_TEMPLATE // Variadic templates - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf // // Extending variadic template template parameters - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf // #define GLM_CXX11_GENERALIZED_INITIALIZERS // Initializer lists - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm // #define GLM_CXX11_STATIC_ASSERT // Static assertions - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html // #define GLM_CXX11_AUTO_TYPE // auto-typed variables - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf // #define GLM_CXX11_AUTO_TYPE // Multi-declarator auto - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf // #define GLM_CXX11_AUTO_TYPE // Removal of auto as a storage-class specifier - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm // #define GLM_CXX11_AUTO_TYPE // New function declarator syntax - GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm // #define GLM_CXX11_LAMBDAS // New wording for C++0x lambdas - GCC 4.5 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf // #define GLM_CXX11_DECLTYPE // Declared type of an expression - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf // // Right angle brackets - GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html // // Default template arguments for function templates DR226 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226 // // Solving the SFINAE problem for expressions DR339 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html // #define GLM_CXX11_ALIAS_TEMPLATE // Template aliases N2258 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf // // Extern templates N1987 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm // #define GLM_CXX11_NULLPTR // Null pointer constant N2431 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf // #define GLM_CXX11_STRONG_ENUMS // Strongly-typed enums N2347 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf // // Forward declarations for enums N2764 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf // // Generalized attributes N2761 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf // // Generalized constant expressions N2235 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf // // Alignment support N2341 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf // #define GLM_CXX11_DELEGATING_CONSTRUCTORS // Delegating constructors N1986 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf // // Inheriting constructors N2540 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm // #define GLM_CXX11_EXPLICIT_CONVERSIONS // Explicit conversion operators N2437 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf // // New character types N2249 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html // // Unicode string literals N2442 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm // // Raw string literals N2442 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm // // Universal character name literals N2170 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html // #define GLM_CXX11_USER_LITERALS // User-defined literals N2765 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf // // Standard Layout Types N2342 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm // #define GLM_CXX11_DEFAULTED_FUNCTIONS // #define GLM_CXX11_DELETED_FUNCTIONS // Defaulted and deleted functions N2346 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm // // Extended friend declarations N1791 GCC 4.7 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf // // Extending sizeof N2253 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html // #define GLM_CXX11_INLINE_NAMESPACES // Inline namespaces N2535 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm // #define GLM_CXX11_UNRESTRICTED_UNIONS // Unrestricted unions N2544 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf // #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS // Local and unnamed types as template arguments N2657 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm // #define GLM_CXX11_RANGE_FOR // Range-based for N2930 GCC 4.6 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html // #define GLM_CXX11_OVERRIDE_CONTROL // Explicit virtual overrides N2928 N3206 N3272 GCC 4.7 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm // // Minimal support for garbage collection and reachability-based leak detection N2670 No // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm // #define GLM_CXX11_NOEXCEPT // Allowing move constructors to throw [noexcept] N3050 GCC 4.6 (core language only) // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html // // Defining move special member functions N3053 GCC 4.6 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html // // Sequence points N2239 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html // // Atomic operations N2427 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html // // Strong Compare and Exchange N2748 GCC 4.5 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html // // Bidirectional Fences N2752 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm // // Memory model N2429 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm // // Data-dependency ordering: atomics and memory model N2664 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm // // Propagating exceptions N2179 GCC 4.4 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html // // Abandoning a process and at_quick_exit N2440 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm // // Allow atomics use in signal handlers N2547 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm // // Thread-local storage N2659 GCC 4.8 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm // // Dynamic initialization and destruction with concurrency N2660 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm // // __func__ predefined identifier N2340 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm // // C99 preprocessor N1653 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm // // long long N1811 GCC 4.3 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf // // Extended integral types N1988 Yes // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf #if(GLM_COMPILER & GLM_COMPILER_GCC) # define GLM_CXX11_STATIC_ASSERT #elif(GLM_COMPILER & GLM_COMPILER_CLANG) # if(__has_feature(cxx_exceptions)) # define GLM_CXX98_EXCEPTIONS # endif # if(__has_feature(cxx_rtti)) # define GLM_CXX98_RTTI # endif # if(__has_feature(cxx_access_control_sfinae)) # define GLM_CXX11_ACCESS_CONTROL_SFINAE # endif # if(__has_feature(cxx_alias_templates)) # define GLM_CXX11_ALIAS_TEMPLATE # endif # if(__has_feature(cxx_alignas)) # define GLM_CXX11_ALIGNAS # endif # if(__has_feature(cxx_attributes)) # define GLM_CXX11_ATTRIBUTES # endif # if(__has_feature(cxx_constexpr)) # define GLM_CXX11_CONSTEXPR # endif # if(__has_feature(cxx_decltype)) # define GLM_CXX11_DECLTYPE # endif # if(__has_feature(cxx_default_function_template_args)) # define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS # endif # if(__has_feature(cxx_defaulted_functions)) # define GLM_CXX11_DEFAULTED_FUNCTIONS # endif # if(__has_feature(cxx_delegating_constructors)) # define GLM_CXX11_DELEGATING_CONSTRUCTORS # endif # if(__has_feature(cxx_deleted_functions)) # define GLM_CXX11_DELETED_FUNCTIONS # endif # if(__has_feature(cxx_explicit_conversions)) # define GLM_CXX11_EXPLICIT_CONVERSIONS # endif # if(__has_feature(cxx_generalized_initializers)) # define GLM_CXX11_GENERALIZED_INITIALIZERS # endif # if(__has_feature(cxx_implicit_moves)) # define GLM_CXX11_IMPLICIT_MOVES # endif # if(__has_feature(cxx_inheriting_constructors)) # define GLM_CXX11_INHERITING_CONSTRUCTORS # endif # if(__has_feature(cxx_inline_namespaces)) # define GLM_CXX11_INLINE_NAMESPACES # endif # if(__has_feature(cxx_lambdas)) # define GLM_CXX11_LAMBDAS # endif # if(__has_feature(cxx_local_type_template_args)) # define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS # endif # if(__has_feature(cxx_noexcept)) # define GLM_CXX11_NOEXCEPT # endif # if(__has_feature(cxx_nonstatic_member_init)) # define GLM_CXX11_NONSTATIC_MEMBER_INIT # endif # if(__has_feature(cxx_nullptr)) # define GLM_CXX11_NULLPTR # endif # if(__has_feature(cxx_override_control)) # define GLM_CXX11_OVERRIDE_CONTROL # endif # if(__has_feature(cxx_reference_qualified_functions)) # define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS # endif # if(__has_feature(cxx_range_for)) # define GLM_CXX11_RANGE_FOR # endif # if(__has_feature(cxx_raw_string_literals)) # define GLM_CXX11_RAW_STRING_LITERALS # endif # if(__has_feature(cxx_rvalue_references)) # define GLM_CXX11_RVALUE_REFERENCES # endif # if(__has_feature(cxx_static_assert)) # define GLM_CXX11_STATIC_ASSERT # endif # if(__has_feature(cxx_auto_type)) # define GLM_CXX11_AUTO_TYPE # endif # if(__has_feature(cxx_strong_enums)) # define GLM_CXX11_STRONG_ENUMS # endif # if(__has_feature(cxx_trailing_return)) # define GLM_CXX11_TRAILING_RETURN # endif # if(__has_feature(cxx_unicode_literals)) # define GLM_CXX11_UNICODE_LITERALS # endif # if(__has_feature(cxx_unrestricted_unions)) # define GLM_CXX11_UNRESTRICTED_UNIONS # endif # if(__has_feature(cxx_user_literals)) # define GLM_CXX11_USER_LITERALS # endif # if(__has_feature(cxx_variadic_templates)) # define GLM_CXX11_VARIADIC_TEMPLATES # endif #endif//(GLM_COMPILER & GLM_COMPILER_CLANG) glm-0.9.9-a2/glm/detail/type_mat3x3.hpp0000600000175000001440000001417413173131001016411 0ustar guususers/// @ref core /// @file glm/detail/type_mat3x3.hpp #pragma once #include "../fwd.hpp" #include "type_vec3.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<3, 3, T, Q> { typedef vec<3, T, Q> col_type; typedef vec<3, T, Q> row_type; typedef mat<3, 3, T, Q> type; typedef mat<3, 3, T, Q> transpose_type; typedef T value_type; private: col_type value[3]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<3, 3, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<3, 3, T, P> const& m); GLM_FUNC_DECL explicit mat(T scalar); GLM_FUNC_DECL mat( T x0, T y0, T z0, T x1, T y1, T z1, T x2, T y2, T z2); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1, col_type const& v2); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3> GLM_FUNC_DECL mat( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2, X3 x3, Y3 y3, Z3 z3); template GLM_FUNC_DECL mat( vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<3, 3, T, Q> & operator=(mat<3, 3, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<3, 3, T, Q> & operator=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(mat<3, 3, U, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(U s); template GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(mat<3, 3, U, Q> const& m); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<3, 3, T, Q> & operator++(); GLM_FUNC_DECL mat<3, 3, T, Q> & operator--(); GLM_FUNC_DECL mat<3, 3, T, Q> operator++(int); GLM_FUNC_DECL mat<3, 3, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m); template GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat3x3.inl" #endif glm-0.9.9-a2/glm/detail/func_geometric.inl0000600000175000001440000001657213173131001017221 0ustar guususers/// @ref core /// @file glm/detail/func_geometric.inl #include "../exponential.hpp" #include "../common.hpp" #include "type_vec2.hpp" #include "type_vec4.hpp" #include "type_float.hpp" namespace glm{ namespace detail { template struct compute_length { GLM_FUNC_QUALIFIER static T call(vec const& v) { return sqrt(dot(v, v)); } }; template struct compute_distance { GLM_FUNC_QUALIFIER static T call(vec const& p0, vec const& p1) { return length(p1 - p0); } }; template struct compute_dot{}; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<1, T, Q> const& a, vec<1, T, Q> const& b) { return a.x * b.x; } }; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& a, vec<2, T, Q> const& b) { vec<2, T, Q> tmp(a * b); return tmp.x + tmp.y; } }; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<3, T, Q> const& a, vec<3, T, Q> const& b) { vec<3, T, Q> tmp(a * b); return tmp.x + tmp.y + tmp.z; } }; template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> tmp(a * b); return (tmp.x + tmp.y) + (tmp.z + tmp.w); } }; template struct compute_cross { GLM_FUNC_QUALIFIER static vec<3, T, Q> call(vec<3, T, Q> const& x, vec<3, T, Q> const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); return vec<3, T, Q>( x.y * y.z - y.y * x.z, x.z * y.x - y.z * x.x, x.x * y.y - y.x * x.y); } }; template struct compute_normalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return v * inversesqrt(dot(v, v)); } }; template struct compute_faceforward { GLM_FUNC_QUALIFIER static vec call(vec const& N, vec const& I, vec const& Nref) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return dot(Nref, I) < static_cast(0) ? N : -N; } }; template struct compute_reflect { GLM_FUNC_QUALIFIER static vec call(vec const& I, vec const& N) { return I - N * dot(N, I) * static_cast(2); } }; template struct compute_refract { GLM_FUNC_QUALIFIER static vec call(vec const& I, vec const& N, T eta) { T const dotValue(dot(N, I)); T const k(static_cast(1) - eta * eta * (static_cast(1) - dotValue * dotValue)); return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast(k >= static_cast(0)); } }; }//namespace detail // length template GLM_FUNC_QUALIFIER genType length(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); return abs(x); } template GLM_FUNC_QUALIFIER T length(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); return detail::compute_length::value>::call(v); } // distance template GLM_FUNC_QUALIFIER genType distance(genType const& p0, genType const& p1) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance' accepts only floating-point inputs"); return length(p1 - p0); } template GLM_FUNC_QUALIFIER T distance(vec const& p0, vec const& p1) { return detail::compute_distance::value>::call(p0, p1); } // dot template GLM_FUNC_QUALIFIER T dot(T x, T y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return x * y; } template GLM_FUNC_QUALIFIER T dot(vec const& x, vec const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); } // cross template GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y) { return detail::compute_cross::value>::call(x, y); } // normalize template GLM_FUNC_QUALIFIER genType normalize(genType const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return x < genType(0) ? genType(-1) : genType(1); } template GLM_FUNC_QUALIFIER vec normalize(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return detail::compute_normalize::value>::call(x); } // faceforward template GLM_FUNC_QUALIFIER genType faceforward(genType const& N, genType const& I, genType const& Nref) { return dot(Nref, I) < static_cast(0) ? N : -N; } template GLM_FUNC_QUALIFIER vec faceforward(vec const& N, vec const& I, vec const& Nref) { return detail::compute_faceforward::value>::call(N, I, Nref); } // reflect template GLM_FUNC_QUALIFIER genType reflect(genType const& I, genType const& N) { return I - N * dot(N, I) * genType(2); } template GLM_FUNC_QUALIFIER vec reflect(vec const& I, vec const& N) { return detail::compute_reflect::value>::call(I, N); } // refract template GLM_FUNC_QUALIFIER genType refract(genType const& I, genType const& N, genType eta) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); genType const dotValue(dot(N, I)); genType const k(static_cast(1) - eta * eta * (static_cast(1) - dotValue * dotValue)); return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast(k >= static_cast(0)); } template GLM_FUNC_QUALIFIER vec refract(vec const& I, vec const& N, T eta) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); return detail::compute_refract::value>::call(I, N, eta); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_geometric_simd.inl" #endif glm-0.9.9-a2/glm/detail/type_float.hpp0000600000175000001440000000545113173131001016375 0ustar guususers/// @ref core /// @file glm/detail/type_float.hpp #pragma once #include "setup.hpp" namespace glm{ namespace detail { typedef float float32; # ifndef GLM_FORCE_SINGLE_ONLY typedef double float64; # endif//GLM_FORCE_SINGLE_ONLY }//namespace detail typedef float lowp_float_t; typedef float mediump_float_t; typedef double highp_float_t; /// @addtogroup core_precision /// @{ /// Low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.4 Floats /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef lowp_float_t lowp_float; /// Medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.4 Floats /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mediump_float_t mediump_float; /// High qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.4 Floats /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef highp_float_t highp_float; #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef mediump_float float_t; #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef highp_float float_t; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) typedef mediump_float float_t; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_float float_t; #else # error "GLM error: multiple default precision requested for floating-point types" #endif typedef float float32; # ifndef GLM_FORCE_SINGLE_ONLY typedef double float64; # endif//GLM_FORCE_SINGLE_ONLY //////////////////// // check type sizes #ifndef GLM_STATIC_ASSERT_NULL GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform"); # ifndef GLM_FORCE_SINGLE_ONLY GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform"); # endif//GLM_FORCE_SINGLE_ONLY #endif//GLM_STATIC_ASSERT_NULL /// @} }//namespace glm glm-0.9.9-a2/glm/detail/type_mat4x3.inl0000600000175000001440000003660013173131001016403 0ustar guususers/// @ref core /// @file glm/detail/type_mat4x3.inl namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; this->value[3] = m.value[3]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<4, 3, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; this->value[3] = m.value[3]; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(T const& s) { this->value[0] = col_type(s, 0, 0); this->value[1] = col_type(0, s, 0); this->value[2] = col_type(0, 0, s); this->value[3] = col_type(0, 0, 0); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat ( T const& x0, T const& y0, T const& z0, T const& x1, T const& y1, T const& z1, T const& x2, T const& y2, T const& z2, T const& x3, T const& y3, T const& z3 ) { this->value[0] = col_type(x0, y0, z0); this->value[1] = col_type(x1, y1, z1); this->value[2] = col_type(x2, y2, z2); this->value[3] = col_type(x3, y3, z3); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat ( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3 ) { this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; this->value[3] = v3; } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3, typename X4, typename Y4, typename Z4> GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat ( X1 const& x1, Y1 const& y1, Z1 const& z1, X2 const& x2, Y2 const& y2, Z2 const& z2, X3 const& x3, Y3 const& y3, Z3 const& z3, X4 const& x4, Y4 const& y4, Z4 const& z4 ) { this->value[0] = col_type(static_cast(x1), value_type(y1), value_type(z1)); this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2)); this->value[2] = col_type(static_cast(x3), value_type(y3), value_type(z3)); this->value[3] = col_type(static_cast(x4), value_type(y4), value_type(z4)); } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat ( vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4 ) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); this->value[3] = col_type(v4); } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<4, 3, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); this->value[3] = col_type(m[3], 0); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type & mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type const& mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>& mat<4, 3, T, Q>::operator=(mat<4, 3, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q>& mat<4, 3, T, Q>::operator=(mat<4, 3, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; this->value[3] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(mat<4, 3, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; this->value[3] += m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; this->value[3] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(mat<4, 3, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; this->value[3] -= m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; this->value[3] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; this->value[3] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; ++this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; --this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator++(int) { mat<4, 3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator--(int) { mat<4, 3, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m) { return mat<4, 3, T, Q>( -m[0], -m[1], -m[2], -m[3]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] + s, m[1] + s, m[2] + s, m[3] + s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] - s, m[1] - s, m[2] - s, m[3] - s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m) { return mat<4, 3, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type operator* ( mat<4, 3, T, Q> const& m, typename mat<4, 3, T, Q>::row_type const& v) { return typename mat<4, 3, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w, m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w); } template GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::row_type operator* ( typename mat<4, 3, T, Q>::col_type const& v, mat<4, 3, T, Q> const& m) { return typename mat<4, 3, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2], v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2], v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]); } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { T const SrcA00 = m1[0][0]; T const SrcA01 = m1[0][1]; T const SrcA02 = m1[0][2]; T const SrcA10 = m1[1][0]; T const SrcA11 = m1[1][1]; T const SrcA12 = m1[1][2]; T const SrcA20 = m1[2][0]; T const SrcA21 = m1[2][1]; T const SrcA22 = m1[2][2]; T const SrcA30 = m1[3][0]; T const SrcA31 = m1[3][1]; T const SrcA32 = m1[3][2]; T const SrcB00 = m2[0][0]; T const SrcB01 = m2[0][1]; T const SrcB02 = m2[0][2]; T const SrcB03 = m2[0][3]; T const SrcB10 = m2[1][0]; T const SrcB11 = m2[1][1]; T const SrcB12 = m2[1][2]; T const SrcB13 = m2[1][3]; T const SrcB20 = m2[2][0]; T const SrcB21 = m2[2][1]; T const SrcB22 = m2[2][2]; T const SrcB23 = m2[2][3]; mat<3, 3, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23; return Result; } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3], m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s) { return mat<4, 3, T, Q>( m[0] / s, m[1] / s, m[2] / s, m[3] / s); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m) { return mat<4, 3, T, Q>( s / m[0], s / m[1], s / m[2], s / m[3]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); } } //namespace glm glm-0.9.9-a2/glm/detail/type_half.hpp0000600000175000001440000000046013173131001016175 0ustar guususers/// @ref core /// @file glm/detail/type_half.hpp #pragma once #include "setup.hpp" namespace glm{ namespace detail { typedef short hdata; GLM_FUNC_DECL float toFloat32(hdata value); GLM_FUNC_DECL hdata toFloat16(float const& value); }//namespace detail }//namespace glm #include "type_half.inl" glm-0.9.9-a2/glm/detail/type_mat2x3.hpp0000600000175000001440000001217713173131001016411 0ustar guususers/// @ref core /// @file glm/detail/type_mat2x3.hpp #pragma once #include "../fwd.hpp" #include "type_vec2.hpp" #include "type_vec3.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<2, 3, T, Q> { typedef vec<3, T, Q> col_type; typedef vec<2, T, Q> row_type; typedef mat<2, 3, T, Q> type; typedef mat<3, 2, T, Q> transpose_type; typedef T value_type; private: col_type value[2]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<2, 3, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<2, 3, T, P> const& m); GLM_FUNC_DECL explicit mat(T scalar); GLM_FUNC_DECL mat( T x0, T y0, T z0, T x1, T y1, T z1); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1); // -- Conversions -- template GLM_FUNC_DECL mat( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2); template GLM_FUNC_DECL mat( vec<3, U, Q> const& v1, vec<3, V, Q> const& v2); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<2, 3, T, Q> & operator=(mat<2, 3, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<2, 3, T, Q> & operator=(mat<2, 3, U, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(mat<2, 3, U, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(mat<2, 3, U, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<2, 3, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<2, 3, T, Q> & operator++ (); GLM_FUNC_DECL mat<2, 3, T, Q> & operator-- (); GLM_FUNC_DECL mat<2, 3, T, Q> operator++(int); GLM_FUNC_DECL mat<2, 3, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 3, T, Q>::col_type operator*(mat<2, 3, T, Q> const& m, typename mat<2, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 3, T, Q>::row_type operator*(typename mat<2, 3, T, Q>::col_type const& v, mat<2, 3, T, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat2x3.inl" #endif glm-0.9.9-a2/glm/detail/type_mat2x2.hpp0000600000175000001440000001373113173131001016405 0ustar guususers/// @ref core /// @file glm/detail/type_mat2x2.hpp #pragma once #include "../fwd.hpp" #include "type_vec2.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<2, 2, T, Q> { typedef vec<2, T, Q> col_type; typedef vec<2, T, Q> row_type; typedef mat<2, 2, T, Q> type; typedef mat<2, 2, T, Q> transpose_type; typedef T value_type; private: col_type value[2]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<2, 2, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<2, 2, T, P> const& m); GLM_FUNC_DECL explicit mat(T scalar); GLM_FUNC_DECL mat( T const& x1, T const& y1, T const& x2, T const& y2); GLM_FUNC_DECL mat( col_type const& v1, col_type const& v2); // -- Conversions -- template GLM_FUNC_DECL mat( U const& x1, V const& y1, M const& x2, N const& y2); template GLM_FUNC_DECL mat( vec<2, U, Q> const& v1, vec<2, V, Q> const& v2); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<2, 2, T, Q> & operator=(mat<2, 2, T, Q> const& v) GLM_DEFAULT; template GLM_FUNC_DECL mat<2, 2, T, Q> & operator=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(mat<2, 2, U, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(U s); template GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(mat<2, 2, U, Q> const& m); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<2, 2, T, Q> & operator++ (); GLM_FUNC_DECL mat<2, 2, T, Q> & operator-- (); GLM_FUNC_DECL mat<2, 2, T, Q> operator++(int); GLM_FUNC_DECL mat<2, 2, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator*(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator*(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2); } //namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat2x2.inl" #endif glm-0.9.9-a2/glm/detail/type_mat.inl0000600000175000001440000000006113173131001016034 0ustar guususers/// @ref core /// @file glm/detail/type_mat.inl glm-0.9.9-a2/glm/detail/type_gentype.hpp0000600000175000001440000001114413173131001016737 0ustar guususers/// @ref core /// @file glm/detail/type_gentype.hpp #pragma once namespace glm { enum profile { nice, fast, simd }; typedef std::size_t sizeType; namespace detail { template < typename VALTYPE, template class TYPE > struct genType { public: enum ctor{null}; typedef VALTYPE value_type; typedef VALTYPE & value_reference; typedef VALTYPE * value_pointer; typedef VALTYPE const * value_const_pointer; typedef TYPE bool_type; typedef sizeType size_type; static bool is_vector(); static bool is_matrix(); typedef TYPE type; typedef TYPE * pointer; typedef TYPE const * const_pointer; typedef TYPE const * const const_pointer_const; typedef TYPE * const pointer_const; typedef TYPE & reference; typedef TYPE const& const_reference; typedef TYPE const& param_type; ////////////////////////////////////// // Address (Implementation details) value_const_pointer value_address() const{return value_pointer(this);} value_pointer value_address(){return value_pointer(this);} //protected: // enum kind // { // GEN_TYPE, // VEC_TYPE, // MAT_TYPE // }; // typedef typename TYPE::kind kind; }; template < typename VALTYPE, template class TYPE > bool genType::is_vector() { return true; } /* template class base { public: ////////////////////////////////////// // Traits typedef sizeType size_type; typedef valTypeT value_type; typedef base class_type; typedef base bool_type; typedef base col_type; typedef base row_type; typedef base transpose_type; static size_type col_size(); static size_type row_size(); static size_type value_size(); static bool is_scalar(); static bool is_vector(); static bool is_matrix(); private: // Data col_type value[colT]; public: ////////////////////////////////////// // Constructors base(); base(class_type const& m); explicit base(T const& x); explicit base(value_type const * const x); explicit base(col_type const * const x); ////////////////////////////////////// // Conversions template explicit base(base const& m); ////////////////////////////////////// // Accesses col_type& operator[](size_type i); col_type const& operator[](size_type i) const; ////////////////////////////////////// // Unary updatable operators class_type& operator= (class_type const& x); class_type& operator+= (T const& x); class_type& operator+= (class_type const& x); class_type& operator-= (T const& x); class_type& operator-= (class_type const& x); class_type& operator*= (T const& x); class_type& operator*= (class_type const& x); class_type& operator/= (T const& x); class_type& operator/= (class_type const& x); class_type& operator++ (); class_type& operator-- (); }; */ //template //struct traits //{ // static const bool is_signed = false; // static const bool is_float = false; // static const bool is_vector = false; // static const bool is_matrix = false; // static const bool is_genType = false; // static const bool is_genIType = false; // static const bool is_genUType = false; //}; //template<> //struct traits //{ // static const bool is_float = true; // static const bool is_genType = true; //}; //template<> //struct traits //{ // static const bool is_float = true; // static const bool is_genType = true; //}; //template<> //struct traits //{ // static const bool is_float = true; // static const bool is_genType = true; //}; //template //struct desc //{ // typedef genType type; // typedef genType * pointer; // typedef genType const* const_pointer; // typedef genType const *const const_pointer_const; // typedef genType *const pointer_const; // typedef genType & reference; // typedef genType const& const_reference; // typedef genType const& param_type; // typedef typename genType::value_type value_type; // typedef typename genType::size_type size_type; // static const typename size_type value_size; //}; //template //const typename desc::size_type desc::value_size = genType::value_size(); }//namespace detail }//namespace glm //#include "type_gentype.inl" glm-0.9.9-a2/glm/detail/func_exponential.inl0000600000175000001440000001027313173131001017561 0ustar guususers/// @ref core /// @file glm/detail/func_exponential.inl #include "../vector_relational.hpp" #include "_vectorize.hpp" #include #include #include namespace glm{ namespace detail { # if GLM_HAS_CXX11_STL using std::log2; # else template genType log2(genType Value) { return std::log(Value) * static_cast(1.4426950408889634073599246810019); } # endif template struct compute_log2 { GLM_FUNC_QUALIFIER static vec call(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'log2' only accept floating-point inputs. Include for integer inputs."); return detail::functor1::call(log2, v); } }; template struct compute_sqrt { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(std::sqrt, x); } }; template struct compute_inversesqrt { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return static_cast(1) / sqrt(x); } }; template struct compute_inversesqrt { GLM_FUNC_QUALIFIER static vec call(vec const& x) { vec tmp(x); vec xhalf(tmp * 0.5f); vec* p = reinterpret_cast*>(const_cast*>(&x)); vec i = vec(0x5f375a86) - (*p >> vec(1)); vec* ptmp = reinterpret_cast*>(&i); tmp = *ptmp; tmp = tmp * (1.5f - xhalf * tmp * tmp); return tmp; } }; }//namespace detail // pow using std::pow; template GLM_FUNC_QUALIFIER vec pow(vec const& base, vec const& exponent) { return detail::functor2::call(pow, base, exponent); } // exp using std::exp; template GLM_FUNC_QUALIFIER vec exp(vec const& x) { return detail::functor1::call(exp, x); } // log using std::log; template GLM_FUNC_QUALIFIER vec log(vec const& x) { return detail::functor1::call(log, x); } //exp2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType exp2(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'exp2' only accept floating-point inputs"); return std::exp(static_cast(0.69314718055994530941723212145818) * x); } template GLM_FUNC_QUALIFIER vec exp2(vec const& x) { return detail::functor1::call(exp2, x); } // log2, ln2 = 0.69314718055994530941723212145818f template GLM_FUNC_QUALIFIER genType log2(genType x) { return log2(vec<1, genType>(x)).x; } template GLM_FUNC_QUALIFIER vec log2(vec const& x) { return detail::compute_log2::is_iec559, detail::is_aligned::value>::call(x); } // sqrt using std::sqrt; template GLM_FUNC_QUALIFIER vec sqrt(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sqrt' only accept floating-point inputs"); return detail::compute_sqrt::value>::call(x); } // inversesqrt template GLM_FUNC_QUALIFIER genType inversesqrt(genType x) { return static_cast(1) / sqrt(x); } template GLM_FUNC_QUALIFIER vec inversesqrt(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'inversesqrt' only accept floating-point inputs"); return detail::compute_inversesqrt::value>::call(x); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_exponential_simd.inl" #endif glm-0.9.9-a2/glm/detail/glm.cpp0000600000175000001440000002024513173131001014777 0ustar guususers/// @ref core /// @file glm/glm.cpp #define GLM_ENABLE_EXPERIMENTAL #include #include #include #include namespace glm { // tvec1 type explicit instantiation template struct vec<1, uint8, lowp>; template struct vec<1, uint16, lowp>; template struct vec<1, uint32, lowp>; template struct vec<1, uint64, lowp>; template struct vec<1, int8, lowp>; template struct vec<1, int16, lowp>; template struct vec<1, int32, lowp>; template struct vec<1, int64, lowp>; template struct vec<1, float32, lowp>; template struct vec<1, float64, lowp>; template struct vec<1, uint8, mediump>; template struct vec<1, uint16, mediump>; template struct vec<1, uint32, mediump>; template struct vec<1, uint64, mediump>; template struct vec<1, int8, mediump>; template struct vec<1, int16, mediump>; template struct vec<1, int32, mediump>; template struct vec<1, int64, mediump>; template struct vec<1, float32, mediump>; template struct vec<1, float64, mediump>; template struct vec<1, uint8, highp>; template struct vec<1, uint16, highp>; template struct vec<1, uint32, highp>; template struct vec<1, uint64, highp>; template struct vec<1, int8, highp>; template struct vec<1, int16, highp>; template struct vec<1, int32, highp>; template struct vec<1, int64, highp>; template struct vec<1, float32, highp>; template struct vec<1, float64, highp>; // tvec2 type explicit instantiation template struct vec<2, uint8, lowp>; template struct vec<2, uint16, lowp>; template struct vec<2, uint32, lowp>; template struct vec<2, uint64, lowp>; template struct vec<2, int8, lowp>; template struct vec<2, int16, lowp>; template struct vec<2, int32, lowp>; template struct vec<2, int64, lowp>; template struct vec<2, float32, lowp>; template struct vec<2, float64, lowp>; template struct vec<2, uint8, mediump>; template struct vec<2, uint16, mediump>; template struct vec<2, uint32, mediump>; template struct vec<2, uint64, mediump>; template struct vec<2, int8, mediump>; template struct vec<2, int16, mediump>; template struct vec<2, int32, mediump>; template struct vec<2, int64, mediump>; template struct vec<2, float32, mediump>; template struct vec<2, float64, mediump>; template struct vec<2, uint8, highp>; template struct vec<2, uint16, highp>; template struct vec<2, uint32, highp>; template struct vec<2, uint64, highp>; template struct vec<2, int8, highp>; template struct vec<2, int16, highp>; template struct vec<2, int32, highp>; template struct vec<2, int64, highp>; template struct vec<2, float32, highp>; template struct vec<2, float64, highp>; // tvec3 type explicit instantiation template struct vec<3, uint8, lowp>; template struct vec<3, uint16, lowp>; template struct vec<3, uint32, lowp>; template struct vec<3, uint64, lowp>; template struct vec<3, int8, lowp>; template struct vec<3, int16, lowp>; template struct vec<3, int32, lowp>; template struct vec<3, int64, lowp>; template struct vec<3, float32, lowp>; template struct vec<3, float64, lowp>; template struct vec<3, uint8, mediump>; template struct vec<3, uint16, mediump>; template struct vec<3, uint32, mediump>; template struct vec<3, uint64, mediump>; template struct vec<3, int8, mediump>; template struct vec<3, int16, mediump>; template struct vec<3, int32, mediump>; template struct vec<3, int64, mediump>; template struct vec<3, float32, mediump>; template struct vec<3, float64, mediump>; template struct vec<3, uint8, highp>; template struct vec<3, uint16, highp>; template struct vec<3, uint32, highp>; template struct vec<3, uint64, highp>; template struct vec<3, int8, highp>; template struct vec<3, int16, highp>; template struct vec<3, int32, highp>; template struct vec<3, int64, highp>; template struct vec<3, float32, highp>; template struct vec<3, float64, highp>; // tvec4 type explicit instantiation template struct vec<4, uint8, lowp>; template struct vec<4, uint16, lowp>; template struct vec<4, uint32, lowp>; template struct vec<4, uint64, lowp>; template struct vec<4, int8, lowp>; template struct vec<4, int16, lowp>; template struct vec<4, int32, lowp>; template struct vec<4, int64, lowp>; template struct vec<4, float32, lowp>; template struct vec<4, float64, lowp>; template struct vec<4, uint8, mediump>; template struct vec<4, uint16, mediump>; template struct vec<4, uint32, mediump>; template struct vec<4, uint64, mediump>; template struct vec<4, int8, mediump>; template struct vec<4, int16, mediump>; template struct vec<4, int32, mediump>; template struct vec<4, int64, mediump>; template struct vec<4, float32, mediump>; template struct vec<4, float64, mediump>; template struct vec<4, uint8, highp>; template struct vec<4, uint16, highp>; template struct vec<4, uint32, highp>; template struct vec<4, uint64, highp>; template struct vec<4, int8, highp>; template struct vec<4, int16, highp>; template struct vec<4, int32, highp>; template struct vec<4, int64, highp>; template struct vec<4, float32, highp>; template struct vec<4, float64, highp>; // tmat2x2 type explicit instantiation template struct mat<2, 2, float32, lowp>; template struct mat<2, 2, float64, lowp>; template struct mat<2, 2, float32, mediump>; template struct mat<2, 2, float64, mediump>; template struct mat<2, 2, float32, highp>; template struct mat<2, 2, float64, highp>; // tmat2x3 type explicit instantiation template struct mat<2, 3, float32, lowp>; template struct mat<2, 3, float64, lowp>; template struct mat<2, 3, float32, mediump>; template struct mat<2, 3, float64, mediump>; template struct mat<2, 3, float32, highp>; template struct mat<2, 3, float64, highp>; // tmat2x4 type explicit instantiation template struct mat<2, 4, float32, lowp>; template struct mat<2, 4, float64, lowp>; template struct mat<2, 4, float32, mediump>; template struct mat<2, 4, float64, mediump>; template struct mat<2, 4, float32, highp>; template struct mat<2, 4, float64, highp>; // tmat3x2 type explicit instantiation template struct mat<3, 2, float32, lowp>; template struct mat<3, 2, float64, lowp>; template struct mat<3, 2, float32, mediump>; template struct mat<3, 2, float64, mediump>; template struct mat<3, 2, float32, highp>; template struct mat<3, 2, float64, highp>; // tmat3x3 type explicit instantiation template struct mat<3, 3, float32, lowp>; template struct mat<3, 3, float64, lowp>; template struct mat<3, 3, float32, mediump>; template struct mat<3, 3, float64, mediump>; template struct mat<3, 3, float32, highp>; template struct mat<3, 3, float64, highp>; // tmat3x4 type explicit instantiation template struct mat<3, 4, float32, lowp>; template struct mat<3, 4, float64, lowp>; template struct mat<3, 4, float32, mediump>; template struct mat<3, 4, float64, mediump>; template struct mat<3, 4, float32, highp>; template struct mat<3, 4, float64, highp>; // tmat4x2 type explicit instantiation template struct mat<4, 2, float32, lowp>; template struct mat<4, 2, float64, lowp>; template struct mat<4, 2, float32, mediump>; template struct mat<4, 2, float64, mediump>; template struct mat<4, 2, float32, highp>; template struct mat<4, 2, float64, highp>; // tmat4x3 type explicit instantiation template struct mat<4, 3, float32, lowp>; template struct mat<4, 3, float64, lowp>; template struct mat<4, 3, float32, mediump>; template struct mat<4, 3, float64, mediump>; template struct mat<4, 3, float32, highp>; template struct mat<4, 3, float64, highp>; // tmat4x4 type explicit instantiation template struct mat<4, 4, float32, lowp>; template struct mat<4, 4, float64, lowp>; template struct mat<4, 4, float32, mediump>; template struct mat<4, 4, float64, mediump>; template struct mat<4, 4, float32, highp>; template struct mat<4, 4, float64, highp>; // tquat type explicit instantiation template struct tquat; template struct tquat; template struct tquat; template struct tquat; template struct tquat; template struct tquat; //tdualquat type explicit instantiation template struct tdualquat; template struct tdualquat; template struct tdualquat; template struct tdualquat; template struct tdualquat; template struct tdualquat; }//namespace glm glm-0.9.9-a2/glm/detail/type_vec4.hpp0000600000175000001440000004213713173131001016133 0ustar guususers/// @ref core /// @file glm/detail/type_vec4.hpp #pragma once #include "type_vec.hpp" #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED # if GLM_HAS_UNRESTRICTED_UNIONS # include "_swizzle.hpp" # else # include "_swizzle_func.hpp" # endif #endif //GLM_SWIZZLE #include namespace glm { template struct vec<4, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec<4, T, Q> type; typedef vec<4, bool, Q> bool_type; // -- Data -- # if GLM_HAS_ONLY_XYZW T x, y, z, w; # elif GLM_HAS_ALIGNED_TYPE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # endif # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # endif union { struct { T x, y, z, w;}; struct { T r, g, b, a; }; struct { T s, t, p, q; }; typename detail::storage::value>::type data; # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED GLM_SWIZZLE4_2_MEMBERS(T, Q, x, y, z, w) GLM_SWIZZLE4_2_MEMBERS(T, Q, r, g, b, a) GLM_SWIZZLE4_2_MEMBERS(T, Q, s, t, p, q) GLM_SWIZZLE4_3_MEMBERS(T, Q, x, y, z, w) GLM_SWIZZLE4_3_MEMBERS(T, Q, r, g, b, a) GLM_SWIZZLE4_3_MEMBERS(T, Q, s, t, p, q) GLM_SWIZZLE4_4_MEMBERS(T, Q, x, y, z, w) GLM_SWIZZLE4_4_MEMBERS(T, Q, r, g, b, a) GLM_SWIZZLE4_4_MEMBERS(T, Q, s, t, p, q) # endif//GLM_SWIZZLE }; # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # endif # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # endif # else union { T x, r, s; }; union { T y, g, t; }; union { T z, b, p; }; union { T w, a, q; }; # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) # endif//GLM_SWIZZLE # endif // -- Component accesses -- /// Return the count of components of the vector typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;} GLM_FUNC_DECL T & operator[](length_type i); GLM_FUNC_DECL T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, Q> const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit vec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(T x, T y, T z, T w); // -- Conversion scalar constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(X _x, Y _y, Z _z, W _w); template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _Y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, P> const& _xy, B _z, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<2, B, P> const& _yz, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, B _y, vec<2, C, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, A, P> const& _xyz, B _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<3, B, P> const& _yzw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, P> const& v); // -- Swizzle constructors -- # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) template GLM_FUNC_DECL vec(detail::_swizzle<4, T, Q, E0, E1, E2, E3> const& that) { *this = that(); } template GLM_FUNC_DECL vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, detail::_swizzle<2, T, Q, F0, F1, -1, -2> const& u) { *this = vec<4, T, Q>(v(), u()); } template GLM_FUNC_DECL vec(T const& x, T const& y, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v) { *this = vec<4, T, Q>(x, y, v()); } template GLM_FUNC_DECL vec(T const& x, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& w) { *this = vec<4, T, Q>(x, v(), w); } template GLM_FUNC_DECL vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& z, T const& w) { *this = vec<4, T, Q>(v(), z, w); } template GLM_FUNC_DECL vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v, T const& w) { *this = vec<4, T, Q>(v(), w); } template GLM_FUNC_DECL vec(T const& x, detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v) { *this = vec<4, T, Q>(x, v()); } # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) // -- Unary arithmetic operators -- GLM_FUNC_DECL vec<4, T, Q>& operator=(vec<4, T, Q> const& v) GLM_DEFAULT; template GLM_FUNC_DECL vec<4, T, Q>& operator=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator+=(U scalar); template GLM_FUNC_DECL vec<4, T, Q>& operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator+=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator-=(U scalar); template GLM_FUNC_DECL vec<4, T, Q>& operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator-=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator*=(U scalar); template GLM_FUNC_DECL vec<4, T, Q>& operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator*=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator/=(U scalar); template GLM_FUNC_DECL vec<4, T, Q>& operator/=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q>& operator/=(vec<4, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL vec<4, T, Q> & operator++(); GLM_FUNC_DECL vec<4, T, Q> & operator--(); GLM_FUNC_DECL vec<4, T, Q> operator++(int); GLM_FUNC_DECL vec<4, T, Q> operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL vec<4, T, Q> & operator%=(U scalar); template GLM_FUNC_DECL vec<4, T, Q> & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator%=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator&=(U scalar); template GLM_FUNC_DECL vec<4, T, Q> & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator&=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator|=(U scalar); template GLM_FUNC_DECL vec<4, T, Q> & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator|=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator^=(U scalar); template GLM_FUNC_DECL vec<4, T, Q> & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator^=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator<<=(U scalar); template GLM_FUNC_DECL vec<4, T, Q> & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator<<=(vec<4, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator>>=(U scalar); template GLM_FUNC_DECL vec<4, T, Q> & operator>>=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> & operator>>=(vec<4, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL vec<4, T, Q> operator+(vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator-(vec<4, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL vec<4, T, Q> operator+(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator-(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator/(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator%(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator&(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator|(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator|(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator^(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator^(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator<<(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<4, T, Q> operator>>(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v); template GLM_FUNC_DECL vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, T, Q> operator~(vec<4, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2); template GLM_FUNC_DECL vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2); template GLM_FUNC_DECL vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_vec4.inl" #endif//GLM_EXTERNAL_TEMPLATE glm-0.9.9-a2/glm/detail/func_integer.inl0000600000175000001440000003456013173131001016675 0ustar guususers/// @ref core /// @file glm/detail/func_integer.inl #include "../ext/vec1.hpp" #include "type_vec2.hpp" #include "type_vec3.hpp" #include "type_vec4.hpp" #include "type_int.hpp" #include "_vectorize.hpp" #if(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC) # include # pragma intrinsic(_BitScanReverse) #endif//(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC) #include #if !GLM_HAS_EXTENDED_INTEGER_TYPE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic ignored "-Wlong-long" # endif # if (GLM_COMPILER & GLM_COMPILER_CLANG) # pragma clang diagnostic ignored "-Wc++11-long-long" # endif #endif namespace glm{ namespace detail { template GLM_FUNC_QUALIFIER T mask(T Bits) { return Bits >= static_cast(sizeof(T) * 8) ? ~static_cast(0) : (static_cast(1) << Bits) - static_cast(1); } template struct compute_bitfieldReverseStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T, T) { return v; } }; template struct compute_bitfieldReverseStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Mask, T Shift) { return (v & Mask) << Shift | (v & (~Mask)) >> Shift; } }; template struct compute_bitfieldBitCountStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T, T) { return v; } }; template struct compute_bitfieldBitCountStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Mask, T Shift) { return (v & Mask) + ((v >> Shift) & Mask); } }; template struct compute_findLSB { GLM_FUNC_QUALIFIER static int call(genIUType Value) { if(Value == 0) return -1; return glm::bitCount(~Value & (Value - static_cast(1))); } }; # if GLM_HAS_BITSCAN_WINDOWS template struct compute_findLSB { GLM_FUNC_QUALIFIER static int call(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } }; # if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32)) template struct compute_findLSB { GLM_FUNC_QUALIFIER static int call(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } }; # endif # endif//GLM_HAS_BITSCAN_WINDOWS template struct compute_findMSB_step_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x, T Shift) { return x | (x >> Shift); } }; template struct compute_findMSB_step_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x, T) { return x; } }; template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& v) { vec x(v); x = compute_findMSB_step_vec= 8>::call(x, static_cast( 1)); x = compute_findMSB_step_vec= 8>::call(x, static_cast( 2)); x = compute_findMSB_step_vec= 8>::call(x, static_cast( 4)); x = compute_findMSB_step_vec= 16>::call(x, static_cast( 8)); x = compute_findMSB_step_vec= 32>::call(x, static_cast(16)); x = compute_findMSB_step_vec= 64>::call(x, static_cast(32)); return vec(sizeof(T) * 8 - 1) - glm::bitCount(~x); } }; # if GLM_HAS_BITSCAN_WINDOWS template GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(compute_findMSB_32, x); } }; # if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32)) template GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value) { unsigned long Result(0); unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast(&Value)); return IsNotNull ? int(Result) : -1; } template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(compute_findMSB_64, x); } }; # endif # endif//GLM_HAS_BITSCAN_WINDOWS }//namespace detail // uaddCarry GLM_FUNC_QUALIFIER uint uaddCarry(uint const& x, uint const& y, uint & Carry) { uint64 const Value64(static_cast(x) + static_cast(y)); uint64 const Max32((static_cast(1) << static_cast(32)) - static_cast(1)); Carry = Value64 > Max32 ? 1u : 0u; return static_cast(Value64 % (Max32 + static_cast(1))); } template GLM_FUNC_QUALIFIER vec uaddCarry(vec const& x, vec const& y, vec& Carry) { vec Value64(vec(x) + vec(y)); vec Max32((static_cast(1) << static_cast(32)) - static_cast(1)); Carry = mix(vec(0), vec(1), greaterThan(Value64, Max32)); return vec(Value64 % (Max32 + static_cast(1))); } // usubBorrow GLM_FUNC_QUALIFIER uint usubBorrow(uint const& x, uint const& y, uint & Borrow) { GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch"); Borrow = x >= y ? static_cast(0) : static_cast(1); if(y >= x) return y - x; else return static_cast((static_cast(1) << static_cast(32)) + (static_cast(y) - static_cast(x))); } template GLM_FUNC_QUALIFIER vec usubBorrow(vec const& x, vec const& y, vec& Borrow) { Borrow = mix(vec(1), vec(0), greaterThanEqual(x, y)); vec const YgeX(y - x); vec const XgeY(vec((static_cast(1) << static_cast(32)) + (vec(y) - vec(x)))); return mix(XgeY, YgeX, greaterThanEqual(y, x)); } // umulExtended GLM_FUNC_QUALIFIER void umulExtended(uint const& x, uint const& y, uint & msb, uint & lsb) { GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch"); uint64 Value64 = static_cast(x) * static_cast(y); msb = static_cast(Value64 >> static_cast(32)); lsb = static_cast(Value64); } template GLM_FUNC_QUALIFIER void umulExtended(vec const& x, vec const& y, vec& msb, vec& lsb) { GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch"); vec Value64(vec(x) * vec(y)); msb = vec(Value64 >> static_cast(32)); lsb = vec(Value64); } // imulExtended GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int& msb, int& lsb) { GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch"); int64 Value64 = static_cast(x) * static_cast(y); msb = static_cast(Value64 >> static_cast(32)); lsb = static_cast(Value64); } template GLM_FUNC_QUALIFIER void imulExtended(vec const& x, vec const& y, vec& msb, vec& lsb) { GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch"); vec Value64(vec(x) * vec(y)); lsb = vec(Value64 & static_cast(0xFFFFFFFF)); msb = vec((Value64 >> static_cast(32)) & static_cast(0xFFFFFFFF)); } // bitfieldExtract template GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits) { return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x; } template GLM_FUNC_QUALIFIER vec bitfieldExtract(vec const& Value, int Offset, int Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldExtract' only accept integer inputs"); return (Value >> static_cast(Offset)) & static_cast(detail::mask(Bits)); } // bitfieldInsert template GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const& Base, genIUType const& Insert, int Offset, int Bits) { return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x; } template GLM_FUNC_QUALIFIER vec bitfieldInsert(vec const& Base, vec const& Insert, int Offset, int Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); T const Mask = static_cast(detail::mask(Bits) << Offset); return (Base & ~Mask) | (Insert & Mask); } // bitfieldReverse template GLM_FUNC_QUALIFIER genType bitfieldReverse(genType x) { return bitfieldReverse(glm::vec<1, genType, glm::defaultp>(x)).x; } template GLM_FUNC_QUALIFIER vec bitfieldReverse(vec const& v) { vec x(v); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 2>::call(x, static_cast(0x5555555555555555ull), static_cast( 1)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 4>::call(x, static_cast(0x3333333333333333ull), static_cast( 2)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 8>::call(x, static_cast(0x0F0F0F0F0F0F0F0Full), static_cast( 4)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 16>::call(x, static_cast(0x00FF00FF00FF00FFull), static_cast( 8)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 32>::call(x, static_cast(0x0000FFFF0000FFFFull), static_cast(16)); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 64>::call(x, static_cast(0x00000000FFFFFFFFull), static_cast(32)); return x; } // bitCount template GLM_FUNC_QUALIFIER int bitCount(genType x) { return bitCount(glm::vec<1, genType, glm::defaultp>(x)).x; } template GLM_FUNC_QUALIFIER vec bitCount(vec const& v) { # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) # pragma warning(disable : 4310) //cast truncates constant value # endif vec::type, Q> x(*reinterpret_cast::type, Q> const *>(&v)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 2>::call(x, typename detail::make_unsigned::type(0x5555555555555555ull), typename detail::make_unsigned::type( 1)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 4>::call(x, typename detail::make_unsigned::type(0x3333333333333333ull), typename detail::make_unsigned::type( 2)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 8>::call(x, typename detail::make_unsigned::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned::type( 4)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 16>::call(x, typename detail::make_unsigned::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned::type( 8)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 32>::call(x, typename detail::make_unsigned::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned::type(16)); x = detail::compute_bitfieldBitCountStep::type, Q, detail::is_aligned::value, sizeof(T) * 8>= 64>::call(x, typename detail::make_unsigned::type(0x00000000FFFFFFFFull), typename detail::make_unsigned::type(32)); return vec(x); # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(pop) # endif } // findLSB template GLM_FUNC_QUALIFIER int findLSB(genIUType Value) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); return detail::compute_findLSB::call(Value); } template GLM_FUNC_QUALIFIER vec findLSB(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); return detail::functor1::call(findLSB, x); } // findMSB template GLM_FUNC_QUALIFIER int findMSB(genIUType v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); return findMSB(vec<1, genIUType>(v)).x; } template GLM_FUNC_QUALIFIER vec findMSB(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); return detail::compute_findMSB_vec::call(v); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_integer_simd.inl" #endif glm-0.9.9-a2/glm/detail/func_geometric_simd.inl0000600000175000001440000000473013173131001020226 0ustar guususers/// @ref core /// @file glm/detail/func_geometric_simd.inl #include "../simd/geometric.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { template struct compute_length<4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v) { return _mm_cvtss_f32(glm_vec4_length(v.data)); } }; template struct compute_distance<4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1) { return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data)); } }; template struct compute_dot, float, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y) { return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); } }; template struct compute_cross { GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b) { __m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x); __m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x); __m128 const xpd0 = glm_vec4_cross(set0, set1); vec<4, float, Q> Result; Result.data = xpd0; return vec<3, float, Q>(Result); } }; template struct compute_normalize<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> Result; Result.data = glm_vec4_normalize(v.data); return Result; } }; template struct compute_faceforward<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& N, vec<4, float, Q> const& I, vec<4, float, Q> const& Nref) { vec<4, float, Q> Result; Result.data = glm_vec4_faceforward(N.data, I.data, Nref.data); return Result; } }; template struct compute_reflect<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N) { vec<4, float, Q> Result; Result.data = glm_vec4_reflect(I.data, N.data); return Result; } }; template struct compute_refract<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N, float eta) { vec<4, float, Q> Result; Result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta)); return Result; } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/detail/type_mat4x4.hpp0000600000175000001440000001520113173131001016403 0ustar guususers/// @ref core /// @file glm/detail/type_mat4x4.hpp #pragma once #include "../fwd.hpp" #include "type_vec4.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<4, 4, T, Q> { typedef vec<4, T, Q> col_type; typedef vec<4, T, Q> row_type; typedef mat<4, 4, T, Q> type; typedef mat<4, 4, T, Q> transpose_type; typedef T value_type; private: col_type value[4]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;} GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<4, 4, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<4, 4, T, P> const& m); GLM_FUNC_DECL explicit mat(T const& x); GLM_FUNC_DECL mat( T const& x0, T const& y0, T const& z0, T const& w0, T const& x1, T const& y1, T const& z1, T const& w1, T const& x2, T const& y2, T const& z2, T const& w2, T const& x3, T const& y3, T const& z3, T const& w3); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, typename X3, typename Y3, typename Z3, typename W3, typename X4, typename Y4, typename Z4, typename W4> GLM_FUNC_DECL mat( X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1, X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2, X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3, X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4); template GLM_FUNC_DECL mat( vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<4, 4, T, Q> & operator=(mat<4, 4, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<4, 4, T, Q> & operator=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(mat<4, 4, U, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(U s); template GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(mat<4, 4, U, Q> const& m); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<4, 4, T, Q> & operator++(); GLM_FUNC_DECL mat<4, 4, T, Q> & operator--(); GLM_FUNC_DECL mat<4, 4, T, Q> operator++(int); GLM_FUNC_DECL mat<4, 4, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator*(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator*(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat4x4.inl" #endif//GLM_EXTERNAL_TEMPLATE glm-0.9.9-a2/glm/detail/type_gentype.inl0000600000175000001440000002114113173131001016730 0ustar guususers/// @ref core /// @file glm/detail/type_gentype.inl namespace glm{ namespace detail{ ///////////////////////////////// // Static functions template typename base::size_type base::col_size() { return cT; } template typename base::size_type base::row_size() { return rT; } template typename base::size_type base::value_size() { return rT * cT; } template bool base::is_scalar() { return rT == 1 && cT == 1; } template bool base::is_vector() { return rT == 1; } template bool base::is_matrix() { return rT != 1; } ///////////////////////////////// // Constructor template base::base() { memset(&this->value, 0, cT * rT * sizeof(vT)); } template base::base ( typename base::class_type const& m ) { for ( typename genType::size_type i = typename base::size_type(0); i < base::col_size(); ++i ) { this->value[i] = m[i]; } } template base::base ( typename base::T const& x ) { if(rT == 1) // vector { for ( typename base::size_type i = typename base::size_type(0); i < base::col_size(); ++i ) { this->value[i][rT] = x; } } else // matrix { memset(&this->value, 0, cT * rT * sizeof(vT)); typename base::size_type stop = cT < rT ? cT : rT; for ( typename base::size_type i = typename base::size_type(0); i < stop; ++i ) { this->value[i][i] = x; } } } template base::base ( typename base::value_type const * const x ) { memcpy(&this->value, &x.value, cT * rT * sizeof(vT)); } template base::base ( typename base::col_type const * const x ) { for ( typename base::size_type i = typename base::size_type(0); i < base::col_size(); ++i ) { this->value[i] = x[i]; } } template template base::base ( base const& m ) { for ( typename base::size_type i = typename base::size_type(0); i < base::col_size(); ++i ) { this->value[i] = base(m[i]); } } ////////////////////////////////////// // Accesses template typename base::col_type& base::operator[] ( typename base::size_type i ) { return this->value[i]; } template typename base::col_type const& base::operator[] ( typename base::size_type i ) const { return this->value[i]; } ////////////////////////////////////// // Unary updatable operators template typename base::class_type& base::operator= ( typename base::class_type const& x ) { memcpy(&this->value, &x.value, cT * rT * sizeof(vT)); return *this; } template typename base::class_type& base::operator+= ( typename base::T const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] += x; return *this; } template typename base::class_type& base::operator+= ( typename base::class_type const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] += x[j][i]; return *this; } template typename base::class_type& base::operator-= ( typename base::T const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] -= x; return *this; } template typename base::class_type& base::operator-= ( typename base::class_type const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] -= x[j][i]; return *this; } template typename base::class_type& base::operator*= ( typename base::T const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] *= x; return *this; } template typename base::class_type& base::operator*= ( typename base::class_type const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] *= x[j][i]; return *this; } template typename base::class_type& base::operator/= ( typename base::T const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] /= x; return *this; } template typename base::class_type& base::operator/= ( typename base::class_type const& x ) { typename base::size_type stop_col = x.col_size(); typename base::size_type stop_row = x.row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) this->value[j][i] /= x[j][i]; return *this; } template typename base::class_type& base::operator++ () { typename base::size_type stop_col = col_size(); typename base::size_type stop_row = row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) ++this->value[j][i]; return *this; } template typename base::class_type& base::operator-- () { typename base::size_type stop_col = col_size(); typename base::size_type stop_row = row_size(); for(typename base::size_type j = 0; j < stop_col; ++j) for(typename base::size_type i = 0; i < stop_row; ++i) --this->value[j][i]; return *this; } } //namespace detail } //namespace glm glm-0.9.9-a2/glm/detail/type_mat3x3.inl0000600000175000001440000003534313173131001016405 0ustar guususers/// @ref core /// @file glm/detail/type_mat3x3.inl #include "../matrix.hpp" namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<3, 3, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(T scalar) { this->value[0] = col_type(scalar, 0, 0); this->value[1] = col_type(0, scalar, 0); this->value[2] = col_type(0, 0, scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat ( T x0, T y0, T z0, T x1, T y1, T z1, T x2, T y2, T z2 ) { this->value[0] = col_type(x0, y0, z0); this->value[1] = col_type(x1, y1, z1); this->value[2] = col_type(x2, y2, z2); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat ( col_type const& v0, col_type const& v1, col_type const& v2 ) { this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3> GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat ( X1 x1, Y1 y1, Z1 z1, X2 x2, Y2 y2, Z2 z2, X3 x3, Y3 y3, Z3 z3 ) { this->value[0] = col_type(static_cast(x1), value_type(y1), value_type(z1)); this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2)); this->value[2] = col_type(static_cast(x3), value_type(y3), value_type(z3)); } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat ( vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3 ) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<3, 3, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = col_type(0, 0, 1); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 1); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type & mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type const& mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator=(mat<3, 3, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator=(mat<3, 3, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(mat<3, 3, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(mat<3, 3, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(mat<3, 3, U, Q> const& m) { return (*this = *this * m); } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(mat<3, 3, U, Q> const& m) { return *this *= inverse(m); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator++(int) { mat<3, 3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator--(int) { mat<3, 3, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( -m[0], -m[1], -m[2]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 3, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( scalar - m[0], scalar - m[1], scalar - m[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 3, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v) { return typename mat<3, 3, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z); } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m) { return typename mat<3, 3, T, Q>::row_type( m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z, m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z, m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { T const SrcA00 = m1[0][0]; T const SrcA01 = m1[0][1]; T const SrcA02 = m1[0][2]; T const SrcA10 = m1[1][0]; T const SrcA11 = m1[1][1]; T const SrcA12 = m1[1][2]; T const SrcA20 = m1[2][0]; T const SrcA21 = m1[2][1]; T const SrcA22 = m1[2][2]; T const SrcB00 = m2[0][0]; T const SrcB01 = m2[0][1]; T const SrcB02 = m2[0][2]; T const SrcB10 = m2[1][0]; T const SrcB11 = m2[1][1]; T const SrcB12 = m2[1][2]; T const SrcB20 = m2[2][0]; T const SrcB21 = m2[2][1]; T const SrcB22 = m2[2][2]; mat<3, 3, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22; return Result; } template GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]); } template GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 3, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2], m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar) { return mat<3, 3, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m) { return mat<3, 3, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2]); } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v) { return inverse(m) * v; } template GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m) { return v * inverse(m); } template GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { mat<3, 3, T, Q> m1_copy(m1); return m1_copy /= m2; } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); } } //namespace glm glm-0.9.9-a2/glm/detail/type_half.inl0000600000175000001440000001071713173131001016176 0ustar guususers/// @ref core /// @file glm/detail/type_half.inl namespace glm{ namespace detail { GLM_FUNC_QUALIFIER float overflow() { volatile float f = 1e10; for(int i = 0; i < 10; ++i) f *= f; // this will overflow before the for loop terminates return f; } union uif32 { GLM_FUNC_QUALIFIER uif32() : i(0) {} GLM_FUNC_QUALIFIER uif32(float f_) : f(f_) {} GLM_FUNC_QUALIFIER uif32(uint32 i_) : i(i_) {} float f; uint32 i; }; GLM_FUNC_QUALIFIER float toFloat32(hdata value) { int s = (value >> 15) & 0x00000001; int e = (value >> 10) & 0x0000001f; int m = value & 0x000003ff; if(e == 0) { if(m == 0) { // // Plus or minus zero // detail::uif32 result; result.i = static_cast(s << 31); return result.f; } else { // // Denormalized number -- renormalize it // while(!(m & 0x00000400)) { m <<= 1; e -= 1; } e += 1; m &= ~0x00000400; } } else if(e == 31) { if(m == 0) { // // Positive or negative infinity // uif32 result; result.i = static_cast((s << 31) | 0x7f800000); return result.f; } else { // // Nan -- preserve sign and significand bits // uif32 result; result.i = static_cast((s << 31) | 0x7f800000 | (m << 13)); return result.f; } } // // Normalized number // e = e + (127 - 15); m = m << 13; // // Assemble s, e and m. // uif32 Result; Result.i = static_cast((s << 31) | (e << 23) | m); return Result.f; } GLM_FUNC_QUALIFIER hdata toFloat16(float const& f) { uif32 Entry; Entry.f = f; int i = static_cast(Entry.i); // // Our floating point number, f, is represented by the bit // pattern in integer i. Disassemble that bit pattern into // the sign, s, the exponent, e, and the significand, m. // Shift s into the position where it will go in in the // resulting half number. // Adjust e, accounting for the different exponent bias // of float and half (127 versus 15). // int s = (i >> 16) & 0x00008000; int e = ((i >> 23) & 0x000000ff) - (127 - 15); int m = i & 0x007fffff; // // Now reassemble s, e and m into a half: // if(e <= 0) { if(e < -10) { // // E is less than -10. The absolute value of f is // less than half_MIN (f may be a small normalized // float, a denormalized float or a zero). // // We convert f to a half zero. // return hdata(s); } // // E is between -10 and 0. F is a normalized float, // whose magnitude is less than __half_NRM_MIN. // // We convert f to a denormalized half. // m = (m | 0x00800000) >> (1 - e); // // Round to nearest, round "0.5" up. // // Rounding may cause the significand to overflow and make // our number normalized. Because of the way a half's bits // are laid out, we don't have to treat this case separately; // the code below will handle it correctly. // if(m & 0x00001000) m += 0x00002000; // // Assemble the half from s, e (zero) and m. // return hdata(s | (m >> 13)); } else if(e == 0xff - (127 - 15)) { if(m == 0) { // // F is an infinity; convert f to a half // infinity with the same sign as f. // return hdata(s | 0x7c00); } else { // // F is a NAN; we produce a half NAN that preserves // the sign bit and the 10 leftmost bits of the // significand of f, with one exception: If the 10 // leftmost bits are all zero, the NAN would turn // into an infinity, so we have to set at least one // bit in the significand. // m >>= 13; return hdata(s | 0x7c00 | m | (m == 0)); } } else { // // E is greater than zero. F is a normalized float. // We try to convert f to a normalized half. // // // Round to nearest, round "0.5" up // if(m & 0x00001000) { m += 0x00002000; if(m & 0x00800000) { m = 0; // overflow in significand, e += 1; // adjust exponent } } // // Handle exponent overflow // if (e > 30) { overflow(); // Cause a hardware floating point overflow; return hdata(s | 0x7c00); // if this returns, the half becomes an } // infinity with the same sign as f. // // Assemble the half from s, e and m. // return hdata(s | (e << 10) | (m >> 13)); } } }//namespace detail }//namespace glm glm-0.9.9-a2/glm/detail/type_mat3x2.inl0000600000175000001440000003043113173131001016375 0ustar guususers/// @ref core /// @file glm/detail/type_mat3x2.inl namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<3, 2, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(T scalar) { this->value[0] = col_type(scalar, 0); this->value[1] = col_type(0, scalar); this->value[2] = col_type(0, 0); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat ( T x0, T y0, T x1, T y1, T x2, T y2 ) { this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); this->value[2] = col_type(x2, y2); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat ( col_type const& v0, col_type const& v1, col_type const& v2 ) { this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; } // -- Conversion constructors -- template template< typename X1, typename Y1, typename X2, typename Y2, typename X3, typename Y3> GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat ( X1 x1, Y1 y1, X2 x2, Y2 y2, X3 x3, Y3 y3 ) { this->value[0] = col_type(static_cast(x1), value_type(y1)); this->value[1] = col_type(static_cast(x2), value_type(y2)); this->value[2] = col_type(static_cast(x3), value_type(y3)); } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat ( vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3 ) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<3, 2, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = col_type(0); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(T(0)); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(T(0)); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type & mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type const& mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator=(mat<3, 2, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator=(mat<3, 2, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(mat<3, 2, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(mat<3, 2, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> & mat<3, 2, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator++(int) { mat<3, 2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator--(int) { mat<3, 2, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m) { return mat<3, 2, T, Q>( -m[0], -m[1], -m[2]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m) { return mat<3, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v) { return typename mat<3, 2, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z); } template GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m) { return typename mat<3, 2, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1], v.x * m[1][0] + v.y * m[1][1], v.x * m[2][0] + v.y * m[2][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { const T SrcA00 = m1[0][0]; const T SrcA01 = m1[0][1]; const T SrcA10 = m1[1][0]; const T SrcA11 = m1[1][1]; const T SrcA20 = m1[2][0]; const T SrcA21 = m1[2][1]; const T SrcB00 = m2[0][0]; const T SrcB01 = m2[0][1]; const T SrcB02 = m2[0][2]; const T SrcB10 = m2[1][0]; const T SrcB11 = m2[1][1]; const T SrcB12 = m2[1][2]; mat<2, 2, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar) { return mat<3, 2, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m) { return mat<3, 2, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); } } //namespace glm glm-0.9.9-a2/glm/detail/type_vec4.inl0000600000175000001440000007136213173131001016130 0ustar guususers/// @ref core /// @file glm/detail/type_tvec4.inl namespace glm{ namespace detail { template struct is_int { enum test {value = 0}; }; template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; template<> struct is_int { enum test {value = ~0}; }; template struct compute_vec4_add { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); } }; template struct compute_vec4_sub { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); } }; template struct compute_vec4_mul { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); } }; template struct compute_vec4_div { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w); } }; template struct compute_vec4_mod { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x % b.x, a.y % b.y, a.z % b.z, a.w % b.w); } }; template struct compute_vec4_and { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x & b.x, a.y & b.y, a.z & b.z, a.w & b.w); } }; template struct compute_vec4_or { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x | b.x, a.y | b.y, a.z | b.z, a.w | b.w); } }; template struct compute_vec4_xor { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w); } }; template struct compute_vec4_shift_left { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x << b.x, a.y << b.y, a.z << b.z, a.w << b.w); } }; template struct compute_vec4_shift_right { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(a.x >> b.x, a.y >> b.y, a.z >> b.z, a.w >> b.w); } }; template struct compute_vec4_equal { GLM_FUNC_QUALIFIER static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return detail::compute_equal::call(v1.x, v2.x) && detail::compute_equal::call(v1.y, v2.y) && detail::compute_equal::call(v1.z, v2.z) && detail::compute_equal::call(v1.w, v2.w); } }; template struct compute_vec4_nequal { GLM_FUNC_QUALIFIER static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return !compute_vec4_equal::value, sizeof(T) * 8, detail::is_aligned::value>::call(v1, v2); } }; template struct compute_vec4_bitwise_not { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& v) { return vec<4, T, Q>(~v.x, ~v.y, ~v.z, ~v.w); } }; }//namespace detail // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, Q>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, Q>::vec(vec<4, T, Q> const& v) : x(v.x), y(v.y), z(v.z), w(v.w) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, Q>::vec(vec<4, T, P> const& v) : x(v.x), y(v.y), z(v.z), w(v.w) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, Q>::vec(T scalar) : x(scalar), y(scalar), z(scalar), w(scalar) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, Q>::vec(T _x, T _y, T _z, T _w) : x(_x), y(_y), z(_z), w(_w) {} // -- Conversion scalar constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, Q>::vec(X _x, Y _y, Z _z, W _w) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_z.x)) , w(static_cast(_w.x)) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, B _z, C _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z.x)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(A _x, vec<2, B, P> const& _yz, C _w) : x(static_cast(_x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w) : x(static_cast(_x.x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(A _x, B _y, vec<2, C, P> const& _zw) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw) : x(static_cast(_x.x)) , y(static_cast(_y.x)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, B _w) : x(static_cast(_xyz.x)) , y(static_cast(_xyz.y)) , z(static_cast(_xyz.z)) , w(static_cast(_w)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w) : x(static_cast(_xyz.x)) , y(static_cast(_xyz.y)) , z(static_cast(_xyz.z)) , w(static_cast(_w.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(A _x, vec<3, B, P> const& _yzw) : x(static_cast(_x)) , y(static_cast(_yzw.x)) , z(static_cast(_yzw.y)) , w(static_cast(_yzw.z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw) : x(static_cast(_x.x)) , y(static_cast(_yzw.x)) , z(static_cast(_yzw.y)) , w(static_cast(_yzw.z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_zw.x)) , w(static_cast(_zw.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) , z(static_cast(v.z)) , w(static_cast(v.w)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER T& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } template GLM_FUNC_QUALIFIER T const& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i) const { assert(i >= 0 && i < this->length()); return (&x)[i]; } // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, T, Q> const& v) { this->x = v.x; this->y = v.y; this->z = v.z; this->w = v.w; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, U, Q> const& v) { this->x = static_cast(v.x); this->y = static_cast(v.y); this->z = static_cast(v.z); this->w = static_cast(v.w); return *this; } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator+=(U scalar) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator-=(U scalar) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator*=(U scalar) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator/=(U scalar) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, Q>(v.x))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, Q>(v))); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator++() { ++this->x; ++this->y; ++this->z; ++this->w; return *this; } template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator--() { --this->x; --this->y; --this->z; --this->w; return *this; } template GLM_FUNC_QUALIFIER vec<4, T, Q> vec<4, T, Q>::operator++(int) { vec<4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER vec<4, T, Q> vec<4, T, Q>::operator--(int) { vec<4, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator%=(U scalar) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator&=(U scalar) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator|=(U scalar) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator^=(U scalar) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator<<=(U scalar) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator>>=(U scalar) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(scalar))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<1, U, Q> const& v) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } template template GLM_FUNC_QUALIFIER vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<4, U, Q> const& v) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned::value>::call(*this, vec<4, T, Q>(v))); } // -- Unary constant operators -- template GLM_FUNC_QUALIFIER vec<4, T, Q> operator+(vec<4, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator-(vec<4, T, Q> const& v) { return vec<4, T, Q>(0) -= v; } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER vec<4, T, Q> operator+(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) += scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) += v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(v) += scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v2) += v1; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) += v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator-(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) -= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) -= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) -= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) -= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) -= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) *= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) *= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(v) *= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v2) *= v1; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) *= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator/(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) /= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) /= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) /= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) /= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) /= v2; } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) %= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) %= v2.x; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) %= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar.x) %= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) %= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) &= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<4, T, Q>(v) &= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) &= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator&(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) &= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) &= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) |= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) |= v2.x; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) |= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator|(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) |= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) |= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) ^= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) ^= v2.x; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) ^= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator^(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) ^= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) ^= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) <<= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) <<= v2.x; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) <<= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator<<(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) <<= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) <<= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar) { return vec<4, T, Q>(v) >>= scalar; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<4, T, Q>(v1) >>= v2.x; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v) { return vec<4, T, Q>(scalar) >>= v; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator>>(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1.x) >>= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return vec<4, T, Q>(v1) >>= v2; } template GLM_FUNC_QUALIFIER vec<4, T, Q> operator~(vec<4, T, Q> const& v) { return detail::compute_vec4_bitwise_not::value, sizeof(T) * 8, detail::is_aligned::value>::call(v); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return detail::compute_vec4_equal::value, sizeof(T) * 8, detail::is_aligned::value>::call(v1, v2); } template GLM_FUNC_QUALIFIER bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2) { return detail::compute_vec4_nequal::value, sizeof(T) * 8, detail::is_aligned::value>::call(v1, v2); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2) { return vec<4, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w); } template GLM_FUNC_QUALIFIER vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2) { return vec<4, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_ALIGNED_TYPE # include "type_vec4_simd.inl" #endif glm-0.9.9-a2/glm/detail/func_trigonometric.inl0000600000175000001440000001215713173131001020123 0ustar guususers/// @ref core /// @file glm/detail/func_trigonometric.inl #include "_vectorize.hpp" #include #include namespace glm { // radians template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'radians' only accept floating-point input"); return degrees * static_cast(0.01745329251994329576923690768489); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec radians(vec const& v) { return detail::functor1::call(radians, v); } // degrees template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'degrees' only accept floating-point input"); return radians * static_cast(57.295779513082320876798154814105); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec degrees(vec const& v) { return detail::functor1::call(degrees, v); } // sin using ::std::sin; template GLM_FUNC_QUALIFIER vec sin(vec const& v) { return detail::functor1::call(sin, v); } // cos using std::cos; template GLM_FUNC_QUALIFIER vec cos(vec const& v) { return detail::functor1::call(cos, v); } // tan using std::tan; template GLM_FUNC_QUALIFIER vec tan(vec const& v) { return detail::functor1::call(tan, v); } // asin using std::asin; template GLM_FUNC_QUALIFIER vec asin(vec const& v) { return detail::functor1::call(asin, v); } // acos using std::acos; template GLM_FUNC_QUALIFIER vec acos(vec const& v) { return detail::functor1::call(acos, v); } // atan template GLM_FUNC_QUALIFIER genType atan(genType y, genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'atan' only accept floating-point input"); return ::std::atan2(y, x); } template GLM_FUNC_QUALIFIER vec atan(vec const& a, vec const& b) { return detail::functor2::call(::std::atan2, a, b); } using std::atan; template GLM_FUNC_QUALIFIER vec atan(vec const& v) { return detail::functor1::call(atan, v); } // sinh using std::sinh; template GLM_FUNC_QUALIFIER vec sinh(vec const& v) { return detail::functor1::call(sinh, v); } // cosh using std::cosh; template GLM_FUNC_QUALIFIER vec cosh(vec const& v) { return detail::functor1::call(cosh, v); } // tanh using std::tanh; template GLM_FUNC_QUALIFIER vec tanh(vec const& v) { return detail::functor1::call(tanh, v); } // asinh # if GLM_HAS_CXX11_STL using std::asinh; # else template GLM_FUNC_QUALIFIER genType asinh(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asinh' only accept floating-point input"); return (x < static_cast(0) ? static_cast(-1) : (x > static_cast(0) ? static_cast(1) : static_cast(0))) * log(std::abs(x) + sqrt(static_cast(1) + x * x)); } # endif template GLM_FUNC_QUALIFIER vec asinh(vec const& v) { return detail::functor1::call(asinh, v); } // acosh # if GLM_HAS_CXX11_STL using std::acosh; # else template GLM_FUNC_QUALIFIER genType acosh(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acosh' only accept floating-point input"); if(x < static_cast(1)) return static_cast(0); return log(x + sqrt(x * x - static_cast(1))); } # endif template GLM_FUNC_QUALIFIER vec acosh(vec const& v) { return detail::functor1::call(acosh, v); } // atanh # if GLM_HAS_CXX11_STL using std::atanh; # else template GLM_FUNC_QUALIFIER genType atanh(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'atanh' only accept floating-point input"); if(std::abs(x) >= static_cast(1)) return 0; return static_cast(0.5) * log((static_cast(1) + x) / (static_cast(1) - x)); } # endif template GLM_FUNC_QUALIFIER vec atanh(vec const& v) { return detail::functor1::call(atanh, v); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_trigonometric_simd.inl" #endif glm-0.9.9-a2/glm/detail/func_trigonometric_simd.inl0000600000175000001440000000000013173131001021117 0ustar guususersglm-0.9.9-a2/glm/detail/func_vector_relational_simd.inl0000600000175000001440000000021413173131001021755 0ustar guususers/// @ref core /// @file glm/detail/func_vector_relational_simd.inl namespace glm{ namespace detail { }//namespace detail }//namespace glm glm-0.9.9-a2/glm/detail/type_mat.hpp0000600000175000001440000011752113173131001016053 0ustar guususers/// @ref core /// @file glm/detail/type_mat.hpp #pragma once #include "qualifier.hpp" namespace glm{ namespace detail { template struct outerProduct_trait{}; }//namespace detail #if GLM_HAS_TEMPLATE_ALIASES template using tmat2x2 = mat<2, 2, T, Q>; template using tmat2x3 = mat<2, 3, T, Q>; template using tmat2x4 = mat<2, 4, T, Q>; template using tmat3x2 = mat<3, 2, T, Q>; template using tmat3x3 = mat<3, 3, T, Q>; template using tmat3x4 = mat<3, 4, T, Q>; template using tmat4x2 = mat<4, 2, T, Q>; template using tmat4x3 = mat<4, 3, T, Q>; template using tmat4x4 = mat<4, 4, T, Q>; #endif//GLM_HAS_TEMPLATE_ALIASES template GLM_FUNC_DECL mat inverse(mat const& m); /// @addtogroup core_precision /// @{ /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2; /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2; /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2; /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2x2; /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2x2; /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2x2; /// @} /// @addtogroup core_precision /// @{ /// 2 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, lowp> lowp_mat2x3; /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, mediump> mediump_mat2x3; /// 2 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, highp> highp_mat2x3; /// @} /// @addtogroup core_precision /// @{ /// 2 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, lowp> lowp_mat2x4; /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, mediump> mediump_mat2x4; /// 2 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, highp> highp_mat2x4; /// @} /// @addtogroup core_precision /// @{ /// 3 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, lowp> lowp_mat3x2; /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, mediump> mediump_mat3x2; /// 3 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, highp> highp_mat3x2; /// @} /// @addtogroup core_precision /// @{ /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3; /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3; /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3; /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3x3; /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3x3; /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3x3; /// @} /// @addtogroup core_precision /// @{ /// 3 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, lowp> lowp_mat3x4; /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, mediump> mediump_mat3x4; /// 3 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, highp> highp_mat3x4; /// @} /// @addtogroup core_precision /// @{ /// 4 columns of 2 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, lowp> lowp_mat4x2; /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, mediump> mediump_mat4x2; /// 4 columns of 2 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, highp> highp_mat4x2; /// @} /// @addtogroup core_precision /// @{ /// 4 columns of 3 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, lowp> lowp_mat4x3; /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, mediump> mediump_mat4x3; /// 4 columns of 3 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, highp> highp_mat4x3; /// @} /// @addtogroup core_precision /// @{ /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4; /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4; /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4; /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4x4; /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4x4; /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4x4; /// @} /// @addtogroup core_types /// @{ ////////////////////////// // Float definition #if(defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_mat2x2 mat2x2; typedef lowp_mat2x3 mat2x3; typedef lowp_mat2x4 mat2x4; typedef lowp_mat3x2 mat3x2; typedef lowp_mat3x3 mat3x3; typedef lowp_mat3x4 mat3x4; typedef lowp_mat4x2 mat4x2; typedef lowp_mat4x3 mat4x3; typedef lowp_mat4x4 mat4x4; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) typedef mediump_mat2x2 mat2x2; typedef mediump_mat2x3 mat2x3; typedef mediump_mat2x4 mat2x4; typedef mediump_mat3x2 mat3x2; typedef mediump_mat3x3 mat3x3; typedef mediump_mat3x4 mat3x4; typedef mediump_mat4x2 mat4x2; typedef mediump_mat4x3 mat4x3; typedef mediump_mat4x4 mat4x4; #else //! 2 columns of 2 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat2x2 mat2x2; //! 2 columns of 3 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat2x3 mat2x3; //! 2 columns of 4 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat2x4 mat2x4; //! 3 columns of 2 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat3x2 mat3x2; //! 3 columns of 3 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat3x3 mat3x3; //! 3 columns of 4 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat3x4 mat3x4; //! 4 columns of 2 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat4x2 mat4x2; //! 4 columns of 3 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat4x3 mat4x3; //! 4 columns of 4 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_mat4x4 mat4x4; #endif//GLM_PRECISION //! 2 columns of 2 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat2x2 mat2; //! 3 columns of 3 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat3x3 mat3; //! 4 columns of 4 components matrix of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef mat4x4 mat4; ////////////////////////// // Double definition /// @addtogroup core_precision /// @{ /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, lowp> lowp_dmat2; /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, mediump> mediump_dmat2; /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, highp> highp_dmat2; /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, lowp> lowp_dmat2x2; /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, mediump> mediump_dmat2x2; /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, highp> highp_dmat2x2; /// @} /// @addtogroup core_precision /// @{ /// 2 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, lowp> lowp_dmat2x3; /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, mediump> mediump_dmat2x3; /// 2 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, highp> highp_dmat2x3; /// @} /// @addtogroup core_precision /// @{ /// 2 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, lowp> lowp_dmat2x4; /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, mediump> mediump_dmat2x4; /// 2 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, highp> highp_dmat2x4; /// @} /// @addtogroup core_precision /// @{ /// 3 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, lowp> lowp_dmat3x2; /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, mediump> mediump_dmat3x2; /// 3 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, highp> highp_dmat3x2; /// @} /// @addtogroup core_precision /// @{ /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_dmat3; /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, mediump> mediump_dmat3; /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, highp> highp_dmat3; /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, lowp> lowp_dmat3x3; /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, mediump> mediump_dmat3x3; /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, highp> highp_dmat3x3; /// @} /// @addtogroup core_precision /// @{ /// 3 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, lowp> lowp_dmat3x4; /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, mediump> mediump_dmat3x4; /// 3 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, highp> highp_dmat3x4; /// @} /// @addtogroup core_precision /// @{ /// 4 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, lowp> lowp_dmat4x2; /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, mediump> mediump_dmat4x2; /// 4 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, highp> highp_dmat4x2; /// @} /// @addtogroup core_precision /// @{ /// 4 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, lowp> lowp_dmat4x3; /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, mediump> mediump_dmat4x3; /// 4 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, highp> highp_dmat4x3; /// @} /// @addtogroup core_precision /// @{ /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, lowp> lowp_dmat4; /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, mediump> mediump_dmat4; /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, highp> highp_dmat4; /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, lowp> lowp_dmat4x4; /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, mediump> mediump_dmat4x4; /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, highp> highp_dmat4x4; /// @} #if(defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_dmat2x2 dmat2x2; typedef lowp_dmat2x3 dmat2x3; typedef lowp_dmat2x4 dmat2x4; typedef lowp_dmat3x2 dmat3x2; typedef lowp_dmat3x3 dmat3x3; typedef lowp_dmat3x4 dmat3x4; typedef lowp_dmat4x2 dmat4x2; typedef lowp_dmat4x3 dmat4x3; typedef lowp_dmat4x4 dmat4x4; #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE)) typedef mediump_dmat2x2 dmat2x2; typedef mediump_dmat2x3 dmat2x3; typedef mediump_dmat2x4 dmat2x4; typedef mediump_dmat3x2 dmat3x2; typedef mediump_dmat3x3 dmat3x3; typedef mediump_dmat3x4 dmat3x4; typedef mediump_dmat4x2 dmat4x2; typedef mediump_dmat4x3 dmat4x3; typedef mediump_dmat4x4 dmat4x4; #else //defined(GLM_PRECISION_HIGHP_DOUBLE) //! 2 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x2 dmat2; //! 3 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x3 dmat3; //! 4 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x4 dmat4; //! 2 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x2 dmat2x2; //! 2 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x3 dmat2x3; //! 2 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x4 dmat2x4; //! 3 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x2 dmat3x2; /// 3 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x3 dmat3x3; /// 3 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x4 dmat3x4; /// 4 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x2 dmat4x2; /// 4 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x3 dmat4x3; /// 4 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x4 dmat4x4; #endif//GLM_PRECISION /// @} }//namespace glm glm-0.9.9-a2/glm/detail/setup.hpp0000600000175000001440000006744313173131001015400 0ustar guususers/// @ref core /// @file glm/detail/setup.hpp #ifndef GLM_SETUP_INCLUDED #define GLM_VERSION_MAJOR 0 #define GLM_VERSION_MINOR 9 #define GLM_VERSION_PATCH 9 #define GLM_VERSION_REVISION 0 #define GLM_VERSION 990 #define GLM_SETUP_INCLUDED GLM_VERSION #if defined(GLM_FORCE_SWIZZLE) && defined(GLM_FORCE_UNRESTRICTED_GENTYPE) # error "Both GLM_FORCE_SWIZZLE and GLM_FORCE_UNRESTRICTED_GENTYPE can't be defined at the same time" #endif #include #include /////////////////////////////////////////////////////////////////////////////////// // Messages #define GLM_MESSAGES_ENABLED 1 #define GLM_MESSAGES_DISABLE 0 #if defined(GLM_FORCE_MESSAGES) # define GLM_MESSAGES GLM_MESSAGES_ENABLED #else # define GLM_MESSAGES GLM_MESSAGES_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// // Detect the platform #include "../simd/platform.h" /////////////////////////////////////////////////////////////////////////////////// // Version #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_VERSION_DISPLAYED) # define GLM_MESSAGE_VERSION_DISPLAYED # pragma message ("GLM: version 0.9.9.0") #endif//GLM_MESSAGES // Report compiler detection #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_COMPILER_DISPLAYED) # define GLM_MESSAGE_COMPILER_DISPLAYED # if GLM_COMPILER & GLM_COMPILER_CUDA # pragma message("GLM: CUDA compiler detected") # elif GLM_COMPILER & GLM_COMPILER_VC # pragma message("GLM: Visual C++ compiler detected") # elif GLM_COMPILER & GLM_COMPILER_CLANG # pragma message("GLM: Clang compiler detected") # elif GLM_COMPILER & GLM_COMPILER_INTEL # pragma message("GLM: Intel Compiler detected") # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma message("GLM: GCC compiler detected") # else # pragma message("GLM: Compiler not detected") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Build model #if defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__) # define GLM_MODEL GLM_MODEL_64 #elif defined(__i386__) || defined(__ppc__) # define GLM_MODEL GLM_MODEL_32 #else # define GLM_MODEL GLM_MODEL_32 #endif// #if !defined(GLM_MODEL) && GLM_COMPILER != 0 # error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message." #endif//GLM_MODEL #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_MODEL_DISPLAYED) # define GLM_MESSAGE_MODEL_DISPLAYED # if(GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: 64 bits model") # elif(GLM_MODEL == GLM_MODEL_32) # pragma message("GLM: 32 bits model") # endif//GLM_MODEL #endif//GLM_MESSAGES #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_ARCH_DISPLAYED) # define GLM_MESSAGE_ARCH_DISPLAYED # if(GLM_ARCH == GLM_ARCH_PURE) # pragma message("GLM: Platform independent code") # elif(GLM_ARCH == GLM_ARCH_AVX2) # pragma message("GLM: AVX2 instruction set") # elif(GLM_ARCH == GLM_ARCH_AVX) # pragma message("GLM: AVX instruction set") # elif(GLM_ARCH == GLM_ARCH_SSE42) # pragma message("GLM: SSE4.2 instruction set") # elif(GLM_ARCH == GLM_ARCH_SSE41) # pragma message("GLM: SSE4.1 instruction set") # elif(GLM_ARCH == GLM_ARCH_SSSE3) # pragma message("GLM: SSSE3 instruction set") # elif(GLM_ARCH == GLM_ARCH_SSE3) # pragma message("GLM: SSE3 instruction set") # elif(GLM_ARCH == GLM_ARCH_SSE2) # pragma message("GLM: SSE2 instruction set") # elif(GLM_ARCH == GLM_ARCH_X86) # pragma message("GLM: x86 instruction set") # elif(GLM_ARCH == GLM_ARCH_NEON) # pragma message("GLM: NEON instruction set") # elif(GLM_ARCH == GLM_ARCH_ARM) # pragma message("GLM: ARM instruction set") # elif(GLM_ARCH == GLM_ARCH_MIPS) # pragma message("GLM: MIPS instruction set") # elif(GLM_ARCH == GLM_ARCH_PPC) # pragma message("GLM: PowerPC architechture") # endif//GLM_ARCH #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // C++ Version // User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14 #define GLM_LANG_CXX98_FLAG (1 << 1) #define GLM_LANG_CXX03_FLAG (1 << 2) #define GLM_LANG_CXX0X_FLAG (1 << 3) #define GLM_LANG_CXX11_FLAG (1 << 4) #define GLM_LANG_CXX1Y_FLAG (1 << 5) #define GLM_LANG_CXX14_FLAG (1 << 6) #define GLM_LANG_CXX1Z_FLAG (1 << 7) #define GLM_LANG_CXXMS_FLAG (1 << 8) #define GLM_LANG_CXXGNU_FLAG (1 << 9) #define GLM_LANG_CXX98 GLM_LANG_CXX98_FLAG #define GLM_LANG_CXX03 (GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG) #define GLM_LANG_CXX0X (GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG) #define GLM_LANG_CXX11 (GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG) #define GLM_LANG_CXX1Y (GLM_LANG_CXX11 | GLM_LANG_CXX1Y_FLAG) #define GLM_LANG_CXX14 (GLM_LANG_CXX1Y | GLM_LANG_CXX14_FLAG) #define GLM_LANG_CXX1Z (GLM_LANG_CXX14 | GLM_LANG_CXX1Z_FLAG) #define GLM_LANG_CXXMS GLM_LANG_CXXMS_FLAG #define GLM_LANG_CXXGNU GLM_LANG_CXXGNU_FLAG #if defined(GLM_FORCE_CXX14) # if((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER <= GLM_COMPILER_GCC50)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER <= GLM_COMPILER_CLANG34)) # pragma message("GLM: Using GLM_FORCE_CXX14 with a compiler that doesn't fully support C++14") # elif GLM_COMPILER & GLM_COMPILER_VC # pragma message("GLM: Using GLM_FORCE_CXX14 but there is no known version of Visual C++ compiler that fully supports C++14") # elif GLM_COMPILER & GLM_COMPILER_INTEL # pragma message("GLM: Using GLM_FORCE_CXX14 but there is no known version of ICC compiler that fully supports C++14") # endif # define GLM_LANG GLM_LANG_CXX14 # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX11) # if((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER <= GLM_COMPILER_GCC48)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER <= GLM_COMPILER_CLANG33)) # pragma message("GLM: Using GLM_FORCE_CXX11 with a compiler that doesn't fully support C++11") # elif GLM_COMPILER & GLM_COMPILER_VC # pragma message("GLM: Using GLM_FORCE_CXX11 but there is no known version of Visual C++ compiler that fully supports C++11") # elif GLM_COMPILER & GLM_COMPILER_INTEL # pragma message("GLM: Using GLM_FORCE_CXX11 but there is no known version of ICC compiler that fully supports C++11") # endif # define GLM_LANG GLM_LANG_CXX11 # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX03) # define GLM_LANG GLM_LANG_CXX03 #elif defined(GLM_FORCE_CXX98) # define GLM_LANG GLM_LANG_CXX98 #else # if GLM_COMPILER & GLM_COMPILER_CLANG # if __cplusplus >= 201402L // GLM_COMPILER_CLANG34 + -std=c++14 # define GLM_LANG GLM_LANG_CXX14 # elif __has_feature(cxx_decltype_auto) && __has_feature(cxx_aggregate_nsdmi) // GLM_COMPILER_CLANG33 + -std=c++1y # define GLM_LANG GLM_LANG_CXX1Y # elif __cplusplus >= 201103L // GLM_COMPILER_CLANG33 + -std=c++11 # define GLM_LANG GLM_LANG_CXX11 # elif __has_feature(cxx_static_assert) // GLM_COMPILER_CLANG29 + -std=c++11 # define GLM_LANG GLM_LANG_CXX0X # elif __cplusplus >= 199711L # define GLM_LANG GLM_LANG_CXX98 # else # define GLM_LANG GLM_LANG_CXX # endif # elif GLM_COMPILER & GLM_COMPILER_GCC # if __cplusplus >= 201402L # define GLM_LANG GLM_LANG_CXX14 # elif __cplusplus >= 201103L # define GLM_LANG GLM_LANG_CXX11 # elif defined(__GXX_EXPERIMENTAL_CXX0X__) # define GLM_LANG GLM_LANG_CXX0X # else # define GLM_LANG GLM_LANG_CXX98 # endif # elif GLM_COMPILER & GLM_COMPILER_VC # ifdef _MSC_EXTENSIONS # if __cplusplus >= 201402L # define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG) # elif __cplusplus >= 201103L # define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG) # else # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG) # endif # else # if __cplusplus >= 201402L # define GLM_LANG GLM_LANG_CXX14 # elif __cplusplus >= 201103L # define GLM_LANG GLM_LANG_CXX11 # else # define GLM_LANG GLM_LANG_CXX0X # endif # endif # elif GLM_COMPILER & GLM_COMPILER_INTEL # ifdef _MSC_EXTENSIONS # define GLM_MSC_EXT GLM_LANG_CXXMS_FLAG # else # define GLM_MSC_EXT 0 # endif # if __cplusplus >= 201402L # define GLM_LANG (GLM_LANG_CXX14 | GLM_MSC_EXT) # elif __cplusplus >= 201103L # define GLM_LANG (GLM_LANG_CXX11 | GLM_MSC_EXT) # elif __INTEL_CXX11_MODE__ # define GLM_LANG (GLM_LANG_CXX0X | GLM_MSC_EXT) # elif __cplusplus >= 199711L # define GLM_LANG (GLM_LANG_CXX98 | GLM_MSC_EXT) # else # define GLM_LANG (GLM_LANG_CXX | GLM_MSC_EXT) # endif # elif GLM_COMPILER & GLM_COMPILER_CUDA # ifdef _MSC_EXTENSIONS # define GLM_MSC_EXT GLM_LANG_CXXMS_FLAG # else # define GLM_MSC_EXT 0 # endif # if GLM_COMPILER >= GLM_COMPILER_CUDA75 # define GLM_LANG (GLM_LANG_CXX0X | GLM_MSC_EXT) # else # define GLM_LANG (GLM_LANG_CXX98 | GLM_MSC_EXT) # endif # else // Unknown compiler # if __cplusplus >= 201402L # define GLM_LANG GLM_LANG_CXX14 # elif __cplusplus >= 201103L # define GLM_LANG GLM_LANG_CXX11 # elif __cplusplus >= 199711L # define GLM_LANG GLM_LANG_CXX98 # else # define GLM_LANG GLM_LANG_CXX // Good luck with that! # endif # ifndef GLM_FORCE_PURE # define GLM_FORCE_PURE # endif # endif #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_LANG_DISPLAYED) # define GLM_MESSAGE_LANG_DISPLAYED # if GLM_LANG & GLM_LANG_CXX1Z_FLAG # pragma message("GLM: C++1z") # elif GLM_LANG & GLM_LANG_CXX14_FLAG # pragma message("GLM: C++14") # elif GLM_LANG & GLM_LANG_CXX1Y_FLAG # pragma message("GLM: C++1y") # elif GLM_LANG & GLM_LANG_CXX11_FLAG # pragma message("GLM: C++11") # elif GLM_LANG & GLM_LANG_CXX0X_FLAG # pragma message("GLM: C++0x") # elif GLM_LANG & GLM_LANG_CXX03_FLAG # pragma message("GLM: C++03") # elif GLM_LANG & GLM_LANG_CXX98_FLAG # pragma message("GLM: C++98") # else # pragma message("GLM: C++ language undetected") # endif//GLM_LANG # if GLM_LANG & (GLM_LANG_CXXGNU_FLAG | GLM_LANG_CXXMS_FLAG) # pragma message("GLM: Language extensions enabled") # endif//GLM_LANG #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Has of C++ features // http://clang.llvm.org/cxx_status.html // http://gcc.gnu.org/projects/cxx0x.html // http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx // Android has multiple STLs but C++11 STL detection doesn't always work #284 #564 #if GLM_PLATFORM == GLM_PLATFORM_ANDROID && !defined(GLM_LANG_STL11_FORCED) # define GLM_HAS_CXX11_STL 0 #elif GLM_COMPILER & GLM_COMPILER_CLANG # if (defined(_LIBCPP_VERSION) && GLM_LANG & GLM_LANG_CXX11_FLAG) || defined(GLM_LANG_STL11_FORCED) # define GLM_HAS_CXX11_STL 1 # else # define GLM_HAS_CXX11_STL 0 # endif #else # define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_PLATFORM != GLM_PLATFORM_WINDOWS) && (GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)))) #endif // N1720 #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_STATIC_ASSERT 1 #else # define GLM_HAS_STATIC_ASSERT ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)) || \ ((GLM_COMPILER & GLM_COMPILER_VC)))) #endif // N1988 #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_EXTENDED_INTEGER_TYPE 1 #else # define GLM_HAS_EXTENDED_INTEGER_TYPE (\ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC)) || \ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CUDA)) || \ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC)) || \ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CLANG))) #endif // N2235 #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_CONSTEXPR __has_feature(cxx_constexpr) # define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_CONSTEXPR 1 # define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR #else # define GLM_HAS_CONSTEXPR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)))) // GCC 4.6 support constexpr but there is a compiler bug causing a crash # define GLM_HAS_CONSTEXPR_PARTIAL (GLM_HAS_CONSTEXPR || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14))) #endif // N2672 #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_INITIALIZER_LISTS 1 #else # define GLM_HAS_INITIALIZER_LISTS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75)))) #endif // N2544 Unrestricted unions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions) #elif GLM_LANG & (GLM_LANG_CXX11_FLAG | GLM_LANG_CXXMS_FLAG) # define GLM_HAS_UNRESTRICTED_UNIONS 1 #else # define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS_FLAG)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75)) || \ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46))) #endif // N2346 #if defined(GLM_FORCE_UNRESTRICTED_GENTYPE) # define GLM_HAS_DEFAULTED_FUNCTIONS 0 #elif GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_DEFAULTED_FUNCTIONS 1 #else # define GLM_HAS_DEFAULTED_FUNCTIONS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ (GLM_COMPILER & GLM_COMPILER_CUDA))) #endif // N2118 #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_RVALUE_REFERENCES 1 #else # define GLM_HAS_RVALUE_REFERENCES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC)) || \ ((GLM_COMPILER & GLM_COMPILER_VC)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1 #else # define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC)) || \ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_TEMPLATE_ALIASES 1 #else # define GLM_HAS_TEMPLATE_ALIASES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC47)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_RANGE_FOR 1 #else # define GLM_HAS_RANGE_FOR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ ((GLM_COMPILER & GLM_COMPILER_VC)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif // N2341 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf #if GLM_COMPILER & GLM_COMPILER_CLANG # define GLM_HAS_ALIGNOF __has_feature(c_alignof) #elif GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_ALIGNOF 1 #else # define GLM_HAS_ALIGNOF ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA70)))) #endif #define GLM_HAS_ONLY_XYZW ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER < GLM_COMPILER_GCC46)) #if GLM_HAS_ONLY_XYZW # pragma message("GLM: GCC older than 4.6 has a bug presenting the use of rgba and stpq components") #endif // #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_ASSIGNABLE 1 #else # define GLM_HAS_ASSIGNABLE ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49)))) #endif // #define GLM_HAS_TRIVIAL_QUERIES 0 // #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_MAKE_SIGNED 1 #else # define GLM_HAS_MAKE_SIGNED ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \ ((GLM_COMPILER & GLM_COMPILER_CUDA)))) #endif #if GLM_ARCH == GLM_ARCH_PURE # define GLM_HAS_BITSCAN_WINDOWS 0 #else # define GLM_HAS_BITSCAN_WINDOWS ((GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT)))) #endif // OpenMP #ifdef _OPENMP # if GLM_COMPILER & GLM_COMPILER_GCC # if GLM_COMPILER >= GLM_COMPILER_GCC61 # define GLM_HAS_OPENMP 45 # elif GLM_COMPILER >= GLM_COMPILER_GCC49 # define GLM_HAS_OPENMP 40 # elif GLM_COMPILER >= GLM_COMPILER_GCC47 # define GLM_HAS_OPENMP 31 # else # define GLM_HAS_OPENMP 0 # endif # elif GLM_COMPILER & GLM_COMPILER_CLANG # if GLM_COMPILER >= GLM_COMPILER_CLANG38 # define GLM_HAS_OPENMP 31 # else # define GLM_HAS_OPENMP 0 # endif # elif GLM_COMPILER & GLM_COMPILER_VC # define GLM_HAS_OPENMP 20 # elif GLM_COMPILER & GLM_COMPILER_INTEL # if GLM_COMPILER >= GLM_COMPILER_INTEL16 # define GLM_HAS_OPENMP 40 # else # define GLM_HAS_OPENMP 0 # endif # else # define GLM_HAS_OPENMP 0 # endif #else # define GLM_HAS_OPENMP 0 #endif /////////////////////////////////////////////////////////////////////////////////// // Static assert #if GLM_HAS_STATIC_ASSERT # define GLM_STATIC_ASSERT(x, message) static_assert(x, message) #elif GLM_COMPILER & GLM_COMPILER_VC # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1] #else # define GLM_STATIC_ASSERT(x, message) # define GLM_STATIC_ASSERT_NULL #endif//GLM_LANG /////////////////////////////////////////////////////////////////////////////////// // Qualifiers #if GLM_COMPILER & GLM_COMPILER_CUDA # define GLM_CUDA_FUNC_DEF __device__ __host__ # define GLM_CUDA_FUNC_DECL __device__ __host__ #else # define GLM_CUDA_FUNC_DEF # define GLM_CUDA_FUNC_DECL #endif #if GLM_COMPILER & GLM_COMPILER_GCC # define GLM_VAR_USED __attribute__ ((unused)) #else # define GLM_VAR_USED #endif #if defined(GLM_FORCE_INLINE) # if GLM_COMPILER & GLM_COMPILER_VC # define GLM_INLINE __forceinline # define GLM_NEVER_INLINE __declspec((noinline)) # elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG) # define GLM_INLINE inline __attribute__((__always_inline__)) # define GLM_NEVER_INLINE __attribute__((__noinline__)) # elif GLM_COMPILER & GLM_COMPILER_CUDA # define GLM_INLINE __forceinline__ # define GLM_NEVER_INLINE __noinline__ # else # define GLM_INLINE inline # define GLM_NEVER_INLINE # endif//GLM_COMPILER #else # define GLM_INLINE inline # define GLM_NEVER_INLINE #endif//defined(GLM_FORCE_INLINE) #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE /////////////////////////////////////////////////////////////////////////////////// // Swizzle operators // User defines: GLM_FORCE_SWIZZLE #define GLM_SWIZZLE_ENABLED 1 #define GLM_SWIZZLE_DISABLE 0 #if defined(GLM_FORCE_SWIZZLE) # define GLM_SWIZZLE GLM_SWIZZLE_ENABLED #else # define GLM_SWIZZLE GLM_SWIZZLE_DISABLE #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED) # define GLM_MESSAGE_SWIZZLE_DISPLAYED # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED # pragma message("GLM: Swizzling operators enabled") # else # pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Allows using not basic types as genType // #define GLM_FORCE_UNRESTRICTED_GENTYPE #ifdef GLM_FORCE_UNRESTRICTED_GENTYPE # define GLM_UNRESTRICTED_GENTYPE 1 #else # define GLM_UNRESTRICTED_GENTYPE 0 #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED) # define GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED # ifdef GLM_FORCE_UNRESTRICTED_GENTYPE # pragma message("GLM: Use unrestricted genType") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Force single only (remove explicit float64 types) #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_SINGLE_ONLY_DISPLAYED) # define GLM_MESSAGE_SINGLE_ONLY_DISPLAYED # ifdef GLM_FORCE_SINGLE_ONLY # pragma message("GLM: Using only single precision floating-point types") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Clip control #define GLM_DEPTH_ZERO_TO_ONE 0x00000001 #define GLM_DEPTH_NEGATIVE_ONE_TO_ONE 0x00000002 #ifdef GLM_FORCE_DEPTH_ZERO_TO_ONE # define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_ZERO_TO_ONE #else # define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_NEGATIVE_ONE_TO_ONE #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_DEPTH_DISPLAYED) # define GLM_MESSAGE_DEPTH_DISPLAYED # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE # pragma message("GLM: Depth clip space: Zero to one") # else # pragma message("GLM: Depth clip space: negative one to one") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM // to use left handed coordinate system by default. #define GLM_LEFT_HANDED 0x00000001 // For DirectX, Metal, Vulkan #define GLM_RIGHT_HANDED 0x00000002 // For OpenGL, default in GLM #ifdef GLM_FORCE_LEFT_HANDED # define GLM_COORDINATE_SYSTEM GLM_LEFT_HANDED #else # define GLM_COORDINATE_SYSTEM GLM_RIGHT_HANDED #endif #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_HANDED_DISPLAYED) # define GLM_MESSAGE_HANDED_DISPLAYED # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED # pragma message("GLM: Coordinate system: left handed") # else # pragma message("GLM: Coordinate system: right handed") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // Qualifiers #if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)) # define GLM_DEPRECATED __declspec(deprecated) # define GLM_ALIGN(x) __declspec(align(x)) # define GLM_ALIGNED_STRUCT(x) struct __declspec(align(x)) # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name # define GLM_RESTRICT_FUNC __declspec(restrict) # define GLM_RESTRICT __restrict # if GLM_COMPILER >= GLM_COMPILER_VC12 # define GLM_VECTOR_CALL __vectorcall # else # define GLM_VECTOR_CALL # endif #elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG | GLM_COMPILER_INTEL) # define GLM_DEPRECATED __attribute__((__deprecated__)) # define GLM_ALIGN(x) __attribute__((aligned(x))) # define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x))) # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment))) # define GLM_RESTRICT_FUNC __restrict__ # define GLM_RESTRICT __restrict__ # if GLM_COMPILER & GLM_COMPILER_CLANG # if GLM_COMPILER >= GLM_COMPILER_CLANG37 # define GLM_VECTOR_CALL __vectorcall # else # define GLM_VECTOR_CALL # endif # else # define GLM_VECTOR_CALL # endif #elif GLM_COMPILER & GLM_COMPILER_CUDA # define GLM_DEPRECATED # define GLM_ALIGN(x) __align__(x) # define GLM_ALIGNED_STRUCT(x) struct __align__(x) # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __align__(x) # define GLM_RESTRICT_FUNC __restrict__ # define GLM_RESTRICT __restrict__ # define GLM_VECTOR_CALL #else # define GLM_DEPRECATED # define GLM_ALIGN # define GLM_ALIGNED_STRUCT(x) struct # define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name # define GLM_RESTRICT_FUNC # define GLM_RESTRICT # define GLM_VECTOR_CALL #endif//GLM_COMPILER #if GLM_HAS_DEFAULTED_FUNCTIONS # define GLM_DEFAULT = default #else # define GLM_DEFAULT #endif #if GLM_HAS_CONSTEXPR || GLM_HAS_CONSTEXPR_PARTIAL # define GLM_CONSTEXPR constexpr # if ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER <= GLM_COMPILER_VC14)) // Visual C++ has a bug #594 https://github.com/g-truc/glm/issues/594 # define GLM_CONSTEXPR_CTOR # else # define GLM_CONSTEXPR_CTOR constexpr # endif #else # define GLM_CONSTEXPR # define GLM_CONSTEXPR_CTOR #endif #if GLM_HAS_CONSTEXPR # define GLM_RELAXED_CONSTEXPR constexpr #else # define GLM_RELAXED_CONSTEXPR const #endif #if GLM_ARCH == GLM_ARCH_PURE # define GLM_CONSTEXPR_SIMD GLM_CONSTEXPR_CTOR #else # define GLM_CONSTEXPR_SIMD #endif #ifdef GLM_FORCE_EXPLICIT_CTOR # define GLM_EXPLICIT explicit #else # define GLM_EXPLICIT #endif /////////////////////////////////////////////////////////////////////////////////// #define GLM_HAS_ALIGNED_TYPE GLM_HAS_UNRESTRICTED_UNIONS /////////////////////////////////////////////////////////////////////////////////// // Length type: all length functions returns a length_t type. // When GLM_FORCE_SIZE_T_LENGTH is defined, length_t is a typedef of size_t otherwise // length_t is a typedef of int like GLSL defines it. // User define: GLM_FORCE_SIZE_T_LENGTH namespace glm { using std::size_t; # if defined(GLM_FORCE_SIZE_T_LENGTH) typedef size_t length_t; # else typedef int length_t; # endif }//namespace glm #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH) # define GLM_MESSAGE_FORCE_SIZE_T_LENGTH # if defined GLM_FORCE_SIZE_T_LENGTH # pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t") # else # pragma message("GLM: .length() returns glm::length_t, a typedef of int following the GLSL specification") # endif #endif//GLM_MESSAGES /////////////////////////////////////////////////////////////////////////////////// // countof #if GLM_HAS_CONSTEXPR_PARTIAL namespace glm { template constexpr std::size_t countof(T const (&)[N]) { return N; } }//namespace glm # define GLM_COUNTOF(arr) glm::countof(arr) #elif defined(_MSC_VER) # define GLM_COUNTOF(arr) _countof(arr) #else # define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0]) #endif /////////////////////////////////////////////////////////////////////////////////// // Check inclusions of different versions of GLM #elif ((GLM_SETUP_INCLUDED != GLM_VERSION) && !defined(GLM_FORCE_IGNORE_VERSION)) # error "GLM error: A different version of GLM is already included. Define GLM_FORCE_IGNORE_VERSION before including GLM headers to ignore this error." #elif GLM_SETUP_INCLUDED == GLM_VERSION #endif//GLM_SETUP_INCLUDED glm-0.9.9-a2/glm/detail/_vectorize.hpp0000600000175000001440000000643613173131001016404 0ustar guususers/// @ref core /// @file glm/detail/_vectorize.hpp #pragma once #include "type_vec1.hpp" #include "type_vec2.hpp" #include "type_vec3.hpp" #include "type_vec4.hpp" namespace glm{ namespace detail { template struct functor1{}; template struct functor1<1, R, T, Q> { GLM_FUNC_QUALIFIER static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v) { return vec<1, R, Q>(Func(v.x)); } }; template struct functor1<2, R, T, Q> { GLM_FUNC_QUALIFIER static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v) { return vec<2, R, Q>(Func(v.x), Func(v.y)); } }; template struct functor1<3, R, T, Q> { GLM_FUNC_QUALIFIER static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v) { return vec<3, R, Q>(Func(v.x), Func(v.y), Func(v.z)); } }; template struct functor1<4, R, T, Q> { GLM_FUNC_QUALIFIER static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v) { return vec<4, R, Q>(Func(v.x), Func(v.y), Func(v.z), Func(v.w)); } }; template struct functor2{}; template struct functor2<1, T, Q> { GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> const& b) { return vec<1, T, Q>(Func(a.x, b.x)); } }; template struct functor2<2, T, Q> { GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> const& b) { return vec<2, T, Q>(Func(a.x, b.x), Func(a.y, b.y)); } }; template struct functor2<3, T, Q> { GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> const& b) { return vec<3, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z)); } }; template struct functor2<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> const& b) { return vec<4, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w)); } }; template struct functor2_vec_sca{}; template struct functor2_vec_sca<1, T, Q> { GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b) { return vec<1, T, Q>(Func(a.x, b)); } }; template struct functor2_vec_sca<2, T, Q> { GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b) { return vec<2, T, Q>(Func(a.x, b), Func(a.y, b)); } }; template struct functor2_vec_sca<3, T, Q> { GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b) { return vec<3, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b)); } }; template struct functor2_vec_sca<4, T, Q> { GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b) { return vec<4, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b)); } }; }//namespace detail }//namespace glm glm-0.9.9-a2/glm/detail/func_packing_simd.inl0000600000175000001440000000020213173131001017652 0ustar guususers/// @ref core /// @file glm/detail/func_packing_simd.inl namespace glm{ namespace detail { }//namespace detail }//namespace glm glm-0.9.9-a2/glm/detail/type_vec3.hpp0000600000175000001440000003434313173131001016132 0ustar guususers/// @ref core /// @file glm/detail/type_vec3.hpp #pragma once #include "type_vec.hpp" #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED # if GLM_HAS_UNRESTRICTED_UNIONS # include "_swizzle.hpp" # else # include "_swizzle_func.hpp" # endif #endif //GLM_SWIZZLE == GLM_SWIZZLE_ENABLED #include namespace glm { template struct vec<3, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec type; typedef vec<3, bool, Q> bool_type; // -- Data -- # if GLM_HAS_ONLY_XYZW T x, y, z; # elif GLM_HAS_ALIGNED_TYPE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # endif # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # endif union { struct{ T x, y, z; }; struct{ T r, g, b; }; struct{ T s, t, p; }; # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED GLM_SWIZZLE3_2_MEMBERS(T, Q, x, y, z) GLM_SWIZZLE3_2_MEMBERS(T, Q, r, g, b) GLM_SWIZZLE3_2_MEMBERS(T, Q, s, t, p) GLM_SWIZZLE3_3_MEMBERS(T, Q, x, y, z) GLM_SWIZZLE3_3_MEMBERS(T, Q, r, g, b) GLM_SWIZZLE3_3_MEMBERS(T, Q, s, t, p) GLM_SWIZZLE3_4_MEMBERS(T, Q, x, y, z) GLM_SWIZZLE3_4_MEMBERS(T, Q, r, g, b) GLM_SWIZZLE3_4_MEMBERS(T, Q, s, t, p) # endif//GLM_SWIZZLE }; # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # endif # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # endif # else union { T x, r, s; }; union { T y, g, t; }; union { T z, b, p; }; # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) # endif//GLM_SWIZZLE # endif//GLM_LANG // -- Component accesses -- /// Return the count of components of the vector typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 3;} GLM_FUNC_DECL T & operator[](length_type i); GLM_FUNC_DECL T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(T a, T b, T c); // -- Conversion scalar constructors -- /// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(X x, Y y, Z z); template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, P> const& _xy, B _z); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<2, B, P> const& _yz); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, P> const& v); // -- Swizzle constructors -- # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) template GLM_FUNC_DECL vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& that) { *this = that(); } template GLM_FUNC_DECL vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& scalar) { *this = vec(v(), scalar); } template GLM_FUNC_DECL vec(T const& scalar, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v) { *this = vec(scalar, v()); } # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) // -- Unary arithmetic operators -- GLM_FUNC_DECL vec & operator=(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL vec & operator=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator+=(U scalar); template GLM_FUNC_DECL vec & operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator+=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator-=(U scalar); template GLM_FUNC_DECL vec & operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator-=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator*=(U scalar); template GLM_FUNC_DECL vec & operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator*=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator/=(U scalar); template GLM_FUNC_DECL vec & operator/=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator/=(vec<3, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL vec & operator++(); GLM_FUNC_DECL vec & operator--(); GLM_FUNC_DECL vec operator++(int); GLM_FUNC_DECL vec operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL vec & operator%=(U scalar); template GLM_FUNC_DECL vec & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator%=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator&=(U scalar); template GLM_FUNC_DECL vec & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator&=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator|=(U scalar); template GLM_FUNC_DECL vec & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator|=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator^=(U scalar); template GLM_FUNC_DECL vec & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator^=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator<<=(U scalar); template GLM_FUNC_DECL vec & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator<<=(vec<3, U, Q> const& v); template GLM_FUNC_DECL vec & operator>>=(U scalar); template GLM_FUNC_DECL vec & operator>>=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator>>=(vec<3, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL vec<3, T, Q> operator+(vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator-(vec<3, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar); template GLM_FUNC_DECL vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator+(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator-(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator*(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator/(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator%(T const& scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator%(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator&(vec<3, T, Q> const& v1, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator&(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator|(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator^(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator<<(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v); template GLM_FUNC_DECL vec<3, T, Q> operator>>(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, T, Q> operator~(vec<3, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2); template GLM_FUNC_DECL vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2); template GLM_FUNC_DECL vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_vec3.inl" #endif//GLM_EXTERNAL_TEMPLATE glm-0.9.9-a2/glm/detail/func_common.inl0000600000175000001440000006162713173131001016534 0ustar guususers/// @ref core /// @file glm/detail/func_common.inl #include "../vector_relational.hpp" #include "type_vec2.hpp" #include "type_vec3.hpp" #include "type_vec4.hpp" #include "_vectorize.hpp" #include namespace glm { // min template GLM_FUNC_QUALIFIER genType min(genType x, genType y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point or integer inputs"); return (y < x) ? y : x; } // max template GLM_FUNC_QUALIFIER genType max(genType x, genType y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point or integer inputs"); return (x < y) ? y : x; } // abs template<> GLM_FUNC_QUALIFIER int32 abs(int32 x) { int32 const y = x >> 31; return (x ^ y) - y; } // round # if GLM_HAS_CXX11_STL using ::std::round; # else template GLM_FUNC_QUALIFIER genType round(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'round' only accept floating-point inputs"); return x < static_cast(0) ? static_cast(int(x - static_cast(0.5))) : static_cast(int(x + static_cast(0.5))); } # endif // trunc # if GLM_HAS_CXX11_STL using ::std::trunc; # else template GLM_FUNC_QUALIFIER genType trunc(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'trunc' only accept floating-point inputs"); return x < static_cast(0) ? -std::floor(-x) : std::floor(x); } # endif }//namespace glm namespace glm{ namespace detail { template struct compute_abs {}; template struct compute_abs { GLM_FUNC_QUALIFIER static genFIType call(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_iec559 || std::numeric_limits::is_signed || GLM_UNRESTRICTED_GENTYPE, "'abs' only accept floating-point and integer scalar or vector inputs"); return x >= genFIType(0) ? x : -x; // TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff; } }; #if GLM_COMPILER & GLM_COMPILER_CUDA template<> struct compute_abs { GLM_FUNC_QUALIFIER static float call(float x) { return fabsf(x); } }; #endif template struct compute_abs { GLM_FUNC_QUALIFIER static genFIType call(genFIType x) { GLM_STATIC_ASSERT( (!std::numeric_limits::is_signed && std::numeric_limits::is_integer) || GLM_UNRESTRICTED_GENTYPE, "'abs' only accept floating-point and integer scalar or vector inputs"); return x; } }; template struct compute_abs_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(abs, x); } }; template struct compute_mix_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, vec const& a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return vec(vec(x) + a * vec(y - x)); } }; template struct compute_mix_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, vec const& a) { vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = a[i] ? y[i] : x[i]; return Result; } }; template struct compute_mix_scalar { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, U const& a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return vec(vec(x) + a * vec(y - x)); } }; template struct compute_mix_scalar { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, bool const& a) { return a ? y : x; } }; template struct compute_mix { GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, U const& a) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return static_cast(static_cast(x) + a * static_cast(y - x)); } }; template struct compute_mix { GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, bool const& a) { return a ? y : x; } }; template struct compute_sign { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return vec(glm::lessThan(vec(0), x)) - vec(glm::lessThan(x, vec(0))); } }; # if GLM_ARCH == GLM_ARCH_X86 template struct compute_sign { GLM_FUNC_QUALIFIER static vec call(vec const& x) { T const Shift(static_cast(sizeof(T) * 8 - 1)); vec const y(vec::type, Q>(-x) >> typename make_unsigned::type(Shift)); return (x >> Shift) | y; } }; # endif template struct compute_floor { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(std::floor, x); } }; template struct compute_ceil { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(std::ceil, x); } }; template struct compute_fract { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return x - floor(x); } }; template struct compute_trunc { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(trunc, x); } }; template struct compute_round { GLM_FUNC_QUALIFIER static vec call(vec const& x) { return detail::functor1::call(round, x); } }; template struct compute_mod { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'mod' only accept floating-point inputs. Include for integer inputs."); return a - b * floor(a / b); } }; template struct compute_min_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y) { return detail::functor2::call(min, x, y); } }; template struct compute_max_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y) { return detail::functor2::call(max, x, y); } }; template struct compute_clamp_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& minVal, vec const& maxVal) { return min(max(x, minVal), maxVal); } }; template struct compute_step_vector { GLM_FUNC_QUALIFIER static vec call(vec const& edge, vec const& x) { return mix(vec(1), vec(0), glm::lessThan(x, edge)); } }; template struct compute_smoothstep_vector { GLM_FUNC_QUALIFIER static vec call(vec const& edge0, vec const& edge1, vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'step' only accept floating-point inputs"); vec const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast(0), static_cast(1))); return tmp * tmp * (static_cast(3) - static_cast(2) * tmp); } }; }//namespace detail template GLM_FUNC_QUALIFIER genFIType abs(genFIType x) { return detail::compute_abs::is_signed>::call(x); } template GLM_FUNC_QUALIFIER vec abs(vec const& x) { return detail::compute_abs_vector::value>::call(x); } // sign // fast and works for any type template GLM_FUNC_QUALIFIER genFIType sign(genFIType x) { GLM_STATIC_ASSERT( std::numeric_limits::is_iec559 || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); return detail::compute_sign<1, genFIType, defaultp, std::numeric_limits::is_iec559, highp>::call(vec<1, genFIType>(x)).x; } template GLM_FUNC_QUALIFIER vec sign(vec const& x) { GLM_STATIC_ASSERT( std::numeric_limits::is_iec559 || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); return detail::compute_sign::is_iec559, detail::is_aligned::value>::call(x); } // floor using ::std::floor; template GLM_FUNC_QUALIFIER vec floor(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'floor' only accept floating-point inputs."); return detail::compute_floor::value>::call(x); } template GLM_FUNC_QUALIFIER vec trunc(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'trunc' only accept floating-point inputs"); return detail::compute_trunc::value>::call(x); } template GLM_FUNC_QUALIFIER vec round(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'round' only accept floating-point inputs"); return detail::compute_round::value>::call(x); } /* // roundEven template GLM_FUNC_QUALIFIER genType roundEven(genType const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'roundEven' only accept floating-point inputs"); return genType(int(x + genType(int(x) % 2))); } */ // roundEven template GLM_FUNC_QUALIFIER genType roundEven(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'roundEven' only accept floating-point inputs"); int Integer = static_cast(x); genType IntegerPart = static_cast(Integer); genType FractionalPart = fract(x); if(FractionalPart > static_cast(0.5) || FractionalPart < static_cast(0.5)) { return round(x); } else if((Integer % 2) == 0) { return IntegerPart; } else if(x <= static_cast(0)) // Work around... { return IntegerPart - static_cast(1); } else { return IntegerPart + static_cast(1); } //else // Bug on MinGW 4.5.2 //{ // return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0)); //} } template GLM_FUNC_QUALIFIER vec roundEven(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'roundEven' only accept floating-point inputs"); return detail::functor1::call(roundEven, x); } // ceil using ::std::ceil; template GLM_FUNC_QUALIFIER vec ceil(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'ceil' only accept floating-point inputs"); return detail::compute_ceil::value>::call(x); } // fract template GLM_FUNC_QUALIFIER genType fract(genType x) { return fract(vec<1, genType>(x)).x; } template GLM_FUNC_QUALIFIER vec fract(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fract' only accept floating-point inputs"); return detail::compute_fract::value>::call(x); } // mod template GLM_FUNC_QUALIFIER genType mod(genType x, genType y) { # if GLM_COMPILER & GLM_COMPILER_CUDA // Another Cuda compiler bug https://github.com/g-truc/glm/issues/530 vec<1, genType, defaultp> Result(mod(vec<1, genType, defaultp>(x), y)); return Result.x; # else return mod(vec<1, genType, defaultp>(x), y).x; # endif } template GLM_FUNC_QUALIFIER vec mod(vec const& x, T y) { return detail::compute_mod::value>::call(x, vec(y)); } template GLM_FUNC_QUALIFIER vec mod(vec const& x, vec const& y) { return detail::compute_mod::value>::call(x, y); } // modf template GLM_FUNC_QUALIFIER genType modf(genType x, genType & i) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'modf' only accept floating-point inputs"); return std::modf(x, &i); } template GLM_FUNC_QUALIFIER vec<1, T, Q> modf(vec<1, T, Q> const& x, vec<1, T, Q> & i) { return vec<1, T, Q>( modf(x.x, i.x)); } template GLM_FUNC_QUALIFIER vec<2, T, Q> modf(vec<2, T, Q> const& x, vec<2, T, Q> & i) { return vec<2, T, Q>( modf(x.x, i.x), modf(x.y, i.y)); } template GLM_FUNC_QUALIFIER vec<3, T, Q> modf(vec<3, T, Q> const& x, vec<3, T, Q> & i) { return vec<3, T, Q>( modf(x.x, i.x), modf(x.y, i.y), modf(x.z, i.z)); } template GLM_FUNC_QUALIFIER vec<4, T, Q> modf(vec<4, T, Q> const& x, vec<4, T, Q> & i) { return vec<4, T, Q>( modf(x.x, i.x), modf(x.y, i.y), modf(x.z, i.z), modf(x.w, i.w)); } //// Only valid if (INT_MIN <= x-y <= INT_MAX) //// min(x,y) //r = y + ((x - y) & ((x - y) >> (sizeof(int) * //CHAR_BIT - 1))); //// max(x,y) //r = x - ((x - y) & ((x - y) >> (sizeof(int) * //CHAR_BIT - 1))); // min template GLM_FUNC_QUALIFIER vec min(vec const& a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point or integer inputs"); return detail::compute_min_vector::value>::call(a, vec(b)); } template GLM_FUNC_QUALIFIER vec min(vec const& a, vec const& b) { return detail::compute_min_vector::value>::call(a, b); } // max template GLM_FUNC_QUALIFIER vec max(vec const& a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point or integer inputs"); return detail::compute_max_vector::value>::call(a, vec(b)); } template GLM_FUNC_QUALIFIER vec max(vec const& a, vec const& b) { return detail::compute_max_vector::value>::call(a, b); } // clamp template GLM_FUNC_QUALIFIER genType clamp(genType x, genType minVal, genType maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs"); return min(max(x, minVal), maxVal); } template GLM_FUNC_QUALIFIER vec clamp(vec const& x, T minVal, T maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs"); return detail::compute_clamp_vector::value>::call(x, vec(minVal), vec(maxVal)); } template GLM_FUNC_QUALIFIER vec clamp(vec const& x, vec const& minVal, vec const& maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs"); return detail::compute_clamp_vector::value>::call(x, minVal, maxVal); } template GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a) { return detail::compute_mix::call(x, y, a); } template GLM_FUNC_QUALIFIER vec mix(vec const& x, vec const& y, U a) { return detail::compute_mix_scalar::value>::call(x, y, a); } template GLM_FUNC_QUALIFIER vec mix(vec const& x, vec const& y, vec const& a) { return detail::compute_mix_vector::value>::call(x, y, a); } // step template GLM_FUNC_QUALIFIER genType step(genType edge, genType x) { return mix(static_cast(1), static_cast(0), x < edge); } template GLM_FUNC_QUALIFIER vec step(T edge, vec const& x) { return detail::compute_step_vector::value>::call(vec(edge), x); } template GLM_FUNC_QUALIFIER vec step(vec const& edge, vec const& x) { return detail::compute_step_vector::value>::call(edge, x); } // smoothstep template GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1))); return tmp * tmp * (genType(3) - genType(2) * tmp); } template GLM_FUNC_QUALIFIER vec smoothstep(T edge0, T edge1, vec const& x) { return detail::compute_smoothstep_vector::value>::call(vec(edge0), vec(edge1), x); } template GLM_FUNC_QUALIFIER vec smoothstep(vec const& edge0, vec const& edge1, vec const& x) { return detail::compute_smoothstep_vector::value>::call(edge0, edge1, x); } # if GLM_HAS_CXX11_STL using std::isnan; # else template GLM_FUNC_QUALIFIER bool isnan(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); # if GLM_HAS_CXX11_STL return std::isnan(x); # elif GLM_COMPILER & GLM_COMPILER_VC return _isnan(x) != 0; # elif GLM_COMPILER & GLM_COMPILER_INTEL # if GLM_PLATFORM & GLM_PLATFORM_WINDOWS return _isnan(x) != 0; # else return ::isnan(x) != 0; # endif # elif (GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) && (GLM_PLATFORM & GLM_PLATFORM_ANDROID) && __cplusplus < 201103L return _isnan(x) != 0; # elif GLM_COMPILER & GLM_COMPILER_CUDA return isnan(x) != 0; # else return std::isnan(x); # endif } # endif template GLM_FUNC_QUALIFIER vec isnan(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = glm::isnan(v[l]); return Result; } # if GLM_HAS_CXX11_STL using std::isinf; # else template GLM_FUNC_QUALIFIER bool isinf(genType x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isinf' only accept floating-point inputs"); # if GLM_HAS_CXX11_STL return std::isinf(x); # elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC) # if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS) return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF; # else return ::isinf(x); # endif # elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG) # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L) return _isinf(x) != 0; # else return std::isinf(x); # endif # elif GLM_COMPILER & GLM_COMPILER_CUDA // http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab return isinf(double(x)) != 0; # else return std::isinf(x); # endif } # endif template GLM_FUNC_QUALIFIER vec isinf(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isinf' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = glm::isinf(v[l]); return Result; } GLM_FUNC_QUALIFIER int floatBitsToInt(float const& v) { union { float in; int out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec floatBitsToInt(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } GLM_FUNC_QUALIFIER uint floatBitsToUint(float const& v) { union { float in; uint out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec floatBitsToUint(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } GLM_FUNC_QUALIFIER float intBitsToFloat(int const& v) { union { int in; float out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec intBitsToFloat(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const& v) { union { uint in; float out; } u; u.in = v; return u.out; } template GLM_FUNC_QUALIFIER vec uintBitsToFloat(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); } template GLM_FUNC_QUALIFIER genType fma(genType const& a, genType const& b, genType const& c) { return a * b + c; } template GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs"); return std::frexp(x, &exp); } template GLM_FUNC_QUALIFIER vec frexp(vec const& v, vec& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = std::frexp(v[l], &exp[l]); return Result; } template GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs"); return std::ldexp(x, exp); } template GLM_FUNC_QUALIFIER vec ldexp(vec const& v, vec const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs"); vec Result; for (length_t l = 0; l < v.length(); ++l) Result[l] = std::ldexp(v[l], exp[l]); return Result; } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_common_simd.inl" #endif glm-0.9.9-a2/glm/detail/_fixes.hpp0000600000175000001440000000065313173131001015503 0ustar guususers/// @ref core /// @file glm/detail/_fixes.hpp #include //! Workaround for compatibility with other libraries #ifdef max #undef max #endif //! Workaround for compatibility with other libraries #ifdef min #undef min #endif //! Workaround for Android #ifdef isnan #undef isnan #endif //! Workaround for Android #ifdef isinf #undef isinf #endif //! Workaround for Chrone Native Client #ifdef log2 #undef log2 #endif glm-0.9.9-a2/glm/detail/type_mat3x4.inl0000600000175000001440000003474713173131001016415 0ustar guususers/// @ref core /// @file glm/detail/type_mat3x4.inl namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<3, 4, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(T scalar) { this->value[0] = col_type(scalar, 0, 0, 0); this->value[1] = col_type(0, scalar, 0, 0); this->value[2] = col_type(0, 0, scalar, 0); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat ( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1, T x2, T y2, T z2, T w2 ) { this->value[0] = col_type(x0, y0, z0, w0); this->value[1] = col_type(x1, y1, z1, w1); this->value[2] = col_type(x2, y2, z2, w2); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat ( col_type const& v0, col_type const& v1, col_type const& v2 ) { this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; } // -- Conversion constructors -- template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, typename X3, typename Y3, typename Z3, typename W3> GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat ( X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2, X3 x3, Y3 y3, Z3 z3, W3 w3 ) { this->value[0] = col_type(static_cast(x1), value_type(y1), value_type(z1), value_type(w1)); this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2), value_type(w2)); this->value[2] = col_type(static_cast(x3), value_type(y3), value_type(z3), value_type(w3)); } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat ( vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3 ) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); } // -- Matrix conversions -- template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<3, 4, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(0, 0, 1, 0); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1, 0); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(m[2], 1, 0); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0, 0, 1, 0); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(m[2], 1, 0); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type & mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type const& mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator=(mat<3, 4, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator=(mat<3, 4, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(mat<3, 4, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(mat<3, 4, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> & mat<3, 4, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; return *this; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator++(int) { mat<3, 4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator--(int) { mat<3, 4, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m) { return mat<3, 4, T, Q>( -m[0], -m[1], -m[2]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m) { return mat<3, 4, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar); } template GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type operator* ( mat<3, 4, T, Q> const& m, typename mat<3, 4, T, Q>::row_type const& v ) { return typename mat<3, 4, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z, m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z); } template GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::row_type operator* ( typename mat<3, 4, T, Q>::col_type const& v, mat<3, 4, T, Q> const& m ) { return typename mat<3, 4, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3], v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3], v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2) { const T SrcA00 = m1[0][0]; const T SrcA01 = m1[0][1]; const T SrcA02 = m1[0][2]; const T SrcA03 = m1[0][3]; const T SrcA10 = m1[1][0]; const T SrcA11 = m1[1][1]; const T SrcA12 = m1[1][2]; const T SrcA13 = m1[1][3]; const T SrcA20 = m1[2][0]; const T SrcA21 = m1[2][1]; const T SrcA22 = m1[2][2]; const T SrcA23 = m1[2][3]; const T SrcB00 = m2[0][0]; const T SrcB01 = m2[0][1]; const T SrcB02 = m2[0][2]; const T SrcB10 = m2[1][0]; const T SrcB11 = m2[1][1]; const T SrcB12 = m2[1][2]; const T SrcB20 = m2[2][0]; const T SrcB21 = m2[2][1]; const T SrcB22 = m2[2][2]; const T SrcB30 = m2[3][0]; const T SrcB31 = m2[3][1]; const T SrcB32 = m2[3][2]; mat<4, 4, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02; Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12; Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12; Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22; Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22; Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22; Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22; Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32; Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32; Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32; Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32; return Result; } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2], m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar) { return mat<3, 4, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m) { return mat<3, 4, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); } } //namespace glm glm-0.9.9-a2/glm/detail/type_vec.hpp0000600000175000001440000006344713173131001016056 0ustar guususers/// @ref core /// @file glm/detail/type_vec.hpp #pragma once #include "qualifier.hpp" #include "type_int.hpp" #include "compute_vector_relational.hpp" namespace glm{ namespace detail { template struct storage { typedef struct type { uint8 data[size]; } type; }; #define GLM_ALIGNED_STORAGE_TYPE_STRUCT(x) \ template \ struct storage { \ GLM_ALIGNED_STRUCT(x) type { \ uint8 data[x]; \ }; \ }; GLM_ALIGNED_STORAGE_TYPE_STRUCT(1) GLM_ALIGNED_STORAGE_TYPE_STRUCT(2) GLM_ALIGNED_STORAGE_TYPE_STRUCT(4) GLM_ALIGNED_STORAGE_TYPE_STRUCT(8) GLM_ALIGNED_STORAGE_TYPE_STRUCT(16) GLM_ALIGNED_STORAGE_TYPE_STRUCT(32) GLM_ALIGNED_STORAGE_TYPE_STRUCT(64) # if GLM_ARCH & GLM_ARCH_SSE2_BIT template<> struct storage { typedef glm_vec4 type; }; template<> struct storage { typedef glm_ivec4 type; }; template<> struct storage { typedef glm_uvec4 type; }; /* # else typedef union __declspec(align(16)) glm_128 { unsigned __int8 data[16]; } glm_128; template<> struct storage { typedef glm_128 type; }; template<> struct storage { typedef glm_128 type; }; template<> struct storage { typedef glm_128 type; }; */ # endif # if (GLM_ARCH & GLM_ARCH_AVX_BIT) template<> struct storage { typedef glm_dvec4 type; }; # endif # if (GLM_ARCH & GLM_ARCH_AVX2_BIT) template<> struct storage { typedef glm_i64vec4 type; }; template<> struct storage { typedef glm_u64vec4 type; }; # endif }//namespace detail #if GLM_HAS_TEMPLATE_ALIASES template using tvec2 = vec<2, T, Q>; template using tvec3 = vec<3, T, Q>; template using tvec4 = vec<4, T, Q>; #endif//GLM_HAS_TEMPLATE_ALIASES /// @addtogroup core_precision /// @{ /// 2 components vector of high single-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, highp> highp_vec2; /// 2 components vector of medium single-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, mediump> mediump_vec2; /// 2 components vector of low single-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, lowp> lowp_vec2; /// 2 components vector of high double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, highp> highp_dvec2; /// 2 components vector of medium double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, mediump> mediump_dvec2; /// 2 components vector of low double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, lowp> lowp_dvec2; /// 2 components vector of high qualifier signed integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, int, highp> highp_ivec2; /// 2 components vector of medium qualifier signed integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, int, mediump> mediump_ivec2; /// 2 components vector of low qualifier signed integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, int, lowp> lowp_ivec2; /// 2 components vector of high qualifier unsigned integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, uint, highp> highp_uvec2; /// 2 components vector of medium qualifier unsigned integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, uint, mediump> mediump_uvec2; /// 2 components vector of low qualifier unsigned integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, uint, lowp> lowp_uvec2; /// 2 components vector of high qualifier bool numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, highp> highp_bvec2; /// 2 components vector of medium qualifier bool numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, mediump> mediump_bvec2; /// 2 components vector of low qualifier bool numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, lowp> lowp_bvec2; /// @} /// @addtogroup core_precision /// @{ /// 3 components vector of high single-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, highp> highp_vec3; /// 3 components vector of medium single-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, mediump> mediump_vec3; /// 3 components vector of low single-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, lowp> lowp_vec3; /// 3 components vector of high double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, highp> highp_dvec3; /// 3 components vector of medium double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, mediump> mediump_dvec3; /// 3 components vector of low double-qualifier floating-point numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, lowp> lowp_dvec3; /// 3 components vector of high qualifier signed integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, int, highp> highp_ivec3; /// 3 components vector of medium qualifier signed integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, int, mediump> mediump_ivec3; /// 3 components vector of low qualifier signed integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, int, lowp> lowp_ivec3; /// 3 components vector of high qualifier unsigned integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, uint, highp> highp_uvec3; /// 3 components vector of medium qualifier unsigned integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, uint, mediump> mediump_uvec3; /// 3 components vector of low qualifier unsigned integer numbers. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, uint, lowp> lowp_uvec3; /// 3 components vector of high qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, highp> highp_bvec3; /// 3 components vector of medium qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, mediump> mediump_bvec3; /// 3 components vector of low qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, lowp> lowp_bvec3; /// @} /// @addtogroup core_precision /// @{ /// 4 components vector of high single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, highp> highp_vec4; /// 4 components vector of medium single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, mediump> mediump_vec4; /// 4 components vector of low single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, lowp> lowp_vec4; /// 4 components vector of high double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, highp> highp_dvec4; /// 4 components vector of medium double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, mediump> mediump_dvec4; /// 4 components vector of low double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, lowp> lowp_dvec4; /// 4 components vector of high qualifier signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, int, highp> highp_ivec4; /// 4 components vector of medium qualifier signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, int, mediump> mediump_ivec4; /// 4 components vector of low qualifier signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, int, lowp> lowp_ivec4; /// 4 components vector of high qualifier unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, uint, highp> highp_uvec4; /// 4 components vector of medium qualifier unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, uint, mediump> mediump_uvec4; /// 4 components vector of low qualifier unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, uint, lowp> lowp_uvec4; /// 4 components vector of high qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, highp> highp_bvec4; /// 4 components vector of medium qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, mediump> mediump_bvec4; /// 4 components vector of low qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, lowp> lowp_bvec4; /// @} /// @addtogroup core_types /// @{ // -- Default float definition -- #if(defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_vec2 vec2; typedef lowp_vec3 vec3; typedef lowp_vec4 vec4; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) typedef mediump_vec2 vec2; typedef mediump_vec3 vec3; typedef mediump_vec4 vec4; #else //defined(GLM_PRECISION_HIGHP_FLOAT) /// 2 components vector of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_vec2 vec2; //! 3 components vector of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_vec3 vec3; //! 4 components vector of floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_vec4 vec4; #endif//GLM_PRECISION // -- Default double definition -- #if(defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_dvec2 dvec2; typedef lowp_dvec3 dvec3; typedef lowp_dvec4 dvec4; #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE)) typedef mediump_dvec2 dvec2; typedef mediump_dvec3 dvec3; typedef mediump_dvec4 dvec4; #else //defined(GLM_PRECISION_HIGHP_DOUBLE) /// 2 components vector of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_dvec2 dvec2; //! 3 components vector of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_dvec3 dvec3; //! 4 components vector of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_dvec4 dvec4; #endif//GLM_PRECISION // -- Signed integer definition -- #if(defined(GLM_PRECISION_LOWP_INT)) typedef lowp_ivec2 ivec2; typedef lowp_ivec3 ivec3; typedef lowp_ivec4 ivec4; #elif(defined(GLM_PRECISION_MEDIUMP_INT)) typedef mediump_ivec2 ivec2; typedef mediump_ivec3 ivec3; typedef mediump_ivec4 ivec4; #else //defined(GLM_PRECISION_HIGHP_INT) /// 2 components vector of signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_ivec2 ivec2; /// 3 components vector of signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_ivec3 ivec3; /// 4 components vector of signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_ivec4 ivec4; #endif//GLM_PRECISION // -- Unsigned integer definition -- #if(defined(GLM_PRECISION_LOWP_UINT)) typedef lowp_uvec2 uvec2; typedef lowp_uvec3 uvec3; typedef lowp_uvec4 uvec4; #elif(defined(GLM_PRECISION_MEDIUMP_UINT)) typedef mediump_uvec2 uvec2; typedef mediump_uvec3 uvec3; typedef mediump_uvec4 uvec4; #else //defined(GLM_PRECISION_HIGHP_UINT) /// 2 components vector of unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_uvec2 uvec2; /// 3 components vector of unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_uvec3 uvec3; /// 4 components vector of unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_uvec4 uvec4; #endif//GLM_PRECISION // -- Boolean definition -- #if(defined(GLM_PRECISION_LOWP_BOOL)) typedef lowp_bvec2 bvec2; typedef lowp_bvec3 bvec3; typedef lowp_bvec4 bvec4; #elif(defined(GLM_PRECISION_MEDIUMP_BOOL)) typedef mediump_bvec2 bvec2; typedef mediump_bvec3 bvec3; typedef mediump_bvec4 bvec4; #else //defined(GLM_PRECISION_HIGHP_BOOL) /// 2 components vector of boolean. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_bvec2 bvec2; /// 3 components vector of boolean. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_bvec3 bvec3; /// 4 components vector of boolean. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_bvec4 bvec4; #endif//GLM_PRECISION /// @} }//namespace glm glm-0.9.9-a2/glm/detail/func_exponential_simd.inl0000600000175000001440000000136613173131001020600 0ustar guususers/// @ref core /// @file glm/detail/func_exponential_simd.inl #include "../simd/exponential.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { template struct compute_sqrt<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> Result; Result.data = _mm_sqrt_ps(v.data); return Result; } }; template<> struct compute_sqrt<4, float, aligned_lowp, true> { GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) { vec<4, float, aligned_lowp> Result; Result.data = glm_vec4_sqrt_lowp(v.data); return Result; } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/detail/type_mat2x2.inl0000600000175000001440000002744613173131001016410 0ustar guususers/// @ref core /// @file glm/detail/type_mat2x2.inl #include "../matrix.hpp" namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<2, 2, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(T scalar) { this->value[0] = col_type(scalar, 0); this->value[1] = col_type(0, scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat ( T const& x0, T const& y0, T const& x1, T const& y1 ) { this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(col_type const& v0, col_type const& v1) { this->value[0] = v0; this->value[1] = v1; } // -- Conversion constructors -- template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat ( X1 const& x1, Y1 const& y1, X2 const& x2, Y2 const& y2 ) { this->value[0] = col_type(static_cast(x1), value_type(y1)); this->value[1] = col_type(static_cast(x2), value_type(y2)); } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); } // -- mat2x2 matrix conversions -- template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<2, 2, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type const& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator=(mat<2, 2, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator=(mat<2, 2, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(U scalar) { this->value[0] += scalar; this->value[1] += scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(mat<2, 2, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(U scalar) { this->value[0] -= scalar; this->value[1] -= scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(mat<2, 2, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(U scalar) { this->value[0] *= scalar; this->value[1] *= scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(mat<2, 2, U, Q> const& m) { return (*this = *this * m); } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(U scalar) { this->value[0] /= scalar; this->value[1] /= scalar; return *this; } template template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(mat<2, 2, U, Q> const& m) { return *this *= inverse(m); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator--() { --this->value[0]; --this->value[1]; return *this; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator++(int) { mat<2, 2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator--(int) { mat<2, 2, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( -m[0], -m[1]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( m[0] + scalar, m[1] + scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 2, T, Q>( m1[0] + m2[0], m1[1] + m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] - scalar, m[1] - scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( scalar - m[0], scalar - m[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 2, T, Q>( m1[0] - m2[0], m1[1] - m2[1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( m[0] * scalar, m[1] * scalar); } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator* ( mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v ) { return vec<2, T, Q>( m[0][0] * v.x + m[1][0] * v.y, m[0][1] * v.x + m[1][1] * v.y); } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator* ( typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m ) { return vec<2, T, Q>( v.x * m[0][0] + v.y * m[0][1], v.x * m[1][0] + v.y * m[1][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return mat<2, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]); } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar) { return mat<2, 2, T, Q>( m[0] / scalar, m[1] / scalar); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m) { return mat<2, 2, T, Q>( scalar / m[0], scalar / m[1]); } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v) { return inverse(m) * v; } template GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m) { return v * inverse(m); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { mat<2, 2, T, Q> m1_copy(m1); return m1_copy /= m2; } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); } } //namespace glm glm-0.9.9-a2/glm/detail/type_vec4_simd.inl0000600000175000001440000002710613173131001017141 0ustar guususers/// @ref core /// @file glm/detail/type_tvec4_simd.inl #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED template struct _swizzle_base1<4, float, Q, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, float, Q> operator ()() const { __m128 data = *reinterpret_cast<__m128 const*>(&this->_buffer); vec<4, float, Q> Result; # if GLM_ARCH & GLM_ARCH_AVX_BIT Result.data = _mm_permute_ps(data, _MM_SHUFFLE(E3, E2, E1, E0)); # else Result.data = _mm_shuffle_ps(data, data, _MM_SHUFFLE(E3, E2, E1, E0)); # endif return Result; } }; template struct _swizzle_base1<4, int32, Q, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, int32, Q> operator ()() const { __m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer); vec<4, int32, Q> Result; Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0)); return Result; } }; template struct _swizzle_base1<4, uint32, Q, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, uint32, Q> operator ()() const { __m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer); vec<4, uint32, Q> Result; Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0)); return Result; } }; # endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED template struct compute_vec4_add { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_add_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_add { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_add_pd(a.data, b.data); return Result; } }; # endif template struct compute_vec4_sub { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_sub_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_sub { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_sub_pd(a.data, b.data); return Result; } }; # endif template struct compute_vec4_mul { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_mul_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_mul { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_mul_pd(a.data, b.data); return Result; } }; # endif template struct compute_vec4_div { static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b) { vec<4, float, Q> Result; Result.data = _mm_div_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template struct compute_vec4_div { static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b) { vec<4, double, Q> Result; Result.data = _mm256_div_pd(a.data, b.data); return Result; } }; # endif template<> struct compute_vec4_div { static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& a, vec<4, float, aligned_lowp> const& b) { vec<4, float, aligned_lowp> Result; Result.data = _mm_mul_ps(a.data, _mm_rcp_ps(b.data)); return Result; } }; template struct compute_vec4_and { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_and_si128(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_and { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_and_si256(a.data, b.data); return Result; } }; # endif template struct compute_vec4_or { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_or_si128(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_or { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_or_si256(a.data, b.data); return Result; } }; # endif template struct compute_vec4_xor { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_xor_si128(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_xor { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_xor_si256(a.data, b.data); return Result; } }; # endif template struct compute_vec4_shift_left { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_sll_epi32(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_shift_left { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_sll_epi64(a.data, b.data); return Result; } }; # endif template struct compute_vec4_shift_right { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm_srl_epi32(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_shift_right { static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b) { vec<4, T, Q> Result; Result.data = _mm256_srl_epi64(a.data, b.data); return Result; } }; # endif template struct compute_vec4_bitwise_not { static vec<4, T, Q> call(vec<4, T, Q> const& v) { vec<4, T, Q> Result; Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1)); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT template struct compute_vec4_bitwise_not { static vec<4, T, Q> call(vec<4, T, Q> const& v) { vec<4, T, Q> Result; Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1)); return Result; } }; # endif template struct compute_vec4_equal { static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { return _mm_movemask_ps(_mm_cmpeq_ps(v1.data, v2.data)) != 0; } }; template struct compute_vec4_equal { static bool call(vec<4, int32, Q> const& v1, vec<4, int32, Q> const& v2) { return _mm_movemask_epi8(_mm_cmpeq_epi32(v1.data, v2.data)) != 0; } }; template struct compute_vec4_nequal { static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) != 0; } }; template struct compute_vec4_nequal { static bool call(vec<4, int32, Q> const& v1, vec<4, int32, Q> const& v2) { return _mm_movemask_epi8(_mm_cmpneq_epi32(v1.data, v2.data)) != 0; } }; }//namespace detail template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_lowp>::vec(float _s) : data(_mm_set1_ps(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_mediump>::vec(float _s) : data(_mm_set1_ps(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_highp>::vec(float _s) : data(_mm_set1_ps(_s)) {} # if GLM_ARCH & GLM_ARCH_AVX_BIT template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, double, aligned_lowp>::vec(double _s) : data(_mm256_set1_pd(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, double, aligned_mediump>::vec(double _s) : data(_mm256_set1_pd(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, double, aligned_highp>::vec(double _s) : data(_mm256_set1_pd(_s)) {} # endif template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_lowp>::vec(int32 _s) : data(_mm_set1_epi32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_mediump>::vec(int32 _s) : data(_mm_set1_epi32(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_highp>::vec(int32 _s) : data(_mm_set1_epi32(_s)) {} # if GLM_ARCH & GLM_ARCH_AVX2_BIT template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int64, aligned_lowp>::vec(int64 _s) : data(_mm256_set1_epi64x(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int64, aligned_mediump>::vec(int64 _s) : data(_mm256_set1_epi64x(_s)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int64, aligned_highp>::vec(int64 _s) : data(_mm256_set1_epi64x(_s)) {} # endif template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_lowp>::vec(float _x, float _y, float _z, float _w) : data(_mm_set_ps(_w, _z, _y, _x)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_mediump>::vec(float _x, float _y, float _z, float _w) : data(_mm_set_ps(_w, _z, _y, _x)) {} template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_highp>::vec(float _x, float _y, float _z, float _w) : data(_mm_set_ps(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_lowp>::vec(int32 _x, int32 _y, int32 _z, int32 _w) : data(_mm_set_epi32(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_mediump>::vec(int32 _x, int32 _y, int32 _z, int32 _w) : data(_mm_set_epi32(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_highp>::vec(int32 _x, int32 _y, int32 _z, int32 _w) : data(_mm_set_epi32(_w, _z, _y, _x)) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_lowp>::vec(int32 _x, int32 _y, int32 _z, int32 _w) : data(_mm_castsi128_ps(_mm_set_epi32(_w, _z, _y, _x))) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_mediump>::vec(int32 _x, int32 _y, int32 _z, int32 _w) : data(_mm_castsi128_ps(_mm_set_epi32(_w, _z, _y, _x))) {} template<> template<> GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_highp>::vec(int32 _x, int32 _y, int32 _z, int32 _w) : data(_mm_castsi128_ps(_mm_set_epi32(_w, _z, _y, _x))) {} }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/detail/type_vec.inl0000600000175000001440000000006013173131001016027 0ustar guususers/// @ref core /// @file glm/detail/type_vec.inl glm-0.9.9-a2/glm/detail/func_matrix_simd.inl0000600000175000001440000000554713173131001017563 0ustar guususers/// @ref core /// @file glm/detail/func_matrix_simd.inl #if GLM_ARCH & GLM_ARCH_SSE2_BIT #include "type_mat4x4.hpp" #include "../geometric.hpp" #include "../simd/matrix.h" #include namespace glm{ namespace detail { template struct compute_matrixCompMult<4, 4, float, Q, true> { GLM_STATIC_ASSERT(detail::is_aligned::value, "Specialization requires aligned"); GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& x, mat<4, 4, float, Q> const& y) { mat<4, 4, float, Q> Result; glm_mat4_matrixCompMult( *static_cast(&x[0].data), *static_cast(&y[0].data), *static_cast(&Result[0].data)); return Result; } }; template struct compute_transpose<4, 4, float, Q, true> { GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m) { mat<4, 4, float, Q> Result; glm_mat4_transpose( *static_cast(&m[0].data), *static_cast(&Result[0].data)); return Result; } }; template struct compute_determinant<4, 4, float, Q, true> { GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, Q> const& m) { return _mm_cvtss_f32(glm_mat4_determinant(*reinterpret_cast<__m128 const(*)[4]>(&m[0].data))); } }; template struct compute_inverse<4, 4, float, Q, true> { GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m) { mat<4, 4, float, Q> Result; glm_mat4_inverse(*reinterpret_cast<__m128 const(*)[4]>(&m[0].data), *reinterpret_cast<__m128(*)[4]>(&Result[0].data)); return Result; } }; }//namespace detail template<> GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp>(vec<4, float, aligned_lowp> const& c, vec<4, float, aligned_lowp> const& r) { __m128 NativeResult[4]; glm_mat4_outerProduct(c.data, r.data, NativeResult); mat<4, 4, float, aligned_lowp> Result; std::memcpy(&Result[0], &NativeResult[0], sizeof(Result)); return Result; } template<> GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump>(vec<4, float, aligned_mediump> const& c, vec<4, float, aligned_mediump> const& r) { __m128 NativeResult[4]; glm_mat4_outerProduct(c.data, r.data, NativeResult); mat<4, 4, float, aligned_mediump> Result; std::memcpy(&Result[0], &NativeResult[0], sizeof(Result)); return Result; } template<> GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_highp> outerProduct<4, 4, float, aligned_highp>(vec<4, float, aligned_highp> const& c, vec<4, float, aligned_highp> const& r) { __m128 NativeResult[4]; glm_mat4_outerProduct(c.data, r.data, NativeResult); mat<4, 4, float, aligned_highp> Result; std::memcpy(&Result[0], &NativeResult[0], sizeof(Result)); return Result; } }//namespace glm #endif glm-0.9.9-a2/glm/detail/func_packing.inl0000600000175000001440000000541413173131001016650 0ustar guususers/// @ref core /// @file glm/detail/func_packing.inl #include "../common.hpp" #include "type_half.hpp" #include "../fwd.hpp" namespace glm { GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const& v) { union { u16 in[2]; uint out; } u; u16vec2 result(round(clamp(v, 0.0f, 1.0f) * 65535.0f)); u.in[0] = result[0]; u.in[1] = result[1]; return u.out; } GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p) { union { uint in; u16 out[2]; } u; u.in = p; return vec2(u.out[0], u.out[1]) * 1.5259021896696421759365224689097e-5f; } GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const& v) { union { i16 in[2]; uint out; } u; i16vec2 result(round(clamp(v, -1.0f, 1.0f) * 32767.0f)); u.in[0] = result[0]; u.in[1] = result[1]; return u.out; } GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p) { union { uint in; i16 out[2]; } u; u.in = p; return clamp(vec2(u.out[0], u.out[1]) * 3.0518509475997192297128208258309e-5f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER uint packUnorm4x8(vec4 const& v) { union { u8 in[4]; uint out; } u; u8vec4 result(round(clamp(v, 0.0f, 1.0f) * 255.0f)); u.in[0] = result[0]; u.in[1] = result[1]; u.in[2] = result[2]; u.in[3] = result[3]; return u.out; } GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p) { union { uint in; u8 out[4]; } u; u.in = p; return vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0039215686274509803921568627451f; } GLM_FUNC_QUALIFIER uint packSnorm4x8(vec4 const& v) { union { i8 in[4]; uint out; } u; i8vec4 result(round(clamp(v, -1.0f, 1.0f) * 127.0f)); u.in[0] = result[0]; u.in[1] = result[1]; u.in[2] = result[2]; u.in[3] = result[3]; return u.out; } GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p) { union { uint in; i8 out[4]; } u; u.in = p; return clamp(vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0078740157480315f, -1.0f, 1.0f); } GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const& v) { union { uint in[2]; double out; } u; u.in[0] = v[0]; u.in[1] = v[1]; return u.out; } GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v) { union { double in; uint out[2]; } u; u.in = v; return uvec2(u.out[0], u.out[1]); } GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const& v) { union { i16 in[2]; uint out; } u; u.in[0] = detail::toFloat16(v.x); u.in[1] = detail::toFloat16(v.y); return u.out; } GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v) { union { uint in; i16 out[2]; } u; u.in = v; return vec2( detail::toFloat32(u.out[0]), detail::toFloat32(u.out[1])); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_packing_simd.inl" #endif glm-0.9.9-a2/glm/detail/func_common_simd.inl0000600000175000001440000001366313173131001017545 0ustar guususers/// @ref core /// @file glm/detail/func_common_simd.inl #if GLM_ARCH & GLM_ARCH_SSE2_BIT #include "../simd/common.h" #include namespace glm{ namespace detail { template struct compute_abs_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_abs(v.data); return result; } }; template struct compute_abs_vector<4, int, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) { vec<4, int, Q> result; result.data = glm_ivec4_abs(v.data); return result; } }; template struct compute_floor<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_floor(v.data); return result; } }; template struct compute_ceil<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_ceil(v.data); return result; } }; template struct compute_fract<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_fract(v.data); return result; } }; template struct compute_round<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) { vec<4, float, Q> result; result.data = glm_vec4_round(v.data); return result; } }; template struct compute_mod<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y) { vec<4, float, Q> result; result.data = glm_vec4_mod(x.data, y.data); return result; } }; template struct compute_min_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { vec<4, float, Q> result; result.data = _mm_min_ps(v1.data, v2.data); return result; } }; template struct compute_min_vector<4, int32, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, int32, Q> const& v1, vec<4, int32, Q> const& v2) { vec<4, int32, Q> result; result.data = _mm_min_epi32(v1.data, v2.data); return result; } }; template struct compute_min_vector<4, uint32, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, uint32, Q> const& v1, vec<4, uint32, Q> const& v2) { vec<4, uint32, Q> result; result.data = _mm_min_epu32(v1.data, v2.data); return result; } }; template struct compute_max_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2) { vec<4, float, Q> result; result.data = _mm_max_ps(v1.data, v2.data); return result; } }; template struct compute_max_vector<4, int32, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, int32, Q> const& v1, vec<4, int32, Q> const& v2) { vec<4, int32, Q> result; result.data = _mm_max_epi32(v1.data, v2.data); return result; } }; template struct compute_max_vector<4, uint32, Q, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v1, vec<4, uint32, Q> const& v2) { vec<4, uint32, Q> result; result.data = _mm_max_epu32(v1.data, v2.data); return result; } }; template struct compute_clamp_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& minVal, vec<4, float, Q> const& maxVal) { vec<4, float, Q> result; result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data); return result; } }; template struct compute_clamp_vector<4, int32, Q, true> { GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, int32, Q> const& x, vec<4, int32, Q> const& minVal, vec<4, int32, Q> const& maxVal) { vec<4, int32, Q> result; result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data); return result; } }; template struct compute_clamp_vector<4, uint32, Q, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& x, vec<4, uint32, Q> const& minVal, vec<4, uint32, Q> const& maxVal) { vec<4, uint32, Q> result; result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data); return result; } }; template struct compute_mix_vector<4, float, bool, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y, vec<4, bool, Q> const& a) { __m128i const Load = _mm_set_epi32(-static_cast(a.w), -static_cast(a.z), -static_cast(a.y), -static_cast(a.x)); __m128 const Mask = _mm_castsi128_ps(Load); vec<4, float, Q> Result; # if 0 && GLM_ARCH & GLM_ARCH_AVX Result.data = _mm_blendv_ps(x.data, y.data, Mask); # else Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data)); # endif return Result; } }; /* FIXME template struct compute_step_vector { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge, vec<4, float, Q> const& x) { vec<4, float, Q> Result; result.data = glm_vec4_step(edge.data, x.data); return result; } }; */ template struct compute_smoothstep_vector<4, float, Q, true> { GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge0, vec<4, float, Q> const& edge1, vec<4, float, Q> const& x) { vec<4, float, Q> Result; Result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data); return Result; } }; }//namespace detail }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/detail/compute_vector_relational.hpp0000600000175000001440000000074513173131001021500 0ustar guususers#pragma once #include "setup.hpp" #include #include namespace glm{ namespace detail { template ::is_iec559> struct compute_equal { GLM_FUNC_QUALIFIER static bool call(T a, T b) { return a == b; } }; template struct compute_equal { GLM_FUNC_QUALIFIER static bool call(T a, T b) { return std::memcmp(&a, &b, sizeof(T)) == 0; } }; }//namespace detail }//namespace glm glm-0.9.9-a2/glm/detail/type_mat3x2.hpp0000600000175000001440000001232413173131001016403 0ustar guususers/// @ref core /// @file glm/detail/type_mat3x2.hpp #pragma once #include "../fwd.hpp" #include "type_vec2.hpp" #include "type_vec3.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<3, 2, T, Q> { typedef vec<2, T, Q> col_type; typedef vec<3, T, Q> row_type; typedef mat<3, 2, T, Q> type; typedef mat<2, 3, T, Q> transpose_type; typedef T value_type; private: col_type value[3]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<3, 2, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<3, 2, T, P> const& m); GLM_FUNC_DECL explicit mat(T scalar); GLM_FUNC_DECL mat( T x0, T y0, T x1, T y1, T x2, T y2); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1, col_type const& v2); // -- Conversions -- template< typename X1, typename Y1, typename X2, typename Y2, typename X3, typename Y3> GLM_FUNC_DECL mat( X1 x1, Y1 y1, X2 x2, Y2 y2, X3 x3, Y3 y3); template GLM_FUNC_DECL mat( vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<3, 2, T, Q> & operator=(mat<3, 2, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<3, 2, T, Q> & operator=(mat<3, 2, U, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(mat<3, 2, U, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(mat<3, 2, U, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<3, 2, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<3, 2, T, Q> & operator++ (); GLM_FUNC_DECL mat<3, 2, T, Q> & operator-- (); GLM_FUNC_DECL mat<3, 2, T, Q> operator++(int); GLM_FUNC_DECL mat<3, 2, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m); template GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m); template GLM_FUNC_DECL typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m); template GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat3x2.inl" #endif glm-0.9.9-a2/glm/detail/type_vec3.inl0000600000175000001440000005650613173131001016132 0ustar guususers/// @ref core /// @file glm/detail/type_tvec3.inl namespace glm { // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<3, T, Q> const& v) : x(v.x), y(v.y), z(v.z) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<3, T, P> const& v) : x(v.x), y(v.y), z(v.z) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(T scalar) : x(scalar), y(scalar), z(scalar) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {} // -- Conversion scalar constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(X _x, Y _y, Z _z) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z) : x(static_cast(_x)) , y(static_cast(_y)) , z(static_cast(_z)) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, B _z) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(A _x, vec<2, B, P> const& _yz) : x(static_cast(_x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz) : x(static_cast(_x.x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<3, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) , z(static_cast(v.z)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) , z(static_cast(v.z)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER T & vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } template GLM_FUNC_QUALIFIER T const& vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i) const { assert(i >= 0 && i < this->length()); return (&x)[i]; } // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v) { this->x = v.x; this->y = v.y; this->z = v.z; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, U, Q> const& v) { this->x = static_cast(v.x); this->y = static_cast(v.y); this->z = static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator+=(U scalar) { this->x += static_cast(scalar); this->y += static_cast(scalar); this->z += static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<1, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.x); this->z += static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<3, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.y); this->z += static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator-=(U scalar) { this->x -= static_cast(scalar); this->y -= static_cast(scalar); this->z -= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<1, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.x); this->z -= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<3, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.y); this->z -= static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator*=(U scalar) { this->x *= static_cast(scalar); this->y *= static_cast(scalar); this->z *= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<1, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.x); this->z *= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<3, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.y); this->z *= static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator/=(U v) { this->x /= static_cast(v); this->y /= static_cast(v); this->z /= static_cast(v); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<1, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.x); this->z /= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<3, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.y); this->z /= static_cast(v.z); return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator++() { ++this->x; ++this->y; ++this->z; return *this; } template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator--() { --this->x; --this->y; --this->z; return *this; } template GLM_FUNC_QUALIFIER vec<3, T, Q> vec<3, T, Q>::operator++(int) { vec<3, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER vec<3, T, Q> vec<3, T, Q>::operator--(int) { vec<3, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator%=(U scalar) { this->x %= scalar; this->y %= scalar; this->z %= scalar; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<1, U, Q> const& v) { this->x %= v.x; this->y %= v.x; this->z %= v.x; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<3, U, Q> const& v) { this->x %= v.x; this->y %= v.y; this->z %= v.z; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator&=(U scalar) { this->x &= scalar; this->y &= scalar; this->z &= scalar; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<1, U, Q> const& v) { this->x &= v.x; this->y &= v.x; this->z &= v.x; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<3, U, Q> const& v) { this->x &= v.x; this->y &= v.y; this->z &= v.z; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator|=(U scalar) { this->x |= scalar; this->y |= scalar; this->z |= scalar; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<1, U, Q> const& v) { this->x |= v.x; this->y |= v.x; this->z |= v.x; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<3, U, Q> const& v) { this->x |= v.x; this->y |= v.y; this->z |= v.z; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator^=(U scalar) { this->x ^= scalar; this->y ^= scalar; this->z ^= scalar; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<1, U, Q> const& v) { this->x ^= v.x; this->y ^= v.x; this->z ^= v.x; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<3, U, Q> const& v) { this->x ^= v.x; this->y ^= v.y; this->z ^= v.z; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator<<=(U scalar) { this->x <<= scalar; this->y <<= scalar; this->z <<= scalar; return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<1, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.x); this->z <<= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<3, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.y); this->z <<= static_cast(v.z); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator>>=(U scalar) { this->x >>= static_cast(scalar); this->y >>= static_cast(scalar); this->z >>= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<1, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.x); this->z >>= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<3, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.y); this->z >>= static_cast(v.z); return *this; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER vec<3, T, Q> operator+(vec<3, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator-(vec<3, T, Q> const& v) { return vec<3, T, Q>( -v.x, -v.y, -v.z); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x + scalar, v.y + scalar, v.z + scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x + scalar.x, v.y + scalar.x, v.z + scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar + v.x, scalar + v.y, scalar + v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator+(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x + v.x, scalar.x + v.y, scalar.x + v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x - scalar, v.y - scalar, v.z - scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator-(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x - scalar.x, v.y - scalar.x, v.z - scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar - v.x, scalar - v.y, scalar - v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator-(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x - v.x, scalar.x - v.y, scalar.x - v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x * scalar, v.y * scalar, v.z * scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x * scalar.x, v.y * scalar.x, v.z * scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar * v.x, scalar * v.y, scalar * v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x * v.x, scalar.x * v.y, scalar.x * v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x / scalar, v.y / scalar, v.z / scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator/(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x / scalar.x, v.y / scalar.x, v.z / scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar / v.x, scalar / v.y, scalar / v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator/(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x / v.x, scalar.x / v.y, scalar.x / v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x / v2.x, v1.y / v2.y, v1.z / v2.z); } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x % scalar, v.y % scalar, v.z % scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator%(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x % scalar.x, v.y % scalar.x, v.z % scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar % v.x, scalar % v.y, scalar % v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator%(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x % v.x, scalar.x % v.y, scalar.x % v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x % v2.x, v1.y % v2.y, v1.z % v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator&(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x & scalar, v.y & scalar, v.z & scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator&(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x & scalar.x, v.y & scalar.x, v.z & scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar & v.x, scalar & v.y, scalar & v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator&(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x & v.x, scalar.x & v.y, scalar.x & v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x & v2.x, v1.y & v2.y, v1.z & v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x | scalar, v.y | scalar, v.z | scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator|(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x | scalar.x, v.y | scalar.x, v.z | scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar | v.x, scalar | v.y, scalar | v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator|(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x | v.x, scalar.x | v.y, scalar.x | v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x | v2.x, v1.y | v2.y, v1.z | v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x ^ scalar, v.y ^ scalar, v.z ^ scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator^(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x ^ scalar.x, v.y ^ scalar.x, v.z ^ scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar ^ v.x, scalar ^ v.y, scalar ^ v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator^(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x ^ v.x, scalar.x ^ v.y, scalar.x ^ v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x ^ v2.x, v1.y ^ v2.y, v1.z ^ v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x << scalar, v.y << scalar, v.z << scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator<<(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x << scalar.x, v.y << scalar.x, v.z << scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar << v.x, scalar << v.y, scalar << v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x << v.x, scalar.x << v.y, scalar.x << v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x << v2.x, v1.y << v2.y, v1.z << v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x >> scalar, v.y >> scalar, v.z >> scalar); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator>>(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x >> scalar.x, v.y >> scalar.x, v.z >> scalar.x); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar >> v.x, scalar >> v.y, scalar >> v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v) { return vec<3, T, Q>( scalar.x >> v.x, scalar.x >> v.y, scalar.x >> v.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return vec<3, T, Q>( v1.x >> v2.x, v1.y >> v2.y, v1.z >> v2.z); } template GLM_FUNC_QUALIFIER vec<3, T, Q> operator~(vec<3, T, Q> const& v) { return vec<3, T, Q>( ~v.x, ~v.y, ~v.z); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return detail::compute_equal::call(v1.x, v2.x) && detail::compute_equal::call(v1.y, v2.y) && detail::compute_equal::call(v1.z, v2.z); } template GLM_FUNC_QUALIFIER bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2) { return !(v1 == v2); } template GLM_FUNC_QUALIFIER vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2) { return vec<3, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z); } template GLM_FUNC_QUALIFIER vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2) { return vec<3, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z); } }//namespace glm glm-0.9.9-a2/glm/detail/type_mat4x2.inl0000600000175000001440000003367413173131001016412 0ustar guususers/// @ref core /// @file glm/detail/type_mat4x2.inl namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; this->value[3] = m.value[3]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<4, 2, T, P> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; this->value[2] = m.value[2]; this->value[3] = m.value[3]; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(T scalar) { this->value[0] = col_type(scalar, 0); this->value[1] = col_type(0, scalar); this->value[2] = col_type(0, 0); this->value[3] = col_type(0, 0); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat ( T x0, T y0, T x1, T y1, T x2, T y2, T x3, T y3 ) { this->value[0] = col_type(x0, y0); this->value[1] = col_type(x1, y1); this->value[2] = col_type(x2, y2); this->value[3] = col_type(x3, y3); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat ( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3 ) { this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; this->value[3] = v3; } // -- Conversion constructors -- template template< typename X1, typename Y1, typename X2, typename Y2, typename X3, typename Y3, typename X4, typename Y4> GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat ( X1 x1, Y1 y1, X2 x2, Y2 y2, X3 x3, Y3 y3, X4 x4, Y4 y4 ) { this->value[0] = col_type(static_cast(x1), value_type(y1)); this->value[1] = col_type(static_cast(x2), value_type(y2)); this->value[2] = col_type(static_cast(x3), value_type(y3)); this->value[3] = col_type(static_cast(x4), value_type(y4)); } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat ( vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3, vec<2, V4, Q> const& v4 ) { this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); this->value[3] = col_type(v4); } // -- Conversion -- template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<4, 2, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(0); this->value[3] = col_type(0); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(0); } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type & mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type const& mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>& mat<4, 2, T, Q>::operator=(mat<4, 2, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q>& mat<4, 2, T, Q>::operator=(mat<4, 2, U, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; this->value[3] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(mat<4, 2, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; this->value[3] += m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; this->value[3] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(mat<4, 2, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; this->value[3] -= m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; this->value[3] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; this->value[3] /= s; return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; ++this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; --this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator++(int) { mat<4, 2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator--(int) { mat<4, 2, T, Q> Result(*this); --*this; return Result; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m) { return mat<4, 2, T, Q>( -m[0], -m[1], -m[2], -m[3]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] + scalar, m[1] + scalar, m[2] + scalar, m[3] + scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] - scalar, m[1] - scalar, m[2] - scalar, m[3] - scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar, m[3] * scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m) { return mat<4, 2, T, Q>( m[0] * scalar, m[1] * scalar, m[2] * scalar, m[3] * scalar); } template GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v) { return typename mat<4, 2, T, Q>::col_type( m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w, m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w); } template GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m) { return typename mat<4, 2, T, Q>::row_type( v.x * m[0][0] + v.y * m[0][1], v.x * m[1][0] + v.y * m[1][1], v.x * m[2][0] + v.y * m[2][1], v.x * m[3][0] + v.y * m[3][1]); } template GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { T const SrcA00 = m1[0][0]; T const SrcA01 = m1[0][1]; T const SrcA10 = m1[1][0]; T const SrcA11 = m1[1][1]; T const SrcA20 = m1[2][0]; T const SrcA21 = m1[2][1]; T const SrcA30 = m1[3][0]; T const SrcA31 = m1[3][1]; T const SrcB00 = m2[0][0]; T const SrcB01 = m2[0][1]; T const SrcB02 = m2[0][2]; T const SrcB03 = m2[0][3]; T const SrcB10 = m2[1][0]; T const SrcB11 = m2[1][1]; T const SrcB12 = m2[1][2]; T const SrcB13 = m2[1][3]; mat<2, 2, T, Q> Result; Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03; Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03; Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13; Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13; return Result; } template GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 2, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3], m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3], m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar) { return mat<4, 2, T, Q>( m[0] / scalar, m[1] / scalar, m[2] / scalar, m[3] / scalar); } template GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m) { return mat<4, 2, T, Q>( scalar / m[0], scalar / m[1], scalar / m[2], scalar / m[3]); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); } } //namespace glm glm-0.9.9-a2/glm/detail/type_int.hpp0000600000175000001440000002153013173131001016056 0ustar guususers/// @ref core /// @file glm/detail/type_int.hpp #pragma once #include "setup.hpp" #if GLM_HAS_MAKE_SIGNED # include #endif #if GLM_HAS_EXTENDED_INTEGER_TYPE # include #endif namespace glm{ namespace detail { # if GLM_HAS_EXTENDED_INTEGER_TYPE typedef std::int8_t int8; typedef std::int16_t int16; typedef std::int32_t int32; typedef std::int64_t int64; typedef std::uint8_t uint8; typedef std::uint16_t uint16; typedef std::uint32_t uint32; typedef std::uint64_t uint64; # else # if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available typedef int64_t sint64; typedef uint64_t uint64; # elif GLM_COMPILER & GLM_COMPILER_VC typedef signed __int64 sint64; typedef unsigned __int64 uint64; # elif GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic ignored "-Wlong-long" __extension__ typedef signed long long sint64; __extension__ typedef unsigned long long uint64; # elif (GLM_COMPILER & GLM_COMPILER_CLANG) # pragma clang diagnostic ignored "-Wc++11-long-long" typedef signed long long sint64; typedef unsigned long long uint64; # else//unknown compiler typedef signed long long sint64; typedef unsigned long long uint64; # endif//GLM_COMPILER typedef signed char int8; typedef signed short int16; typedef signed int int32; typedef sint64 int64; typedef unsigned char uint8; typedef unsigned short uint16; typedef unsigned int uint32; typedef uint64 uint64; #endif// typedef signed int lowp_int_t; typedef signed int mediump_int_t; typedef signed int highp_int_t; typedef unsigned int lowp_uint_t; typedef unsigned int mediump_uint_t; typedef unsigned int highp_uint_t; # if GLM_HAS_MAKE_SIGNED using std::make_signed; using std::make_unsigned; # else//GLM_HAS_MAKE_SIGNED template struct make_signed {}; template<> struct make_signed { typedef char type; }; template<> struct make_signed { typedef short type; }; template<> struct make_signed { typedef int type; }; template<> struct make_signed { typedef long type; }; template<> struct make_signed { typedef char type; }; template<> struct make_signed { typedef short type; }; template<> struct make_signed { typedef int type; }; template<> struct make_signed { typedef long type; }; template struct make_unsigned {}; template<> struct make_unsigned { typedef unsigned char type; }; template<> struct make_unsigned { typedef unsigned short type; }; template<> struct make_unsigned { typedef unsigned int type; }; template<> struct make_unsigned { typedef unsigned long type; }; template<> struct make_unsigned { typedef unsigned char type; }; template<> struct make_unsigned { typedef unsigned short type; }; template<> struct make_unsigned { typedef unsigned int type; }; template<> struct make_unsigned { typedef unsigned long type; }; template<> struct make_signed { typedef long long type; }; template<> struct make_signed { typedef long long type; }; template<> struct make_unsigned { typedef unsigned long long type; }; template<> struct make_unsigned { typedef unsigned long long type; }; # endif//GLM_HAS_MAKE_SIGNED }//namespace detail typedef detail::int8 int8; typedef detail::int16 int16; typedef detail::int32 int32; typedef detail::int64 int64; typedef detail::uint8 uint8; typedef detail::uint16 uint16; typedef detail::uint32 uint32; typedef detail::uint64 uint64; /// @addtogroup core_precision /// @{ /// Low qualifier signed integer. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::lowp_int_t lowp_int; /// Medium qualifier signed integer. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::mediump_int_t mediump_int; /// High qualifier signed integer. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::highp_int_t highp_int; /// Low qualifier unsigned integer. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::lowp_uint_t lowp_uint; /// Medium qualifier unsigned integer. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::mediump_uint_t mediump_uint; /// High qualifier unsigned integer. /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::highp_uint_t highp_uint; #if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT)) typedef mediump_int int_t; #elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT)) typedef highp_int int_t; #elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT)) typedef mediump_int int_t; #elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT)) typedef lowp_int int_t; #else # error "GLM error: multiple default precision requested for signed integer types" #endif #if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT)) typedef mediump_uint uint_t; #elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT)) typedef highp_uint uint_t; #elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT)) typedef mediump_uint uint_t; #elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT)) typedef lowp_uint uint_t; #else # error "GLM error: multiple default precision requested for unsigned integer types" #endif /// Unsigned integer type. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers typedef unsigned int uint; /// @} //////////////////// // check type sizes #ifndef GLM_STATIC_ASSERT_NULL GLM_STATIC_ASSERT(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform"); GLM_STATIC_ASSERT(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform"); GLM_STATIC_ASSERT(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform"); GLM_STATIC_ASSERT(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform"); GLM_STATIC_ASSERT(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform"); GLM_STATIC_ASSERT(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform"); GLM_STATIC_ASSERT(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform"); GLM_STATIC_ASSERT(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform"); #endif//GLM_STATIC_ASSERT_NULL }//namespace glm glm-0.9.9-a2/glm/detail/type_vec2.hpp0000600000175000001440000003201313173131001016121 0ustar guususers/// @ref core /// @file glm/detail/type_vec2.hpp #pragma once #include "type_vec.hpp" #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED # if GLM_HAS_UNRESTRICTED_UNIONS # include "_swizzle.hpp" # else # include "_swizzle_func.hpp" # endif #endif //GLM_SWIZZLE #include namespace glm { template struct vec<2, T, Q> { // -- Implementation detail -- typedef T value_type; typedef vec type; typedef vec<2, bool, Q> bool_type; // -- Data -- # if GLM_HAS_ONLY_XYZW T x, y; # elif GLM_HAS_ALIGNED_TYPE # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" # endif # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wgnu-anonymous-struct" # pragma clang diagnostic ignored "-Wnested-anon-types" # endif union { struct{ T x, y; }; struct{ T r, g; }; struct{ T s, t; }; # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED GLM_SWIZZLE2_2_MEMBERS(T, Q, x, y) GLM_SWIZZLE2_2_MEMBERS(T, Q, r, g) GLM_SWIZZLE2_2_MEMBERS(T, Q, s, t) GLM_SWIZZLE2_3_MEMBERS(T, Q, x, y) GLM_SWIZZLE2_3_MEMBERS(T, Q, r, g) GLM_SWIZZLE2_3_MEMBERS(T, Q, s, t) GLM_SWIZZLE2_4_MEMBERS(T, Q, x, y) GLM_SWIZZLE2_4_MEMBERS(T, Q, r, g) GLM_SWIZZLE2_4_MEMBERS(T, Q, s, t) # endif//GLM_SWIZZLE }; # if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop # endif # if GLM_COMPILER & GLM_COMPILER_GCC # pragma GCC diagnostic pop # endif # else union {T x, r, s;}; union {T y, g, t;}; # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P) # endif//GLM_SWIZZLE # endif // -- Component accesses -- /// Return the count of components of the vector typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;} GLM_FUNC_DECL T& operator[](length_type i); GLM_FUNC_DECL T const& operator[](length_type i) const; // -- Implicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, T, P> const& v); // -- Explicit basic constructors -- GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(T x, T y); // -- Conversion constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A x, B y); template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& x, vec<1, B, Q> const& y); // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, P> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<2, U, P> const& v); // -- Swizzle constructors -- # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) template GLM_FUNC_DECL vec(detail::_swizzle<2, T, Q, E0, E1,-1,-2> const& that) { *this = that(); } # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) // -- Unary arithmetic operators -- GLM_FUNC_DECL vec& operator=(vec const& v) GLM_DEFAULT; template GLM_FUNC_DECL vec& operator=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec& operator+=(U scalar); template GLM_FUNC_DECL vec& operator+=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec& operator+=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec& operator-=(U scalar); template GLM_FUNC_DECL vec& operator-=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec& operator-=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec& operator*=(U scalar); template GLM_FUNC_DECL vec& operator*=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec& operator*=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec& operator/=(U scalar); template GLM_FUNC_DECL vec& operator/=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec& operator/=(vec<2, U, Q> const& v); // -- Increment and decrement operators -- GLM_FUNC_DECL vec & operator++(); GLM_FUNC_DECL vec & operator--(); GLM_FUNC_DECL vec operator++(int); GLM_FUNC_DECL vec operator--(int); // -- Unary bit operators -- template GLM_FUNC_DECL vec & operator%=(U scalar); template GLM_FUNC_DECL vec & operator%=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator%=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec & operator&=(U scalar); template GLM_FUNC_DECL vec & operator&=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator&=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec & operator|=(U scalar); template GLM_FUNC_DECL vec & operator|=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator|=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec & operator^=(U scalar); template GLM_FUNC_DECL vec & operator^=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator^=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec & operator<<=(U scalar); template GLM_FUNC_DECL vec & operator<<=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator<<=(vec<2, U, Q> const& v); template GLM_FUNC_DECL vec & operator>>=(U scalar); template GLM_FUNC_DECL vec & operator>>=(vec<1, U, Q> const& v); template GLM_FUNC_DECL vec & operator>>=(vec<2, U, Q> const& v); }; // -- Unary operators -- template GLM_FUNC_DECL vec<2, T, Q> operator+(vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator-(vec<2, T, Q> const& v); // -- Binary operators -- template GLM_FUNC_DECL vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar); template GLM_FUNC_DECL vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v); template GLM_FUNC_DECL vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, T, Q> operator~(vec<2, T, Q> const& v); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2); template GLM_FUNC_DECL vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2); template GLM_FUNC_DECL vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_vec2.inl" #endif//GLM_EXTERNAL_TEMPLATE glm-0.9.9-a2/glm/detail/type_mat4x4_simd.inl0000600000175000001440000000013313173131001017410 0ustar guususers/// @ref core /// @file glm/detail/type_mat4x4_sse2.inl namespace glm { }//namespace glm glm-0.9.9-a2/glm/detail/type_mat4x4.inl0000600000175000001440000005451713173131001016413 0ustar guususers/// @ref core /// @file glm/detail/type_mat4x4.inl #include "../matrix.hpp" namespace glm { // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<4, 4, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<4, 4, T, P> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(T const& s) { this->value[0] = col_type(s, 0, 0, 0); this->value[1] = col_type(0, s, 0, 0); this->value[2] = col_type(0, 0, s, 0); this->value[3] = col_type(0, 0, 0, s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat ( T const& x0, T const& y0, T const& z0, T const& w0, T const& x1, T const& y1, T const& z1, T const& w1, T const& x2, T const& y2, T const& z2, T const& w2, T const& x3, T const& y3, T const& z3, T const& w3 ) { this->value[0] = col_type(x0, y0, z0, w0); this->value[1] = col_type(x1, y1, z1, w1); this->value[2] = col_type(x2, y2, z2, w2); this->value[3] = col_type(x3, y3, z3, w3); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat ( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3 ) { this->value[0] = v0; this->value[1] = v1; this->value[2] = v2; this->value[3] = v3; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<4, 4, U, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); this->value[2] = col_type(m[2]); this->value[3] = col_type(m[3]); } // -- Conversions -- template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, typename X3, typename Y3, typename Z3, typename W3, typename X4, typename Y4, typename Z4, typename W4> GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat ( X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1, X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2, X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3, X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4 ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid."); this->value[0] = col_type(static_cast(x1), value_type(y1), value_type(z1), value_type(w1)); this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2), value_type(w2)); this->value[2] = col_type(static_cast(x3), value_type(y3), value_type(z3), value_type(w3)); this->value[3] = col_type(static_cast(x4), value_type(y4), value_type(z4), value_type(w4)); } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat ( vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4 ) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); this->value[0] = col_type(v1); this->value[1] = col_type(v2); this->value[2] = col_type(v3); this->value[3] = col_type(v4); } // -- Matrix conversions -- template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<3, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); this->value[3] = col_type(0, 0, 0, 1); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<2, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<3, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(m[2], 1, 0); this->value[3] = col_type(0, 0, 0, 1); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<2, 4, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<4, 2, T, Q> const& m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); this->value[2] = col_type(0, 0, 1, 0); this->value[3] = col_type(0, 0, 0, 1); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<3, 4, T, Q> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = col_type(0, 0, 0, 1); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>::mat(mat<4, 3, T, Q> const& m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); this->value[2] = col_type(m[2], 0); this->value[3] = col_type(m[3], 1); } // -- Accesses -- template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type & mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) { assert(i < this->length()); return this->value[i]; } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type const& mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) const { assert(i < this->length()); return this->value[i]; } // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator=(mat<4, 4, T, Q> const& m) { //memcpy could be faster //memcpy(&this->value, &m.value, 16 * sizeof(valType)); this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator=(mat<4, 4, U, Q> const& m) { //memcpy could be faster //memcpy(&this->value, &m.value, 16 * sizeof(valType)); this->value[0] = m[0]; this->value[1] = m[1]; this->value[2] = m[2]; this->value[3] = m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(U s) { this->value[0] += s; this->value[1] += s; this->value[2] += s; this->value[3] += s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(mat<4, 4, U, Q> const& m) { this->value[0] += m[0]; this->value[1] += m[1]; this->value[2] += m[2]; this->value[3] += m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(U s) { this->value[0] -= s; this->value[1] -= s; this->value[2] -= s; this->value[3] -= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(mat<4, 4, U, Q> const& m) { this->value[0] -= m[0]; this->value[1] -= m[1]; this->value[2] -= m[2]; this->value[3] -= m[3]; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(U s) { this->value[0] *= s; this->value[1] *= s; this->value[2] *= s; this->value[3] *= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(mat<4, 4, U, Q> const& m) { return (*this = *this * m); } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(U s) { this->value[0] /= s; this->value[1] /= s; this->value[2] /= s; this->value[3] /= s; return *this; } template template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(mat<4, 4, U, Q> const& m) { return *this *= inverse(m); } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator++() { ++this->value[0]; ++this->value[1]; ++this->value[2]; ++this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator--() { --this->value[0]; --this->value[1]; --this->value[2]; --this->value[3]; return *this; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator++(int) { mat<4, 4, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator--(int) { mat<4, 4, T, Q> Result(*this); --*this; return Result; } // -- Unary constant operators -- template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m) { return m; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( -m[0], -m[1], -m[2], -m[3]); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s) { return mat<4, 4, T, Q>( m[0] + s, m[1] + s, m[2] + s, m[3] + s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( m[0] + s, m[1] + s, m[2] + s, m[3] + s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 4, T, Q>( m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s) { return mat<4, 4, T, Q>( m[0] - s, m[1] - s, m[2] - s, m[3] - s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( s - m[0], s - m[1], s - m[2], s - m[3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return mat<4, 4, T, Q>( m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const & s) { return mat<4, 4, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( m[0] * s, m[1] * s, m[2] * s, m[3] * s); } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator* ( mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v ) { /* __m128 v0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(0, 0, 0, 0)); __m128 v1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(1, 1, 1, 1)); __m128 v2 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(2, 2, 2, 2)); __m128 v3 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 3, 3, 3)); __m128 m0 = _mm_mul_ps(m[0].data, v0); __m128 m1 = _mm_mul_ps(m[1].data, v1); __m128 a0 = _mm_add_ps(m0, m1); __m128 m2 = _mm_mul_ps(m[2].data, v2); __m128 m3 = _mm_mul_ps(m[3].data, v3); __m128 a1 = _mm_add_ps(m2, m3); __m128 a2 = _mm_add_ps(a0, a1); return typename mat<4, 4, T, Q>::col_type(a2); */ typename mat<4, 4, T, Q>::col_type const Mov0(v[0]); typename mat<4, 4, T, Q>::col_type const Mov1(v[1]); typename mat<4, 4, T, Q>::col_type const Mul0 = m[0] * Mov0; typename mat<4, 4, T, Q>::col_type const Mul1 = m[1] * Mov1; typename mat<4, 4, T, Q>::col_type const Add0 = Mul0 + Mul1; typename mat<4, 4, T, Q>::col_type const Mov2(v[2]); typename mat<4, 4, T, Q>::col_type const Mov3(v[3]); typename mat<4, 4, T, Q>::col_type const Mul2 = m[2] * Mov2; typename mat<4, 4, T, Q>::col_type const Mul3 = m[3] * Mov3; typename mat<4, 4, T, Q>::col_type const Add1 = Mul2 + Mul3; typename mat<4, 4, T, Q>::col_type const Add2 = Add0 + Add1; return Add2; /* return typename mat<4, 4, T, Q>::col_type( m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0] * v[3], m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1] * v[3], m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2] * v[3], m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3] * v[3]); */ } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator* ( typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m ) { return typename mat<4, 4, T, Q>::row_type( m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3], m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3], m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3], m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]); } template GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2) { return mat<2, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]); } template GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2) { return mat<3, 4, T, Q>( m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3], m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3], m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3], m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3], m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3], m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3], m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3], m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3], m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3], m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3], m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3], m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { typename mat<4, 4, T, Q>::col_type const SrcA0 = m1[0]; typename mat<4, 4, T, Q>::col_type const SrcA1 = m1[1]; typename mat<4, 4, T, Q>::col_type const SrcA2 = m1[2]; typename mat<4, 4, T, Q>::col_type const SrcA3 = m1[3]; typename mat<4, 4, T, Q>::col_type const SrcB0 = m2[0]; typename mat<4, 4, T, Q>::col_type const SrcB1 = m2[1]; typename mat<4, 4, T, Q>::col_type const SrcB2 = m2[2]; typename mat<4, 4, T, Q>::col_type const SrcB3 = m2[3]; mat<4, 4, T, Q> Result; Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3]; Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3]; Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3]; Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3]; return Result; } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s) { return mat<4, 4, T, Q>( m[0] / s, m[1] / s, m[2] / s, m[3] / s); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m) { return mat<4, 4, T, Q>( s / m[0], s / m[1], s / m[2], s / m[3]); } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v) { return inverse(m) * v; } template GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m) { return v * inverse(m); } template GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { mat<4, 4, T, Q> m1_copy(m1); return m1_copy /= m2; } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE # include "type_mat4x4_simd.inl" #endif glm-0.9.9-a2/glm/detail/func_integer_simd.inl0000600000175000001440000000326013173131001017702 0ustar guususers/// @ref core /// @file glm/detail/func_integer_simd.inl #include "../simd/integer.h" #if GLM_ARCH & GLM_ARCH_SSE2_BIT namespace glm{ namespace detail { template struct compute_bitfieldReverseStep<4, uint32, Q, true, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift) { __m128i const set0 = v.data; __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); __m128i const and1 = _mm_and_si128(set0, set1); __m128i const sft1 = _mm_slli_epi32(and1, Shift); __m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1)); __m128i const and2 = _mm_and_si128(set0, set2); __m128i const sft2 = _mm_srai_epi32(and2, Shift); __m128i const or0 = _mm_or_si128(sft1, sft2); return or0; } }; template struct compute_bitfieldBitCountStep<4, uint32, Q, true, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift) { __m128i const set0 = v.data; __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); __m128i const and0 = _mm_and_si128(set0, set1); __m128i const sft0 = _mm_slli_epi32(set0, Shift); __m128i const and1 = _mm_and_si128(sft0, set1); __m128i const add0 = _mm_add_epi32(and0, and1); return add0; } }; }//namespace detail # if GLM_ARCH & GLM_ARCH_AVX_BIT template<> GLM_FUNC_QUALIFIER int bitCount(uint32 x) { return _mm_popcnt_u32(x); } # if(GLM_MODEL == GLM_MODEL_64) template<> GLM_FUNC_QUALIFIER int bitCount(uint64 x) { return static_cast(_mm_popcnt_u64(x)); } # endif//GLM_MODEL # endif//GLM_ARCH }//namespace glm #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT glm-0.9.9-a2/glm/detail/func_vector_relational.inl0000600000175000001440000000526113173131001020750 0ustar guususers/// @ref core /// @file glm/detail/func_vector_relational.inl #include "compute_vector_relational.hpp" namespace glm { template GLM_FUNC_QUALIFIER vec lessThan(vec const& x, vec const& y) { assert(x.length() == y.length()); vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] < y[i]; return Result; } template GLM_FUNC_QUALIFIER vec lessThanEqual(vec const& x, vec const& y) { assert(x.length() == y.length()); vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] <= y[i]; return Result; } template GLM_FUNC_QUALIFIER vec greaterThan(vec const& x, vec const& y) { assert(x.length() == y.length()); vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] > y[i]; return Result; } template GLM_FUNC_QUALIFIER vec greaterThanEqual(vec const& x, vec const& y) { assert(x.length() == y.length()); vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = x[i] >= y[i]; return Result; } template GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y) { assert(x.length() == y.length()); vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = detail::compute_equal::call(x[i], y[i]); return Result; } template GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y) { assert(x.length() == y.length()); vec Result; for(length_t i = 0; i < x.length(); ++i) Result[i] = !detail::compute_equal::call(x[i], y[i]); return Result; } template GLM_FUNC_QUALIFIER bool any(vec const& v) { bool Result = false; for(length_t i = 0; i < v.length(); ++i) Result = Result || v[i]; return Result; } template GLM_FUNC_QUALIFIER bool all(vec const& v) { bool Result = true; for(length_t i = 0; i < v.length(); ++i) Result = Result && v[i]; return Result; } template GLM_FUNC_QUALIFIER vec not_(vec const& v) { vec Result; for(length_t i = 0; i < v.length(); ++i) Result[i] = !v[i]; return Result; } }//namespace glm #if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS # include "func_vector_relational_simd.inl" #endif glm-0.9.9-a2/glm/detail/qualifier.hpp0000600000175000001440000000442613173131001016211 0ustar guususers/// @ref core /// @file glm/detail/qualifier.hpp #pragma once #include "setup.hpp" namespace glm { /// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp) enum qualifier { packed_highp, ///< Typed data is tightly packed in memory and operations are executed with high precision in term of ULPs packed_mediump, ///< Typed data is tightly packed in memory and operations are executed with medium precision in term of ULPs for higher performance packed_lowp, ///< Typed data is tightly packed in memory and operations are executed with low precision in term of ULPs to maximize performance # if GLM_HAS_ALIGNED_TYPE aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance aligned = aligned_highp, ///< By default aligned qualifier is also high precision # endif highp = packed_highp, ///< By default highp qualifier is also packed mediump = packed_mediump, ///< By default mediump qualifier is also packed lowp = packed_lowp, ///< By default lowp qualifier is also packed packed = packed_highp, ///< By default packed qualifier is also high precision # if GLM_HAS_ALIGNED_TYPE && defined(GLM_FORCE_ALIGNED) defaultp = aligned_highp # else defaultp = highp # endif }; template struct vec; template struct mat; namespace detail { template struct is_aligned { static const bool value = false; }; # if GLM_HAS_ALIGNED_TYPE template<> struct is_aligned { static const bool value = true; }; template<> struct is_aligned { static const bool value = true; }; template<> struct is_aligned { static const bool value = true; }; # endif }//namespace detail }//namespace glm glm-0.9.9-a2/glm/detail/type_mat2x4.hpp0000600000175000001440000001227213173131001016406 0ustar guususers/// @ref core /// @file glm/detail/type_mat2x4.hpp #pragma once #include "../fwd.hpp" #include "type_vec2.hpp" #include "type_vec4.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<2, 4, T, Q> { typedef vec<4, T, Q> col_type; typedef vec<2, T, Q> row_type; typedef mat<2, 4, T, Q> type; typedef mat<4, 2, T, Q> transpose_type; typedef T value_type; private: col_type value[2]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<2, 4, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<2, 4, T, P> const& m); GLM_FUNC_DECL explicit mat(T scalar); GLM_FUNC_DECL mat( T x0, T y0, T z0, T w0, T x1, T y1, T z1, T w1); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2> GLM_FUNC_DECL mat( X1 x1, Y1 y1, Z1 z1, W1 w1, X2 x2, Y2 y2, Z2 z2, W2 w2); template GLM_FUNC_DECL mat( vec<4, U, Q> const& v1, vec<4, V, Q> const& v2); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<2, 4, T, Q> & operator=(mat<2, 4, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<2, 4, T, Q> & operator=(mat<2, 4, U, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(mat<2, 4, U, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(mat<2, 4, U, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<2, 4, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<2, 4, T, Q> & operator++ (); GLM_FUNC_DECL mat<2, 4, T, Q> & operator-- (); GLM_FUNC_DECL mat<2, 4, T, Q> operator++(int); GLM_FUNC_DECL mat<2, 4, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m); template GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m); template GLM_FUNC_DECL typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m); template GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2); template GLM_FUNC_DECL mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar); template GLM_FUNC_DECL mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat2x4.inl" #endif glm-0.9.9-a2/glm/detail/_swizzle_func.hpp0000600000175000001440000010312713173131001017107 0ustar guususers/// @ref core /// @file glm/detail/_swizzle_func.hpp #pragma once #define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B) \ vec<2, T, Q> A ## B() CONST \ { \ return vec<2, T, Q>(this->A, this->B); \ } #define GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, CONST, A, B, C) \ vec<3, T, Q> A ## B ## C() CONST \ { \ return vec<3, T, Q>(this->A, this->B, this->C); \ } #define GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, CONST, A, B, C, D) \ vec<4, T, Q> A ## B ## C ## D() CONST \ { \ return vec<4, T, Q>(this->A, this->B, this->C, this->D); \ } #define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(T, P, L, CONST, A, B) \ template \ vec vec::A ## B() CONST \ { \ return vec<2, T, Q>(this->A, this->B); \ } #define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(T, P, L, CONST, A, B, C) \ template \ vec<3, T, Q> vec::A ## B ## C() CONST \ { \ return vec<3, T, Q>(this->A, this->B, this->C); \ } #define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(T, P, L, CONST, A, B, C, D) \ template \ vec<4, T, Q> vec::A ## B ## C ## D() CONST \ { \ return vec<4, T, Q>(this->A, this->B, this->C, this->D); \ } #define GLM_MUTABLE #define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, B, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC2(T, P) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, x, y) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, r, g) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, s, t) #define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) #define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, B, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, A, B, C) \ GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) #define GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, x, y, z) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, r, g, b) \ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, s, t, p) #define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, C) #define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, B) #define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, C, A) #define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) #define GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, x, y, z, w) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, r, g, b, a) \ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, s, t, p, q) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, x, y) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, r, g) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, s, t) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, x, y, z) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, r, g, b) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, s, t, p) #define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, D) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, A) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, B) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, C) \ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, D) #define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, D) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, A) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, B) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, C) \ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, D) #define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, D) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, A) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, B) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, C) \ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, D) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \ GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) #define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, x, y, z, w) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, r, g, b, a) \ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, s, t, p, q) glm-0.9.9-a2/glm/detail/type_mat4x3.hpp0000600000175000001440000001320213173131001016401 0ustar guususers/// @ref core /// @file glm/detail/type_mat4x3.hpp #pragma once #include "../fwd.hpp" #include "type_vec3.hpp" #include "type_vec4.hpp" #include "type_mat.hpp" #include #include namespace glm { template struct mat<4, 3, T, Q> { typedef vec<3, T, Q> col_type; typedef vec<4, T, Q> row_type; typedef mat<4, 3, T, Q> type; typedef mat<3, 4, T, Q> transpose_type; typedef T value_type; private: col_type value[4]; public: // -- Accesses -- typedef length_t length_type; GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; } GLM_FUNC_DECL col_type & operator[](length_type i); GLM_FUNC_DECL col_type const& operator[](length_type i) const; // -- Constructors -- GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<4, 3, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat(mat<4, 3, T, P> const& m); GLM_FUNC_DECL explicit mat(T const& x); GLM_FUNC_DECL mat( T const& x0, T const& y0, T const& z0, T const& x1, T const& y1, T const& z1, T const& x2, T const& y2, T const& z2, T const& x3, T const& y3, T const& z3); GLM_FUNC_DECL mat( col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3); // -- Conversions -- template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, typename X3, typename Y3, typename Z3, typename X4, typename Y4, typename Z4> GLM_FUNC_DECL mat( X1 const& x1, Y1 const& y1, Z1 const& z1, X2 const& x2, Y2 const& y2, Z2 const& z2, X3 const& x3, Y3 const& y3, Z3 const& z3, X4 const& x4, Y4 const& y4, Z4 const& z4); template GLM_FUNC_DECL mat( vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4); // -- Matrix conversions -- template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, U, P> const& m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, Q> const& x); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, Q> const& x); // -- Unary arithmetic operators -- GLM_FUNC_DECL mat<4, 3, T, Q> & operator=(mat<4, 3, T, Q> const& m) GLM_DEFAULT; template GLM_FUNC_DECL mat<4, 3, T, Q> & operator=(mat<4, 3, U, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(U s); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(mat<4, 3, U, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(U s); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(mat<4, 3, U, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator*=(U s); template GLM_FUNC_DECL mat<4, 3, T, Q> & operator/=(U s); // -- Increment and decrement operators -- GLM_FUNC_DECL mat<4, 3, T, Q>& operator++(); GLM_FUNC_DECL mat<4, 3, T, Q>& operator--(); GLM_FUNC_DECL mat<4, 3, T, Q> operator++(int); GLM_FUNC_DECL mat<4, 3, T, Q> operator--(int); }; // -- Unary operators -- template GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m); template GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m); // -- Binary operators -- template GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m); template GLM_FUNC_DECL typename mat<4, 3, T, Q>::col_type operator*(mat<4, 3, T, Q> const& m, typename mat<4, 3, T, Q>::row_type const& v); template GLM_FUNC_DECL typename mat<4, 3, T, Q>::row_type operator*(typename mat<4, 3, T, Q>::col_type const& v, mat<4, 3, T, Q> const& m); template GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2); template GLM_FUNC_DECL mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s); template GLM_FUNC_DECL mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m); // -- Boolean operators -- template GLM_FUNC_DECL bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); template GLM_FUNC_DECL bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2); }//namespace glm #ifndef GLM_EXTERNAL_TEMPLATE #include "type_mat4x3.inl" #endif //GLM_EXTERNAL_TEMPLATE glm-0.9.9-a2/glm/detail/type_vec1.inl0000600000175000001440000003155013173131001016120 0ustar guususers/// @ref core /// @file glm/detail/type_vec1.inl namespace glm { // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec(vec<1, T, Q> const& v) : x(v.x) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec(vec<1, T, P> const& v) : x(v.x) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec(T scalar) : x(scalar) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec(vec<1, U, P> const& v) : x(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec(vec<2, U, P> const& v) : x(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec(vec<3, U, P> const& v) : x(static_cast(v.x)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER T & vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } template GLM_FUNC_QUALIFIER T const& vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type i) const { assert(i >= 0 && i < this->length()); return (&x)[i]; } // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v) { this->x = v.x; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, U, Q> const& v) { this->x = static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator+=(U scalar) { this->x += static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator+=(vec<1, U, Q> const& v) { this->x += static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator-=(U scalar) { this->x -= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator-=(vec<1, U, Q> const& v) { this->x -= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator*=(U scalar) { this->x *= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator*=(vec<1, U, Q> const& v) { this->x *= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator/=(U scalar) { this->x /= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator/=(vec<1, U, Q> const& v) { this->x /= static_cast(v.x); return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator++() { ++this->x; return *this; } template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator--() { --this->x; return *this; } template GLM_FUNC_QUALIFIER vec<1, T, Q> vec<1, T, Q>::operator++(int) { vec<1, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER vec<1, T, Q> vec<1, T, Q>::operator--(int) { vec<1, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator%=(U scalar) { this->x %= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator%=(vec<1, U, Q> const& v) { this->x %= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator&=(U scalar) { this->x &= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator&=(vec<1, U, Q> const& v) { this->x &= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator|=(U scalar) { this->x |= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator|=(vec<1, U, Q> const& v) { this->x |= U(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator^=(U scalar) { this->x ^= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator^=(vec<1, U, Q> const& v) { this->x ^= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator<<=(U scalar) { this->x <<= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator<<=(vec<1, U, Q> const& v) { this->x <<= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator>>=(U scalar) { this->x >>= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator>>=(vec<1, U, Q> const& v) { this->x >>= static_cast(v.x); return *this; } // -- Unary constant operators -- template GLM_FUNC_QUALIFIER vec<1, T, Q> operator+(vec<1, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator-(vec<1, T, Q> const& v) { return vec<1, T, Q>( -v.x); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x + scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar + v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x + v2.x); } //operator- template GLM_FUNC_QUALIFIER vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x - scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar - v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x - v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x * scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar * v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x * v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x / scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar / v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x / v2.x); } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x % scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar % v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x % v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x & scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar & v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x & v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x | scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar | v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x | v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x ^ scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar ^ v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x ^ v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( static_cast(v.x << scalar)); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar << v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x << v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar) { return vec<1, T, Q>( v.x >> scalar); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v) { return vec<1, T, Q>( scalar >> v.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<1, T, Q>( v1.x >> v2.x); } template GLM_FUNC_QUALIFIER vec<1, T, Q> operator~(vec<1, T, Q> const& v) { return vec<1, T, Q>( ~v.x); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return detail::compute_equal::call(v1.x, v2.x); } template GLM_FUNC_QUALIFIER bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2) { return !(v1 == v2); } template GLM_FUNC_QUALIFIER vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2) { return vec<1, bool, Q>(v1.x && v2.x); } template GLM_FUNC_QUALIFIER vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2) { return vec<1, bool, Q>(v1.x || v2.x); } }//namespace glm glm-0.9.9-a2/glm/detail/dummy.cpp0000600000175000001440000001143013173131001015347 0ustar guususers/// @ref core /// @file glm/core/dummy.cpp /// /// GLM is a header only library. There is nothing to compile. /// dummy.cpp exist only a wordaround for CMake file. /* #define GLM_MESSAGES #include #include #include struct material { glm::vec4 emission; // Ecm glm::vec4 ambient; // Acm glm::vec4 diffuse; // Dcm glm::vec4 specular; // Scm float shininess; // Srm }; struct light { glm::vec4 ambient; // Acli glm::vec4 diffuse; // Dcli glm::vec4 specular; // Scli glm::vec4 position; // Ppli glm::vec4 halfVector; // Derived: Hi glm::vec3 spotDirection; // Sdli float spotExponent; // Srli float spotCutoff; // Crli // (range: [0.0,90.0], 180.0) float spotCosCutoff; // Derived: cos(Crli) // (range: [1.0,0.0],-1.0) float constantAttenuation; // K0 float linearAttenuation; // K1 float quadraticAttenuation;// K2 }; // Sample 1 #include // glm::vec3 #include // glm::cross, glm::normalize glm::vec3 computeNormal ( glm::vec3 const& a, glm::vec3 const& b, glm::vec3 const& c ) { return glm::normalize(glm::cross(c - a, b - a)); } typedef unsigned int GLuint; #define GL_FALSE 0 void glUniformMatrix4fv(GLuint, int, int, float*){} // Sample 2 #include // glm::vec3 #include // glm::vec4, glm::ivec4 #include // glm::mat4 #include // glm::translate, glm::rotate, glm::scale, glm::perspective #include // glm::value_ptr void func(GLuint LocationMVP, float Translate, glm::vec2 const& Rotate) { glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f)); glm::mat4 View = glm::rotate(ViewRotateX, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f)); glm::mat4 MVP = Projection * View * Model; glUniformMatrix4fv(LocationMVP, 1, GL_FALSE, glm::value_ptr(MVP)); } // Sample 3 #include // glm::vec2 #include // glm::packUnorm2x16 #include // glm::uint #include // glm::i8vec2, glm::i32vec2 std::size_t const VertexCount = 4; // Float quad geometry std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2); glm::vec2 const PositionDataF32[VertexCount] = { glm::vec2(-1.0f,-1.0f), glm::vec2( 1.0f,-1.0f), glm::vec2( 1.0f, 1.0f), glm::vec2(-1.0f, 1.0f) }; // Half-float quad geometry std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::uint); glm::uint const PositionDataF16[VertexCount] = { glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, -1.0f))), glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, -1.0f))), glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, 1.0f))), glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, 1.0f))) }; // 8 bits signed integer quad geometry std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2); glm::i8vec2 const PositionDataI8[VertexCount] = { glm::i8vec2(-1,-1), glm::i8vec2( 1,-1), glm::i8vec2( 1, 1), glm::i8vec2(-1, 1) }; // 32 bits signed integer quad geometry std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2); glm::i32vec2 const PositionDataI32[VertexCount] = { glm::i32vec2 (-1,-1), glm::i32vec2 ( 1,-1), glm::i32vec2 ( 1, 1), glm::i32vec2 (-1, 1) }; struct intersection { glm::vec4 position; glm::vec3 normal; }; */ /* // Sample 4 #include // glm::vec3 #include // glm::normalize, glm::dot, glm::reflect #include // glm::pow #include // glm::vecRand3 glm::vec3 lighting ( intersection const& Intersection, material const& Material, light const& Light, glm::vec3 const& View ) { glm::vec3 Color(0.0f); glm::vec3 LightVertor(glm::normalize( Light.position - Intersection.position + glm::vecRand3(0.0f, Light.inaccuracy)); if(!shadow(Intersection.position, Light.position, LightVertor)) { float Diffuse = glm::dot(Intersection.normal, LightVector); if(Diffuse <= 0.0f) return Color; if(Material.isDiffuse()) Color += Light.color() * Material.diffuse * Diffuse; if(Material.isSpecular()) { glm::vec3 Reflect(glm::reflect( glm::normalize(-LightVector), glm::normalize(Intersection.normal))); float Dot = glm::dot(Reflect, View); float Base = Dot > 0.0f ? Dot : 0.0f; float Specular = glm::pow(Base, Material.exponent); Color += Material.specular * Specular; } } return Color; } */ int main() { /* glm::vec1 o(1); glm::vec2 a(1); glm::vec3 b(1); glm::vec4 c(1); glm::quat q; glm::dualquat p; glm::mat4 m(1); float a0 = normalizeDotA(a, a); float b0 = normalizeDotB(b, b); float c0 = normalizeDotC(c, c); */ return 0; } glm-0.9.9-a2/glm/detail/type_vec2.inl0000600000175000001440000005123113173131001016117 0ustar guususers/// @ref core /// @file glm/core/type_tvec2.inl namespace glm { // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(vec<2, T, Q> const& v) : x(v.x), y(v.y) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(vec<2, T, P> const& v) : x(v.x), y(v.y) {} // -- Explicit basic constructors -- template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(T scalar) : x(scalar), y(scalar) {} template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(T _x, T _y) : x(_x), y(_y) {} // -- Conversion scalar constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(A _x, B _y) : x(static_cast(_x)) , y(static_cast(_y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y) : x(static_cast(_x.x)) , y(static_cast(_y.x)) {} // -- Conversion vector constructors -- template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(vec<2, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(vec<3, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, Q>::vec(vec<4, U, P> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} // -- Component accesses -- template GLM_FUNC_QUALIFIER T & vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } template GLM_FUNC_QUALIFIER T const& vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i) const { assert(i >= 0 && i < this->length()); return (&x)[i]; } // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v) { this->x = v.x; this->y = v.y; return *this; } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, U, Q> const& v) { this->x = static_cast(v.x); this->y = static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator+=(U scalar) { this->x += static_cast(scalar); this->y += static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<1, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<2, U, Q> const& v) { this->x += static_cast(v.x); this->y += static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator-=(U scalar) { this->x -= static_cast(scalar); this->y -= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<1, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<2, U, Q> const& v) { this->x -= static_cast(v.x); this->y -= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator*=(U scalar) { this->x *= static_cast(scalar); this->y *= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<1, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<2, U, Q> const& v) { this->x *= static_cast(v.x); this->y *= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator/=(U scalar) { this->x /= static_cast(scalar); this->y /= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<1, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<2, U, Q> const& v) { this->x /= static_cast(v.x); this->y /= static_cast(v.y); return *this; } // -- Increment and decrement operators -- template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator++() { ++this->x; ++this->y; return *this; } template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator--() { --this->x; --this->y; return *this; } template GLM_FUNC_QUALIFIER vec<2, T, Q> vec<2, T, Q>::operator++(int) { vec<2, T, Q> Result(*this); ++*this; return Result; } template GLM_FUNC_QUALIFIER vec<2, T, Q> vec<2, T, Q>::operator--(int) { vec<2, T, Q> Result(*this); --*this; return Result; } // -- Unary bit operators -- template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator%=(U scalar) { this->x %= static_cast(scalar); this->y %= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<1, U, Q> const& v) { this->x %= static_cast(v.x); this->y %= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<2, U, Q> const& v) { this->x %= static_cast(v.x); this->y %= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator&=(U scalar) { this->x &= static_cast(scalar); this->y &= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<1, U, Q> const& v) { this->x &= static_cast(v.x); this->y &= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<2, U, Q> const& v) { this->x &= static_cast(v.x); this->y &= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator|=(U scalar) { this->x |= static_cast(scalar); this->y |= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<1, U, Q> const& v) { this->x |= static_cast(v.x); this->y |= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<2, U, Q> const& v) { this->x |= static_cast(v.x); this->y |= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator^=(U scalar) { this->x ^= static_cast(scalar); this->y ^= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<1, U, Q> const& v) { this->x ^= static_cast(v.x); this->y ^= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<2, U, Q> const& v) { this->x ^= static_cast(v.x); this->y ^= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator<<=(U scalar) { this->x <<= static_cast(scalar); this->y <<= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<1, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<2, U, Q> const& v) { this->x <<= static_cast(v.x); this->y <<= static_cast(v.y); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator>>=(U scalar) { this->x >>= static_cast(scalar); this->y >>= static_cast(scalar); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<1, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.x); return *this; } template template GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<2, U, Q> const& v) { this->x >>= static_cast(v.x); this->y >>= static_cast(v.y); return *this; } // -- Unary arithmetic operators -- template GLM_FUNC_QUALIFIER vec<2, T, Q> operator+(vec<2, T, Q> const& v) { return v; } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator-(vec<2, T, Q> const& v) { return vec<2, T, Q>( -v.x, -v.y); } // -- Binary arithmetic operators -- template GLM_FUNC_QUALIFIER vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x + scalar, v.y + scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x + v2.x, v1.y + v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar + v.x, scalar + v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x + v2.x, v1.x + v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x + v2.x, v1.y + v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x - scalar, v.y - scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x - v2.x, v1.y - v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar - v.x, scalar - v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x - v2.x, v1.x - v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x - v2.x, v1.y - v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x * scalar, v.y * scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x * v2.x, v1.y * v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar * v.x, scalar * v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x * v2.x, v1.x * v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x * v2.x, v1.y * v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x / scalar, v.y / scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x / v2.x, v1.y / v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar / v.x, scalar / v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x / v2.x, v1.x / v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x / v2.x, v1.y / v2.y); } // -- Binary bit operators -- template GLM_FUNC_QUALIFIER vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x % scalar, v.y % scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x % v2.x, v1.y % v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar % v.x, scalar % v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x % v2.x, v1.x % v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x % v2.x, v1.y % v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x & scalar, v.y & scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x & v2.x, v1.y & v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar & v.x, scalar & v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x & v2.x, v1.x & v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x & v2.x, v1.y & v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x | scalar, v.y | scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x | v2.x, v1.y | v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar | v.x, scalar | v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x | v2.x, v1.x | v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x | v2.x, v1.y | v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x ^ scalar, v.y ^ scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x ^ v2.x, v1.y ^ v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar ^ v.x, scalar ^ v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x ^ v2.x, v1.x ^ v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x ^ v2.x, v1.y ^ v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x << scalar, v.y << scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x << v2.x, v1.y << v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar << v.x, scalar << v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x << v2.x, v1.x << v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x << v2.x, v1.y << v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar) { return vec<2, T, Q>( v.x >> scalar, v.y >> scalar); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2) { return vec<2, T, Q>( v1.x >> v2.x, v1.y >> v2.x); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v) { return vec<2, T, Q>( scalar >> v.x, scalar >> v.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x >> v2.x, v1.x >> v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return vec<2, T, Q>( v1.x >> v2.x, v1.y >> v2.y); } template GLM_FUNC_QUALIFIER vec<2, T, Q> operator~(vec<2, T, Q> const& v) { return vec<2, T, Q>( ~v.x, ~v.y); } // -- Boolean operators -- template GLM_FUNC_QUALIFIER bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return detail::compute_equal::call(v1.x, v2.x) && detail::compute_equal::call(v1.y, v2.y); } template GLM_FUNC_QUALIFIER bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2) { return !(v1 == v2); } template GLM_FUNC_QUALIFIER vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2) { return vec<2, bool, Q>(v1.x && v2.x, v1.y && v2.y); } template GLM_FUNC_QUALIFIER vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2) { return vec<2, bool, Q>(v1.x || v2.x, v1.y || v2.y); } }//namespace glm glm-0.9.9-a2/util/0000700000175000001440000000000013173131001012443 5ustar guususersglm-0.9.9-a2/util/conan-package/0000700000175000001440000000000013173131001015132 5ustar guususersglm-0.9.9-a2/util/conan-package/FindGLM.cmake0000600000175000001440000000025413173131001017357 0ustar guususersFIND_PATH( GLM_INCLUDE_DIR NAMES glm PATHS include) INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLM REQUIRED_VARS GLM_INCLUDE_DIR) glm-0.9.9-a2/util/conan-package/conanfile.py0000600000175000001440000000131013173131001017437 0ustar guususersimport os from conans import ConanFile class GlmConan(ConanFile): name = "glm" version = "master" generators = "txt" url="https://github.com/g-truc/glm" description="OpenGL Mathematics (GLM)" license = "https://github.com/g-truc/glm/blob/manual/copying.txt" exports_sources = ["FindGLM.cmake", os.sep.join(["..", "..", "glm*"])] exports = "lib_licenses/*" def build(self): self.output.info("No compilation necessary for GLM") def package(self): self.copy("FindGLM.cmake", ".", ".") self.copy("*", src="glm", dst=os.sep.join([".", "include", "glm"])) self.copy("lib_licenses/license*", dst="licenses", ignore_case=True, keep_path=False) glm-0.9.9-a2/util/conan-package/README.md0000600000175000001440000000036113173131001016413 0ustar guususersConan package for the [GLM](https://github.com/g-truc/glm) library The package is hosted on [bintray](https://bintray.com/conan/conan-center?filterByPkgName=glm%3Ag-truc). It works on Windows (Visual Studio or MinGW), MacOS/OSX and Linux. glm-0.9.9-a2/util/conan-package/.gitignore0000600000175000001440000000027213173131001017125 0ustar guususers#Backup files *\~ *swp #OSX Thumbs.db .DS_Store #Emacs buffers \#*\# \.#* #Conan test_package/build conanfile.pyc conaninfo.txt conanbuildinfo.txt conanbuildinfo.cmake !FindGLM.cmake glm-0.9.9-a2/util/conan-package/lib_licenses/0000700000175000001440000000000013173131001017565 5ustar guususersglm-0.9.9-a2/util/conan-package/lib_licenses/LICENSE2.txt0000600000175000001440000000207313173131001021476 0ustar guususersThe MIT License Copyright (c) 2005 - 2017 G-Truc Creation Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. glm-0.9.9-a2/util/conan-package/lib_licenses/LICENSE1.txt0000600000175000001440000000230213173131001021470 0ustar guususersThe Happy Bunny License (Modified MIT License) Copyright (c) 2005 - 2017 G-Truc Creation Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Restrictions: By making use of the Software for military purposes, you choose to make a Bunny unhappy. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. glm-0.9.9-a2/util/conan-package/test_package/0000700000175000001440000000000013173131001017564 5ustar guususersglm-0.9.9-a2/util/conan-package/test_package/conanfile.py0000600000175000001440000000064513173131001022103 0ustar guususersfrom conans import ConanFile, CMake import os class TestGlm(ConanFile): settings = "os", "compiler", "build_type", "arch" generators = "cmake" def build(self): cmake = CMake(self) self.run('cmake "%s" %s' % (self.conanfile_directory, cmake.command_line)) self.run("cmake --build . %s" % cmake.build_config) def test(self): self.run(os.sep.join([".","bin", "testGlm"])) glm-0.9.9-a2/util/conan-package/test_package/main.cpp0000600000175000001440000000011213173131001021210 0ustar guususers#include "glm/glm.hpp" int main (){ glm::mat4x4 aMatrix; return 0; } glm-0.9.9-a2/util/conan-package/test_package/CMakeLists.txt0000600000175000001440000000035113173131001022325 0ustar guususersproject(GlmTest) cmake_minimum_required(VERSION 3.0.0) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup() if(MSVC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") endif(MSVC) add_executable(testGlm main.cpp) glm-0.9.9-a2/util/usertype.dat0000600000175000001440000000506213173131001015022 0ustar guususersattribute const uniform varying break continue do for while if else in out inout float int void bool true false discard return mat2 mat3 mat4 mat2x2 mat3x3 mat4x4 mat2x3 mat3x2 mat2x4 mat4x2 mat3x4 mat4x3 vec2 vec3 vec4 ivec2 ivec3 ivec4 uvec2 uvec3 uvec4 bvec2 bvec3 bvec4 sampler1D sampler2D sampler3D samplerCube sampler1DShadow sampler2DShadow struct asm class union enum typedef template this packed goto switch default inline noinline volatile public static extern external interface long short double half fixed unsigned input output sampler2DRect sampler3DRect sampler2DRectShadow sizeof cast namespace using layout location smooth flat noperspective centroid invariant lowp mediump highp precision patch sample subroutine hvec2 hvec3 hvec4 fvec2 fvec3 fvec4 dvec2 dvec3 dvec4 on final abstract limited access self uchar schar uint sint int8 int16 int32 int64 sint8 sint16 sint32 sint64 uint8 uint16 uint32 uint64 float16 float32 float64 quat hquat fquat dquat handle handle8 handle16 handle32 handle64 flag flag8 flag16 flag32 flag64 import export hmat2 hmat3 hmat4 fmat2 fmat3 fmat4 dmat2 dmat3 dmat4 hmat2x3 hmat3x2 hmat2x4 hmat4x2 hmat3x4 hmat4x3 fmat2x3 fmat3x2 fmat2x4 fmat4x2 fmat3x4 fmat4x3 dmat2x3 dmat3x2 dmat2x4 dmat4x2 dmat3x4 dmat4x3 null pi epsilon infinite self byte word dword qword new_object new_array delete_object delete_array int8 int16 int32 int64 i8 i16 i32 i64 i8vec2 i8vec3 i8vec4 i16vec2 i16vec3 i16vec4 i32vec2 i32vec3 i32vec4 i64vec2 i64vec3 i64vec4 uint8 uint16 uint32 uint64 u8 u16 u32 u64 u8vec2 u8vec3 u8vec4 u16vec2 u16vec3 u16vec4 u32vec2 u32vec3 u32vec4 u64vec2 u64vec3 u64vec4 float16 float32 float64 f16 f32 f64 f16vec2 f16vec3 f16vec4 f32vec2 f32vec3 f32vec4 f64vec2 f64vec3 f64vec4 f16mat2 f16mat3 f16mat4 f16mat2x3 f16mat2x4 f16mat3x2 f16mat3x4 f16mat4x2 f16mat4x3 f32mat2 f32mat3 f32mat4 f32mat2x3 f32mat2x4 f32mat3x2 f32mat3x4 f32mat4x2 f32mat4x3 f64mat2 f64mat3 f64mat4 f64mat2x3 f64mat2x4 f64mat3x2 f64mat3x4 f64mat4x2 f64mat4x3 f16quat f32quat f64quat bool1 bool2 bool3 bool4 bool1x1 bool2x2 bool3x3 bool4x4 bool2x3 bool2x4 bool3x2 bool3x4 bool4x2 bool4x3 int1 int2 int3 int4 int1x1 int2x2 int3x3 int4x4 int2x3 int2x4 int3x2 int3x4 int4x2 int4x3 half1 half2 half3 half4 half2x2 half3x3 half4x4 half2x3 half2x4 half3x2 half3x4 half4x2 half4x3 float1 float2 float3 float4 float1x1 float2x2 float3x3 float4x4 float2x3 float2x4 float3x2 float3x4 float4x2 float4x3 double1 double2 double3 double4 double1x1 double2x2 double3x3 double4x4 double2x3 double2x4 double3x2 double3x4 double4x2 double4x3 glm-0.9.9-a2/util/glm.natvis0000600000175000001440000000334313173131001014455 0ustar guususers {x} x {x}, {y} x y {x}, {y}, {z} x y z {x}, {y}, {z}, {w} x y z w ({x}, {y}, {z}), {w} x y z w (({real.x}, {real.y}, {real.z}), {real.w}), (({dual.x}, {dual.y}, {dual.z}), {dual.w}) real dual glm-0.9.9-a2/util/autoexp.vc2010.dat0000600000175000001440000037463013173131001015553 0ustar guususers; AutoExp.Dat - templates for automatically expanding data ; Copyright(c) Microsoft Corporation. All Rights Reserved. ;--------------------------------------------------------------- ; ; While debugging, Data Tips and items in the Watch and Variable ; windows are automatically expanded to show their most important ; elements. The expansion follows the format given by the rules ; in this file. You can add rules for your types or change the ; predefined rules. ; ; For good examples, read the rules in this file. ; ; To find what the debugger considers the type of a variable to ; be, add it to the Watch window and look at the Type column. ; ; An AutoExpand rule is a line with the name of a type, an equals ; sign, and text with replaceable parts in angle brackets. The ; part in angle brackets names a member of the type and an ; optional Watch format specifier. ; ; AutoExpand rules use the following syntax. The equals sign (=), ; angle brackets (<>), and comma are taken literally. Square ; brackets ([]) indicate optional items. ; ; type=[text]... ; ; type Name of the type (may be followed by <*> for template ; types such as the ATL types listed below). ; ; text Any text.Usually the name of the member to display, ; or a shorthand name for the member. ; ; member Name of a member to display. ; ; format Watch format specifier. One of the following: ; ; Letter Description Sample Display ; ------ -------------------------- ------------ ------------- ; d,i Signed decimal integer 0xF000F065,d -268373915 ; u Unsigned decimal integer 0x0065,u 101 ; o Unsigned octal integer 0xF065,o 0170145 ; x,X Hexadecimal integer 61541,X 0X0000F065 ; l,h long or short prefix for 00406042,hx 0x0c22 ; d, i, u, o, x, X ; f Signed floating-point 3./2.,f 1.500000 ; e Signed scientific-notation 3./2.,e 1.500000e+000 ; g Shorter of e and f 3./2.,g 1.5 ; c Single character 0x0065,c 'e' ; s Zero-terminated string pVar,s "Hello world" ; su Unicode string pVar,su "Hello world" ; ; For details of other format specifiers see Help under: ; "format specifiers/watch variable" ; ; The special format <,t> specifies the name of the most-derived ; type of the object. This is especially useful with pointers or ; references to a base class. ; ; If there is no rule for a class, the base classes are checked for ; a matching rule. ; ; There are some special entries allowed in the AutoExpand section: ; $BUILTIN is used to display more complex types that need to do more ; than just show a member variable or two. ; $ADDIN allows external DLLs to be added to display even more complex ; types via the EE Add-in API. The first argument is the DLL name, the ; second argument is the name of the export from the DLL to use. For ; further information on this API see the sample called EEAddIn. ; ; WARNING: if hexadecimal mode is on in the watch window, all numbers here are ; evaluated in hex, e.g. 42 becomes 0x42 [AutoExpand] ; from windef.h tagPOINT =x= y= tagRECT =top= bottom= left= right= ; from winuser.h tagMSG =msg= wp= lp= ; intrinsics __m64 = __m128=$BUILTIN(M128) __m128i=$BUILTIN(M128I) __m128d=$BUILTIN(M128D) ; from afxwin.h CDC =hDC= attrib= CPaintDC =<,t> hWnd= CPoint =x= y= CRect =top= bottom= left= right= CSize =cx= cy= CWnd =<,t> hWnd= CWinApp =<,t> CWinThread =<,t> h= proc= ; from afxcoll.h CPtrList =cnt= ; from afxstat_.h CProcessLocalObject =<,t> CThreadLocalObject =<,t> ; from afx.h CArchiveException =cause= CFile =hFile= name= CFileException =cause= OS Error=m_lOsError CMemFile =pos= size= CObject =<,t> CRuntimeClass = CStdioFile =FILE*= name= CTimeSpan =time= CTime =time= ; from afxcoll.h CByteArray =count= CStringList =count= ; same for all CXXXArray classes ; same for CXXXList ; same for CMapXXToXX ; various string classes from MFC & ATL _com_error= _bstr_t=m_wstr,su> (m_RefCount,u>) _com_ptr_t<*>= _LARGE_INTEGER= _ULARGE_INTEGER= ATL::CComPtr<*>=

ATL::CComQIPtr<*>=

tagVARIANT=$BUILTIN(VARIANT) VARIANT=$BUILTIN(VARIANT) _GUID=$BUILTIN(GUID) ; see EEAddIn sample for how to use these ;_SYSTEMTIME=$ADDIN(EEAddIn.dll,AddIn_SystemTime) ;_FILETIME=$ADDIN(EEAddIn.dll,AddIn_FileTime) [Visualizer] ; This section contains visualizers for STL and ATL containers ; DO NOT MODIFY ATL::CStringT|CSimpleStringT|ATL::CSimpleStringT{ preview ([$e.m_pszData,s]) stringview ([$e.m_pszData,sb]) } ATL::CStringT|CSimpleStringT|ATL::CSimpleStringT|ATL::CStringT|CSimpleStringT|ATL::CSimpleStringT{ preview ([$e.m_pszData,su]) stringview ([$e.m_pszData,sub]) } ATL::CComBSTR{ preview ([$e.m_str,su]) stringview ([$e.m_str,sub]) } ; Many visualizers use nested #()s. ; Why not use #(foo, bar) instead of #(#(foo), #(bar))? ; The former alphabetically sorts its fields, while the latter does not. ;------------------------------------------------------------------------------ ; std::pair from ;------------------------------------------------------------------------------ std::pair<*>{ ; pair is previewed with "(, )". preview ( #( "(", $e.first, ", ", $e.second, ")" ) ) ; We gloss over the fact that first and second are actually stored in _Pair_base. children ( #( #(first : $e.first), #(second : $e.second) ) ) } ;------------------------------------------------------------------------------ ; std::plus, etc. from ;------------------------------------------------------------------------------ ; STL functors are previewed with their names. ; They have no state, so they have no children. std::plus<*>{ preview ( "plus" ) children ( #array(expr: 0, size: 0) ) } std::minus<*>{ preview ( "minus" ) children ( #array(expr: 0, size: 0) ) } std::multiplies<*>{ preview ( "multiplies" ) children ( #array(expr: 0, size: 0) ) } std::divides<*>{ preview ( "divides" ) children ( #array(expr: 0, size: 0) ) } std::modulus<*>{ preview ( "modulus" ) children ( #array(expr: 0, size: 0) ) } std::negate<*>{ preview ( "negate" ) children ( #array(expr: 0, size: 0) ) } std::equal_to<*>{ preview ( "equal_to" ) children ( #array(expr: 0, size: 0) ) } std::not_equal_to<*>{ preview ( "not_equal_to" ) children ( #array(expr: 0, size: 0) ) } std::greater<*>{ preview ( "greater" ) children ( #array(expr: 0, size: 0) ) } std::less<*>{ preview ( "less" ) children ( #array(expr: 0, size: 0) ) } std::greater_equal<*>{ preview ( "greater_equal" ) children ( #array(expr: 0, size: 0) ) } std::less_equal<*>{ preview ( "less_equal" ) children ( #array(expr: 0, size: 0) ) } std::logical_and<*>{ preview ( "logical_and" ) children ( #array(expr: 0, size: 0) ) } std::logical_or<*>{ preview ( "logical_or" ) children ( #array(expr: 0, size: 0) ) } std::logical_not<*>{ preview ( "logical_not" ) children ( #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::not1() from ; std::not2() from ;------------------------------------------------------------------------------ ; STL negators are previewed with "not[12]()". ; They have a child with the fake name of [pred], so that the ; stored functor can be inspected. std::unary_negate<*>{ preview ( #( "not1(", $e._Functor, ")" ) ) children ( #([pred] : $e._Functor) ) } std::binary_negate<*>{ preview ( #( "not2(", $e._Functor, ")" ) ) children ( #([pred] : $e._Functor) ) } ;------------------------------------------------------------------------------ ; std::bind1st() from ; std::bind2nd() from ;------------------------------------------------------------------------------ ; STL binders are previewed with "bind1st(, )" or "bind2nd(, )". ; We gloss over the fact that they derive from unary_function. std::binder1st<*>{ preview ( #( "bind1st(", $e.op, ", ", $e.value, ")" ) ) children ( #( #(op : $e.op), #(value : $e.value) ) ) } std::binder2nd<*>{ preview ( #( "bind2nd(", $e.op, ", ", $e.value, ")" ) ) children ( #( #(op : $e.op), #(value : $e.value) ) ) } ;------------------------------------------------------------------------------ ; std::ptr_fun() from ;------------------------------------------------------------------------------ ; STL function pointer adaptors are previewed with "ptr_fun()". ; Function pointers have no children, so the adaptors have no children. std::pointer_to_unary_function<*>|std::pointer_to_binary_function<*>{ preview ( #( "ptr_fun(", $e._Pfun, ")" ) ) children ( #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::mem_fun() from ; std::mem_fun_ref() from ;------------------------------------------------------------------------------ ; See ptr_fun(). std::mem_fun_t<*>|std::mem_fun1_t<*>|std::const_mem_fun_t<*>|std::const_mem_fun1_t<*>{ preview ( #( "mem_fun(", $e._Pmemfun, ")" ) ) children ( #array(expr: 0, size: 0) ) } std::mem_fun_ref_t<*>|std::mem_fun1_ref_t<*>|std::const_mem_fun_ref_t<*>|std::const_mem_fun1_ref_t<*>{ preview ( #( "mem_fun_ref(", $e._Pmemfun, ")" ) ) children ( #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::auto_ptr from ;------------------------------------------------------------------------------ std::auto_ptr<*>{ ; An empty auto_ptr is previewed with "empty". ; Otherwise, it is previewed with "auto_ptr ". preview ( #if ($e._Myptr == 0) ( "empty" ) #else ( #( "auto_ptr ", *$e._Myptr ) ) ) ; An empty auto_ptr has no children. ; Otherwise, it has a single child, its stored pointer, with a fake name of [ptr]. children ( #if ($e._Myptr == 0) ( #array(expr: 0, size: 0) ) #else ( #([ptr] : $e._Myptr) ) ) } ;------------------------------------------------------------------------------ ; std::basic_string from ;------------------------------------------------------------------------------ ; basic_string is previewed with its stored string. ; It has [size] and [capacity] children, followed by [0], [1], [2], etc. children ; displaying its stored characters. ; The ($e._Myres) < ($e._BUF_SIZE) test determines whether the Small String Optimization ; is in effect. ; NOTE: The parentheses in ($e._Myres) < ($e._BUF_SIZE) are necessary. std::basic_string{ preview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,s] ) #else ( [$e._Bx._Ptr,s] )) stringview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sb] ) #else ( [$e._Bx._Ptr,sb] )) children ( #( #([size] : $e._Mysize), #([capacity] : $e._Myres), #if (($e._Myres) < ($e._BUF_SIZE)) ( #array(expr: $e._Bx._Buf[$i], size: $e._Mysize) ) #else ( #array(expr: $e._Bx._Ptr[$i], size: $e._Mysize) ) ) ) } std::basic_string|std::basic_string{ preview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,su] ) #else ( [$e._Bx._Ptr,su] )) stringview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sub] ) #else ( [$e._Bx._Ptr,sub] )) children ( #( #([size] : $e._Mysize), #([capacity] : $e._Myres), #if (($e._Myres) < ($e._BUF_SIZE)) ( #array(expr: $e._Bx._Buf[$i], size: $e._Mysize) ) #else ( #array(expr: $e._Bx._Ptr[$i], size: $e._Mysize) ) ) ) } std::_String_iterator|std::_String_const_iterator{ preview ( [$e._Ptr,s] ) stringview ( [$e._Ptr,sb] ) children ( #([ptr] : $e._Ptr) ) } std::_String_iterator|std::_String_const_iterator|std::_String_iterator|std::_String_const_iterator{ preview ( [$e._Ptr,su] ) stringview ( [$e._Ptr,sub] ) children ( #([ptr] : $e._Ptr) ) } ;------------------------------------------------------------------------------ ; std::vector from ;------------------------------------------------------------------------------ ; Despite its packed representation, vector is visualized like vector. std::vector{ preview ( #( "[", $e._Mysize, "](", #array( expr: (bool)(($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)) & 1), size: $e._Mysize ), ")" ) ) children ( #( #([size] : $e._Mysize), #([capacity] : ($e._Myvec._Myend - $e._Myvec._Myfirst) * _VBITS), #array( expr: (bool)(($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)) & 1), size: $e._Mysize ) ) ) } std::_Vb_reference<*>|std::_Vb_iterator<*>|std::_Vb_const_iterator<*>{ preview ( (bool)((*$e._Myptr >> $e._Myoff) & 1) ) children ( #( #([ptr] : $e._Myptr), #([offset] : $e._Myoff) ) ) } ;------------------------------------------------------------------------------ ; std::vector from ;------------------------------------------------------------------------------ ; vector is previewed with "[]()". ; It has [size] and [capacity] children, followed by its elements. ; The other containers follow its example. std::vector<*>{ preview ( #( "[", $e._Mylast - $e._Myfirst, "](", #array( expr: $e._Myfirst[$i], size: $e._Mylast - $e._Myfirst ), ")" ) ) children ( #( #([size] : $e._Mylast - $e._Myfirst), #([capacity] : $e._Myend - $e._Myfirst), #array( expr: $e._Myfirst[$i], size: $e._Mylast - $e._Myfirst ) ) ) } std::_Vector_iterator<*>|std::_Vector_const_iterator<*>{ preview ( *$e._Ptr ) children ( #([ptr] : $e._Ptr) ) } ;------------------------------------------------------------------------------ ; std::deque from ;------------------------------------------------------------------------------ std::deque<*>{ preview ( #( "[", $e._Mysize, "](", #array( expr: $e._Map[(($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS], size: $e._Mysize ), ")" ) ) children ( #( #array( expr: $e._Map[(($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS], size: $e._Mysize ) ) ) } std::_Deque_iterator<*,*>|std::_Deque_const_iterator<*,*>{ preview ( #if ($e._Myoff >= ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff + ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mysize) ( "end" ) #else ( ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Map[($e._Myoff / ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS] ) ) children ( #if ($e._Myoff >= ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff + ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mysize) ( #array(expr: 0, size: 0) ) #else ( #( #([index] : $e._Myoff - ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff), #([ptr] : &((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Map[($e._Myoff / ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS] ) ) ) ) } ;------------------------------------------------------------------------------ ; std::list from ;------------------------------------------------------------------------------ std::list<*>{ preview ( #( "[", $e._Mysize, "](", #list( head: $e._Myhead->_Next, size: $e._Mysize, next: _Next ) : $e._Myval, ")" ) ) children ( #list( head: $e._Myhead->_Next, size: $e._Mysize, next: _Next ) : $e._Myval ) } std::_List_iterator<*>|std::_List_const_iterator<*>{ preview ( $e._Ptr->_Myval ) children ( #([ptr] : &$e._Ptr->_Myval) ) } ;------------------------------------------------------------------------------ ; std::queue from ; std::stack from ;------------------------------------------------------------------------------ std::queue<*>|std::stack<*>{ preview ( $e.c ) children ( #(c : $e.c) ) } ;------------------------------------------------------------------------------ ; std::priority_queue from ;------------------------------------------------------------------------------ std::priority_queue<*>{ preview ( $e.c ) children ( #( #(c [heap]: $e.c), #(comp : $e.comp) ) ) } ;------------------------------------------------------------------------------ ; std::map from ; std::multimap from ; std::set from ; std::multiset from ;------------------------------------------------------------------------------ std::map<*>|std::multimap<*>|std::set<*>|std::multiset<*>{ preview ( #( "[", $e._Mysize, "](", #tree( head: $e._Myhead->_Parent, skip: $e._Myhead, left: _Left, right: _Right, size: $e._Mysize ) : $e._Myval, ")" ) ) children ( #( #([comp] : $e.comp), #tree( head: $e._Myhead->_Parent, skip: $e._Myhead, left: _Left, right: _Right, size: $e._Mysize ) : $e._Myval ) ) } std::_Tree_iterator<*>|std::_Tree_const_iterator<*>{ preview ( $e._Ptr->_Myval ) children ( #([ptr] : &$e._Ptr->_Myval) ) } ;------------------------------------------------------------------------------ ; std::bitset from ;------------------------------------------------------------------------------ std::bitset<*>{ preview ( #( "[", $e._EEN_BITS, "](", #array( expr: [($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)) & 1,d], size: $e._EEN_BITS ), ")" ) ) children ( #array( expr: [($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)) & 1,d], size: $e._EEN_BITS ) ) } std::bitset<*>::reference{ preview ( [($e._Pbitset->_Array[$i / $e._Pbitset->_Bitsperword] >> ($e._Mypos % $e._Pbitset->_Bitsperword)) & 1,d] ) children ( #( #([bitset] : $e._Pbitset), #([pos] : $e._Mypos) ) ) } ;------------------------------------------------------------------------------ ; std::reverse_iterator from ;------------------------------------------------------------------------------ std::reverse_iterator >|std::reverse_iterator >{ preview ( #( "reverse_iterator to ", $e.current._Ptr[-1] ) ) children ( #( #([to] : $e.current._Ptr - 1), #(current : $e.current) ) ) } std::reverse_iterator >|std::reverse_iterator >{ preview ( #( "reverse_iterator to ", #if ($e.current._Myoff != 0) ( (bool)((*$e.current._Myptr >> ($e.current._Myoff - 1)) & 1) ) #else ( (bool)(($e.current._Myptr[-1] >> (_VBITS - 1)) & 1) ) ) ) children ( #if ($e.current._Myoff != 0) ( #( #([to ptr] : $e.current._Myptr), #([to offset] : $e.current._Myoff - 1), #(current : $e.current) ) ) #else ( #( #([to ptr] : $e.current._Myptr - 1), #([to offset] : _VBITS - 1), #(current : $e.current) ) ) ) } std::reverse_iterator >|std::reverse_iterator >{ preview ( #( "reverse_iterator to ", $e.current._Ptr[-1] ) ) children ( #( #([to] : $e.current._Ptr - 1), #(current : $e.current) ) ) } std::reverse_iterator >|std::reverse_iterator >{ preview ( #( "reverse_iterator to ", #if ($e.current._Myoff == ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff) ( "end" ) #else ( ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Map[(($e.current._Myoff - 1) / ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Mapsize][($e.current._Myoff - 1) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS] ) ) ) children ( #if ($e.current._Myoff == ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff) ( #(current : $e.current) ) #else ( #( #([to index] : ($e.current._Myoff - 1) - ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff), #([to ptr] : &((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Map[(($e.current._Myoff - 1) / ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Mapsize][($e.current._Myoff - 1) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS] ), #(current : $e.current) ) ) ) } std::reverse_iterator >|std::reverse_iterator >{ preview ( #( "reverse_iterator to ", $e.current._Ptr->_Prev->_Myval ) ) children ( #( #([to] : &$e.current._Ptr->_Prev->_Myval), #(current : $e.current) ) ) } std::reverse_iterator >|std::reverse_iterator >{ preview ( #( "reverse_iterator to ", #if ($e.current._EEN_IDL == 0) ( $e.current._Ptr[-1] ) #else ( #if ($e.current._Idx == 0) ( "end" ) #else ( $e.current._Ptr[$e.current._Idx - 1] ) ) ) ) children ( #if ($e.current._EEN_IDL == 0) ( #( #([to] : $e.current._Ptr - 1), #(current : $e.current) ) ) #else ( #if ($e.current._Idx == 0) ( #(current : $e.current) ) #else ( #( #([to] : $e.current._Ptr + $e.current._Idx - 1), #(current : $e.current) ) ) ) ) } std::reverse_iterator<*>{ preview ( #( "reverse_iterator current ", $e.current ) ) children ( #(current : $e.current) ) } ;------------------------------------------------------------------------------ ; std::complex from ;------------------------------------------------------------------------------ std::complex<*>{ preview ( #if ($e._Val[1] == 0) ( ; Purely real. $e._Val[0] ) #else ( #if ($e._Val[0] == 0) ( ; Purely imaginary. #if ($e._Val[1] < 0) ( #("-i*", -$e._Val[1]) ) #else ( #("i*", $e._Val[1]) ) ) #else ( ; Mixed. #if ($e._Val[1] < 0) ( #($e._Val[0], "-i*", -$e._Val[1]) ) #else ( #($e._Val[0], "+i*", $e._Val[1]) ) ) ) ) children ( #( #(real : $e._Val[0]), #(imag : $e._Val[1]) ) ) } ;------------------------------------------------------------------------------ ; std::valarray from ;------------------------------------------------------------------------------ std::valarray<*>{ preview ( #( "[", $e._Mysize, "](", #array( expr: $e._Myptr[$i], size: $e._Mysize ), ")" ) ) children ( #array( expr: $e._Myptr[$i], size: $e._Mysize ) ) } ;------------------------------------------------------------------------------ ; std::tr1::reference_wrapper from ;------------------------------------------------------------------------------ std::tr1::reference_wrapper<*>{ preview ( #if ($e._Callee._EEN_INDIRECT == 1) ( ; For ordinary T, reference_wrapper stores a T * _Callee._Ptr ; which is non-null. Actual references are previewed with what they ; refer to, so reference_wrapper is previewed with dereferencing its ; stored pointer. *$e._Callee._Ptr ) #else ( ; When T is a pointer to data member type, reference_wrapper ; stores a T _Callee._Object directly. $e._Callee._Object ) ) children ( #if ($e._Callee._EEN_INDIRECT == 1) ( ; Actual references have the same children as what they refer to. ; Unfortunately, there appears to be no way to imitate this exactly. ; Therefore, we make reference_wrapper appear to have a single ; child, its stored pointer, with a fake name of [ptr]. #([ptr] : $e._Callee._Ptr) ) #else ( ; When T is a pointer to data member type, T has no children, ; so we make reference_wrapper appear to have no children. #array(expr: 0, size: 0) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::shared_ptr from ;------------------------------------------------------------------------------ std::tr1::_Ref_count<*>{ preview ( "default" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ref_count_del<*>{ preview ( "custom deleter" ) children ( #([deleter] : $e._Dtor) ) } std::tr1::_Ref_count_del_alloc<*>{ preview ( "custom deleter, custom allocator" ) children ( #( #([deleter] : $e._Dtor), #([allocator] : $e._Myal) ) ) } std::tr1::_Ref_count_obj<*>{ preview ( "make_shared" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ref_count_obj_alloc<*>{ preview ( "allocate_shared" ) children ( #([allocator] : $e._Myal) ) } std::tr1::shared_ptr<*>{ preview ( ; shared_ptr stores a T * _Ptr . #if ($e._Ptr == 0) ( ; A default-constructed shared_ptr has a null _Ptr and a null _Rep, ; and is formally said to be empty. ; A shared_ptr constructed from a null pointer has a null _Ptr ; and a NON-null _Rep . It is formally said to own the null pointer. ; We preview both with "empty". "empty" ) #else ( ; Raw pointers are previewed with " ". ; auto_ptr is previewed with "auto_ptr ". ; Following these examples, shared_ptr is previewed with ; "shared_ptr [N strong refs, M weak refs]". #( "shared_ptr ", *$e._Ptr, " [", $e._Rep->_Uses, #if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"), #if ($e._Rep->_Weaks - 1 > 0) ( #( ", ", $e._Rep->_Weaks - 1, #if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs") ) ), "] [", *$e._Rep, "]" ) ; Note: _Rep->_Uses counts how many shared_ptrs share ownership of the object, ; so we directly display it as the strong reference count. ; _Rep->_Weaks counts how many shared_ptrs and weak_ptrs share ownership of ; the "representation object" (or "control block"). All of the shared_ptrs are ; counted as a single owner. That is, _Weaks is initialized to 1, and when ; _Uses falls to 0, _Weaks is decremented. This avoids incrementing and decrementing ; _Weaks every time that a shared_ptr gains or loses ownership. Therefore, ; _Weaks - 1 is the weak reference count, the number of weak_ptrs that are observing ; the shared object. ) ) children ( #if ($e._Ptr == 0) ( ; We make empty shared_ptrs (and shared_ptrs that own ; the null pointer) appear to have no children. #array(expr: 0, size: 0) ) #else ( #( ; We make shared_ptr appear to have two children: ; Its stored pointer, with a fake name of [ptr]. #([ptr] : $e._Ptr), ; Its deleter and allocator, which may be default or custom. #([deleter and allocator] : *$e._Rep) ) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::weak_ptr from ;------------------------------------------------------------------------------ std::tr1::weak_ptr<*>{ preview ( #if ($e._Ptr == 0) ( "empty" ) #elif ($e._Rep->_Uses == 0) ( ; weak_ptr is just like shared_ptr, except that a weak_ptr can be expired. #( "expired [", *$e._Rep, "]" ) ) #else ( #( "weak_ptr ", *$e._Ptr, " [", $e._Rep->_Uses, #if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"), #if ($e._Rep->_Weaks - 1 > 0) ( #( ", ", $e._Rep->_Weaks - 1, #if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs") ) ), "] [", *$e._Rep, "]" ) ) ) children ( #if ($e._Ptr == 0) ( #array(expr: 0, size: 0) ) #elif ($e._Rep->_Uses == 0) ( ; When a weak_ptr is expired, we show its deleter and allocator. ; The deleter has already been used, but the control block has not yet been deallocated. #([deleter and allocator] : *$e._Rep) ) #else ( #( #([ptr] : $e._Ptr), #([deleter and allocator] : *$e._Rep) ) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::mem_fn() from ;------------------------------------------------------------------------------ ; Note that when mem_fn() is given a data member pointer, it returns a _Call_wrapper<_Callable_pmd<*> > . ; Data member pointers themselves don't have useful previews, so we don't attempt to visualize this. ; When mem_fn() is given a member function pointer, it returns a _Mem_fn[N], which we can visualize. std::tr1::_Mem_fn1<*>|std::tr1::_Mem_fn2<*>|std::tr1::_Mem_fn3<*>|std::tr1::_Mem_fn4<*>|std::tr1::_Mem_fn5<*>|std::tr1::_Mem_fn6<*>|std::tr1::_Mem_fn7<*>|std::tr1::_Mem_fn8<*>|std::tr1::_Mem_fn9<*>|std::tr1::_Mem_fn10<*>{ preview ( ; We preview the functor returned by mem_fn() with "mem_fn()". #( "mem_fn(", $e._Callee._Object, ")" ) ) children ( ; Member function pointers have no children. #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::tr1::bind() from ;------------------------------------------------------------------------------ ; bind() placeholders are previewed with their names. ; They have no state, so they have no children. std::tr1::_Ph<1>{ preview ( "_1" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<2>{ preview ( "_2" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<3>{ preview ( "_3" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<4>{ preview ( "_4" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<5>{ preview ( "_5" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<6>{ preview ( "_6" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<7>{ preview ( "_7" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<8>{ preview ( "_8" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<9>{ preview ( "_9" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ph<10>{ preview ( "_10" ) children ( #array(expr: 0, size: 0) ) } ; The functor returned by bind(f, t1, t2) is previewed with "bind(f, t1, t2)". ; It has children with the fake names of [f], [t1], [t2], etc. std::tr1::_Bind<*,*,std::tr1::_Bind0<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind0<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind1<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind1<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind2<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind2<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind3<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind3<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind4<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind4<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ", ", $e._Bx._Vx3, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2), #([t4] : $e._Bx._Vx3) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind5<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind5<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ", ", $e._Bx._Vx3, ", ", $e._Bx._Vx4, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2), #([t4] : $e._Bx._Vx3), #([t5] : $e._Bx._Vx4) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind6<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind6<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ", ", $e._Bx._Vx3, ", ", $e._Bx._Vx4, ", ", $e._Bx._Vx5, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2), #([t4] : $e._Bx._Vx3), #([t5] : $e._Bx._Vx4), #([t6] : $e._Bx._Vx5) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind7<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind7<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ", ", $e._Bx._Vx3, ", ", $e._Bx._Vx4, ", ", $e._Bx._Vx5, ", ", $e._Bx._Vx6, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2), #([t4] : $e._Bx._Vx3), #([t5] : $e._Bx._Vx4), #([t6] : $e._Bx._Vx5), #([t7] : $e._Bx._Vx6) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind8<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind8<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ", ", $e._Bx._Vx3, ", ", $e._Bx._Vx4, ", ", $e._Bx._Vx5, ", ", $e._Bx._Vx6, ", ", $e._Bx._Vx7, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2), #([t4] : $e._Bx._Vx3), #([t5] : $e._Bx._Vx4), #([t6] : $e._Bx._Vx5), #([t7] : $e._Bx._Vx6), #([t8] : $e._Bx._Vx7) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind9<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind9<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ", ", $e._Bx._Vx3, ", ", $e._Bx._Vx4, ", ", $e._Bx._Vx5, ", ", $e._Bx._Vx6, ", ", $e._Bx._Vx7, ", ", $e._Bx._Vx8, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2), #([t4] : $e._Bx._Vx3), #([t5] : $e._Bx._Vx4), #([t6] : $e._Bx._Vx5), #([t7] : $e._Bx._Vx6), #([t8] : $e._Bx._Vx7), #([t9] : $e._Bx._Vx8) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind10<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind10<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ", ", $e._Bx._Vx0, ", ", $e._Bx._Vx1, ", ", $e._Bx._Vx2, ", ", $e._Bx._Vx3, ", ", $e._Bx._Vx4, ", ", $e._Bx._Vx5, ", ", $e._Bx._Vx6, ", ", $e._Bx._Vx7, ", ", $e._Bx._Vx8, ", ", $e._Bx._Vx9, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object), #([t1] : $e._Bx._Vx0), #([t2] : $e._Bx._Vx1), #([t3] : $e._Bx._Vx2), #([t4] : $e._Bx._Vx3), #([t5] : $e._Bx._Vx4), #([t6] : $e._Bx._Vx5), #([t7] : $e._Bx._Vx6), #([t8] : $e._Bx._Vx7), #([t9] : $e._Bx._Vx8), #([t10] : $e._Bx._Vx9) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::function from ;------------------------------------------------------------------------------ std::tr1::_Impl_no_alloc0<*>|std::tr1::_Impl_no_alloc1<*>|std::tr1::_Impl_no_alloc2<*>|std::tr1::_Impl_no_alloc3<*>|std::tr1::_Impl_no_alloc4<*>|std::tr1::_Impl_no_alloc5<*>|std::tr1::_Impl_no_alloc6<*>|std::tr1::_Impl_no_alloc7<*>|std::tr1::_Impl_no_alloc8<*>|std::tr1::_Impl_no_alloc9<*>|std::tr1::_Impl_no_alloc10<*>{ preview ( $e._Callee._Object ) children ( #([functor] : $e._Callee._Object) ) } std::tr1::_Impl0<*>|std::tr1::_Impl1<*>|std::tr1::_Impl2<*>|std::tr1::_Impl3<*>|std::tr1::_Impl4<*>|std::tr1::_Impl5<*>|std::tr1::_Impl6<*>|std::tr1::_Impl7<*>|std::tr1::_Impl8<*>|std::tr1::_Impl9<*>|std::tr1::_Impl10<*>{ preview ( $e._Callee._Object ) children ( #( #([functor] : $e._Callee._Object), #([allocator] : $e._Myal) ) ) } std::tr1::function<*>{ preview ( #if ($e._Impl == 0) ( ; Detecting empty functions is trivial. "empty" ) #else ( *$e._Impl ) ) children ( #if ($e._Impl == 0) ( ; We make empty functions appear to have no children. #array(expr: 0, size: 0) ) #else ( #([functor and allocator] : *$e._Impl) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::tuple from ;------------------------------------------------------------------------------ ; tuple is visualized like pair, except that we have to give fake names to tuple's children. std::tr1::tuple{ preview ( "()" ) children ( #array(expr: 0, size: 0) ) } std::tr1::tuple<*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ")" ) ) children ( #( [0] : $e._Impl._Value ) ) } std::tr1::tuple<*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value ) ) } std::tr1::tuple<*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value ) ) } std::tr1::tuple<*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value, [3] : $e._Impl._Tail._Tail._Tail._Value ) ) } std::tr1::tuple<*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value, [3] : $e._Impl._Tail._Tail._Tail._Value, [4] : $e._Impl._Tail._Tail._Tail._Tail._Value ) ) } std::tr1::tuple<*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value, [3] : $e._Impl._Tail._Tail._Tail._Value, [4] : $e._Impl._Tail._Tail._Tail._Tail._Value, [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value ) ) } std::tr1::tuple<*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value, [3] : $e._Impl._Tail._Tail._Tail._Value, [4] : $e._Impl._Tail._Tail._Tail._Tail._Value, [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value ) ) } std::tr1::tuple<*,*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value, [3] : $e._Impl._Tail._Tail._Tail._Value, [4] : $e._Impl._Tail._Tail._Tail._Tail._Value, [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value, [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value ) ) } std::tr1::tuple<*,*,*,*,*,*,*,*,*,std::tr1::_Nil>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value, [3] : $e._Impl._Tail._Tail._Tail._Value, [4] : $e._Impl._Tail._Tail._Tail._Tail._Value, [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value, [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, [8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value ) ) } std::tr1::tuple<*,*,*,*,*,*,*,*,*,*>{ preview ( #( "(", $e._Impl._Value, ", ", $e._Impl._Tail._Value, ", ", $e._Impl._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, ")" ) ) children ( #( [0] : $e._Impl._Value, [1] : $e._Impl._Tail._Value, [2] : $e._Impl._Tail._Tail._Value, [3] : $e._Impl._Tail._Tail._Tail._Value, [4] : $e._Impl._Tail._Tail._Tail._Tail._Value, [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value, [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value, [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, [8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value, [9] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value ) ) } ;------------------------------------------------------------------------------ ; std::tr1::array from ;------------------------------------------------------------------------------ std::tr1::array<*>{ preview ( ; An actual array is previewed with its address. ; array is previewed like vector. #( "[", $e._EEN_SIZE, "](", #array(expr: $e._Elems[$i], size: $e._EEN_SIZE), ")" ) ) children ( ; Just like an actual array. #array(expr: $e._Elems[$i], size: $e._EEN_SIZE) ) } std::_Array_iterator<*>|std::_Array_const_iterator<*>{ preview ( #if ($e._EEN_IDL == 0) ( *$e._Ptr ) #else ( #if ($e._Idx == $e._EEN_SIZE) ( ; array iterators are represented by _Ptr + _Idx, ; and they know how large their parent arrays are. Therefore, detecting ; end iterators is trivial. "end" ) #else ( ; Like vector iterators, array iterators are previewed with what they point to. $e._Ptr[$e._Idx] ) ) ) children ( #if ($e._EEN_IDL == 0) ( #([ptr] : $e._Ptr) ) #else ( #if ($e._Idx == $e._EEN_SIZE) ( ; We make end iterators appear to have no children. #array(expr: 0, size: 0) ) #else ( ; An array iterator is conceptually a pointer, so we make it appear to store one. #([ptr] : $e._Ptr + $e._Idx) ) ) ) } ;------------------------------------------------------------------------------ ; stdext::hash_map from ; stdext::hash_multimap from ; stdext::hash_set from ; stdext::hash_multiset from ;------------------------------------------------------------------------------ stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>{ preview ( #( "[", $e._List._Mysize, "](", #list( head: $e._List._Myhead->_Next, size: $e._List._Mysize, next: _Next ) : $e._Myval, ")" ) ) children ( #list( head: $e._List._Myhead->_Next, size: $e._List._Mysize, next: _Next ) : $e._Myval ) } ;------------------------------------------------------------------------------ ; std::tr1::unordered_map from ; std::tr1::unordered_multimap from ; std::tr1::unordered_set from ; std::tr1::unordered_multiset from ;------------------------------------------------------------------------------ std::hash<*>{ preview ( "hash" ) children ( #array(expr: 0, size: 0) ) } std::tr1::unordered_map<*>|std::tr1::unordered_multimap<*>|std::tr1::unordered_set<*>|std::tr1::unordered_multiset<*>{ preview ( #( "[", $e._List._Mysize, "](", #list( head: $e._List._Myhead->_Next, size: $e._List._Mysize, next: _Next ) : $e._Myval, ")" ) ) children ( #( #([hash] : $e.comp._Hashobj), #([equal] : $e.comp._Keyeqobj), #list( head: $e._List._Myhead->_Next, size: $e._List._Mysize, next: _Next ) : $e._Myval ) ) } ;------------------------------------------------------------------------------ ; std::tr1::basic_regex from ;------------------------------------------------------------------------------ std::tr1::basic_regex<*>{ preview ( #if ($e._Rep == 0) ( ; Default construction creates an empty basic_regex. "empty" ) #elif ($e._EEN_VIS == 1) ( ; By default, _ENHANCED_REGEX_VISUALIZER is defined to be 1 in debug and 0 in ship. ; When it is 1, basic_regex stores the string from which it was constructed. ; When it is 0, basic_regex stores only the resulting finite state machine. $e._Visualization ) #else ( ; basic_regex contains many static const flags, which would be shown in the preview by default. ; Its actual members are _Rep and _Traits. _Rep holds the finite state machine, so we ; use it to preview basic_regex. (It does contain some human-readable information.) *$e._Rep ) ) children ( #if ($e._Rep == 0) ( ; We make empty basic_regexes appear to have no children. #array(expr: 0, size: 0) ) #elif ($e._EEN_VIS == 1) ( ; We want to hide those static const flags. ; We also want to give _Visualization a fake name. #( #([str] : $e._Visualization), #(_Rep : $e._Rep), #(_Traits : $e._Traits) ) ) #else ( ; We want to hide those static const flags. #( _Rep : $e._Rep, _Traits : $e._Traits ) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::sub_match from ;------------------------------------------------------------------------------ std::tr1::sub_match|std::tr1::sub_match|std::tr1::sub_match|std::tr1::sub_match|std::tr1::sub_match|std::tr1::sub_match{ preview ( ; It would be nice if we could preview sub_match with its str(). ; However, visualizers cannot handle strings represented by pointer pairs. ; Therefore, our preview contains more limited information. #if ($e.matched) ( ; If this sub_match participated in a match, ; we preview it with its length(). $e.second - $e.first ) #else ( ; Otherwise, we preview it with its matched bool (i.e. "false"). ; (Why not length() (i.e. "0")? It's meaningful to have ; matched == true and length() == 0. "false" ) ) children ( #( ; sub_match's three data members are public, but we list them here ; (a) to display matched before first and second, and ; (b) to gloss over the fact that sub_match derives from std::pair. #(matched : $e.matched), #(first : $e.first), #(second : $e.second) ) ) } std::tr1::sub_match >|std::tr1::sub_match >{ preview ( #if ($e.matched) ( ; We visualize ssub_match and wssub_match just like csub_match and wcsub_match, ; except that when determining the length(), we can't subtract iterators. ; We have to subtract their stored pointers. $e.second._Ptr - $e.first._Ptr ) #else ( "false" ) ) children ( #( #(matched : $e.matched), #(first : $e.first), #(second : $e.second) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::match_results from ;------------------------------------------------------------------------------ std::tr1::match_results<*>{ preview ( ; A match_results object is empty iff its vector _Matches is empty. #if ($e._Matches._Myfirst == $e._Matches._Mylast) ( "empty" ) #else ( ; We preview a non-empty match_results object with its vector. $e._Matches ) ) children ( #if ($e._Matches._Myfirst == $e._Matches._Mylast) ( ; We make empty match_results appear to have no children. #array(expr: 0, size: 0) ) #else ( ; As match_results has operator[](), prefix(), and suffix() member functions, ; we make it appear to directly contain [0], [1], [2], etc. elements, ; as well as [prefix] and [suffix] elements. #( #array(expr: $e._Matches._Myfirst[$i], size: $e._Matches._Mylast - $e._Matches._Myfirst), #([prefix] : $e._Prefix), #([suffix] : $e._Suffix) ) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::regex_iterator from ;------------------------------------------------------------------------------ std::tr1::regex_iterator<*>{ preview ( #if ($e._MyRe == 0) ( ; We represent end-of-sequence regex_iterators with null regex pointers. "end" ) #else ( ; Dereferenceable regex_iterators return match_results when dereferenced, ; so we'll preview them with that. $e._MyVal ) ) children ( #if ($e._MyRe == 0) ( ; We make end-of-sequence regex_iterators appear to have no children. #array(expr: 0, size: 0) ) #else ( ; For ease of understanding, we make dereferenceable regex_iterators ; appear to have data members with the "for exposition only" names from TR1. #( #([begin] : $e._Begin), #([end] : $e._End), #([pregex] : $e._MyRe), #([flags] : $e._Flags), #([match] : $e._MyVal) ) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::regex_token_iterator from ;------------------------------------------------------------------------------ std::tr1::regex_token_iterator<*>{ preview ( #if ($e._Res == 0) ( ; We represent end-of-sequence regex_token_iterators with null result pointers. "end" ) #else ( ; Dereferenceable regex_token_iterators return *result when dereferenced, ; so we'll preview them with that. *$e._Res ) ) children ( #if ($e._Res == 0) ( ; We make end-of-sequence regex_token_iterators appear to have no children. #array(expr: 0, size: 0) ) #else ( ; For ease of understanding, we make dereferenceable regex_token_iterators ; appear to have data members with the "for exposition only" names from TR1. #( #([position] : $e._Pos), #([result] : $e._Res), #([suffix] : $e._Suffix), #([N] : $e._Cur), #([subs] : $e._Subs) ) ) ) } ;------------------------------------------------------------------------------ ; std::identity, etc. from ;------------------------------------------------------------------------------ std::identity<*>{ preview ( "identity" ) children ( #array(expr: 0, size: 0) ) } std::bit_and<*>{ preview ( "bit_and" ) children ( #array(expr: 0, size: 0) ) } std::bit_or<*>{ preview ( "bit_or" ) children ( #array(expr: 0, size: 0) ) } std::bit_xor<*>{ preview ( "bit_xor" ) children ( #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::unique_ptr from ;------------------------------------------------------------------------------ std::unique_ptr<*>{ preview ( #if ($e._Myptr == 0) ( "empty" ) #else ( #( "unique_ptr ", *$e._Myptr ) ) ) children ( #if ($e._Myptr == 0) ( #array(expr: 0, size: 0) ) #else ( #([ptr] : $e._Myptr) ) ) } ;------------------------------------------------------------------------------ ; std::forward_list from ;------------------------------------------------------------------------------ std::forward_list<*>{ preview ( #( "(", #list( head: $e._Myhead, next: _Next ) : $e._Myval, ")" ) ) children ( #list( head: $e._Myhead, next: _Next ) : $e._Myval ) } std::_Flist_iterator<*>|std::_Flist_const_iterator<*>{ preview ( #if ($e._Ptr == 0) ( "end" ) #else ( $e._Ptr->_Myval ) ) children ( #if ($e._Ptr == 0) ( #array(expr: 0, size: 0) ) #else ( #([ptr] : &$e._Ptr->_Myval) ) ) } ;------------------------------------------------------------------------------ ; PROPVARIANT ;------------------------------------------------------------------------------ ; Visualizers for VT_VECTOR C arrays tagCAC|tagCAUB|tagCAI|tagCAUI|tagCAL|tagCAUL|tagCAFLT|tagCADBL|tagCACY|tagCADATE|tagCABSTR|tagCABSTRBLOB|tagCABOOL|tagCASCODE|tagCAPROPVARIANT|tagCAH|tagCAUH|tagCALPSTR|tagCALPWSTR|tagCAFILETIME|tagCACLIPDATA|tagCACLSID{ preview( #( "[", $e.cElems , "](", #array ( expr : ($e.pElems)[$i], size : $e.cElems ), ")" ) ) children ( #array ( expr : ($e.pElems)[$i], size : $e.cElems ) ) } ; Visualizers for SAFE ARRAY tagSAFEARRAY|SAFEARRAY{ preview( #if ($e.fFeatures & 0x0080) ; FADF_HAVEVARTYPE ( ; Switch on the variant type field - which is stored 4 bytes ; before the beginning of the SAFEARRAY type #switch( ((unsigned *)&($e))[-1] ) #case 0x2 ; VT_I2 | VT_ARRAY ( #( "safearray of I2 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((signed short *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x3 ; VT_I4 | VT_ARRAY ( #( "safearray of I4 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((signed int *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x4 ; VT_R4 | VT_ARRAY ( #( "safearray of R4 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((float *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x5 ; VT_R8 | VT_ARRAY ( #( "safearray of R8 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((double *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x6 ; VT_CY | VT_ARRAY ( #( "safearray of CY = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((CY *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x7 ; VT_DATE | VT_ARRAY ( #( "safearray of DATE = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((DATE *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x8 ; VT_BSTR | VT_ARRAY ( #( "safearray of BSTR = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((wchar_t **)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0xa ; VT_ERROR | VT_ARRAY ( #( "safearray of ERROR = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((long *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0xb ; VT_BOOL | VT_ARRAY ( #( "safearray of BOOL = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((short *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0xc ; VT_VARIANT | VT_ARRAY ( #( "safearray of VARIANT = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x10 ; VT_I1 | VT_ARRAY ( #( "safearray of I1 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((signed char *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x11 ; VT_UI1 | VT_ARRAY ( #( "safearray of UI1 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((unsigned char *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x12 ; VT_UI2 | VT_ARRAY ( #( "safearray of UI2 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((unsigned short *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x13 ; VT_UI4 | VT_ARRAY ( #( "safearray of UI4 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((unsigned int *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x14 ; VT_I8 | VT_ARRAY ( #( "safearray of I8 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((signed __int64 *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x15 ; VT_UI8 | VT_ARRAY ( #( "safearray of UI8 = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((unsigned __int64 *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x16 ; VT_INT | VT_ARRAY ( #( "safearray of INT = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((int *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x17 ; VT_UINT | VT_ARRAY ( #( "safearray of UINT = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((unsigned *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x1e ; VT_LPSTR | VT_ARRAY ( #( "safearray of LPSTR = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((char **)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x1f ; VT_LPWSTR | VT_ARRAY ( #( "safearray of LPWSTR = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((wchar_t **)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x40 ; VT_FILETIME | VT_ARRAY ( #( "safearray of FILETIME = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((FILETIME *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x47 ; VT_CLIPDATA | VT_ARRAY ( #( "safearray of CLIPDATA = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((CLIPDATA *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) #case 0x48 ; VT_CLSID | VT_ARRAY ( #( "safearray of CLSID = [", ; output the rank array #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", ; output the data elements #array( expr: ((CLSID *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")" ) ) ) #elif ($e.fFeatures & 0x0100) ; FADF_BSTR ( #("safearray of BSTR = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")") ) #elif ($e.fFeatures & 0x0200) ; FADF_UNKNOWN ( #("safearray of IUnknown* = [",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", #array(expr: ((IUnknown * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")") ) #elif ($e.fFeatures & 0x0400) ; FADF_DISPATCH ( #("safearray of IDispatch* = [",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", #array(expr: ((IDispatch * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")") ) #elif ($e.fFeatures & 0x0800) ; FADF_VARIANT ( #("safearray of VARIANT = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")") ) ) children ( #( ;[actual members]: [$e,!], #if ($e.fFeatures & 0x0080) ; FADF_HAVEVARTYPE ( #switch( ((unsigned *)&($e))[-1] ) ; for some reason the VT field is before the SAFEARRAY struct #case 2 ; VT_I2|VT_ARRAY ( #array( expr: ((signed short *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 3 ; VT_I4|VT_ARRAY ( #array( expr: ((signed int *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 4 ; VT_R4|VT_ARRAY ( #array( expr: ((float *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 5 ; VT_R8|VT_ARRAY ( #array( expr: ((double *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x10 ; VT_I1|VT_ARRAY ( #array( expr: ((signed char *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x11 ; VT_UI1|VT_ARRAY ( #array( expr: ((unsigned char *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x12 ; VT_UI2|VT_ARRAY ( #array( expr: ((unsigned short *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x13 ; VT_UI4|VT_ARRAY ( #array( expr: ((unsigned int *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x14 ; VT_I8|VT_ARRAY ( #array( expr: ((signed __int64 *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x15 ; VT_UI8|VT_ARRAY ( #array( expr: ((unsigned __int64 *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x1e ; VT_LPSTR|VT_ARRAY ( #array( expr: ((char * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x1f ; VT_LPWSTR|VT_ARRAY ( #array( expr: ((wchar_t **)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0xc ; VT_VARIANT|VT_ARRAY ( #array( expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0xb ; VT_BOOL|VT_ARRAY ( #array( expr: ((short *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0xa ; VT_ERROR|VT_ARRAY ( #array( expr: ((long *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 6 ; VT_CY|VT_ARRAY ( #array( expr: ((CY *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 7 ; VT_DATE|VT_ARRAY ( #array( expr: ((DATE *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x40 ; VT_FILETIME|VT_ARRAY ( #array( expr: ((FILETIME *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x48 ; VT_CLSID|VT_ARRAY ( #array( expr: ((CLSID *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x47 ; VT_CF|VT_ARRAY ( #array( expr: ((CLIPDATA *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 8 ; VT_BSTR|VT_ARRAY ( #array( expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x16 ; VT_INT|VT_ARRAY ( #array( expr: ((int *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #case 0x17 ; VT_UINT|VT_ARRAY ( #array( expr: ((unsigned int*)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #default ( #([actual members]: [$e,!]) ) #except ( #([actual members]: [$e,!]) ) ) #elif ($e.fFeatures & 0x0100) ; FADF_BSTR ( #array(expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #elif ($e.fFeatures & 0x0200) ; FADF_UNKNOWN ( #array(expr: ((IUnknown * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #elif ($e.fFeatures & 0x0400) ; FADF_DISPATCH ( #array(expr: ((IDispatch * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) #elif ($e.fFeatures & 0x0800) ; FADF_VARIANT ( #array(expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ) ) ) ) } tagPROPVARIANT|tagVARIANT|PROPVARIANT|VARIANT{ preview( #switch ($e.vt) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Base Types ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #case 0 ( #("Empty") ) ; VT_EMPTY #case 1 ( #("NULL") ) ; VT_NULL #case 2 ( #("I2 = ", $e.iVal) ) ; VT_I2 #case 3 ( #("I4 = ", $e.lVal) ) ; VT_I4 #case 4 ( #("R4 = ", $e.fltVal) ) ; VT_R4 #case 5 ( #("R8 = ", $e.dblVal) ) ; VT_R8 #case 6 ( #("CY = ", $e.cyVal) ) ; VT_CY #case 7 ( #("DATE = ", $e.date) ) ; VT_DATE #case 8 ( #("BSTR = ", $e.bstrVal) ) ; VT_BSTR #case 9 ( #("DISPATCH = ", $e.pdispVal) ) ; VT_DISPATCH #case 10 ( #("ERROR = ", $e.scode) ) ; VT_ERROR #case 0xB ( #("BOOL = ", $e.boolVal) ) ; VT_BOOL #case 0xC ( #("VARIANT ") ) ; VT_VARIANT #case 0xD ( #("UNKNOWN = ", $e.punkVal) ) ; VT_UNKOWN #case 0xE ( #("DECIMAL = ", $e.decVal) ) ; VT_DECIMAL #case 0x10 ( #("I1 = ", $e.cVal) ) ; VT_I1 #case 0x11 ( #("UI1 = ", $e.bVal) ) ; VT_UI1 #case 0x12 ( #("UI2 = ", $e.uiVal) ) ; VT_UI2 #case 0x13 ( #("UI4 = ", $e.ulVal) ) ; VT_UI4 #case 0x14 ( #("I8 = ", *(__int64*)&$e.dblVal) ) ; VT_I8 #case 0x15 ( #("UI8 = ", *(unsigned __int64*)&$e.dblVal) ) ; VT_UI8 #case 0x16 ( #("INT = ", $e.intVal) ) ; VT_INT #case 0x17 ( #("UINT = ", $e.uintVal) ) ; VT_UINT #case 0x18 ( #("VOID ") ) ; VT_VOID #case 0x19 ( #("HRESULT ") ) ; VT_HRESULT #case 0x1A ( #("PTR ") ) ; VT_PTR #case 0x1B ( #("SAFEARRAY ") ) ; VT_SAFEARRAY #case 0x1C ( #("CARRAY ") ) ; VT_CARRAY #case 0x1D ( #("USERDEFINED ") ) ; VT_USERDEFINED #case 0x1E ( #("LPSTR = ", $e.pszVal) ) ; VT_LPSTR #case 0x1F ( #("LPWSTR = ", $e.pwszVal) ) ; VT_LPWSTR #case 0x24 ( #("RECORD ") ) ; VT_RECORD #case 0x26 ( #("UINT_PTR ") ) ; VT_UINT_PTR #case 0x40 ( #("FILETIME = ", $e.filetime) ) ; VT_FILETIME #case 0x42 ( #("STREAM = ", $e.pStream) ) ; VT_STREAM #case 0x43 ( #("STORAGE = ", $e.pStorage) ) ; VT_STORAGE #case 0x44 ( #("STREAMED_OBJECT = ", $e.pStream) ) ; VT_STREAMED_OBJECT #case 0x45 ( #("STORED_OBJECT = ", $e.pStorage) ) ; VT_STORED_OBJECT #case 0x46 ( #("BLOB_OBJECT = ", $e.blob ) ) ; VT_BLOB_OBJECT #case 0x47 ( #("CF = ", $e.pclipdata) ) ; VT_CF #case 0x48 ( #("CLSID = ", $e.puuid) ) ; VT_CLSID #case 0x49 ( #("VERSIONED_STREAM = ", $e.pVersionedStream) ) ; VT_VERSIONED_STREAM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Vector types ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #case 0x1002 ( #("vector of I2 = ", $e.cai) ) ; VT_I2|VT_VECTOR #case 0x1003 ( #("vector of I4 = ", $e.cal) ) ; VT_I4|VT_VECTOR #case 0x1004 ( #("vector of R4 = ", $e.caflt) ) ; VT_R4|VT_VECTOR #case 0x1005 ( #("vector of R8 = ", $e.cadbl) ) ; VT_R8|VT_VECTOR #case 0x1010 ( #("vector of I1 = ", $e.cac) ) ; VT_I1|VT_VECTOR #case 0x1011 ( #("vector of UI1 = ", $e.caub) ) ; VT_UI1|VT_VECTOR #case 0x1012 ( #("vector of UI2 = ", $e.caui) ) ; VT_UI2|VT_VECTOR #case 0x1013 ( #("vector of UI4 = ", $e.caul) ) ; VT_UI4|VT_VECTOR #case 0x1014 ( #("vector of I8 = ", $e.cah) ) ; VT_I8|VT_VECTOR #case 0x1015 ( #("vector of UI8 = ", $e.cauh) ) ; VT_UI8|VT_VECTOR #case 0x101E ( #("vector of LPSTR = ", $e.calpstr) ) ; VT_LPSTR|VT_VECTOR #case 0x101F ( #("vector of LPWSTR = ", $e.calpwstr) ) ; VT_LPWSTR|VT_VECTOR #case 0x100C ( #("vector of VARIANT ", $e.capropvar) ) ; VT_VARIANT|VT_VECTOR #case 0x100B ( #("vector of BOOL = ", $e.cabool) ) ; VT_BOOL|VT_VECTOR #case 0x100A ( #("vector of ERROR = ", $e.cascode) ) ; VT_ERROR|VT_VECTOR #case 0x1006 ( #("vector of CY = ", $e.cacy) ) ; VT_CY|VT_VECTOR #case 0x1007 ( #("vector of DATE = ", $e.cadate) ) ; VT_DATE|VT_VECTOR #case 0x1040 ( #("vector of FILETIME = ", $e.cafiletime) ) ; VT_FILETIME|VT_VECTOR #case 0x1048 ( #("vector of CLSID = ", $e.cauuid) ) ; VT_CLSID|VT_VECTOR #case 0x1047 ( #("vector of CF = ", $e.caclipdata) ) ; VT_CF|VT_VECTOR #case 0x1008 ( #("vector of BSTR = ", $e.cabstr) ) ; VT_BSTR|VT_VECTOR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Byref Types ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #case 0x4016 ( #("byref of INT = ", $e.pintVal) ) ; VT_INT|VT_BYREF #case 0x4017 ( #("byref of UINT = ", $e.puintVal) ) ; VT_UINT|VT_BYREF #case 0x4002 ( #("byref of I2 = ", $e.piVal) ) ; VT_I2|VT_BYREF #case 0x4003 ( #("byref of I4 = ", $e.plVal) ) ; VT_I4|VT_BYREF #case 0x4004 ( #("byref of R4 = ", $e.pfltVal) ) ; VT_R4|VT_BYREF #case 0x4005 ( #("byref of R8 = ", $e.pdblVal) ) ; VT_R8|VT_BYREF #case 0x4010 ( #("byref of I1 = ", $e.pcVal) ) ; VT_I1|VT_BYREF #case 0x4011 ( #("byref of UI1 = ", $e.pbVal) ) ; VT_UI1|VT_BYREF #case 0x4012 ( #("byref of UI2 = ", $e.puiVal) ) ; VT_UI2|VT_BYREF #case 0x4013 ( #("byref of UI4 = ", $e.pulVal) ) ; VT_UI4|VT_BYREF #case 0x4014 ( #("byref of I8 = ", (__int64*)$e.pdblVal) ) ; VT_I8|VT_BYREF #case 0x4015 ( #("byref of UI8 = ", (unsigned __int64*)$e.pudblVal) ) ; VT_UI8|VT_BYREF #case 0x400C ( #("byref of VARIANT ", $e.pvarVal) ) ; VT_VARIANT|VT_BYREF #case 0x400B ( #("byref of BOOL = ", $e.pboolVal) ) ; VT_BOOL|VT_BYREF #case 0x400A ( #("byref of ERROR = ", $e.pscode) ) ; VT_ERROR|VT_BYREF #case 0x4006 ( #("byref of CY = ", $e.pcyVal) ) ; VT_CY|VT_BYREF #case 0x4007 ( #("byref of DATE = ", $e.pdate) ) ; VT_DATE|VT_BYREF #case 0x4008 ( #("byref of BSTR = ", $e.pbstrVal) ) ; VT_BSTR|VT_BYREF #case 0x400E ( #("byref of DECIMAL = ", $e.pdecVal) ) ; VT_DECIMAL|VT_BYREF #case 0x400D ( #("byref of UNKNOWN = ", $e.ppunkVal) ) ; VT_UNKOWN|VT_BYREF #case 0x4009 ( #("byref of DISPATCH = ", $e.ppdispVal) ) ; VT_DISPATCH|VT_BYREF #case 0x6000 ( #("byref of ARRAY = ", $e.pparray) ) ; VT_ARRAY|VT_BYREF #default ( #if ($e.vt & 0x2000) ( $e.parray) #else ( #("Unknown vt type = ", $e.vt)) ) ) children( #( vt: $e.vt, #switch ($e.vt) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Base Types ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #case 0x2 ( #(I2 : $e.iVal) ) ; VT_I2 #case 0x3 ( #(I4 : $e.lVal) ) ; VT_I4 #case 0x4 ( #(R4 : $e.fltVal) ) ; VT_R4 #case 0x5 ( #(R8 : $e.dblVal) ) ; VT_R8 #case 0x6 ( #(CY : $e.cyVal) ) ; VT_CY #case 0x7 ( #(DATE : $e.date) ) ; VT_DATE #case 0x8 ( #(BSTR : $e.bstrVal) ) ; VT_BSTR #case 0x9 ( #(DISPATCH : $e.pdispVal) ) ; VT_DISPATCH #case 0xA ( #(ERROR : $e.scode) ) ; VT_ERROR #case 0xB ( #(BOOL : $e.boolVal) ) ; VT_BOOL #case 0xD ( #(UNKNOWN : $e.punkVal) ) ; VT_UNKOWN #case 0xE ( #(DECIMAL : $e.decVal) ) ; VT_DECIMAL #case 0x10 ( #(I1 : $e.cVal) ) ; VT_I1 #case 0x11 ( #(UI1 : $e.bVal) ) ; VT_UI1 #case 0x12 ( #(UI2 : $e.uiVal) ) ; VT_UI2 #case 0x13 ( #(UI4 : $e.ulVal) ) ; VT_UI4 #case 0x14 ( #(I8 : *(__int64*)&$e.dblVal) ) ; VT_I8 #case 0x15 ( #(UI8 : *(unsigned __int64*)&$e.dblVal) ) ; VT_UI8 #case 0x16 ( #(INT : $e.intVal) ) ; VT_INT #case 0x17 ( #(UINT : $e.uintVal) ) ; VT_UINT #case 0x1E ( #(LPSTR : $e.pszVal) ) ; VT_LPSTR #case 0x1F ( #(LPWSTR : $e.pwszVal) ) ; VT_LPWSTR #case 0x40 ( #(FILETIME : $e.filetime) ) ; VT_FILETIME #case 0x42 ( #(STREAM : $e.pStream) ) ; VT_STREAM #case 0x43 ( #(STORAGE : $e.pStorage) ) ; VT_STORAGE #case 0x44 ( #(STREAMED_OBJECT : $e.pStream) ) ; VT_STREAMED_OBJECT #case 0x45 ( #(STORED_OBJECT : $e.pStorage) ) ; VT_STORED_OBJECT #case 0x46 ( #(BLOB_OBJECT : $e.blob ) ) ; VT_BLOB_OBJECT #case 0x47 ( #(CF : $e.pclipdata) ) ; VT_CF #case 0x48 ( #(CLSID : $e.puuid) ) ; VT_CLSID #case 0x49 ( #(VERSIONED_STREAM : $e.pVersionedStream) ) ; VT_VERSIONED_STREAM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Vector types ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #case 0x1002 ( #(vector of I2 : $e.cai) ) ; VT_I2|VT_VECTOR #case 0x1003 ( #(vector of I4 : $e.cal) ) ; VT_I4|VT_VECTOR #case 0x1004 ( #(vector of R4 : $e.caflt) ) ; VT_R4|VT_VECTOR #case 0x1005 ( #(vector of R8 : $e.cadbl) ) ; VT_R8|VT_VECTOR #case 0x1010 ( #(vector of I1 : $e.cac) ) ; VT_I1|VT_VECTOR #case 0x1011 ( #(vector of UI1 : $e.caub) ) ; VT_UI1|VT_VECTOR #case 0x1012 ( #(vector of UI2 : $e.caui) ) ; VT_UI2|VT_VECTOR #case 0x1013 ( #(vector of UI4 : $e.caul) ) ; VT_UI4|VT_VECTOR #case 0x1014 ( #(vector of I8 : $e.cah) ) ; VT_I8|VT_VECTOR #case 0x1015 ( #(vector of UI8 : $e.cauh) ) ; VT_UI8|VT_VECTOR #case 0x101E ( #(vector of LPSTR : $e.calpstr) ) ; VT_LPSTR|VT_VECTOR #case 0x101F ( #(vector of LPWSTR : $e.calpwstr) ) ; VT_LPWSTR|VT_VECTOR #case 0x100C ( #(vector of VARIANT : $e.capropvar) ) ; VT_VARIANT|VT_VECTOR #case 0x100B ( #(vector of BOOL : $e.cabool) ) ; VT_BOOL|VT_VECTOR #case 0x100A ( #(vector of ERROR : $e.cascode) ) ; VT_ERROR|VT_VECTOR #case 0x1006 ( #(vector of CY : $e.cacy) ) ; VT_CY|VT_VECTOR #case 0x1007 ( #(vector of DATE : $e.cadate) ) ; VT_DATE|VT_VECTOR #case 0x1040 ( #(vector of FILETIME : $e.cafiletime) ) ; VT_FILETIME|VT_VECTOR #case 0x1048 ( #(vector of CLSID : $e.cauuid) ) ; VT_CLSID|VT_VECTOR #case 0x1047 ( #(vector of CF : $e.caclipdata) ) ; VT_CF|VT_VECTOR #case 0x1008 ( #(vector of BSTR : $e.cabstr) ) ; VT_BSTR|VT_VECTOR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Byref Types ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #case 0x4016 ( #(byref of INT : $e.pintVal) ) ; VT_INT|VT_BYREF #case 0x4017 ( #(byref of UINT : $e.puintVal) ) ; VT_UINT|VT_BYREF #case 0x4002 ( #(byref of I2 : $e.piVal) ) ; VT_I2|VT_BYREF #case 0x4003 ( #(byref of I4 : $e.plVal) ) ; VT_I4|VT_BYREF #case 0x4004 ( #(byref of R4 : $e.pfltVal) ) ; VT_R4|VT_BYREF #case 0x4005 ( #(byref of R8 : $e.pdblVal) ) ; VT_R8|VT_BYREF #case 0x4010 ( #(byref of I1 : $e.pcVal) ) ; VT_I1|VT_BYREF #case 0x4011 ( #(byref of UI1 : $e.pbVal) ) ; VT_UI1|VT_BYREF #case 0x4012 ( #(byref of UI2 : $e.puiVal) ) ; VT_UI2|VT_BYREF #case 0x4013 ( #(byref of UI4 : $e.pulVal) ) ; VT_UI4|VT_BYREF #case 0x4014 ( #(byref of I8 : (__int64*)$e.pdblVal) ) ; VT_I8|VT_BYREF #case 0x4015 ( #(byref of UI8 : (unsigned __int64*)$e.pdblVal) ) ; VT_UI8|VT_BYREF #case 0x400C ( #(byref of VARIANT : $e.pvarVal) ) ; VT_VARIANT|VT_BYREF #case 0x400B ( #(byref of BOOL : $e.pboolVal) ) ; VT_BOOL|VT_BYREF #case 0x400A ( #(byref of ERROR : $e.pscode) ) ; VT_ERROR|VT_BYREF #case 0x4006 ( #(byref of CY : $e.pcyVal) ) ; VT_CY|VT_BYREF #case 0x4007 ( #(byref of DATE : $e.pdate) ) ; VT_DATE|VT_BYREF #case 0x4008 ( #(byref of BSTR : $e.pbstrVal) ) ; VT_BSTR|VT_BYREF #case 0x400E ( #(byref of DECIMAL : $e.pdecVal) ) ; VT_DECIMAL|VT_BYREF #case 0x400D ( #(byref of UNKNOWN : $e.ppunkVal) ) ; VT_UNKOWN|VT_BYREF #case 0x4009 ( #(byref of DISPATCH : $e.ppdispVal) ) ; VT_DISPATCH|VT_BYREF #case 0x6000 ( #(byref of ARRAY : $e.pparray) ) ; VT_ARRAY|VT_BYREF ; the following are either empty or invalid vt values for a variant ; #case 0 ( #(Empty :) ) ; VT_EMPTY ; #case 0x1 ( #(NULL :) ) ; VT_NULL ; #case 0xC ( #(VARIANT :) ) ; VT_VARIANT ; #case 0x18 ( #(VOID :) ) ; VT_VOID ; #case 0x19 ( #(HRESULT :) ) ; VT_HRESULT ; #case 0x1A ( #(PTR :) ) ; VT_PTR ; #case 0x1B ( #(SAFEARRAY :) ) ; VT_SAFEARRAY ; #case 0x1C ( #(CARRAY :) ) ; VT_CARRAY ; #case 0x1D ( #(USERDEFINED :) ) ; VT_USERDEFINED ; #case 0x24 ( #(RECORD :) ) ; VT_RECORD ; #case 0x26 ( #(UINT_PTR :) ) ; VT_UINT_PTR #default ( #if ($e.vt & 0x2000 ) ( #(safearray: $e.parray)) #else ( #( [raw members]: [$e,!] ; unformatted data members ) ) ) #except ( #( [raw members]: [$e,!] ; unformatted data members ) ) ) ) } ; Visualizers for data structures in namespace Concurrency ;------------------------------------------------------------------------------ ; Concurrency::message from ;------------------------------------------------------------------------------ Concurrency::message<*>{ preview ( #( $e.payload ) ) children ( #( #(payload: $e.payload), #([msg_id]: $e._M_id) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::multi_link_registry from ;------------------------------------------------------------------------------ Concurrency::multi_link_registry<*>{ preview ( #( "[", $e._M_vector._M_index, "](", #array( expr: *($e._M_vector._M_array[$i]), size: $e._M_vector._M_index ), ")" ) ) children ( #( #([size]: $e._M_vector._M_index), #array( expr: *($e._M_vector._M_array[$i]), size: $e._M_vector._M_index ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_Queue from ;------------------------------------------------------------------------------ Concurrency::details::_Queue<*>{ preview ( #( "[", $e._M_count, "](", #list( head: $e._M_pHead, next: _M_pNext, size: _M_count ), ")" ) ) children ( #( #([size]: $e._M_count), #list( head: $e._M_pHead, next: _M_pNext, size: _M_count ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::unbounded_buffer from ;------------------------------------------------------------------------------ Concurrency::unbounded_buffer<*>{ preview ( #( $e._M_messageBuffer ) ) children ( #( #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(messages: $e._M_messageBuffer), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_targets: $e._M_connectedTargets), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::overwrite_buffer from ;------------------------------------------------------------------------------ Concurrency::overwrite_buffer<*>{ preview ( #( $e._M_pMessage ) ) children ( #( #(value: *($e._M_pMessage)), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_targets: $e._M_connectedTargets), #(reserving_target: *($e._M_pReservedFor)), #(reserved_message: *($e._M_pReservedMessage)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::single_assignment from ;------------------------------------------------------------------------------ Concurrency::single_assignment<*>{ preview ( #( $e._M_pMessage ) ) children ( #( #(value: *($e._M_pMessage)), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_targets: $e._M_connectedTargets), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::call from ;------------------------------------------------------------------------------ Concurrency::call<*>{ preview ( #( $e._M_pFunc ) ) children ( #( #(call_method: $e._M_pFunc), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::transformer from ;------------------------------------------------------------------------------ Concurrency::transformer<*>{ preview ( #( $e._M_pFunc ) ) children ( #( #(transform_method: $e._M_pFunc), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(messages: $e._M_messageBuffer), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_target: *($e._M_connectedTargets._M_connectedLink)), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::choice from ;------------------------------------------------------------------------------ Concurrency::choice<*>{ preview ( #( "[", #if ($e._M_pSingleAssignment->_M_fIsInitialized) ("initialized") #else ("not_initialized"), "] ", $e._M_sourceTuple ) ) children ( #( #([input_count]: $e._M_pSingleAssignment->_M_connectedSources._M_links._M_vector._M_index), #(index: $e._M_pSingleAssignment->_M_pMessage->payload), #(source_tuple: $e._M_sourceTuple), #(linked_sources: $e._M_pSingleAssignment->_M_connectedSources._M_links), #(linked_targets: $e._M_pSingleAssignment->_M_connectedTargets), #(reserving_target: *($e._M_pSingleAssignment->_M_pReservedFor)), #(Scheduler: *($e._M_pScheduler)), #(ScheduleGroup: *($e._M_pScheduleGroup)), #([raw _M_pSourceChoices] : $e._M_pSourceChoices) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::join<*,*>::_MessageArray from ;------------------------------------------------------------------------------ Concurrency::join<*,*>::_MessageArray{ preview ( #( "[", $e._M_count, "](", #array( expr: *(((Concurrency::message<$T1>**)$e._M_messages)[$i]), size: $e._M_count ), ")" ) ) children ( #( #([size]: $e._M_count), #array( expr: *(((Concurrency::message<$T1>**)$e._M_messages)[$i]), size: $e._M_count ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::join<*,*>::_SavedMessageIdArray from ;------------------------------------------------------------------------------ Concurrency::join<*,*>::_SavedMessageIdArray{ preview ( #( "[", $e._M_count, "](", #array( expr: ((int*)$e._M_savedIds)[$i], size: $e._M_count ), ")" ) ) children ( #( #([size]: $e._M_count), #array( expr: ((int*)$e._M_savedIds)[$i], size: $e._M_count ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::join from ;------------------------------------------------------------------------------ Concurrency::join<*,*>{ preview ( #( "[", $e._M_messageArray._M_count - $e._M_messagesRemaining, "/", $e._M_messageArray._M_count, "](", #array( expr: *($e._M_connectedSources._M_links._M_vector._M_array[$i]), size: $e._M_connectedSources._M_links._M_vector._M_index ), ")" ) ) children ( #( #([join_type]: (Concurrency::join_type)$T2), #([offer_count]: $e._M_messageArray._M_count - $e._M_messagesRemaining), #(offer_IDs: $e._M_savedMessageIdArray), #([input_count]: $e._M_messageArray._M_count), #(input_values: $e._M_messageArray), #(messages: $e._M_messageBuffer), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_target: $e._M_connectedTargets._M_connectedLink), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::multitype_join from ;------------------------------------------------------------------------------ Concurrency::multitype_join<*,*>{ preview ( #( "[", $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index - $e._M_pJoinNode->_M_counter, "/", $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index, "]", $e._M_sourceTuple ) ) children ( #( #([join_type]: (Concurrency::join_type)$T2), #([offer_count]: $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index - $e._M_pJoinNode->_M_counter), #([input_count]: $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index), #(source_tuple: $e._M_sourceTuple), #(messages: $e._M_pJoinNode->_M_messageBuffer), #(linked_sources: $e._M_pJoinNode->_M_connectedSources._M_links), #(linked_target: $e._M_pJoinNode->_M_connectedTargets._M_connectedLink), #(reserving_target: *($e._M_pJoinNode->_M_pReservedFor)), #(Scheduler: *($e._M_pJoinNode->_M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_pJoinNode->_M_messageProcessor._M_pScheduleGroup)), #([raw _M_pSourceJoins] : $e._M_pSourceJoins) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::timer from ;------------------------------------------------------------------------------ Concurrency::timer<*>{ preview ( #( $e._M_state ) ) children ( #( #(state: $e._M_state), #(value: $e._M_value), #(repeating: $e._M_fRepeating), #(interval_ms: $e._M_ms), #(linked_target: *($e._M_connectedTargets._M_connectedLink)), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::SchedulerBase from ; Concurrency::details::ThreadScheduler from ; Concurrency::details::UMSThreadScheduler from ;------------------------------------------------------------------------------ Concurrency::details::SchedulerBase|Concurrency::details::ThreadScheduler|Concurrency::details::UMSThreadScheduler{ preview ( #( "[", $e.m_id, "] ", #if ($e.m_schedulerKind == 0) ("ThreadScheduler") #else ("UmsScheduler"), #if ($e.m_id == $e.s_pDefaultScheduler->m_id) (", default") #else ("") ) ) children ( #( #(ID: $e.m_id), #(SchedulerPolicy: $e.m_policy), #(VirtualProcessorCount: $e.m_virtualProcessorCount), #(ReferenceCount: $e.m_refCount), #([isDefaultScheduler]: $e.m_id == $e.s_pDefaultScheduler->m_id) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::ScheduleGroupBase from ; Concurrency::details::CacheLocalScheduleGroup from ; Concurrency::details::FairScheduleGroup from ;------------------------------------------------------------------------------ Concurrency::details::ScheduleGroupBase|Concurrency::details::CacheLocalScheduleGroup|Concurrency::details::FairScheduleGroup{ preview ( #( "[", $e.m_id, "]", #if ($e.m_kind & 4) (" AnonymousScheduleGroup") #else ("") ) ) children ( #( #(ID: $e.m_id), #(Scheduler: *($e.m_pScheduler)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::ContextBase from ; Concurrency::details::InternalContextBase from ; Concurrency::details::ThreadInternalContext from ; Concurrency::details::UMSThreadInternalContext from ;------------------------------------------------------------------------------ Concurrency::details::ContextBase|Concurrency::details::InternalContextBase|Concurrency::details::ThreadInternalContext|Concurrency::details::UMSThreadInternalContext{ preview ( #( "[", $e.m_threadId, "] ", #if ($e.m_blockedState == 0) ("not_concrt_blocked") #elif ($e.m_blockedState == 1) ("concrt_blocked") #elif ($e.m_blockedState == 2) ("ums_sync_blocked") #elif ($e.m_blockedState == 4) ("ums_async_blocked") #else ("") ) ) children ( #( #(ID: $e.m_id), #(ThreadID: $e.m_threadId), #(Scheduler: *($e.m_pScheduler)), #(ScheduleGroup: *($e.m_pGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::ExternalContextBase from ;------------------------------------------------------------------------------ Concurrency::details::ExternalContextBase{ preview ( #( "[", $e.m_threadId, "] ", #if ($e.m_contextSwitchingFence == 1) ("concrt_blocked") #else ("not_concrt_blocked") ) ) children ( #( #(ID: $e.m_id), #(ThreadID: $e.m_threadId), #(Scheduler: *($e.m_pScheduler)), #(ScheduleGroup: *($e.m_pGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::SchedulerPolicy from ;------------------------------------------------------------------------------ Concurrency::SchedulerPolicy{ preview ( #( $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulerKind, ", Min=", $e._M_pPolicyBag->_M_values._M_specificValues._M_minConcurrency, ", Max=", $e._M_pPolicyBag->_M_values._M_specificValues._M_maxConcurrency ) ) children ( #( #(SchedulerKind: $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulerKind), #(MinConcurrency: $e._M_pPolicyBag->_M_values._M_specificValues._M_minConcurrency), #(MaxConcurrency: $e._M_pPolicyBag->_M_values._M_specificValues._M_maxConcurrency), #(TargetOversubscriptionFactor: $e._M_pPolicyBag->_M_values._M_specificValues._M_targetOversubscriptionFactor), #(LocalContextCacheSize: $e._M_pPolicyBag->_M_values._M_specificValues._M_localContextCacheSize), #(ContextStackSize: $e._M_pPolicyBag->_M_values._M_specificValues._M_contextStackSize), #(ContextPriority: $e._M_pPolicyBag->_M_values._M_specificValues._M_contextPriority), #(SchedulingProtocol: $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulingProtocol), #(DynamicProgressFeedback: $e._M_pPolicyBag->_M_values._M_specificValues._M_dynamicProgressFeedback) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::event from ;------------------------------------------------------------------------------ Concurrency::event{ preview ( #( #if ($e._M_pWaitChain == 1) ("set") #else ("not_set") ) ) children ( #( #([is_set]: ($e._M_pWaitChain == 1)), #([has_waiters]: (($e._M_pWaitChain != 0) && ($e._M_pWaitChain != 1))) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::critical_section from ;------------------------------------------------------------------------------ Concurrency::critical_section{ preview ( #( #if ($e._M_pHead != 0) ("locked") #else ("not_locked") ) ) children ( #( #([is_locked]: ($e._M_pHead != 0)), #(OwningContext: *((Concurrency::Context*)($e._M_activeNode[0]))) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::critical_section::scoped_lock from ;------------------------------------------------------------------------------ Concurrency::critical_section::scoped_lock{ preview ( #( $e._M_critical_section ) ) children ( #( CriticalSection: $e._M_critical_section ) ) } ;------------------------------------------------------------------------------ ; Concurrency::reader_writer_lock from ;------------------------------------------------------------------------------ Concurrency::reader_writer_lock{ preview ( #( #if (($e._M_lockState < 8) && ($e._M_lockState & 2)) ("held_by_writer") #elif ($e._M_lockState >= 8) ( #( "held_by_reader(s) [", ($e._M_lockState / 8), "]" ) ) #else ("not_held") ) ) children ( #( #([is_reader_lock_held]: ($e._M_lockState >= 8)), #([num_reader_lock_holders]: ($e._M_lockState / 8)), #([is_writer_lock_held]: ($e._M_lockState < 8) && ($e._M_lockState & 2)), #(OwningWriterContext: *((Concurrency::Context*)($e._M_activeWriter[0]))) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::reader_writer_lock::scoped_lock from ; Concurrency::reader_writer_lock::scoped_lock_read from ;------------------------------------------------------------------------------ Concurrency::reader_writer_lock::scoped_lock|Concurrency::reader_writer_lock::scoped_lock_read{ preview ( #( $e._M_reader_writer_lock ) ) children ( #( ReaderWriterLock: $e._M_reader_writer_lock ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_TaskCollectionBase from ;------------------------------------------------------------------------------ Concurrency::details::_TaskCollectionBase{ preview ( #( #if ((((int)$e._M_pException & ~0x3) != 0) && (((int)$e._M_pException & ~0x3) != 0xC)) ("exception") #else ("no_exception") ) ) children ( #( #([has_exception]: (((int)$e._M_pException & ~0x3) != 0) && (((int)$e._M_pException & ~0x3) != 0xC)), #(CreatingContext: *((Concurrency::Context*)$e._M_pOwningContext)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::task_group from ; Concurrency::structured_task_group from ;------------------------------------------------------------------------------ Concurrency::task_group|Concurrency::structured_task_group{ preview ( #( #if ((((int)$e._M_task_collection._M_pException & ~0x3) != 0) && (((int)$e._M_task_collection._M_pException & ~0x3) != 0xC)) ("exception") #else ("no_exception") ) ) children ( #( #([has_exception]: (((int)$e._M_task_collection._M_pException & ~0x3) != 0) && (((int)$e._M_task_collection._M_pException & ~0x3) != 0xC)), #(CreatingContext: *((Concurrency::Context*)$e._M_task_collection._M_pOwningContext)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::task_handle from ;------------------------------------------------------------------------------ Concurrency::task_handle<*>{ preview ( #( $e._M_function ) ) children ( #( #(Function: $e._M_function), #(RuntimeOwnsLifetime: $e._M_fRuntimeOwnsLifetime), #(TaskCollection: *($e._M_pTaskCollection)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::combinable from ;------------------------------------------------------------------------------ Concurrency::combinable<*>{ preview( #( "(", #array( expr: *($e._M_buckets[$i]), size: $e._M_size ) : #list( head: $e, next: _M_chain ) : $e._M_value, ")" ) ) children( #( #array( expr: *($e._M_buckets[$i]), size: $e._M_size ) : #list( head: $e, next: _M_chain ) : $e._M_value, #(InitFunction : $e._M_fnInitialize) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::concurrent_vector from ;------------------------------------------------------------------------------ Concurrency::concurrent_vector<*,*>{ preview( #( "[", $e._My_early_size._M_value, "](", #array ( expr: #( #if (($i >> 1) == 0) ((($T1*)$e._My_segment._M_value[0]._My_array)[$i]) #else ((($T1*)$e._My_segment._M_value[__log2($i)]._My_array)[$i - (0x1 << __log2($i))]) ), size: $e._My_early_size._M_value ), ")" ) ) children( #( [size] : $e._My_early_size._M_value, #array ( expr: #( #if (($i >> 1) == 0) ((($T1*)$e._My_segment._M_value[0]._My_array)[$i]) #else ((($T1*)$e._My_segment._M_value[__log2($i)]._My_array)[$i - (0x1 << __log2($i))]) ), size: $e._My_early_size._M_value ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_Vector_iterator from ;------------------------------------------------------------------------------ Concurrency::details::_Vector_iterator,*>{ preview( #( #if (($e._My_index >> 1) == 0) ((($T1*)$e._My_vector->_My_segment._M_value[0]._My_array)[$e._My_index]) #else ((($T1*)$e._My_vector->_My_segment._M_value[__log2($e._My_index)]._My_array)[$e._My_index - (0x1 << __log2($e._My_index))]) ) ) children( #( [ptr]: #if (($e._My_index >> 1) == 0) (&((($T1*)$e._My_vector->_My_segment._M_value[0]._My_array)[$e._My_index])) #else (&((($T1*)$e._My_vector->_My_segment._M_value[__log2($e._My_index)]._My_array)[$e._My_index - (0x1 << __log2($e._My_index))])) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::concurrent_queue from ;------------------------------------------------------------------------------ Concurrency::concurrent_queue<*,*>{ preview ( #( "[", $e._My_rep->_Tail_counter._M_value - $e._My_rep->_Head_counter._M_value, "](", #array ( expr : #if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 0) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 1) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 2) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 3) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 4) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 5) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 6) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 7) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 8) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 9) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 10) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 11) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 12) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 13) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 14) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 15) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 16) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 17) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 18) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 19) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])))))))))))))))))))), size : #if ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value < 20*8*$e._Items_per_page) ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value) #else (20*8*$e._Items_per_page) ), ")" ) ) children ( #( #([unsafe_size]: $e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value), #array ( expr : #if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 0) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 1) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 2) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 3) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 4) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 5) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 6) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 7) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 8) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 9) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 10) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 11) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 12) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 13) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 14) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 15) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 16) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 17) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 18) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 19) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])))))))))))))))))))), size : #if ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value < 20*8*$e._Items_per_page) ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value) #else (20*8*$e._Items_per_page) ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_Concurrent_queue_iterator from ;------------------------------------------------------------------------------ Concurrency::details::_Concurrent_queue_iterator,*>{ preview( #( *(($T1*)$e._My_item) ) ) children( #( [ptr]: (($T1*)$e._My_item) ) ) } ; This section lets you define your own errors for the HRESULT display. ; You need to list the error code in unsigned decimal, followed by the message. ; Changes will take effect the next time you redisplay the variable. [hresult] ;1234=my custom error code [Visualizer] glm::detail::tvec2<*>{ preview ( #(#($c.x,$c.y)) ) children ( #([x]: $c.x,[y]: $c.y) ) } glm::detail::tvec3<*>{ preview ( #($e.x,$e.y,$e.z) ) children ( #([x]: $e.x,[y]: $e.y,[z]: $e.z) ) } glm::detail::tvec4<*>{ preview ( #($c.x,$c.y,$c.z,$c.w) ) children ( #([x]: $e.x,[y]: $e.y,[z]: $e.z, #([w]: $e.w)) ) } glm-0.9.9-a2/util/autoexp.txt0000600000175000001440000000066213173131001014677 0ustar guususers[Visualizer] glm::detail::tvec2<*>{ preview ( #(#($c.x,$c.y)) ) children ( #([x]: $c.x,[y]: $c.y) ) } glm::detail::tvec3<*>{ preview ( #($e.x,$e.y,$e.z) ) children ( #([x]: $e.x,[y]: $e.y,[z]: $e.z) ) } glm::detail::tvec4<*>{ preview ( #($c.x,$c.y,$c.z,$c.w) ) children ( #([x]: $e.x,[y]: $e.y,[z]: $e.z, #([w]: $e.w)) ) } glm-0.9.9-a2/doc/0000700000175000001440000000000013233403571012246 5ustar guususersglm-0.9.9-a2/doc/man.doxy0000600000175000001440000031642713173131001013732 0ustar guususers# Doxyfile 1.8.10 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all text # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv # built into libc) for the transcoding. See http://www.gnu.org/software/libiconv # for the list of possible encodings. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = "0.9.9 API documenation" # The PROJECT_NUMBER tag can be used to enter a project or revision number. This # could be handy for archiving the generated documentation or if some version # control system is used. PROJECT_NUMBER = # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = # With the PROJECT_LOGO tag one can specify a logo or an icon that is included # in the documentation. The maximum height of the logo should not exceed 55 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy # the logo to the output directory. PROJECT_LOGO = G:/Source/G-Truc/glm/doc/manual/logo-mini.png # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. If a relative path is # entered, it will be relative to the location where doxygen was started. If # left blank the current directory will be used. OUTPUT_DIRECTORY = . # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this # option can be useful when feeding doxygen a huge amount of source files, where # putting all generated files in the same directory would otherwise causes # performance problems for the file system. # The default value is: NO. CREATE_SUBDIRS = NO # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII # characters to appear in the names of generated files. If set to NO, non-ASCII # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode # U+3044. # The default value is: NO. ALLOW_UNICODE_NAMES = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, # Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member # descriptions after the members that are listed in the file and class # documentation (similar to Javadoc). Set to NO to disable this. # The default value is: YES. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief # description of a member or function before the detailed description # # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. # The default value is: YES. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator that is # used to form the text in various listings. Each string in this list, if found # as the leading text of the brief description, will be stripped from the text # and the result, after processing the whole list, is used as the annotated # text. Otherwise, the brief description is used as-is. If left blank, the # following values are used ($name is automatically replaced with the name of # the entity):The $name class, The $name widget, The $name file, is, provides, # specifies, contains, represents, a, an and the. ABBREVIATE_BRIEF = "The $name class " \ "The $name widget " \ "The $name file " \ is \ provides \ specifies \ contains \ represents \ a \ an \ the # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # doxygen will generate a detailed section even if there is only a brief # description. # The default value is: NO. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. # The default value is: NO. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path # before files name in the file list and in the header files. If set to NO the # shortest path that makes the file name unique will be used # The default value is: YES. FULL_PATH_NAMES = NO # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. # Stripping is only done if one of the specified strings matches the left-hand # part of the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the path to # strip. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = "C:/Documents and Settings/Groove/ " # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the # path mentioned in the documentation of a class, which tells the reader which # header file to include in order to use a class. If left blank only the name of # the header file containing the class definition is used. Otherwise one should # specify the list of include paths that are normally passed to the compiler # using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but # less readable) file names. This can be useful is your file systems doesn't # support long names like on DOS, Mac, or CD-ROM. # The default value is: NO. SHORT_NAMES = YES # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the # first line (until the first dot) of a Javadoc-style comment as the brief # description. If set to NO, the Javadoc-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = YES # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first # line (until the first dot) of a Qt-style comment as the brief description. If # set to NO, the Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a # multi-line C++ special comment block (i.e. a block of //! or /// comments) as # a brief description. This used to be the default behavior. The new default is # to treat a multi-line C++ comment block as a detailed description. Set this # tag to YES if you prefer the old behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new # page for each member. If set to NO, the documentation of a member will be part # of the file/class/namespace that contains it. # The default value is: NO. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen # uses this value to replace tabs by spaces in code fragments. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that act as commands in # the documentation. An alias has the form: # name=value # For example adding # "sideeffect=@par Side Effects:\n" # will allow you to put the command \sideeffect (or @sideeffect) in the # documentation, which will result in a user-defined paragraph with heading # "Side Effects:". You can put \n's in the value part of an alias to insert # newlines. ALIASES = # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding "class=itcl::class" # will allow you to use the command class in the itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all # members will be omitted, etc. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for VHDL. # The default value is: NO. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, and # language is one of the parsers supported by doxygen: IDL, Java, Javascript, # C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: # FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: # Fortran. In the later case the parser tries to guess whether the code is fixed # or free formatted code, this is the default for Fortran type files), VHDL. For # instance to make doxygen treat .inc files as Fortran files (default is PHP), # and .f files as C (default is Fortran), use: inc=Fortran f=C. # # Note: For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. EXTENSION_MAPPING = # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See http://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by putting a % sign in front of the word or # globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should set this # tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = NO # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen # will parse them like normal C++ but will assume all classes use public instead # of private inheritance when no explicit protection keyword is present. # The default value is: NO. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES will make # doxygen to replace the get and set methods by a property in the documentation. # This will only work if the methods are indeed getting or setting a simple # type. If this is not the case, or you want to show the methods anyway, you # should set this option to NO. # The default value is: YES. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. # The default value is: NO. DISTRIBUTE_GROUP_DOC = NO # If one adds a struct or class to a group and this option is enabled, then also # any nested class or struct is added to the same group. By default this option # is disabled and one has to add nested compounds explicitly via \ingroup. # The default value is: NO. GROUP_NESTED_COMPOUNDS = NO # Set the SUBGROUPING tag to YES to allow class member groups of the same type # (for instance a group of public functions) to be put as a subgroup of that # type (e.g. under the Public Functions section). Set it to NO to prevent # subgrouping. Alternatively, this can be done per class using the # \nosubgrouping command. # The default value is: YES. SUBGROUPING = NO # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or # enum is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically be # useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in # documentation are documented, even if no documentation was available. Private # class members and static file members will be hidden unless the # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = NO # If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = NO # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES, all static members of a file will be # included in the documentation. # The default value is: NO. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined # locally in source files will be included in the documentation. If set to NO, # only classes defined in header files are included. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = NO # This flag is only useful for Objective-C code. If set to YES, local methods, # which are defined in the implementation section but not in the interface are # included in the documentation. If set to NO, only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base name of # the file that contains the anonymous namespace. By default anonymous namespace # are hidden. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO these # members will be included in the various overviews, but no documentation # section is generated. This option has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_MEMBERS = YES # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. If set # to NO, these classes will be included in the various overviews. This option # has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = YES # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # (class|struct|union) declarations. If set to NO, these declarations will be # included in the documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = YES # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any # documentation blocks found inside the body of a function. If set to NO, these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = YES # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file # names in lower-case letters. If set to YES, upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. # The default value is: system dependent. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES, the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = YES # If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will # append additional text to a page's title, such as Class Reference. If set to # YES the compound reference will be hidden. # The default value is: NO. HIDE_COMPOUND_REFERENCE= NO # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = NO # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each # grouped member an include statement to the documentation, telling the reader # which file to include in order to use the member. # The default value is: NO. SHOW_GROUPED_MEMB_INC = NO # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = NO # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the # (detailed) documentation of file and class members alphabetically by member # name. If set to NO, the members will appear in declaration order. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO, the members will appear in declaration order. Note that # this will also influence the order of the classes in the class list. # The default value is: NO. SORT_BRIEF_DOCS = YES # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy # of group names into alphabetical order. If set to NO the group names will # appear in their defined order. # The default value is: NO. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by # fully-qualified names, including namespaces. If set to NO, the class list will # be sorted only by class name, not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the alphabetical # list. # The default value is: NO. SORT_BY_SCOPE_NAME = YES # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo # list. This list is created by putting \todo commands in the documentation. # The default value is: YES. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test # list. This list is created by putting \test commands in the documentation. # The default value is: YES. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug # list. This list is created by putting \bug commands in the documentation. # The default value is: YES. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) # the deprecated list. This list is created by putting \deprecated commands in # the documentation. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have for it to appear in the # documentation. If the initializer consists of more lines than specified here # it will be hidden. Use a value of 0 to hide initializers completely. The # appearance of the value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at # the bottom of the documentation of classes and structs. If set to YES, the # list will mention the files that were used to generate the documentation. # The default value is: YES. SHOW_USED_FILES = NO # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This # will remove the Files entry from the Quick Index and from the Folder Tree View # (if specified). # The default value is: YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces # page. This will remove the Namespaces entry from the Quick Index and from the # Folder Tree View (if specified). # The default value is: YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. You can # optionally specify a file name after the option, if omitted DoxygenLayout.xml # will be used as the name of the layout file. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. See also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error (stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some parameters # in a documented function, or documenting parameters that don't exist or using # markup commands wrongly. # The default value is: YES. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO, doxygen will only warn about wrong or incomplete # parameter documentation, but not about the absence of documentation. # The default value is: NO. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that doxygen # can produce. The string should contain the $file, $line, and $text tags, which # will be replaced by the file and line number from which the warning originated # and the warning text. Optionally the format may contain $version, which will # be replaced by the version of the file (if it could be obtained via # FILE_VERSION_FILTER) # The default value is: $file:$line: $text. WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning and error # messages should be written. If left blank the output is written to standard # error (stderr). WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is used to specify the files and/or directories that contain # documented source files. You may enter file names like myfile.cpp or # directories like /usr/src/myproject. Separate the files or directories with # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING # Note: If this tag is empty the current directory is searched. INPUT = ../glm \ . # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: http://www.gnu.org/software/libiconv) for the list of # possible encodings. # The default value is: UTF-8. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and # *.h) to filter out the source-files in the directories. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # read by doxygen. # # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp, # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, # *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, # *.vhdl, *.ucf, *.qsf, *.as and *.js. FILE_PATTERNS = *.hpp \ *.doxy # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = YES # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories use the pattern */test/* EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or directories # that contain example code fragments that are included (see the \include # command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank all # files are included. EXAMPLE_PATTERNS = * # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude commands # irrespective of the value of the RECURSIVE tag. # The default value is: NO. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be included in the documentation (see the # \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command: # # # # where is the value of the INPUT_FILTER tag, and is the # name of an input file. Doxygen will then use the output that the filter # program writes to standard output. If FILTER_PATTERNS is specified, this tag # will be ignored. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: pattern=filter # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = NO # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will be # generated. Documented entities will be cross-referenced with these sources. # # Note: To get rid of all source code in the generated output, make sure that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = YES # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES then for each documented # function all documented functions referencing it will be listed. # The default value is: NO. REFERENCED_BY_RELATION = YES # If the REFERENCES_RELATION tag is set to YES then for each documented function # all documented entities called/used by that function will be listed. # The default value is: NO. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set # to YES then the hyperlinks from functions in REFERENCES_RELATION and # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will # link to the documentation. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = YES # If the USE_HTAGS tag is set to YES then the references to source code will # point to the HTML generated by the htags(1) tool instead of doxygen built-in # source browser. The htags tool is part of GNU's global source tagging system # (see http://www.gnu.org/software/global/global.html). You will need version # 4.8.6 or higher. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the config file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a # verbatim copy of the header file for each class for which an include is # specified. Set to NO to disable this. # See also: Section \class. # The default value is: YES. VERBATIM_HEADERS = YES # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the # clang parser (see: http://clang.llvm.org/) for more accurate parsing at the # cost of reduced performance. This can be particularly helpful with template # rich C++ code for which doxygen's built-in parser lacks the necessary type # information. # Note: The availability of this option depends on whether or not doxygen was # compiled with the --with-libclang option. # The default value is: NO. CLANG_ASSISTED_PARSING = NO # If clang assisted parsing is enabled you can provide the compiler with command # line options that you would normally use when invoking the compiler. Note that # the include paths will already be set by doxygen for the files and directories # specified with INPUT and INCLUDE_PATH. # This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. CLANG_OPTIONS = #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all # compounds will be generated. Enable this if the project contains a lot of # classes, structs, unions or interfaces. # The default value is: YES. ALPHABETICAL_INDEX = NO # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in # which the alphabetical index list will be split. # Minimum value: 1, maximum value: 20, default value: 5. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all classes will # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag # can be used to specify a prefix (or a list of prefixes) that should be ignored # while generating the index headers. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output # The default value is: YES. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of # it. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each # generated HTML page (for example: .htm, .php, .asp). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style # sheet that is used by each HTML page. It can be used to fine-tune the look of # the HTML output. If left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined # cascading style sheets that are included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefore more robust against future updates. # Doxygen will copy the style sheet files to the output directory. # Note: The order of the extra style sheet files is of importance (e.g. the last # style sheet in the list overrules the setting of the previous ones in the # list). For an example see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the style sheet and background images according to # this color. Hue is specified as an angle on a colorwheel, see # http://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use grayscales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting this # to YES can help to show when doxygen was last run and thus if the # documentation is up to date. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_TIMESTAMP = NO # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = NO # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files will be # generated that can be used as input for Apple's Xcode 3 integrated development # environment (see: http://developer.apple.com/tools/xcode/), introduced with # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a # Makefile in the HTML output directory. Running make will produce the docset in # that directory and running make install will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at # startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html # for more information. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = NO # This tag determines the name of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "Doxygen generated docs" # This tag specifies a string that should uniquely identify the documentation # set bundle. This should be a reverse domain-name style string, e.g. # com.mycompany.MyDocSet. Doxygen will append .docset to the name. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = org.doxygen.Project # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on # Windows. # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = NO # The CHM_FILE tag can be used to specify the file name of the resulting .chm # file. You can add a path in front of the file if the result should not be # written to the html output directory. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # The HHC_LOCATION tag can be used to specify the location (absolute path # including file name) of the HTML help compiler (hhc.exe). If non-empty, # doxygen will try to run the HTML help compiler on the generated index.hhp. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # The GENERATE_CHI flag controls if a separate .chi index file is generated # (YES) or that it should be included in the master .chm file (NO). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # The BINARY_TOC flag controls whether a binary table of contents is generated # (YES) or a normal table of contents (NO) in the .chm file. Furthermore it # enables the Previous and Next buttons. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help # (.qch) of the generated HTML documentation. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify # the file name of the resulting .qch file. The path specified is relative to # the HTML output folder. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- # folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's filter section matches. Qt Help Project / Filter Attributes (see: # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # The QHG_LOCATION tag can be used to specify the location of Qt's # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the # generated .qhp file. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = NO # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = org.doxygen.Project # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. If the tag # value is set to YES, a side panel will be generated containing a tree-like # index structure (just like the one that is generated for HTML Help). For this # to work a browser that supports JavaScript, DHTML, CSS and frames is required # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can # further fine-tune the look of the index. As an example, the default style # sheet generated by doxygen has an example that shows how to put an image at # the root of the tree instead of the PROJECT_NAME. Since the tree basically has # the same information as the tab index, you could consider setting # DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = NO # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 4 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used # to set the initial width (in pixels) of the frame in which the tree is shown. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. When you change the font size after a successful # doxygen run you need to manually remove any form_*.png images from the HTML # output directory to force them to be regenerated. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are not # supported properly for IE 6.0, but are supported on all modern browsers. # # Note that when changing this option you need to delete any form_*.png files in # the HTML output directory before the changes have effect. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # http://www.mathjax.org) which uses client side Javascript for the rendering # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # the MathJax output. See the MathJax site (see: # http://docs.mathjax.org/en/latest/output.html) for more details. # Possible values are: HTML-CSS (which is slower, but has the best # compatibility), NativeMML (i.e. MathML) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from http://www.mathjax.org before deployment. # The default value is: http://cdn.mathjax.org/mathjax/latest. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = http://www.mathjax.org/mathjax # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , /