Merge branch 'vanilla_0.4.4' and resolve conflicts

TODO: Validate for removed patches due to relocation

Resolved Conflicts:
	LibOVR/Src/Kernel/OVR_ThreadsWinAPI.cpp
	LibOVR/Src/OVR_Linux_HMDDevice.cpp
	LibOVR/Src/OVR_OSX_HMDDevice.cpp
	LibOVR/Src/OVR_Profile.cpp
	LibOVR/Src/OVR_Sensor2Impl.cpp
	LibOVR/Src/OVR_SensorFusion.cpp
	LibOVR/Src/OVR_SensorImpl.cpp
	LibOVR/Src/OVR_Win32_DeviceStatus.cpp
	LibOVR/Src/OVR_Win32_HIDDevice.cpp
	LibOVR/Src/OVR_Win32_HIDDevice.h
	LibOVR/Src/OVR_Win32_HMDDevice.cpp

1 files changed, 1524 insertions, 0 deletions

diff --git a/LibOVR/Src/Kernel/OVR_Compiler.h b/LibOVR/Src/Kernel/OVR_Compiler.h
new file mode 100644
index 0000000..93a4181
--- /dev/null
+++ b/LibOVR/Src/Kernel/OVR_Compiler.h
@@ -0,0 +1,1524 @@
+/************************************************************************************
+
+PublicHeader:   OVR.h
+Filename    :   OVR_Compiler.h
+Content     :   Compiler-specific feature identification and utilities
+Created     :   June 19, 2014
+Notes       : 
+
+Copyright   :   Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License"); 
+you may not use the Oculus VR Rift SDK except in compliance with the License, 
+which is provided at the time of installation or download, or which 
+otherwise accompanies this software in either electronic or hard copy form.
+
+You may obtain a copy of the License at
+
+http://www.oculusvr.com/licenses/LICENSE-3.2 
+
+Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+
+#ifndef OVR_Compiler_h
+#define OVR_Compiler_h
+
+#pragma once
+
+
+// References
+//    https://gcc.gnu.org/projects/cxx0x.html
+//    https://gcc.gnu.org/projects/cxx1y.html
+//    http://clang.llvm.org/cxx_status.html
+//    http://msdn.microsoft.com/en-us/library/hh567368.aspx
+//    https://docs.google.com/spreadsheet/pub?key=0AoBblDsbooe4dHZuVTRoSTFBejk5eFBfVk1GWlE5UlE&output=html
+//    http://nadeausoftware.com/articles/2012/10/c_c_tip_how_detect_compiler_name_and_version_using_compiler_predefined_macros
+
+
+//-----------------------------------------------------------------------------------
+// ***** Compiler
+//
+//  The following compilers are defined: (OVR_CC_x)
+//
+//     MSVC     - Microsoft Visual C/C++
+//     INTEL    - Intel C++ for Linux / Windows
+//     GNU      - GNU C++
+//     ARM      - ARM C/C++
+
+#if defined(__INTEL_COMPILER)
+// Intel 4.0                    = 400
+// Intel 5.0                    = 500
+// Intel 6.0                    = 600
+// Intel 8.0                    = 800
+// Intel 9.0                    = 900
+#  define OVR_CC_INTEL       __INTEL_COMPILER
+
+#elif defined(_MSC_VER)
+// MSVC 5.0                     = 1100
+// MSVC 6.0                     = 1200
+// MSVC 7.0 (VC2002)            = 1300
+// MSVC 7.1 (VC2003)            = 1310
+// MSVC 8.0 (VC2005)            = 1400
+// MSVC 9.0 (VC2008)            = 1500
+// MSVC 10.0 (VC2010)           = 1600
+// MSVC 11.0 (VC2012) = 1700
+// MSVC 12.0 (VC2013)           = 1800
+#  define OVR_CC_MSVC        _MSC_VER
+
+#if _MSC_VER == 0x1600
+#  if _MSC_FULL_VER < 160040219
+#     error "Oculus does not support VS2010 without SP1 installed."
+#  endif
+#endif
+
+#elif defined(__GNUC__)
+#  define OVR_CC_GNU
+
+#elif defined(__clang__)
+#  define OVR_CC_CLANG
+
+#elif defined(__CC_ARM)
+#  define OVR_CC_ARM
+
+#else
+#  error "Oculus does not support this Compiler"
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CC_VERSION
+//
+//    M = major version
+//    m = minor version
+//    p = patch release
+//    b = build number
+//
+//    Compiler      Format   Example
+//    ----------------------------
+//    OVR_CC_GNU    Mmm      408 means GCC 4.8
+//    OVR_CC_CLANG  Mmm      305 means clang 3.5 
+//    OVR_CC_MSVC   MMMM     1700 means VS2012
+//    OVR_CC_ARM    Mmpbbb   401677 means 4.0, patch 1, build 677
+//    OVR_CC_INTEL  MMmm     1210 means 12.10
+//    OVR_CC_EDG    Mmm      407 means EDG 4.7
+//
+#if defined(OVR_CC_GNU)
+    #define OVR_CC_VERSION ((__GNUC__ * 100) + __GNUC_MINOR__)
+#elif defined(OVR_CC_CLANG)
+    #define OVR_CC_VERSION ((__clang_major__ * 100) + __clang_minor__)
+#elif defined(OVR_CC_MSVC)
+    #define OVR_CC_VERSION _MSC_VER // Question: Should we recognize _MSC_FULL_VER?
+#elif defined(OVR_CC_ARM)
+    #define OVR_CC_VERSION __ARMCC_VERSION
+#elif defined(OVR_CC_INTEL)
+    #if defined(__INTEL_COMPILER)
+        #define OVR_CC_VERSION __INTEL_COMPILER
+    #elif defined(__ICL)
+        #define OVR_CC_VERSION __ICL
+    #elif defined(__ICC)
+        #define OVR_CC_VERSION __ICC
+    #elif defined(__ECC)
+        #define OVR_CC_VERSION __ECC
+    #endif
+#elif defined(OVR_CC_EDG)
+    #define OVR_CC_VERSION __EDG_VERSION__  // This is a generic fallback for EDG-based compilers which aren't specified above (e.g. as OVR_CC_ARM)
+#endif
+
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_DISABLE_OPTIMIZATION / OVR_RESTORE_OPTIMIZATION
+//
+// Allows for the dynamic disabling and restoring of compiler optimizations in code.
+// This is useful for helping deal with potential compiler code generation problems.
+// With VC++ the usage must be outside of function bodies. This can be used only to
+// temporarily disable optimization for a block of code and not to temporarily enable
+// optimization for a block of code.
+//
+// Clang doesn't support this as of June 2014, though function __attribute__((optimize(0))
+// is supposedly supported by clang in addition to GCC. To consider: Make a wrapper for
+// this attribute-based functionality.
+//
+// Example usage:
+//     OVR_DISABLE_OPTIMIZATION()
+//     void Test() { ... }
+//     OVR_RESTORE_OPTIMIZATION()
+//
+#if !defined(OVR_DISABLE_OPTIMIZATION)
+    #if defined(OVR_CC_GNU) && (OVR_CC_VERSION > 404) && (defined(OVR_CPU_X86) || defined(OVR_CPU_X86_64))
+        #define OVR_DISABLE_OPTIMIZATION() \
+            _Pragma("GCC push_options")    \
+            _Pragma("GCC optimize 0")
+    #elif defined(OVR_CC_MSVC)
+        #define OVR_DISABLE_OPTIMIZATION() __pragma(optimize("", off))
+    #else
+        #define OVR_DISABLE_OPTIMIZATION()
+    #endif
+#endif
+
+#if !defined(OVR_RESTORE_OPTIMIZATION)
+    #if defined(OVR_CC_GNU) && (OVR_CC_VERSION > 404) && (defined(OVR_CPU_X86) || defined(OVR_CPU_X86_64))
+        #define OVR_RESTORE_OPTIMIZATION() _Pragma("GCC pop_options")
+    #elif defined(OVR_CC_MSVC)
+        #define OVR_RESTORE_OPTIMIZATION() __pragma(optimize("", on))
+    #else
+        #define OVR_RESTORE_OPTIMIZATION()
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// *****  OVR_DISABLE_GNU_WARNING / OVR_RESTORE_GNU_WARNING
+//
+// Portable wrapper for disabling GCC compiler warnings, one at a time. See example
+// usage for usage by example.
+//
+// Example usage:
+//     OVR_DISABLE_GNU_WARNING(-Wmissing-braces)  // Only one warning per usage.
+//     OVR_DISABLE_GNU_WARNING(-Wunused-variable)
+//     <code>
+//     OVR_RESTORE_GNU_WARNINGS()
+//     OVR_RESTORE_GNU_WARNINGS()                 // Must match each disable with a restore.
+//
+#if !defined(OVR_DISABLE_GNU_WARNING)
+    #if defined(OVR_CC_GNU)
+        #define ODGW1(x) #x
+        #define ODGW2(x) ODGW1(GCC diagnostic ignored x)
+        #define ODGW3(x) ODGW2(#x)
+    #endif
+
+    #if defined(OVR_CC_GNU) && (OVR_CC_VERSION >= 406)
+        #define OVR_DISABLE_GNU_WARNING(w)  \
+            _Pragma("GCC diagnostic push")  \
+            _Pragma(ODGW3(w))
+    #elif defined(OVR_CC_GNU) && (OVR_CC_VERSION >= 404)  // GCC 4.4 doesn't support diagnostic push, but supports disabling warnings.
+        #define OVR_DISABLE_GNU_WARNING(w)  \
+            _Pragma(ODGW3(w))
+    #else
+        #define OVR_DISABLE_GNU_WARNING(w)
+    #endif
+#endif
+
+#if !defined(OVR_RESTORE_GNU_WARNING)
+    #if defined(OVR_CC_GNU) && (OVR_CC_VERSION >= 4006)
+        #define OVR_RESTORE_GNU_WARNINGS()  \
+            _Pragma("GCC diagnostic pop")
+    #else
+        #define OVR_RESTORE_GNU_WARNING()
+    #endif
+#endif
+
+
+
+// -----------------------------------------------------------------------------------
+// *****  OVR_DISABLE_CLANG_WARNING / OVR_RESTORE_CLANG_WARNING
+//
+// Portable wrapper for disabling GCC compiler warnings, one at a time. See example
+// usage for usage by example.
+//
+// Example usage:
+//     OVR_DISABLE_CLANG_WARNING(-Wmissing-braces)  // Only one warning per usage.
+//     OVR_DISABLE_CLANG_WARNING(-Wunused-variable)
+//     <code>
+//     OVR_RESTORE_CLANG_WARNINGS()
+//     OVR_RESTORE_CLANG_WARNINGS()                 // Must match each disable with a restore.
+//
+//
+#if !defined(OVR_DISABLE_CLANG_WARNING)
+    #if defined(OVR_CC_CLANG)
+        #define ODCW1(x) #x
+        #define ODCW2(x) ODCW1(clang diagnostic ignored x)
+        #define ODCW3(x) ODCW2(#x)
+
+        #define OVR_DISABLE_CLANG_WARNING(w)   \
+            _Pragma("clang diagnostic push")  \
+            _Pragma(ODCW3(w))
+    #else
+        #define OVR_DISABLE_CLANG_WARNING(w)
+    #endif
+#endif
+
+#if !defined(OVR_RESTORE_CLANG_WARNING)
+    #if defined(OVR_CC_CLANG)
+        #define OVR_RESTORE_CLANG_WARNING()    \
+            _Pragma("clang diagnostic pop")
+    #else
+        #define OVR_RESTORE_CLANG_WARNING()
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_DISABLE_MSVC_WARNING / OVR_RESTORE_MSVC_WARNING
+//
+// Portable wrapper for disabling VC++ compiler warnings. See example usage for usage
+// by example.
+//
+// Example usage:
+//     OVR_DISABLE_MSVC_WARNING(4556 4782 4422)
+//     <code>
+//     OVR_RESTORE_MSVC_WARNING()
+//
+#if !defined(OVR_DISABLE_MSVC_WARNING)
+    #if defined(OVR_CC_MSVC)
+        #define OVR_DISABLE_MSVC_WARNING(w) \
+            __pragma(warning(push))         \
+            __pragma(warning(disable:w))
+    #else
+        #define OVR_DISABLE_MSVC_WARNING(w)
+    #endif
+#endif
+
+#if !defined(OVR_RESTORE_MSVC_WARNING)
+    #if defined(OVR_CC_MSVC)
+        #define OVR_RESTORE_MSVC_WARNING() \
+            __pragma(warning(pop))
+    #else
+        #define OVR_RESTORE_MSVC_WARNING()
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_DISABLE_ALL_MSVC_WARNINGS / OVR_RESTORE_ALL_MSVC_WARNINGS
+//
+// Portable wrapper for disabling all VC++ compiler warnings.
+// OVR_RESTORE_ALL_MSVC_WARNINGS restores warnings that were disabled by 
+// OVR_DISABLE_ALL_MSVC_WARNINGS. Any previously enabled warnings will still be 
+// enabled after OVR_RESTORE_ALL_MSVC_WARNINGS.
+//
+// Example usage:
+//     OVR_DISABLE_ALL_MSVC_WARNINGS()
+//     <code>
+//     OVR_RESTORE_ALL_MSVC_WARNINGS()
+
+#if !defined(OVR_DISABLE_ALL_MSVC_WARNINGS)
+    #if defined(OVR_CC_MSVC)
+        #define OVR_DISABLE_ALL_MSVC_WARNINGS() \
+            __pragma(warning(push, 0))
+    #else
+        #define OVR_DISABLE_ALL_MSVC_WARNINGS()
+    #endif
+#endif
+
+#if !defined(OVR_RESTORE_ALL_MSVC_WARNINGS)
+    #if defined(OVR_CC_MSVC)
+        #define OVR_RESTORE_ALL_MSVC_WARNINGS() \
+            __pragma(warning(pop))
+    #else
+        #define OVR_RESTORE_ALL_MSVC_WARNINGS()
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CC_HAS_FEATURE
+//
+// This is a portable way to use compile-time feature identification available 
+// with some compilers in a clean way. Direct usage of __has_feature in preprocessing
+// statements of non-supporting compilers results in a preprocessing error.
+//
+// Example usage:
+//     #if OVR_CC_HAS_FEATURE(is_pod)
+//         if(__is_pod(T)) // If the type is plain data then we can safely memcpy it.
+//             memcpy(&destObject, &srcObject, sizeof(object));
+//     #endif
+//
+#if !defined(OVR_CC_HAS_FEATURE)
+    #if defined(__clang__) // http://clang.llvm.org/docs/LanguageExtensions.html#id2
+        #define OVR_CC_HAS_FEATURE(x) __has_feature(x)
+    #else
+        #define OVR_CC_HAS_FEATURE(x) 0
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CC_HAS_BUILTIN
+//
+//
+// This is a portable way to use compile-time builtin identification available 
+// with some compilers in a clean way. Direct usage of __has_builtin in preprocessing
+// statements of non-supporting compilers results in a preprocessing error.
+//
+// Example usage:
+//     #if OVR_CC_HAS_BUILTIN(__builtin_trap)
+//         #define DEBUG_BREAK __builtin_trap
+//     #endif
+//  
+#if !defined(OVR_CC_HAS_BUILTIN)
+    #if defined(__clang__) 
+        #define OVR_CC_HAS_BUILTIN(x) __has_builtin(x) // http://clang.llvm.org/docs/LanguageExtensions.html#id2
+    #else
+        #define OVR_CC_HAS_BUILTIN(x) 0
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP11_ENABLED / OVR_CPP_CPP14_ENABLED
+//
+// Defined as 1 if the compiler has its available C++11 support enabled, else undefined.
+// This does not mean that all of C++11 or any particular feature of C++11 is supported
+// by the compiler. It means that whatever C++11 support the compiler has is enabled.
+// This also includes existing and older compilers that still identify C++11 as C++0x.
+//
+#if !defined(OVR_CPP11_ENABLED) && defined(__cplusplus)
+    #if defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
+        #define OVR_CPP11_ENABLED 1
+    #elif defined(_MSC_VER) && (_MSC_VER >= 1500)   // VS2010+, the first version with any significant C++11 support. 
+        #define OVR_CPP11_ENABLED 1
+    #elif (__cplusplus >= 201103L)                  // 201103 is the first C++11 version.
+        #define OVR_CPP11_ENABLED 1
+    #else
+        // Leave undefined
+    #endif
+#endif
+
+#if !defined(OVR_CPP_CPP14_ENABLED) && defined(__cplusplus)
+    #if defined(_MSC_VER) && (_MSC_VER >= 1800)     // VS2013+, the first version with any significant C++14 support. 
+        #define OVR_CPP_CPP14_ENABLED 1
+    #elif (__cplusplus > 201103L)
+        #define OVR_CPP_CPP14_ENABLED 1
+    #else
+        // Leave undefined
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_EXCEPTIONS / OVR_CPP_NO_UNWIND
+//
+// OVR_CPP_NO_EXCEPTIONS is defined as 1 if the compiler doesn't support C++ 
+// exceptions or is configured to disable support for them. Else not defined.
+// If OVR_CPP_NO_EXCEPTIONS is defined then attempts to use try/catch
+// related C++ statements result in a compilation error with many
+// compilers.
+//
+// OVR_CPP_NO_UNWIND is defined as 1 if the compiler supports exceptions but 
+// doesn't support stack unwinding in the presence of an exception. Else not defined.
+// For the Microsoft compiler, disabling exceptions means disabling stack unwinding
+// and not disabling exceptions themselves.
+//
+// Example usage:
+//     void Test() {
+//         #if !defined(OVR_CPP_NO_EXCEPTIONS)
+//             try {
+//         #endif
+//             void* ptr = new Object;
+//         #if !defined(OVR_CPP_NO_EXCEPTIONS)
+//             catch(...) { ... }
+//         #endif
+
+#if !defined(OVR_CPP_NO_EXCEPTIONS)
+    #if defined(OVR_CPP_GNUC) && defined(_NO_EX)
+        #define OVR_CPP_NO_EXCEPTIONS 1
+    #elif (defined(OVR_CC_GNU) || defined(OVR_CC_CLANG) || defined(OVR_CC_INTEL) || defined(OVR_CC_ARM)) && !defined(__EXCEPTIONS)
+        #define OVR_CPP_NO_EXCEPTIONS 1
+    #elif defined(OVR_CC_MSVC) && !defined(_CPPUNWIND)
+        #define OVR_CPP_NO_UNWIND 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_RTTI
+//
+// Defined as 1 if C++ run-time type information support is unavailable or disabled
+// by the compiler. Else undefined. Allows you to write portable code in the face
+// of the possibility that RTTI is disabled.
+//
+// Example usage:
+//     #if !OVR_CPP_NO_RTTI
+//         #include <typeinfo>
+//         int x = std::dynamic_cast<int>(3.4f);
+//     #endif
+
+#if defined(__clang__) && !OVR_CC_HAS_FEATURE(cxx_rtti)
+    #define OVR_CPP_NO_RTTI 1
+#elif defined(__GNUC__) && !defined(__GXX_RTTI)
+    #define OVR_CPP_NO_RTTI 1
+#elif defined(_MSC_VER) && !defined(_CPPRTTI)
+    #define OVR_CPP_NO_RTTI 1
+#elif defined(__CC_ARM) && defined(__TARGET_CPU_MPCORE) && !defined(__RTTI)
+    #define OVR_CPP_NO_RTTI 1
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_STATIC_ASSERT
+//
+// Defined as 1 if C++ run-time type information support is available and enabled
+// by the compiler. Else undefined.
+//
+// Example usage:
+//     #if OVR_CPP_NO_STATIC_ASSERT
+//         #define MY_ASSERT(x) { int zero = 0; switch(zero) {case 0: case (x):;} }
+//     #else
+//         #define MY_ASSERT(x) static_assert((x), #x)
+//     #endif
+
+#if !defined(OVR_CPP_NO_STATIC_ASSERT)
+    #if !(defined(__GNUC__) && (defined(__GXX_EXPERIMENTAL_CXX0X__) || (defined(__cplusplus) && (__cplusplus >= 201103L)))) && \
+        !(defined(__clang__) && defined(__cplusplus) && OVR_CC_HAS_FEATURE(cxx_static_assert)) &&                              \
+        !(defined(_MSC_VER) && (_MSC_VER >= 1600) && defined(__cplusplus)) &&                 /* VS2010+  */                   \
+        !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) && defined(OVR_CPP11_ENABLED)) /* EDG 4.1+ */
+	    #define OVR_CPP_NO_STATIC_ASSERT 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_NULLPTR
+//
+// Defined as 1 if the compiler doesn't support C++11 nullptr built in type. 
+// Otherwise undefined. Does not identify if the standard library defines 
+// std::nullptr_t, as some standard libraries are further behind in standardization 
+// than the compilers using them (e.g. Apple clang with the supplied libstdc++). 
+//
+// OVR_Nullptr.h provides a portable nullptr and std::nullptr_t for when the 
+// compiler or standard library do not.
+
+#if !defined(OVR_CPP_NO_NULLPTR)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_nullptr))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 406))           /* GCC 4.6+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                /* VS2010+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403)))  /* EDG 4.3+  */    
+        #define OVR_CPP_NO_NULLPTR 1
+    #endif
+#endif  
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_RVALUE_REFERENCES
+//
+// Defined as 1 if the compiler doesn't support C++11 rvalue references and move semantics.
+// Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_RVALUE_REFERENCES)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_rvalue_references)) /* clang    */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 405))                    /* GCC 4.5+ */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                         /* VS2010+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403)))           /* EDG 4.3+ */    
+        #define OVR_CPP_NO_RVALUE_REFERENCES 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_AUTO
+// 
+// Defined as 1 if the compiler doesn't support C++11 auto keyword. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_AUTO)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_auto_type))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))             /* GCC 4.4+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                  /* VS2010+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 309)))    /* EDG 3.9+  */  
+        #define OVR_CPP_NO_AUTO 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_RANGE_BASED_FOR_LOOP
+//
+// Defined as 1 if the compiler doesn't support C++11 range-based for loops.
+// Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_RANGE_BASED_FOR_LOOP)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_range_for)) /* clang    */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 406))            /* GCC 4.6+ */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1700))                 /* VS2012+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405)))   /* EDG 4.5+ */    
+        #define OVR_CPP_NO_RANGE_BASED_FOR_LOOP 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_CONSTEXPR / OVR_CPP_NO_RELAXED_CONSTEXPR
+//
+// OVR_CPP_NO_CONSTEXPR is defined as 1 if the compiler doesn't support C++11 constexpr.
+// OVR_CPP_NO_RELAXED_CONSTEXPR is defined as 1 if the compiler doesn't support C++14 constexpr.
+// Otherwise undefined.
+// See the OVR_CONSTEXPR / OVR_CONSTEXPR_OR_CONST macros for portable wrappers of this functionality.
+
+#if !defined(OVR_CPP_NO_CONSTEXPR)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_constexpr))  /* clang    */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 406))             /* GCC 4.6+ */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406)))    /* EDG 4.6+ */    
+        // Not supported by VC++ through at least VS2013.
+        #define OVR_CPP_NO_CONSTEXPR 1
+    #endif
+#endif
+
+#if !defined(OVR_CPP_NO_RELAXED_CONSTEXPR)
+    #if !defined(OVR_CPP14_ENABLED) || \
+        !(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_relaxed_constexpr)) /* clang */
+        // Supported only by clang as of this writing.
+        #define OVR_CPP_NO_RELAXED_CONSTEXPR 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_LAMBDA_EXPRESSIONS
+//
+// Defined as 1 if the compiler doesn't support C++11 lambda expressions. Otherwise undefined.
+// Some compilers have slightly crippled versions of this.
+
+#if !defined(OVR_CPP_NO_LAMBDA_EXPRESSIONS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_lambdas))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))           /* GCC 4.4+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                /* VS2010+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401)))  /* EDG 4.1+  */ 
+        // Conversion of lambdas to function pointers is not supported until EDG 4.5.
+        #define OVR_CPP_NO_LAMBDA_EXPRESSIONS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_ALIGNOF
+//
+// Defined as 1 if the compiler supports C++11 alignof. Otherwise undefined.
+// Some compilers support __alignof__ instead of alignof, so for portability you 
+// should use OVR_ALIGNOF instead of directly using C++11 alignof.
+
+#if !defined(OVR_CPP_NO_ALIGNOF)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209))  /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 300))  /* Apple clang 3.0+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 401))                     /* GCC 4.1+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1900))                          /* VS2014+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 400)))            /* EDG 4.0+         */
+        #define OVR_CPP_NO_ALIGNOF 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_ALIGNAS
+//
+// Defined as 1 if the compiler supports C++11 alignas. Otherwise undefined.
+// See the OVR_ALIGNAS for a portable wrapper for alignas functionality.
+
+#if !defined(OVR_CPP_NO_ALIGNAS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 300))  /* clang 3.0+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 408))                     /* GCC 4.8+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1900))                          /* VS2014+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 408)))            /* EDG 4.8+         */
+        #define OVR_CPP_NO_ALIGNAS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_OVERRIDE
+//
+// Defined as 1 if the compiler doesn't support C++11 override. Otherwise undefined.
+// See the OVR_OVERRIDE and OVR_FINALOVERRIDE macros for a portable wrapper.
+
+#if !defined(OOVR_CPP_NO_OVERRIDE)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209)) /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 400)) /* Apple clang 4.0+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 407))                    /* GCC 4.7+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1500))                         /* VS2008+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 408)))           /* EDG 4.8+         */     
+        #define OVR_CPP_NO_OVERRIDE 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_FINAL
+// 
+// Defined as 1 if the compiler doesn't support C++11 final attribute. Otherwise undefined.
+// See the OVR_FINAL and OVR_FINALOVERRIDE macros for a portable wrapper.
+
+#if !defined(OOVR_CPP_NO_FINAL)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209))  /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 400))  /* Apple clang 4.0+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 407))                     /* GCC 4.7+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1500))                          /* VS2008+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 408)))            /* EDG 4.8+         */    
+        #define OVR_CPP_NO_FINAL 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_EXTERN_TEMPLATE
+//
+// Defined as 1 if the compiler doesn't support C++11 extern template.
+// Otherwise undefined. See OVR_EXTERN_TEMPLATE for wrapper macro.
+
+#if !defined(OVR_CPP_NO_EXTERN_TEMPLATE)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209))  /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 406))                     /* GCC 4.6+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1700))                          /* VS2012+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401)))            /* EDG 4.1+         */ 
+        #define OVR_CPP_NO_EXTERN_TEMPLATE 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_VARIADIC_TEMPLATES
+//
+// Defined as 1 if the compiler doesn't support C++11 variadic templates. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_VARIADIC_TEMPLATES)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_variadic_templates)) /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                     /* GCC 4.4+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                          /* VS2013+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403)))            /* EDG 4.3+  */   
+        #define OVR_CPP_NO_VARIADIC_TEMPLATES 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_NOEXCEPT
+//
+// Defined as 1 if the compiler supports C++11 noexcept. Otherwise undefined.
+// http://en.cppreference.com/w/cpp/language/noexcept
+// See OVR_NOEXCEPT / OVR_NOEXCEPT_IF / OVR_NOEXCEPT_EXPR for a portable wrapper
+// for noexcept functionality.
+
+#if !defined(OVR_CPP_NO_NOEXCEPT)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_noexcept))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 406))            /* GCC 4.6+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1900))                 /* VS2014+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405)))   /* EDG 4.5+  */
+        #define OVR_CPP_NO_NOEXCEPT 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_DECLTYPE
+//
+// Defined as 1 if the compiler doesn't support C++11 decltype. Otherwise undefined.
+// Some compilers (e.g. VS2012) support most uses of decltype but don't support 
+// decltype with incomplete types (which is an uncommon usage seen usually in 
+// template metaprogramming).  We don't include this support as a requirement for
+// our definition of decltype support here.
+
+#if !defined(OVR_CPP_NO_DECLTYPE)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_decltype))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 403))            /* GCC 4.3+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                 /* VS2010+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402)))   /* EDG 4.2+  */       
+        // VC++ fails to support decltype for incomplete types until VS2013.
+        // EDG fails to support decltype for incomplete types until v4.8.
+        #define OVR_CPP_NO_DECLTYPE 1
+    #endif
+#endif  
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_DEFAULTED_FUNCTIONS
+// 
+// Defined as 1 if the compiler doesn't support C++11 defaulted functions. Otherwise undefined.
+// Some compilers have slightly crippled versions of this.
+
+#if !defined(OVR_CPP_NO_DEFAULTED_FUNCTIONS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_defaulted_functions))/* clang    */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                     /* GCC 4.4+ */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                          /* VS2013+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401)))            /* EDG 4.1+ */
+        // Up through at least VS2013 it's unsupported for defaulted move constructors and move assignment operators.
+        // Until EDG 4.8 it's unsupported for defaulted move constructors and move assigment operators.
+        #define OVR_CPP_NO_DEFAULTED_FUNCTIONS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_DELETED_FUNCTIONS
+// 
+// Defined as 1 if the compiler doesn't support C++11 deleted functions. Otherwise undefined.
+// Some compilers have slightly crippled versions of this.
+
+#if !defined(OVR_CPP_NO_DELETED_FUNCTIONS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_defaulted_functions)) /* clang    */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                      /* GCC 4.4+ */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                           /* VS2013+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401)))             /* EDG 4.1+ */  
+        // Up through at least VS2013 it's unsupported for defaulted move constructors and move assignment operators.
+        // Until EDG 4.8 it's unsupported for defaulted move constructors and move assigment operators.
+        #define OVR_CPP_NO_DELETED_FUNCTIONS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_STANDARD_LAYOUT_TYPES
+// 
+// Defined as 1 if the compiler doesn't support C++11 standard layout (relaxed POD). Otherwise undefined.
+// http://en.cppreference.com/w/cpp/types/is_standard_layout
+
+#if !defined(OVR_CPP_NO_STANDARD_LAYOUT_TYPES)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 300)) /* clang 3.0+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401)) /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 405))                    /* GCC 4.5+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1700))                         /* VS2013+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406)))           /* EDG 4.6+         */  
+        #define OVR_CPP_NO_STANDARD_LAYOUT_TYPES 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_FORWARD_DECLARED_ENUMS
+//
+// Defined as 1 if the compiler doesn't support C++11 forward declared enums. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_FORWARD_DECLARED_ENUMS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 301))  /* clang 3.1+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 406))                     /* GCC 4.6+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1700))                          /* VS2012+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405)))            /* EDG 4.5+         */ 
+        #define OVR_CPP_NO_FORWARD_DECLARED_ENUMS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_STRONGLY_TYPED_ENUMS
+//
+// Defined as 1 if the compiler doesn't support C++11 strongly typed enums. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_STRONGLY_TYPED_ENUMS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_strong_enums))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                /* GCC 4.4+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1700))                     /* VS2012+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 400)))       /* EDG 4.0+ */ 
+        #define OVR_CPP_NO_STRONGLY_TYPED_ENUMS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_TRAILING_RETURN_TYPES
+//
+// Defined as 1 if the compiler doesn't support C++11 trailing return types. Otherwise undefined.
+// http://en.wikipedia.org/wiki/C%2B%2B11#Alternative_function_syntax
+
+#if !defined(OVR_CPP_NO_TRAILING_RETURN_TYPES)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_trailing_return)) /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                  /* GCC 4.4+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                       /* VS2010+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401)))         /* EDG 4.1+ */    
+        #define OVR_CPP_NO_TRAILING_RETURN_TYPES 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_TEMPLATE_ALIASES
+//
+// Defined as 1 if the compiler doesn't support C++11 template aliases. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_TEMPLATE_ALIASES)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_alias_templates)) /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 407))                  /* GCC 4.7+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                       /* VS2013+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402)))         /* EDG 4.2+  */ 
+        #define OVR_CPP_NO_TEMPLATE_ALIASES 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_INITIALIZER_LISTS
+//
+// Defined as 1 if the compiler doesn't support C++11 initializer lists. Otherwise undefined.
+// This refers to the compiler support for this and not the Standard Library support for std::initializer_list,
+// as a new compiler with an old standard library (e.g. Apple clang with libstdc++) may not support std::initializer_list.
+
+#if !defined(OVR_CPP_NO_INITIALIZER_LISTS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_generalized_initializers)) /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                           /* GCC 4.4+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                                /* VS2013+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405)))                  /* EDG 4.5+  */
+        #define OVR_CPP_NO_INITIALIZER_LISTS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_NORETURN
+//
+// Defined as 1 if the compiler doesn't support the C++11 noreturn attribute. Otherwise undefined.
+// http://en.cppreference.com/w/cpp/language/attributes
+//
+#if !defined(OVR_CPP_NO_NORETURN)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 301))  /* clang 3.1+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 408))                     /* GCC 4.8+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1500))                          /* VS2008+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402)))            /* EDG 4.2+         */
+        // Supported with VC++ only via __declspec(noreturn) (see OVR_NORETURN).
+        #define OVR_CPP_NO_NORETURN 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_NONSTATIC_MEMBER_INITIALIZERS
+//
+// Defined as 1 if the compiler doesn't support C++11 in-class non-static member initializers. Otherwise undefined.
+// http://en.cppreference.com/w/cpp/language/data_members
+
+#if !defined(OVR_CPP_NO_NONSTATIC_MEMBER_INITIALIZERS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 301))  /* clang 3.1+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 407))                     /* GCC 4.7+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                          /* VS2013+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406)))            /* EDG 4.6+         */
+        #define OVR_CPP_NO_NONSTATIC_MEMBER_INITIALIZERS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_DOUBLE_TEMPLATE_BRACKETS
+//
+// Defined as 1 if the compiler supports nested template declarations with >>, 
+// as supported by C++11. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_DOUBLE_TEMPLATE_ANGLE_BRACKETS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209))  /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 400))  /* Apple clang 4.0+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 403))                     /* GCC 4.3+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                          /* VS2010+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401)))            /* EDG 4.1+         */
+        #define OVR_CPP_NO_DOUBLE_TEMPLATE_BRACKETS 1
+    #endif
+#endif
+
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_INHERITING_CONSTRUCTORS
+//
+// Defined as 1 if the compiler supports C++11 inheriting constructors. Otherwise undefined.
+// Example usage:
+//     struct A { explicit A(int x){} };
+//     struct B : public A { using A::A; }; // As if B redeclared A::A(int).
+
+#if !defined(OVR_CPP_NO_INHERITING_CONSTRUCTORS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_inheriting_constructors))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 408))                           /* GCC 4.8+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1900))                                /* VS2014+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 408)))                  /* EDG 4.8+  */
+        #define OVR_CPP_NO_INHERITING_CONSTRUCTORS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_DELEGATING_CONSTRUCTORS
+//
+// Defined as 1 if the compiler supports C++11 delegating constructors. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_DELEGATING_CONSTRUCTORS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 300))  /* clang 3.0+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 407))                     /* GCC 4.7+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                          /* VS2013+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407)))            /* EDG 4.7+         */
+        #define OVR_CPP_NO_DELEGATING_CONSTRUCTORS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
+//  
+// Defined as 1 if the compiler supports C++11 function template default arguments. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209))  /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.0+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 403))                     /* GCC 4.3+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                          /* VS2013+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403)))            /* EDG 4.3+         */
+        #define OVR_CPP_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_UNRESTRICTED_UNIONS
+//
+// Defined as 1 if the compiler supports C++11 unrestricted unions. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_UNRESTRICTED_UNIONS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 301))  /* clang 3.1+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 406))                     /* GCC 4.6+         */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406)))            /* EDG 4.6+         */
+        // Not supported by VC++ as of VS2013.
+        #define OVR_CPP_NO_UNRESTRICTED_UNIONS 1
+    #endif
+#endif
+
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_EXTENDED_SIZEOF
+//
+// Defined as 1 if the compiler supports C++11 class sizeof extensions (e.g. sizeof SomeClass::someMember). 
+// Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_EXTENDED_SIZEOF)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 301))  /* clang 3.1+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 405))                     /* GCC 4.5+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1900))                          /* VS2014+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405)))            /* EDG 4.5+         */
+        #define OVR_CPP_NO_EXTENDED_SIZEOF 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_INLINE_NAMESPACES
+//
+// Defined as 1 if the compiler supports C++11 inlined namespaces. Otherwise undefined.
+// http://en.cppreference.com/w/cpp/language/namespace#Inline_namespaces
+
+#if !defined(OVR_CPP_NO_INLINE_NAMESPACES)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209))  /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 400))  /* Apple clang 4.0+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                     /* GCC 4.4+         */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405)))            /* EDG 4.5+         */
+        // Not supported by VC++ as of VS2013.
+        #define OVR_CPP_NO_INLINE_NAMESPACES 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_EXPLICIT_CONVERSION_OPERATORS
+//
+// Defined as 1 if the compiler supports C++11 explicit conversion operators. Otherwise undefined.
+// http://en.cppreference.com/w/cpp/language/explicit
+
+#if !defined(OVR_CPP_NO_EXPLICIT_CONVERSION_OPERATORS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_explicit_conversions))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 405))                        /* GCC 4.5+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                             /* VS2013+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 404)))               /* EDG 4.4+  */
+        #define OVR_CPP_NO_EXPLICIT_CONVERSION_OPERATORS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
+//
+// Defined as 1 if the compiler supports C++11 local class template parameters. Otherwise undefined.
+// Example:
+//     void Test() {   
+//         struct LocalClass{ };
+//         SomeTemplateClass<LocalClass> t; // Allowed only in C++11
+//     }
+
+#if !defined(OVR_CPP_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS) 
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_local_type_template_args))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 405))                            /* GCC 4.5+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                                 /* VS2010+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402)))                   /* EDG 4.2+  */
+        #define OVR_CPP_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_NEW_CHARACTER_TYPES
+//
+// Defined as 1 if the compiler natively supports C++11 char16_t and char32_t. Otherwise undefined.
+// VC++ through at least VS2013 defines char16_t as unsigned short in its standard library,
+// but it is not a native type or unique type, nor can you for a string literal with it.
+
+#if !defined(OVR_CPP_NO_NEW_CHARACTER_TYPES)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_unicode_literals))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                    /* GCC 4.4+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407)))           /* EDG 4.7+  */
+        // Not supported by VC++ as of VS2013.
+        #define OVR_CPP_NO_NEW_CHARACTER_TYPES 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_UNICODE_CHAR_NAME_LITERALS
+//
+// Defined as 1 if the compiler supports C++11 \u and \U character literals for 
+// native char16_t and char32_t types.
+//
+#if !defined(OVR_CPP_NO_UNICODE_CHAR_NAME_LITERALS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 301))  /* clang 3.1+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 405))                     /* GCC 4.5+         */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 408)))            /* EDG 4.8+         */
+        // Not supported by VC++ as of VS2013. VC++'s existing \U and \u are non-conforming.
+        #define OVR_CPP_NO_UNICODE_CHAR_NAME_LITERALS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_USER_DEFINED_LITERALS
+//
+// Defined as 1 if the compiler supports C++11 user-defined literals. Otherwise undefined.
+
+#if !defined(OVR_CPP_NO_USER_DEFINED_LITERALS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 301))  /* clang 3.1+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 401))  /* Apple clang 4.1+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 407))                     /* GCC 4.7+         */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 408)))            /* EDG 4.8+         */
+        // Not supported by VC++ as of VS2013.
+        #define OVR_CPP_NO_USER_DEFINED_LITERALS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_UNICODE_STRING_LITERALS
+//
+// Defined as 1 if the compiler supports C++11 Unicode string literals. Otherwise undefined.
+// http://en.wikipedia.org/wiki/C%2B%2B11#New_string_literals
+
+#if !defined(OVR_CPP_NO_UNICODE_STRING_LITERALS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_unicode_literals))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                    /* GCC 4.4+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407)))           /* EDG 4.7+  */
+        // Not supported by VC++ as of VS2013.
+        #define OVR_CPP_NO_UNICODE_STRING_LITERALS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_RAW_STRING_LITERALS
+//
+// Defined as 1 if the compiler supports C++11 raw literals. Otherwise undefined.
+// http://en.wikipedia.org/wiki/C%2B%2B11#New_string_literals
+
+#if !defined(OVR_CPP_NO_RAW_STRING_LITERALS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_raw_string_literals))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 405))                       /* GCC 4.5+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407)))              /* EDG 4.7+  */
+        // Not supported by VC++ as of VS2013.
+        #define OVR_CPP_NO_RAW_STRING_LITERALS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_UNIFIED_INITIALIZATION_SYNTAX
+//
+// Defined as 1 if the compiler supports C++11 unified initialization.
+// http://en.wikipedia.org/wiki/C%2B%2B11#Uniform_initialization
+
+#if !defined(OVR_CPP_NO_UNIFIED_INITIALIZATION_SYNTAX)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_generalized_initializers))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 404))                            /* GCC 4.4+  */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1800))                                 /* VS2013+   */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406)))                   /* EDG 4.6+  */
+        #define OVR_CPP_NO_UNIFIED_INITIALIZATION_SYNTAX 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_EXTENDED_FRIEND_DECLARATIONS
+//
+// Defined as 1 if the compiler supports C++11 extended friends.
+
+#if !defined(OVR_CPP_NO_EXTENDED_FRIEND_DECLARATIONS)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && !defined(__APPLE__) && (__clang__ >= 209))  /* clang 2.9+       */ && \
+         !(defined(__clang__) &&  defined(__APPLE__) && (__clang__ >= 400))  /* Apple clang 4.0+ */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 407))                     /* GCC 4.7+         */ && \
+         !(defined(_MSC_VER) && (_MSC_VER >= 1600))                          /* VS2010+          */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401)))            /* EDG 4.1+         */
+        #define OVR_CPP_NO_EXTENDED_FRIEND_DECLARATIONS 1
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_CPP_NO_THREAD_LOCAL
+//
+// Defined as 1 if the compiler supports C++11 thread_local. Else undefined. Does not
+// indicate if the compiler supports C thread-local compiler extensions such as __thread
+// and declspec(thread). Use OVR_THREAD_LOCAL if you want to declare a thread-local 
+// variable that supports C++11 thread_local when available but the C extension when 
+// it's available. The primary difference between C++11 thread_local and C extensions is
+// that C++11 thread_local supports non-PODs and calls their constructors and destructors.
+//
+// Note that thread_local requires both compiler and linker support, and so it's possible
+// that the compiler may support thread_local but the linker does not.
+
+#if !defined(OVR_CPP_NO_THREAD_LOCAL)
+    #if !defined(OVR_CPP11_ENABLED) || \
+        (!(defined(__clang__) && OVR_CC_HAS_FEATURE(cxx_thread_local))  /* clang     */ && \
+         !(defined(__GNUC__) && (OVR_CC_VERSION >= 408))                /* GCC 4.8+  */ && \
+         !(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 408)))       /* EDG 4.8+  */
+        #define OVR_CPP_NO_THREAD_LOCAL 1
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_ALIGNAS / OVR_ALIGNOF
+//
+//    OVR_ALIGNAS(n)        // Specifies a size_t power of two alignment for a type or instance.
+//    OVR_ALIGNOF(type)     // Returns the size_t alignment of a type or instance.
+//
+// Example usage:
+//    OVR_ALIGNAS(8) char c = 'c';                      // Specifies that the instance c be aligned to an 8 byte boundary.
+//    typedef OVR_ALIGNAS(8) char C;                    // Specifies that the type C be aligned to an 8 byte boundary.
+//    struct OVR_ALIGNAS(64) S{ char array[16]; };      // Specfies that the struct S have a natural alignment of 64.
+//    OVR_ALIGNAS(32) S s;                              // Specifies that the instance s of struct S be aligned to an 32 byte boundary.
+//    OVR_ALIGNAS(32) struct T{ char array[16]; } t;    // Specfies that the instance t of struct T have a natural alignment of 32.
+//    struct OVR_ALIGNAS(T) U{};                        // Specifes that U be aligned the same as T. Supported only by C++11 compilers (see OVR_CPP_NO_ALIGNAS).
+//
+//    size_t a = OVR_ALIGNOF(double);                   // Returns the natural alignment of the double type.
+//    size_t a = OVR_ALIGNOF(S);                        // Returns the natural alignment of the struct S type.
+//
+// Note: If C++11 alignas is supported, then alignas/OVR_ALIGNAS may take a const expression in addition to a constant.
+// Note: The C11 Standard species the _Alignas keyword and alignas as a macro for it in <stdalign.h>
+
+#if !defined(OVR_ALIGNAS)
+    #if defined(OVR_CC_GNU) && !defined(OVR_CPP_NO_ALIGNAS)     // If C++11 alignas is supported...
+        #define OVR_ALIGNAS(n) alignas(n)
+    #elif defined(__clang__) && !defined(OVR_CPP_NO_ALIGNAS)
+        #define OVR_ALIGNAS(n) alignas(n)
+    #elif defined(OVR_CC_GNU) || defined(__clang__)
+        #define OVR_ALIGNAS(n) __attribute__((aligned(n)))
+    #elif defined(OVR_CC_MSVC) || defined(OVR_CC_INTEL)
+        #define OVR_ALIGNAS(n) __declspec(align(n))             // For Microsoft the alignment must be a literal integer.
+    #elif defined(OVR_CC_ARM)
+        #define OVR_ALIGNAS(n) __align(n)
+    #else
+        #error Need to define OVR_ALIGNAS
+    #endif
+#endif
+
+#if !defined(OVR_ALIGNOF)
+    #if defined(OVR_CC_GNU) && !defined(OVR_CPP_NO_ALIGNOF)     // If C++11 alignof is supported...
+        #define OVR_ALIGNOF(type) alignof(type)
+    #elif defined(__clang__) && !defined(OVR_CPP_NO_ALIGNOF)
+        #define OVR_ALIGNOF(type) alignof(type)
+    #elif defined(OVR_CC_GNU) || defined(__clang__)
+        #define OVR_ALIGNOF(type) ((size_t)__alignof__(type))
+    #elif defined(OVR_CC_MSVC) || defined(OVR_CC_INTEL)
+        #define OVR_ALIGNOF(type) ((size_t)__alignof(type))
+    #elif defined(OVR_CC_ARM)
+        #define OVR_ALIGNOF(type) ((size_t)__ALIGNOF__(type))
+    #else
+        #error Need to define OVR_ALIGNOF
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_ASSUME / OVR_ANALYSIS_ASSUME
+//
+// This is a portable wrapper for VC++'s __assume and __analysis_assume.
+// __analysis_assume is typically used to quell VC++ static analysis warnings.
+//
+// Example usage:
+//    void Test(char c){
+//       switch(c){
+//          case 'a':
+//          case 'b':
+//          case 'c':
+//          case 'd':
+//             break;
+//          default:
+//             OVR_ASSUME(0); // Unreachable code.
+//       }
+//    }
+//
+//    size_t Test(char* str){
+//       OVR_ANALYSIS_ASSUME(str != nullptr);
+//       return strlen(str);
+//    }
+
+#if !defined(OVR_ASSUME)
+    #if defined(OVR_CC_MSVC)
+        #define OVR_ASSUME(x)          __assume(x)
+        #define OVR_ANALYSIS_ASSUME(x) __analysis_assume(!!(x))
+    #else
+        #define OVR_ASSUME(x)
+        #define OVR_ANALYSIS_ASSUME(x)
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_RESTRICT
+//
+// Wraps the C99 restrict keyword in a portable way.
+// C++11 and C++14 don't have restrict but this functionality is supported by 
+// all C++ compilers.
+//
+// Example usage:
+//    void* memcpy(void* OVR_RESTRICT s1, const void* OVR_RESTRICT s2, size_t n);
+
+#if !defined(OVR_RESTRICT)
+    #define OVR_RESTRICT __restrict // Currently supported by all compilers of significance to us.
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_NOEXCEPT / OVR_NOEXCEPT_IF(predicate) / OVR_NOEXCEPT_EXPR(expression)
+//
+// Implements a portable wrapper for C++11 noexcept.
+// http://en.cppreference.com/w/cpp/language/noexcept
+//
+// Example usage:
+//     void Test() OVR_NOEXCEPT {} // This function doesn't throw.
+//
+//     template <typename T>
+//     void DoNothing() OVR_NOEXCEPT_IF(OVR_NOEXCEPT_EXPR(T())) // Throws an if and only if T::T(int) throws.
+//         { T t(3); }
+//
+#if !defined(OVR_NOEXCEPT)
+    #if defined(OVR_CPP_NOEXCEPT)
+        #define OVR_NOEXCEPT
+        #define OVR_NOEXCEPT_IF(predicate)
+        #define OVR_NOEXCEPT_EXPR(expression) false
+    #else
+        #define OVR_NOEXCEPT noexcept
+        #define OVR_NOEXCEPT_IF(predicate) noexcept((predicate))
+        #define OVR_NOEXCEPT_EXPR(expression) noexcept((expression))
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_FINAL
+//
+// Wraps the C++11 final keyword in a portable way.
+// http://en.cppreference.com/w/cpp/language/final
+//
+// Example usage:
+//     struct Test { virtual int GetValue() OVR_FINAL; };
+
+#if !defined(OVR_FINAL)
+    #if defined(OVR_CC_MSVC) && (OVR_CC_VERSION < 1700) // VC++ 2012 and earlier
+        #define OVR_FINAL sealed
+    #elif defined(OVR_CPP_INHERITANCE_FINAL)
+        #define OVR_FINAL
+    #else
+        #define OVR_FINAL final
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_OVERRIDE
+//
+// Wraps the C++11 override keyword in a portable way.
+// http://en.cppreference.com/w/cpp/language/override
+//
+// Example usage:
+//        struct Parent { virtual void Func(int); };
+//        struct Child : public Parent { void Func(int) OVR_OVERRIDE; };
+
+#if !defined(OVR_CPP11_ENABLED)
+#define OVR_OVERRIDE
+#elif !defined(OVR_OVERRIDE)
+    #if defined(OVR_CPP_OVERRIDE)
+        #define OVR_OVERRIDE
+    #else
+        #if (defined(_MSC_VER) && (_MSC_VER <= 1600))
+            #pragma warning(disable : 4481)
+        #endif
+        #define OVR_OVERRIDE override
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_FINAL_OVERRIDE
+//
+// Wraps the C++11 final+override keywords (a common combination) in a portable way.
+//
+// Example usage:
+//     struct Parent { virtual void Func(); };
+//     struct Child : public Parent { virtual void Func() OVR_FINAL_OVERRIDE; };
+
+#if !defined(OVR_FINAL_OVERRIDE)
+    #define OVR_FINAL_OVERRIDE OVR_FINAL OVR_OVERRIDE
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_EXTERN_TEMPLATE
+//
+// Portable wrapper for C++11 extern template. This tells the compiler to not instantiate
+// the template in the current translation unit, which can significantly speed up 
+// compilation and avoid problems due to two translation units compiling code with 
+// different settings.
+//
+// Example usage:
+//     OVR_EXTERN_TEMPLATE(class basic_string<char>); // Nothing to do for non-C++11 compilers.
+
+#if !defined(OVR_EXTERN_TEMPLATE)
+    #if defined(OVR_CPP_EXTERN_TEMPLATE)
+        #define OVR_EXTERN_TEMPLATE(decl)
+    #else
+        #define OVR_EXTERN_TEMPLATE(decl) extern template decl
+    #endif
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_CONSTEXPR  / OVR_CONSTEXPR_OR_CONST
+//
+// Portable wrapper for C++11 constexpr. Doesn't include C++14 relaxed constexpr,
+// for which a different wrapper name is reserved.
+//
+// Example usage:
+//     OVR_CONSTEXPR int Test() { return 15; }          // This can be optimized better by a C++11 compiler that supports constexpr.
+//     OVR_CONSTEXPR_OR_CONST float x = 3.14159f;       // This can be optimized better by a C++11 compiler, but if not then at least make it const.
+
+#if !defined(OVR_CONSTEXPR)
+    #if defined(OVR_CPP_NO_CONSTEXPR)
+        #define OVR_CONSTEXPR
+    #else
+        #define OVR_CONSTEXPR constexpr
+    #endif
+#endif
+
+#if !defined(OVR_CONSTEXPR_OR_CONST)
+    #if defined(OVR_CPP_NO_CONSTEXPR)
+        #define OVR_CONSTEXPR_OR_CONST const
+    #else
+        #define OVR_CONSTEXPR_OR_CONST constexpr
+    #endif
+#endif
+
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_FUNCTION_DELETE / OVR_FUNCTION_DEFAULT
+//
+// Wraps the C++11 delete and default keywords in a way that allows for cleaner code
+// while making for a better version of uncallable or default functions.
+//
+// Example usage:
+//     struct Test{
+//         Test() OVR_FUNCTION_DEFAULT;            // Non-C++11 compilers will require a separate definition for Test().
+//     private:                                   // Users should put OVR_FUNCTION_DELETE usage in a private 
+//         void Uncallable() OVR_FUNCTION_DELETE;  // area for compatibility with pre-C++11 compilers.
+//     };
+
+#if defined(OVR_CPP_NO_DELETED_FUNCTIONS)
+    #define OVR_FUNCTION_DELETE
+#else
+    #define OVR_FUNCTION_DELETE = delete
+#endif
+
+#if defined(OVR_CPP_NO_DEFAULTED_FUNCTIONS)
+    #define OVR_FUNCTION_DEFAULT
+#else
+    #define OVR_FUNCTION_DEFAULT = default
+#endif
+
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_NON_COPYABLE
+//
+// Allows you to specify a class as being neither copy-constructible nor assignable,
+// which is a commonly needed pattern in C++ programming. Classes with this declaration
+// are required to be default constructible (as are most classes). For pre-C++11
+// compilers this macro declares a private section for the class, which will be
+// inherited by whatever code is directly below the macro invocation by default.
+//
+// Example usage:
+//    struct Test {
+//       Test();
+//       ...
+//       OVR_NON_COPYABLE(Test)
+//    };
+
+#if !defined(OVR_NON_COPYABLE)
+    #if defined(OVR_CPP_NO_DELETED_FUNCTIONS)
+        #define OVR_NON_COPYABLE(Type)   \
+            private:                     \
+            Type(const Type&);           \
+            void operator=(const Type&);
+    #else
+        #define OVR_NON_COPYABLE(Type)   \
+            Type(const Type&) = delete;  \
+            void operator=(const Type&) = delete;
+    #endif
+#endif
+
+
+
+#endif  // header include guard
+
+
+
+