Merge branch 'vanilla_0.5.0.1' into jogamp_0.5.0.1

Conflicts:
	LibOVR/Include/OVR_CAPI_0_5_0.h
	LibOVR/Src/CAPI/CAPI_HMDState.cpp
	LibOVR/Src/Displays/OVR_Win32_Dxgi_Display.h
	LibOVR/Src/Kernel/OVR_System.cpp
	LibOVR/Src/OVR_CAPI.cpp
	LibOVR/Src/OVR_Profile.cpp
	LibOVRKernel/Src/Kernel/OVR_ThreadsWinAPI.cpp
	LibOVRKernel/Src/Kernel/OVR_Types.h

1 files changed, 1416 insertions, 0 deletions

diff --git a/LibOVR/Src/OVR_CAPIShim.c b/LibOVR/Src/OVR_CAPIShim.c
new file mode 100755
index 0000000..351e057
--- /dev/null
+++ b/LibOVR/Src/OVR_CAPIShim.c
@@ -0,0 +1,1416 @@
+/************************************************************************************
+
+Filename    :   OVR_CAPIShim.c
+Content     :   CAPI DLL user library
+Created     :   November 20, 2014
+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.
+
+************************************************************************************/
+
+
+#include "OVR_CAPI.h"
+#include "OVR_Version.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#if defined(_WIN32)
+    #include <Windows.h>
+#else
+    #if defined(__APPLE__)
+        #include <mach-o/dyld.h>
+        #include <sys/syslimits.h>
+        #include <libgen.h>
+        #include <pwd.h>
+        #include <unistd.h>
+    #endif
+    #include <dlfcn.h>
+    #include <sys/stat.h>
+    #include <unistd.h>
+#endif
+
+
+#if defined(_MSC_VER)
+    #pragma warning(push)
+    #pragma warning(disable: 4996) // 'getenv': This function or variable may be unsafe.
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_ENABLE_DEVELOPER_SEARCH
+//
+// If defined then our shared library loading code searches for developer build
+// directories.
+//
+#if !defined(OVR_ENABLE_DEVELOPER_SEARCH)
+#endif
+
+
+// -----------------------------------------------------------------------------------
+// ***** OVR_BUILD_DEBUG
+//
+// Defines OVR_BUILD_DEBUG when the compiler default debug preprocessor is set.
+//
+// If you want to control the behavior of these flags, then explicitly define
+// either -DOVR_BUILD_RELEASE or -DOVR_BUILD_DEBUG in the compiler arguments.
+
+#if !defined(OVR_BUILD_DEBUG) && !defined(OVR_BUILD_RELEASE)
+    #if defined(_MSC_VER)
+        #if defined(_DEBUG)
+            #define OVR_BUILD_DEBUG
+        #endif
+    #else
+        #if defined(DEBUG)
+            #define OVR_BUILD_DEBUG
+        #endif
+    #endif
+#endif
+
+
+//-----------------------------------------------------------------------------------
+// ***** FilePathCharType, ModuleHandleType, ModuleFunctionType
+//
+#if defined(_WIN32)                                       // We need to use wchar_t on Microsoft platforms, as that's the native file system character type.
+    #define FilePathCharType       wchar_t                // #define instead of typedef because debuggers (VC++, XCode) don't recognize typedef'd types as a string type.
+    typedef HMODULE                ModuleHandleType;
+    typedef FARPROC                ModuleFunctionType;
+#else
+    #define FilePathCharType       char
+    typedef void*                  ModuleHandleType;
+    typedef void*                  ModuleFunctionType;
+#endif
+
+#define ModuleHandleTypeNull   ((ModuleHandleType)NULL)
+#define ModuleFunctionTypeNull ((ModuleFunctionType)NULL)
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_MAX_PATH
+//
+#if !defined(OVR_MAX_PATH)
+    #if defined(_WIN32)
+        #define OVR_MAX_PATH  _MAX_PATH
+    #elif defined(__APPLE__)
+        #define OVR_MAX_PATH  PATH_MAX
+    #else
+        #define OVR_MAX_PATH  1024
+    #endif
+#endif
+
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_DECLARE_IMPORT
+//
+// Creates typedef and pointer declaration for a function of a given signature.
+// The typedef is <FunctionName>Type, and the pointer is <FunctionName>Ptr.
+//
+// Example usage:
+//     int MultiplyValues(float x, float y);  // Assume this function exists in an external shared library. We don't actually need to redeclare it.
+//     OVR_DECLARE_IMPORT(int, MultiplyValues, (float x, float y)) // This creates a local typedef and pointer for it.
+
+#define OVR_DECLARE_IMPORT(ReturnValue, FunctionName, Arguments)  \
+    typedef ReturnValue (OVR_CDECL *FunctionName##Type)Arguments; \
+    FunctionName##Type FunctionName##Ptr = NULL;
+
+
+
+//-----------------------------------------------------------------------------------
+// ***** OVR_GETFUNCTION
+//
+// Loads <FunctionName>Ptr from hLibOVR if not already loaded.
+// Assumes a variable named <FunctionName>Ptr of type <FunctionName>Type exists which is called <FunctionName> in LibOVR.
+//
+// Example usage:
+//     OVR_GETFUNCTION(MultiplyValues)    // Normally this would be done on library init and not before every usage.
+//     int result = MultiplyValuesPtr(3.f, 4.f);
+
+#if !defined(OVR_DLSYM)
+    #if defined(_WIN32)
+        #define OVR_DLSYM(dlImage, name) GetProcAddress(dlImage, name)
+    #else
+        #define OVR_DLSYM(dlImage, name) dlsym(dlImage, name)
+    #endif
+#endif
+
+#define OVR_GETFUNCTION(f)             \
+    if(!f##Ptr)                        \
+    {                                  \
+        union                          \
+        {                              \
+            f##Type p1;                \
+            ModuleFunctionType p2;     \
+        } u;                           \
+        u.p2 = OVR_DLSYM(hLibOVR, #f); \
+        f##Ptr = u.p1;                 \
+    }
+
+
+#if defined(__APPLE__) || defined(OVR_ENABLE_DEVELOPER_SEARCH)
+static size_t OVR_strlcpy(char* dest, const char* src, size_t destsize)
+{
+    const char* s = src;
+    size_t      n = destsize;
+
+    if(n && --n)
+    {
+        do{
+            if((*dest++ = *s++) == 0)
+                break;
+        } while(--n);
+    }
+
+    if(!n)
+    {
+        if(destsize)
+            *dest = 0;
+        while(*s++)
+            { }
+    }
+
+    return (size_t)((s - src) - 1);
+}
+#endif // __APPLE__ || OVR_ENABLE_DEVELOPER_SEARCH
+
+
+#if defined(__APPLE__) // Currently used on Apple only.
+    static size_t OVR_strlcat(char* dest, const char* src, size_t destsize)
+    {
+        const size_t d = destsize ? strlen(dest) : 0;
+        const size_t s = strlen(src);
+        const size_t t = s + d;
+
+        if(t < destsize)
+            memcpy(dest + d, src, (s + 1) * sizeof(*src));
+        else
+        {
+            if(destsize)
+            {
+                memcpy(dest + d, src, ((destsize - d) - 1) * sizeof(*src));
+                dest[destsize - 1] = 0;
+            }
+        }
+
+        return t;
+    }
+#endif
+
+
+#if defined(__APPLE__)
+    static ovrBool OVR_strend(const char* pStr, const char* pFind, size_t strLength, size_t findLength)
+    {
+        if(strLength == (size_t)-1)
+            strLength = strlen(pStr);
+        if(findLength == (size_t)-1)
+            findLength = strlen(pFind);
+        if(strLength >= findLength)
+            return (strcmp(pStr + strLength - findLength, pFind) == 0);
+        return ovrFalse;
+    }
+            
+    static ovrBool OVR_isBundleFolder(const char* filePath)
+    {
+        static const char* extensionArray[] = { ".app", ".bundle", ".framework", ".plugin", ".kext" };
+        size_t i;
+
+        for(i = 0; i < sizeof(extensionArray)/sizeof(extensionArray[0]); i++)
+        {
+            if(OVR_strend(filePath, extensionArray[i], (size_t)-1, (size_t)-1))
+                return ovrTrue;
+        }
+                
+        return ovrFalse;
+    }
+#endif
+
+
+#if defined(OVR_ENABLE_DEVELOPER_SEARCH)
+
+// Returns true if the path begins with the given prefix.
+// Doesn't support non-ASCII paths, else the return value may be incorrect.
+static int OVR_PathStartsWith(const FilePathCharType* path, const char* prefix)
+{
+    while(*prefix)
+    {
+        if(tolower((unsigned char)*path++) != tolower((unsigned char)*prefix++))
+            return ovrFalse;
+    }
+
+    return ovrTrue;
+}
+
+#endif
+
+
+static ovrBool OVR_GetCurrentWorkingDirectory(FilePathCharType* directoryPath, size_t directoryPathCapacity)
+{
+    #if defined(_WIN32)
+        DWORD dwSize = GetCurrentDirectoryW((DWORD)directoryPathCapacity, directoryPath);
+
+        if((dwSize > 0) && (directoryPathCapacity > 1)) // Test > 1 so we have room to possibly append a \ char.
+        {
+            size_t length = wcslen(directoryPath);
+
+            if((length == 0) || ((directoryPath[length - 1] != L'\\') && (directoryPath[length - 1] != L'/')))
+            {
+                directoryPath[length++] = L'\\';
+                directoryPath[length]   = L'\0';
+            }
+
+            return ovrTrue;
+        }
+
+    #else
+        char* cwd = getcwd(directoryPath, directoryPathCapacity);
+
+        if(cwd && directoryPath[0] && (directoryPathCapacity > 1)) // Test > 1 so we have room to possibly append a / char.
+        {
+            size_t length = strlen(directoryPath);
+
+            if((length == 0) || (directoryPath[length - 1] != '/'))
+            {
+                directoryPath[length++] = '/';
+                directoryPath[length]   = '\0';
+            }
+
+            return ovrTrue;
+        }
+    #endif
+
+    if(directoryPathCapacity > 0)
+        directoryPath[0] = '\0';
+
+    return ovrFalse;
+}
+
+
+// The appContainer argument is specific currently to only Macintosh. If true and the application is a .app bundle then it returns the 
+// location of the bundle and not the path to the executable within the bundle. Else return the path to the executable binary itself.
+// The moduleHandle refers to the relevant dynamic (a.k.a. shared) library. The main executable is the main module, and each of the shared
+// libraries is a module. This way you can specify that you want to know the directory of the given shared library, which may be different
+// from the main executable. If the moduleHandle is NULL then the current application module is used.
+static ovrBool OVR_GetCurrentApplicationDirectory(FilePathCharType* directoryPath, size_t directoryPathCapacity, ovrBool appContainer, ModuleHandleType moduleHandle)
+{
+    #if defined(_WIN32)
+        DWORD length = GetModuleFileNameW(moduleHandle, directoryPath, (DWORD)directoryPathCapacity);
+        DWORD pos;
+
+        if((length != 0) && (length < (DWORD)directoryPathCapacity)) // If there wasn't an error and there was enough capacity...
+        {
+            for(pos = length; (pos > 0) && (directoryPath[pos] != '\\') && (directoryPath[pos] != '/'); --pos)
+            {
+                if((directoryPath[pos - 1] != '\\') && (directoryPath[pos - 1] != '/'))
+                   directoryPath[pos - 1] = 0;
+            }
+
+            return ovrTrue;
+        }
+
+        (void)appContainer; // Not used on this platform.
+
+    #elif defined(__APPLE__)
+        uint32_t directoryPathCapacity32 = (uint32_t)directoryPathCapacity;
+        int result = _NSGetExecutablePath(directoryPath, &directoryPathCapacity32);
+    
+        if(result == 0) // If success...
+        {
+            char realPath[OVR_MAX_PATH];
+
+            if(realpath(directoryPath, realPath)) // realpath returns the canonicalized absolute file path.
+            {
+                size_t length = 0;
+
+                if(appContainer) // If the caller wants the path to the containing bundle...
+                {
+                    char    containerPath[OVR_MAX_PATH];
+                    ovrBool pathIsContainer;
+
+                    OVR_strlcpy(containerPath, realPath, sizeof(containerPath));
+                    pathIsContainer = OVR_isBundleFolder(containerPath);
+
+                    while(!pathIsContainer && strncmp(containerPath, ".", OVR_MAX_PATH) && strncmp(containerPath, "/", OVR_MAX_PATH)) // While the container we're looking for is not found and while the path doesn't start with a . or /
+                    {
+                        OVR_strlcpy(containerPath, dirname(containerPath), sizeof(containerPath));
+                        pathIsContainer = OVR_isBundleFolder(containerPath);
+                    }
+                
+                    if(pathIsContainer)
+                        length = OVR_strlcpy(directoryPath, containerPath, directoryPathCapacity);
+                }
+
+                if(length == 0) // If not set above in the appContainer block...
+                    length = OVR_strlcpy(directoryPath, realPath, directoryPathCapacity);
+                
+                while(length-- && (directoryPath[length] != '/'))
+                    directoryPath[length] = '\0'; // Strip the file name from the file path, leaving a trailing / char.
+
+                return ovrTrue;
+            }
+        }
+
+        (void)moduleHandle;  // Not used on this platform.
+
+    #else
+        ssize_t length = readlink("/proc/self/exe", directoryPath, directoryPathCapacity);
+        ssize_t pos;
+
+        if(length > 0)
+        {
+            for(pos = length; (pos > 0) && (directoryPath[pos] != '/'); --pos)
+            {
+                if(directoryPath[pos - 1] != '/')
+                   directoryPath[pos - 1]  = '\0';
+            }
+
+            return ovrTrue;
+        }
+
+        (void)appContainer; // Not used on this platform.
+        (void)moduleHandle;
+    #endif
+
+    if(directoryPathCapacity > 0)
+        directoryPath[0] = '\0';
+
+    return ovrFalse;
+}
+
+
+#if defined(_WIN32) || defined(OVR_ENABLE_DEVELOPER_SEARCH) // Used only in these cases
+
+// Get the file path to the current module's (DLL or EXE) directory within the current process. 
+// Will be different from the process module handle if the current module is a DLL and is in a different directory than the EXE module.
+// If successful then directoryPath will be valid and ovrTrue is returned, else directoryPath will be empty and ovrFalse is returned.
+static ovrBool OVR_GetCurrentModuleDirectory(FilePathCharType* directoryPath, size_t directoryPathCapacity, ovrBool appContainer)
+{
+    #if defined(_WIN32)
+        HMODULE hModule;
+        BOOL result = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCWSTR)(uintptr_t)OVR_GetCurrentModuleDirectory, &hModule);
+        if(result)
+            OVR_GetCurrentApplicationDirectory(directoryPath, directoryPathCapacity, ovrTrue, hModule);
+        else
+            directoryPath[0] = 0;
+
+        (void)appContainer;
+
+        return directoryPath[0] ? ovrTrue : ovrFalse;
+    #else
+        return OVR_GetCurrentApplicationDirectory(directoryPath, directoryPathCapacity, appContainer, NULL);
+    #endif
+}
+
+#endif
+
+
+static ModuleHandleType OVR_OpenLibrary(const FilePathCharType* libraryPath)
+{
+    #if defined(_WIN32)
+        return LoadLibraryW(libraryPath);
+    #else
+        // Don't bother trying to dlopen() a file that is not even there.
+        if (access(libraryPath, X_OK | R_OK ) != 0)
+        {
+            return NULL;
+        }
+
+        dlerror(); // Clear any previous dlopen() errors
+
+        // Use RTLD_NOW because we don't want unexpected stalls at runtime, and the library isn't very large.
+        // Use RTLD_LOCAL to avoid unilaterally exporting resolved symbols to the rest of this process.
+        void *lib = dlopen(libraryPath, RTLD_NOW | RTLD_LOCAL);
+
+        if (!lib)
+        {
+            #if defined(__APPLE__)
+            // TODO: Output the error in whatever logging system OSX uses (jhughes)
+            #else  // __APPLE__
+            fprintf(stderr, "ERROR: Can't load '%s':\n%s\n", libraryPath, dlerror());
+            #endif // __APPLE__
+        }
+
+        return lib;
+    #endif
+}
+
+
+/*  Currently not in use, but expected to be used in the future
+static void OVR_CloseLibrary(ModuleHandleType hLibrary)
+{
+    if (hLibrary)
+    {
+        #if defined(_WIN32)
+            FreeLibrary(hLibrary);
+        #else
+            dlclose(hLibrary);
+        #endif
+    }
+}
+*/
+
+
+// Returns a valid ModuleHandleType (e.g. Windows HMODULE) or returns ModuleHandleTypeNull (e.g. NULL).
+// The caller is required to eventually call OVR_CloseLibrary on a valid return handle.
+//
+static ModuleHandleType OVR_FindLibraryPath(int requestedProductVersion, int requestedMajorVersion,
+                               FilePathCharType* libraryPath, size_t libraryPathCapacity)
+{
+    ModuleHandleType moduleHandle;
+    int printfResult;
+    FilePathCharType developerDir[OVR_MAX_PATH];
+
+    #if defined(_MSC_VER)
+        #if defined(_WIN64)
+            const char* pBitDepth = "64";
+        #else
+            const char* pBitDepth = "32";
+        #endif
+    #elif defined(__APPLE__)
+		// For Apple platforms we are using a Universal Binary LibOVRRT dylib which has both 32 and 64 in it.
+	#else // Other Unix.
+        #if defined(__x86_64__)
+            const char* pBitDepth = "64";
+        #else
+            const char* pBitDepth = "32";
+        #endif
+    #endif
+
+    moduleHandle = ModuleHandleTypeNull;
+    if(libraryPathCapacity)
+    libraryPath[0] = '\0';
+    
+    // Support checking for a developer library location override via the OVR_SDK_ROOT environment variable.
+    developerDir[0] = '\0';
+
+    #if defined(OVR_ENABLE_DEVELOPER_SEARCH)
+    {
+        #if (defined(_MSC_VER) || defined(_WIN32)) && !defined(OVR_FILE_PATH_SEPARATOR)
+            #define OVR_FILE_PATH_SEPARATOR "\\"
+        #else
+            #define OVR_FILE_PATH_SEPARATOR "/"
+        #endif
+
+        char sdkRoot[OVR_MAX_PATH];
+        const char* pSDKRootEnv = getenv("OVR_SDK_ROOT"); // Example value: /dev/OculusSDK/0.4/Main/
+        
+        if(pSDKRootEnv)
+        {
+            size_t length = OVR_strlcpy(sdkRoot, pSDKRootEnv, sizeof(sdkRoot));
+            
+            if((length > 0) || (length < sizeof(sdkRoot)))
+            {
+                if(sdkRoot[length-1] == OVR_FILE_PATH_SEPARATOR[0])
+                    sdkRoot[length-1] = '\0';
+            }
+            else
+                sdkRoot[0] = '\0';
+        }
+        else
+        {
+            // __FILE__ maps to <sdkRoot>/LibOVR/Src/OVR_CAPIShim.c
+            char* pLibOVR;
+            size_t i;
+
+            // We assume that __FILE__ returns a full path, which isn't the case for some compilers.
+            // Need to compile with /FC under VC++ for __FILE__ to expand to the full file path.
+            // clang expands __FILE__ to a full path by default.
+            OVR_strlcpy(sdkRoot, __FILE__, sizeof(sdkRoot));
+            for(i = 0; sdkRoot[i]; ++i)
+                sdkRoot[i] = (char)tolower(sdkRoot[i]); // Microsoft doesn't maintain case.
+            pLibOVR = strstr(sdkRoot, "libovr");
+            if(pLibOVR && (pLibOVR > sdkRoot))
+                pLibOVR[-1] = '\0';
+            else
+                sdkRoot[0] = '\0';
+        }
+
+        if(sdkRoot[0])
+        {
+            // We want to use a developer version of the library only if the application is also being executed from 
+            // a developer location. Ideally we would do this by checking that the relative path from the executable to 
+            // the shared library is the same at runtime as it was when the executable was first built, but we don't have 
+            // an easy way to do that from here and it would require some runtime help from the application code. 
+            // Instead we verify that the application is simply in the same developer tree that was was when built.
+            // We could put in some additional logic to make it very likely to know if the EXE is in its original location.
+            FilePathCharType modulePath[OVR_MAX_PATH];
+            const ovrBool pathMatch = OVR_GetCurrentModuleDirectory(modulePath, OVR_MAX_PATH, ovrTrue) && 
+                                        (OVR_PathStartsWith(modulePath, sdkRoot) == ovrTrue);
+            if(pathMatch == ovrFalse)
+            {
+                sdkRoot[0] = '\0'; // The application module is not in the developer tree, so don't try to use the developer shared library.
+            }
+        }
+
+        if(sdkRoot[0])
+        {
+            #if defined(OVR_BUILD_DEBUG)
+                const char* pConfigDirName = "Debug";
+            #else
+                const char* pConfigDirName = "Release";
+            #endif
+            
+            #if defined(_MSC_VER)
+                #if defined(_WIN64)
+                    const char* pArchDirName = "x64";
+                #else
+                    const char* pArchDirName = "Win32";
+                #endif
+            #else
+                #if defined(__x86_64__)
+                    const char* pArchDirName = "x86_64";
+                #else
+                    const char* pArchDirName = "i386";
+                #endif
+            #endif
+
+            #if defined(_MSC_VER) && (_MSC_VER == 1600)
+                const char* pCompilerVersion = "VS2010";
+            #elif defined(_MSC_VER) && (_MSC_VER == 1700)
+                const char* pCompilerVersion = "VS2012";
+            #elif defined(_MSC_VER) && (_MSC_VER == 1800)
+                const char* pCompilerVersion = "VS2013";
+            #elif defined(_MSC_VER) && (_MSC_VER == 1900)
+                const char* pCompilerVersion = "VS2014";
+            #endif
+
+            #if defined(_WIN32)
+                int count = swprintf_s(developerDir, OVR_MAX_PATH, L"%hs\\LibOVR\\Lib\\Windows\\%hs\\%hs\\%hs\\", 
+                                        sdkRoot, pArchDirName, pConfigDirName, pCompilerVersion);
+            #elif defined(__APPLE__)
+                // Apple/XCode doesn't let you specify an arch in build paths, which is OK if we build a universal binary.
+                (void)pArchDirName;
+                int count = snprintf(developerDir, OVR_MAX_PATH, "%s/LibOVR/Lib/Mac/%s/",
+                                        sdkRoot, pConfigDirName);
+            #else
+                int count = snprintf(developerDir, OVR_MAX_PATH, "%s/LibOVR/Lib/Linux/%s/%s/", 
+                                        sdkRoot, pArchDirName, pConfigDirName);
+            #endif
+            
+            if((count < 0) || (count >= (int)OVR_MAX_PATH)) // If there was an error or capacity overflow... clear the string.
+            {
+                developerDir[0] = '\0';
+            }
+        }
+    }
+    #endif // OVR_ENABLE_DEVELOPER_SEARCH
+
+    {    
+        FilePathCharType cwDir[OVR_MAX_PATH]; // Will be filled in below.
+        FilePathCharType appDir[OVR_MAX_PATH];
+        size_t i;
+
+        #if defined(_WIN32)
+            FilePathCharType  moduleDir[OVR_MAX_PATH];
+            FilePathCharType* directoryArray[5];
+            directoryArray[0] = cwDir;
+            directoryArray[1] = moduleDir;
+            directoryArray[2] = appDir;
+            directoryArray[3] = developerDir;   // Developer directory.
+            directoryArray[4] = L"";            // No directory, which causes Windows to use the standard search strategy to find the DLL.
+
+            OVR_GetCurrentModuleDirectory(moduleDir, sizeof(moduleDir)/sizeof(moduleDir[0]), ovrTrue);
+
+        #elif defined(__APPLE__)
+            // https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/dyld.1.html
+        
+            FilePathCharType  homeDir[OVR_MAX_PATH];
+            FilePathCharType  homeFrameworkDir[OVR_MAX_PATH];
+            FilePathCharType* directoryArray[5];
+            size_t            homeDirLength = 0;
+
+            const char* pHome = getenv("HOME"); // Try getting the HOME environment variable.
+        
+            if (pHome)
+            {
+                homeDirLength = OVR_strlcpy(homeDir, pHome, sizeof(homeDir));
+            }
+            else
+            {
+                // https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man3/getpwuid_r.3.html
+                const long pwBufferSize = sysconf(_SC_GETPW_R_SIZE_MAX);
+        
+                if (pwBufferSize != -1)
+                {
+                    char pwBuffer[pwBufferSize];
+                    struct passwd  pw;
+                    struct passwd* pwResult = NULL;
+                   
+                    if ((getpwuid_r(getuid(), &pw, pwBuffer, pwBufferSize, &pwResult) == 0) && pwResult)
+                        homeDirLength = OVR_strlcpy(homeDir, pw.pw_dir, sizeof(homeDir));
+                }
+            }
+    
+            if (homeDirLength)
+            {
+                if (homeDir[homeDirLength - 1] == '/')
+                    homeDir[homeDirLength - 1] = '\0';
+                OVR_strlcpy(homeFrameworkDir, homeDir, sizeof(homeFrameworkDir));
+                OVR_strlcat(homeFrameworkDir, "/Library/Frameworks/", sizeof(homeFrameworkDir));
+            }
+            else
+            {
+                homeFrameworkDir[0] = '\0';
+            }
+    
+            directoryArray[0] = cwDir;
+            directoryArray[1] = appDir;
+            directoryArray[2] = homeFrameworkDir;           // ~/Library/Frameworks/
+            directoryArray[3] = "/Library/Frameworks/";     // DYLD_FALLBACK_FRAMEWORK_PATH
+            directoryArray[4] = developerDir;               // Developer directory.
+
+        #else
+            #define STR1(x) #x
+            #define STR(x)  STR1(x)
+            #ifdef LIBDIR
+                #define TEST_LIB_DIR STR(LIBDIR) "/"
+            #else
+                #define TEST_LIB_DIR appDir
+            #endif
+
+            FilePathCharType* directoryArray[5];
+            directoryArray[0] = cwDir;
+            directoryArray[1] = TEST_LIB_DIR;           // Directory specified by LIBDIR if defined.
+            directoryArray[2] = developerDir;           // Developer directory.
+            directoryArray[3] = "/usr/local/lib/";
+            directoryArray[4] = "/usr/lib/";
+        #endif
+
+        OVR_GetCurrentWorkingDirectory(cwDir, sizeof(cwDir) / sizeof(cwDir[0]));
+        OVR_GetCurrentApplicationDirectory(appDir, sizeof(appDir) / sizeof(appDir[0]), ovrTrue, NULL);
+
+        // Versioned file expectations.
+        //     Windows: LibOVRRT<BIT_DEPTH>_<PRODUCT_VERSION>_<MAJOR_VERSION>.dll                                  // Example: LibOVRRT64_1_1.dll -- LibOVRRT 64 bit, product 1, major version 1, minor/patch/build numbers unspecified in the name.
+        //     Mac:     LibOVRRT_<PRODUCT_VERSION>.framework/Versions/<MAJOR_VERSION>/LibOVRRT_<PRODUCT_VERSION>   // We are not presently using the .framework bundle's Current directory to hold the version number. This may change.
+        //     Linux:   libOVRRT<BIT_DEPTH>_<PRODUCT_VERSION>.so.<MAJOR_VERSION>                                   // The file on disk may contain a minor version number, but a symlink is used to map this major-only version to it.
+
+        // Since we are manually loading the LibOVR dynamic library, we need to look in various locations for a file
+        // that matches our requirements. The functionality required is somewhat similar to the operating system's 
+        // dynamic loader functionality. Each OS has some differences in how this is handled.
+        // Future versions of this may iterate over all libOVRRT.so.* files in the directory and use the one that matches our requirements.
+        //
+        // We need to look for a library that matches the product version and major version of the caller's request,
+        // and that library needs to support a minor version that is >= the requested minor version. Currently we
+        // don't test the minor version here, as the library is named based only on the product and major version.
+        // Currently the minor version test is handled via the initialization of the library and the initialization
+        // fails if minor version cannot be supported by the library. The reason this is done during initialization
+        // is that the library can at runtime support multiple minor versions based on the user's request. To the
+        // external user, all that matters it that they call ovr_Initialize with a requested version and it succeeds
+        // or fails.
+        //
+        // The product version is something that is at a higher level than the major version, and is not something that's
+        // always seen in libraries (an example is the well-known LibXml2 library, in which the 2 is essentially the product version).
+
+        for(i = 0; i < sizeof(directoryArray)/sizeof(directoryArray[0]); ++i)
+        {
+            #if defined(_WIN32)
+                printfResult = swprintf(libraryPath, libraryPathCapacity, L"%lsLibOVRRT%hs_%d_%d.dll", directoryArray[i], pBitDepth, requestedProductVersion, requestedMajorVersion);
+
+            #elif defined(__APPLE__)
+                // https://developer.apple.com/library/mac/documentation/MacOSX/Conceptual/BPFrameworks/Concepts/VersionInformation.html
+                // Macintosh application bundles have the option of embedding dependent frameworks within the application
+                // bundle itself. A problem with that is that it doesn't support vendor-supplied updates to the framework.
+                printfResult = snprintf(libraryPath, libraryPathCapacity, "%sLibOVRRT_%d.framework/Versions/%d/LibOVRRT_%d", directoryArray[i], requestedProductVersion, requestedMajorVersion, requestedProductVersion);
+
+            #else // Unix
+                // Applications that depend on the OS (e.g. ld-linux / ldd) can rely on the library being in a common location 
+                // such as /usr/lib or can rely on the -rpath linker option to embed a path for the OS to check for the library,
+                // or can rely on the LD_LIBRARY_PATH environment variable being set. It's generally not recommended that applications
+                // depend on LD_LIBRARY_PATH be globally modified, partly due to potentialy security issues.
+                // Currently we check the current application directory, current working directory, and then /usr/lib and possibly others.
+                printfResult = snprintf(libraryPath, libraryPathCapacity, "%slibOVRRT%s_%d.so.%d", directoryArray[i], pBitDepth, requestedProductVersion, requestedMajorVersion);
+            #endif
+
+            if((printfResult >= 0) && (printfResult < (int)libraryPathCapacity))
+            {
+                moduleHandle = OVR_OpenLibrary(libraryPath);
+                if(moduleHandle != ModuleHandleTypeNull)
+                    return moduleHandle;
+            }
+        }
+    }
+
+    return moduleHandle;
+}
+
+
+
+//-----------------------------------------------------------------------------------
+// ***** hLibOVR
+//
+// global handle to the LivOVR shared library.
+//
+static ModuleHandleType hLibOVR = NULL;
+
+// This function is currently unsupported.
+ModuleHandleType ovr_GetLibOVRRTHandle()
+{
+    return hLibOVR;
+}
+
+
+
+//-----------------------------------------------------------------------------------
+// ***** Function declarations
+//
+// To consider: Move OVR_DECLARE_IMPORT and the declarations below to OVR_CAPI.h
+//
+//OVR_DECLARE_IMPORT(ovrBool,        ovr_InitializeRenderingShim, ())
+OVR_DECLARE_IMPORT(ovrBool,          ovr_InitializeRenderingShimVersion, (int requestedMinorVersion))
+OVR_DECLARE_IMPORT(ovrBool,          ovr_Initialize, (ovrInitParams const* params))
+OVR_DECLARE_IMPORT(ovrBool,          ovr_Shutdown, ())
+OVR_DECLARE_IMPORT(const char*,      ovr_GetVersionString, ())
+OVR_DECLARE_IMPORT(int,              ovrHmd_Detect, ())
+OVR_DECLARE_IMPORT(ovrHmd,           ovrHmd_Create, (int index))
+OVR_DECLARE_IMPORT(void,             ovrHmd_Destroy, (ovrHmd hmd))
+OVR_DECLARE_IMPORT(ovrHmd,           ovrHmd_CreateDebug, (ovrHmdType type))
+OVR_DECLARE_IMPORT(const char*,      ovrHmd_GetLastError, (ovrHmd hmd))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_AttachToWindow, (ovrHmd hmd, void* window, const ovrRecti* destMirrorRect, const ovrRecti* sourceRenderTargetRect))
+OVR_DECLARE_IMPORT(unsigned int,     ovrHmd_GetEnabledCaps, (ovrHmd hmd))
+OVR_DECLARE_IMPORT(void,             ovrHmd_SetEnabledCaps, (ovrHmd hmd, unsigned int hmdCaps))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_ConfigureTracking, (ovrHmd hmd, unsigned int supportedTrackingCaps, unsigned int requiredTrackingCaps))
+OVR_DECLARE_IMPORT(void,             ovrHmd_RecenterPose, (ovrHmd hmd))
+OVR_DECLARE_IMPORT(ovrTrackingState, ovrHmd_GetTrackingState, (ovrHmd hmd, double absTime))
+OVR_DECLARE_IMPORT(ovrSizei,         ovrHmd_GetFovTextureSize, (ovrHmd hmd, ovrEyeType eye, ovrFovPort fov, float pixelsPerDisplayPixel))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_ConfigureRendering, ( ovrHmd hmd, const ovrRenderAPIConfig* apiConfig, unsigned int distortionCaps, const ovrFovPort eyeFovIn[2], ovrEyeRenderDesc eyeRenderDescOut[2] ))
+OVR_DECLARE_IMPORT(ovrFrameTiming,   ovrHmd_BeginFrame, (ovrHmd hmd, unsigned int frameIndex))
+OVR_DECLARE_IMPORT(void,             ovrHmd_EndFrame, (ovrHmd hmd, const ovrPosef renderPose[2], const ovrTexture eyeTexture[2]))
+OVR_DECLARE_IMPORT(void,             ovrHmd_GetEyePoses, (ovrHmd hmd, unsigned int frameIndex, const ovrVector3f hmdToEyeViewOffset[2], ovrPosef outEyePoses[2], ovrTrackingState* outHmdTrackingState))
+OVR_DECLARE_IMPORT(ovrPosef,         ovrHmd_GetHmdPosePerEye, (ovrHmd hmd, ovrEyeType eye))
+OVR_DECLARE_IMPORT(ovrEyeRenderDesc, ovrHmd_GetRenderDesc, (ovrHmd hmd, ovrEyeType eyeType, ovrFovPort fov))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_CreateDistortionMesh, (ovrHmd hmd, ovrEyeType eyeType, ovrFovPort fov, unsigned int distortionCaps, ovrDistortionMesh *meshData))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_CreateDistortionMeshDebug, (ovrHmd hmddesc, ovrEyeType eyeType, ovrFovPort fov, unsigned int distortionCaps, ovrDistortionMesh *meshData, float debugEyeReliefOverrideInMetres))
+OVR_DECLARE_IMPORT(void,             ovrHmd_DestroyDistortionMesh, (ovrDistortionMesh* meshData ))
+OVR_DECLARE_IMPORT(void,             ovrHmd_GetRenderScaleAndOffset, (ovrFovPort fov, ovrSizei textureSize, ovrRecti renderViewport, ovrVector2f uvScaleOffsetOut[2] ))
+OVR_DECLARE_IMPORT(ovrFrameTiming,   ovrHmd_GetFrameTiming, (ovrHmd hmd, unsigned int frameIndex))
+OVR_DECLARE_IMPORT(ovrFrameTiming,   ovrHmd_BeginFrameTiming, (ovrHmd hmd, unsigned int frameIndex))
+OVR_DECLARE_IMPORT(void,             ovrHmd_EndFrameTiming, (ovrHmd hmd))
+OVR_DECLARE_IMPORT(void,             ovrHmd_ResetFrameTiming, (ovrHmd hmd, unsigned int frameIndex))
+OVR_DECLARE_IMPORT(void,             ovrHmd_GetEyeTimewarpMatrices, (ovrHmd hmd, ovrEyeType eye, ovrPosef renderPose, ovrMatrix4f twmOut[2]))
+OVR_DECLARE_IMPORT(void,             ovrHmd_GetEyeTimewarpMatricesDebug, (ovrHmd hmd, ovrEyeType eye, ovrPosef renderPose, ovrQuatf playerTorsoMotion, ovrMatrix4f twmOut[2], double debugTimingOffsetInSeconds))
+//OVR_DECLARE_IMPORT(ovrMatrix4f,      ovrMatrix4f_Projection, (ovrFovPort fov, float znear, float zfar, unsigned int projectionModFlags))
+//OVR_DECLARE_IMPORT(ovrMatrix4f,      ovrMatrix4f_OrthoSubProjection, (ovrMatrix4f projection, ovrVector2f orthoScale, float orthoDistance, float hmdToEyeViewOffsetX))
+OVR_DECLARE_IMPORT(double,           ovr_GetTimeInSeconds, ())
+//OVR_DECLARE_IMPORT(double,           ovr_WaitTillTime, (double absTime))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_ProcessLatencyTest, (ovrHmd hmd, unsigned char rgbColorOut[3]))
+OVR_DECLARE_IMPORT(const char*,      ovrHmd_GetLatencyTestResult, (ovrHmd hmd))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_GetLatencyTest2DrawColor, (ovrHmd hmddesc, unsigned char rgbColorOut[3]))
+OVR_DECLARE_IMPORT(void,             ovrHmd_GetHSWDisplayState, (ovrHmd hmd, ovrHSWDisplayState *hasWarningState))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_DismissHSWDisplay, (ovrHmd hmd))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_GetBool, (ovrHmd hmd, const char* propertyName, ovrBool defaultVal))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_SetBool, (ovrHmd hmd, const char* propertyName, ovrBool value))
+OVR_DECLARE_IMPORT(int,              ovrHmd_GetInt, (ovrHmd hmd, const char* propertyName, int defaultVal))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_SetInt, (ovrHmd hmd, const char* propertyName, int value))
+OVR_DECLARE_IMPORT(float,            ovrHmd_GetFloat, (ovrHmd hmd, const char* propertyName, float defaultVal))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_SetFloat, (ovrHmd hmd, const char* propertyName, float value))
+OVR_DECLARE_IMPORT(unsigned int,     ovrHmd_GetFloatArray, (ovrHmd hmd, const char* propertyName, float values[], unsigned int arraySize))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_SetFloatArray, (ovrHmd hmd, const char* propertyName, float values[], unsigned int arraySize))
+OVR_DECLARE_IMPORT(const char*,      ovrHmd_GetString, (ovrHmd hmd, const char* propertyName, const char* defaultVal))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_SetString, (ovrHmd hmddesc, const char* propertyName, const char* value))
+OVR_DECLARE_IMPORT(int,              ovr_TraceMessage, (int level, const char* message))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_StartPerfLog, (ovrHmd hmd, const char* fileName, const char* userData1))
+OVR_DECLARE_IMPORT(ovrBool,          ovrHmd_StopPerfLog, (ovrHmd hmd))
+
+static ovrBool OVR_LoadSharedLibrary(int requestedMinorVersion, int requestedPatchVersion)
+{
+    FilePathCharType filePath[OVR_MAX_PATH];
+
+    if(hLibOVR)
+        return ovrTrue;
+
+    hLibOVR = OVR_FindLibraryPath(requestedMinorVersion, requestedPatchVersion,
+                             filePath, sizeof(filePath) / sizeof(filePath[0]));
+    if(!hLibOVR)
+        return ovrFalse;
+
+  //OVR_GETFUNCTION(ovr_InitializeRenderingShim)    // No longer exposed.
+    OVR_GETFUNCTION(ovr_InitializeRenderingShimVersion)
+    OVR_GETFUNCTION(ovr_Initialize)
+    OVR_GETFUNCTION(ovr_Shutdown)
+    OVR_GETFUNCTION(ovr_GetVersionString)
+    OVR_GETFUNCTION(ovrHmd_Detect)
+    OVR_GETFUNCTION(ovrHmd_Create)
+    OVR_GETFUNCTION(ovrHmd_Destroy)
+    OVR_GETFUNCTION(ovrHmd_CreateDebug)
+    OVR_GETFUNCTION(ovrHmd_GetLastError)
+    OVR_GETFUNCTION(ovrHmd_AttachToWindow)
+    OVR_GETFUNCTION(ovrHmd_GetEnabledCaps)
+    OVR_GETFUNCTION(ovrHmd_SetEnabledCaps)
+    OVR_GETFUNCTION(ovrHmd_ConfigureTracking)
+    OVR_GETFUNCTION(ovrHmd_RecenterPose)
+    OVR_GETFUNCTION(ovrHmd_GetTrackingState)
+    OVR_GETFUNCTION(ovrHmd_GetFovTextureSize)
+    OVR_GETFUNCTION(ovrHmd_ConfigureRendering)
+    OVR_GETFUNCTION(ovrHmd_BeginFrame)
+    OVR_GETFUNCTION(ovrHmd_EndFrame)
+    OVR_GETFUNCTION(ovrHmd_GetEyePoses)
+    OVR_GETFUNCTION(ovrHmd_GetHmdPosePerEye)
+    OVR_GETFUNCTION(ovrHmd_GetRenderDesc)
+    OVR_GETFUNCTION(ovrHmd_CreateDistortionMesh)
+    OVR_GETFUNCTION(ovrHmd_CreateDistortionMeshDebug)
+    OVR_GETFUNCTION(ovrHmd_DestroyDistortionMesh)
+    OVR_GETFUNCTION(ovrHmd_GetRenderScaleAndOffset)
+    OVR_GETFUNCTION(ovrHmd_GetFrameTiming)
+    OVR_GETFUNCTION(ovrHmd_BeginFrameTiming)
+    OVR_GETFUNCTION(ovrHmd_EndFrameTiming)
+    OVR_GETFUNCTION(ovrHmd_ResetFrameTiming)
+    OVR_GETFUNCTION(ovrHmd_GetEyeTimewarpMatrices)
+    OVR_GETFUNCTION(ovrHmd_GetEyeTimewarpMatricesDebug)
+  //OVR_GETFUNCTION(ovrMatrix4f_Projection)
+  //OVR_GETFUNCTION(ovrMatrix4f_OrthoSubProjection)
+    OVR_GETFUNCTION(ovr_GetTimeInSeconds)
+  //OVR_GETFUNCTION(ovr_WaitTillTime)
+    OVR_GETFUNCTION(ovrHmd_ProcessLatencyTest)
+    OVR_GETFUNCTION(ovrHmd_GetLatencyTestResult)
+    OVR_GETFUNCTION(ovrHmd_GetLatencyTest2DrawColor)
+    OVR_GETFUNCTION(ovrHmd_GetHSWDisplayState)
+    OVR_GETFUNCTION(ovrHmd_DismissHSWDisplay)
+    OVR_GETFUNCTION(ovrHmd_GetBool)
+    OVR_GETFUNCTION(ovrHmd_SetBool)
+    OVR_GETFUNCTION(ovrHmd_GetInt)
+    OVR_GETFUNCTION(ovrHmd_SetInt)
+    OVR_GETFUNCTION(ovrHmd_GetFloat)
+    OVR_GETFUNCTION(ovrHmd_SetFloat)
+    OVR_GETFUNCTION(ovrHmd_GetFloatArray)
+    OVR_GETFUNCTION(ovrHmd_SetFloatArray)
+    OVR_GETFUNCTION(ovrHmd_GetString)
+    OVR_GETFUNCTION(ovrHmd_SetString)
+    OVR_GETFUNCTION(ovr_TraceMessage)
+    OVR_GETFUNCTION(ovrHmd_StartPerfLog)
+    OVR_GETFUNCTION(ovrHmd_StopPerfLog)
+
+    return ovrTrue;
+}
+
+static void OVR_UnloadSharedLibrary()
+{
+    // TBD: Currently there are some CAPI functions and code in the render shim that does
+    // not work with unloading the LibOVRRT. We also have the problem that LibOVR returns 
+    // a string pointer in the GetLastError function.
+    //OVR_CloseLibrary(hLibOVR);
+    //hLibOVR = NULL;
+}
+
+
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovr_InitializeRenderingShim()
+{
+    return ovr_InitializeRenderingShimVersion(OVR_MINOR_VERSION);
+}
+
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovr_InitializeRenderingShimVersion(int requestedMinorVersion)
+{
+    // By design we ignore the build version in the library search.
+    ovrBool result = OVR_LoadSharedLibrary(OVR_PRODUCT_VERSION, OVR_MAJOR_VERSION);
+
+    if (!result)
+        return ovrFalse;
+
+    result = ovr_InitializeRenderingShimVersionPtr(requestedMinorVersion);
+
+    if (result == ovrFalse)
+        OVR_UnloadSharedLibrary();
+
+    return result;
+}
+
+
+// These defaults are also in CAPI.cpp
+static const ovrInitParams DefaultParams = {
+    ovrInit_RequestVersion, // Flags
+    OVR_MINOR_VERSION,      // RequestedMinorVersion
+    0,                      // LogCallback
+    0                       // ConnectionTimeoutSeconds
+};
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovr_Initialize(ovrInitParams const* inputParams)
+{
+    ovrBool result;
+    ovrInitParams params;
+
+    if (!inputParams)
+    {
+        params = DefaultParams;
+    }
+    else
+    {
+        params = *inputParams;
+
+        // If not requesting a particular minor version,
+        if (!(params.Flags & ovrInit_RequestVersion))
+        {
+            // Enable requesting the default minor version.
+            params.Flags |= ovrInit_RequestVersion;
+            params.RequestedMinorVersion = OVR_MINOR_VERSION;
+        }
+    }
+
+#if defined(OVR_BUILD_DEBUG)
+    // If no debug setting is provided,
+    if (!(params.Flags & (ovrInit_Debug | ovrInit_ForceNoDebug)))
+    {
+        // Set the debug flag in debug mode.
+        params.Flags |= ovrInit_Debug;
+    }
+#endif
+
+    // By design we ignore the build version in the library search.
+    result = OVR_LoadSharedLibrary(OVR_PRODUCT_VERSION, OVR_MAJOR_VERSION);
+    if (!result)
+        return ovrFalse;
+
+    result = ovr_InitializePtr(&params);
+    if (result == ovrFalse)
+        OVR_UnloadSharedLibrary();
+
+    return result;
+}
+
+OVR_PUBLIC_FUNCTION(void) ovr_Shutdown()
+{
+    if (!ovr_ShutdownPtr)
+        return;
+    ovr_ShutdownPtr();
+    OVR_UnloadSharedLibrary();
+}
+
+OVR_PUBLIC_FUNCTION(const char*) ovr_GetVersionString()
+{
+    if (!ovr_GetVersionStringPtr)
+        return "(Unable to load LibOVR)";
+    return ovr_GetVersionStringPtr();
+}
+
+OVR_PUBLIC_FUNCTION(int) ovrHmd_Detect()
+{
+    if (!ovrHmd_DetectPtr)
+        return -1;
+    return ovrHmd_DetectPtr();
+}
+
+OVR_PUBLIC_FUNCTION(ovrHmd) ovrHmd_Create(int index)
+{
+    if (!ovrHmd_CreatePtr)
+        return 0;
+    return ovrHmd_CreatePtr(index);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_Destroy(ovrHmd hmd)
+{
+    if (!ovrHmd_DestroyPtr)
+        return;
+    ovrHmd_DestroyPtr(hmd);
+}
+
+OVR_PUBLIC_FUNCTION(ovrHmd) ovrHmd_CreateDebug(ovrHmdType type)
+{
+    if (!ovrHmd_CreateDebugPtr)
+        return 0;
+    return ovrHmd_CreateDebugPtr(type);
+}
+
+OVR_PUBLIC_FUNCTION(const char*) ovrHmd_GetLastError(ovrHmd hmd)
+{
+    if (!ovrHmd_GetLastErrorPtr)
+        return "(Unable to load LibOVR)";
+    return ovrHmd_GetLastErrorPtr(hmd);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_AttachToWindow(ovrHmd hmd, void* window,
+                                const ovrRecti* destMirrorRect, const ovrRecti* sourceRenderTargetRect)
+{
+    if (!ovrHmd_AttachToWindowPtr)
+        return ovrFalse;
+    return ovrHmd_AttachToWindowPtr(hmd, window, destMirrorRect, sourceRenderTargetRect);
+}
+
+OVR_PUBLIC_FUNCTION(unsigned int) ovrHmd_GetEnabledCaps(ovrHmd hmd)
+{
+    if (!ovrHmd_GetEnabledCapsPtr)
+        return 0;
+    return ovrHmd_GetEnabledCapsPtr(hmd);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_SetEnabledCaps(ovrHmd hmd, unsigned int hmdCaps)
+{
+    if (!ovrHmd_SetEnabledCapsPtr)
+        return;
+    ovrHmd_SetEnabledCapsPtr(hmd, hmdCaps);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_ConfigureTracking(ovrHmd hmd, unsigned int supportedTrackingCaps,
+                                                         unsigned int requiredTrackingCaps)
+{
+    if (!ovrHmd_ConfigureTrackingPtr)
+        return ovrFalse;
+    return ovrHmd_ConfigureTrackingPtr(hmd, supportedTrackingCaps, requiredTrackingCaps);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_RecenterPose(ovrHmd hmd)
+{
+    if (!ovrHmd_RecenterPosePtr)
+        return;
+    ovrHmd_RecenterPosePtr(hmd);
+}
+
+OVR_PUBLIC_FUNCTION(ovrTrackingState) ovrHmd_GetTrackingState(ovrHmd hmd, double absTime)
+{
+    if (!ovrHmd_GetTrackingStatePtr)
+    {
+        static ovrTrackingState nullTrackingState;
+        memset(&nullTrackingState, 0, sizeof(nullTrackingState));
+        return nullTrackingState;
+    }
+
+    return ovrHmd_GetTrackingStatePtr(hmd, absTime);
+}
+
+
+
+OVR_PUBLIC_FUNCTION(ovrSizei) ovrHmd_GetFovTextureSize(ovrHmd hmd, ovrEyeType eye, ovrFovPort fov,
+                                             float pixelsPerDisplayPixel)
+{
+    if (!ovrHmd_GetFovTextureSizePtr)
+    {
+        static ovrSizei nullSize;
+        memset(&nullSize, 0, sizeof(nullSize));
+        return nullSize;
+    }
+
+    return ovrHmd_GetFovTextureSizePtr(hmd, eye, fov, pixelsPerDisplayPixel);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_ConfigureRendering(ovrHmd hmd, const ovrRenderAPIConfig* apiConfig, unsigned int distortionCaps,
+                                  const ovrFovPort eyeFovIn[2], ovrEyeRenderDesc eyeRenderDescOut[2])
+{
+    if (!ovrHmd_ConfigureRenderingPtr)
+        return ovrFalse;
+    return ovrHmd_ConfigureRenderingPtr(hmd, apiConfig, distortionCaps, eyeFovIn, eyeRenderDescOut);
+}
+
+OVR_PUBLIC_FUNCTION(ovrFrameTiming) ovrHmd_BeginFrame(ovrHmd hmd, unsigned int frameIndex)
+{
+    if (!ovrHmd_BeginFramePtr)
+    {
+        static ovrFrameTiming nullFrameTiming;
+        memset(&nullFrameTiming, 0, sizeof(nullFrameTiming));
+        return nullFrameTiming;
+    }
+    return ovrHmd_BeginFramePtr(hmd, frameIndex);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_EndFrame(ovrHmd hmd, const ovrPosef renderPose[2], const ovrTexture eyeTexture[2])
+{
+    if (!ovrHmd_EndFramePtr)
+        return;
+    ovrHmd_EndFramePtr(hmd, renderPose, eyeTexture);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_GetEyePoses(ovrHmd hmd, unsigned int frameIndex, const ovrVector3f hmdToEyeViewOffset[2],
+                                             ovrPosef outEyePoses[2], ovrTrackingState* outHmdTrackingState)
+{
+    if (!ovrHmd_GetEyePosesPtr)
+        return;
+    ovrHmd_GetEyePosesPtr(hmd, frameIndex, hmdToEyeViewOffset, outEyePoses, outHmdTrackingState);
+}
+
+OVR_PUBLIC_FUNCTION(ovrPosef) ovrHmd_GetHmdPosePerEye(ovrHmd hmd, ovrEyeType eye)
+{
+    if (!ovrHmd_GetHmdPosePerEyePtr)
+    {
+        static ovrPosef nullPose;
+        memset(&nullPose, 0, sizeof(nullPose));
+        nullPose.Orientation.w = 1.0f; // Return a proper quaternion.
+        return nullPose;
+    }
+    return ovrHmd_GetHmdPosePerEyePtr(hmd, eye);
+}
+
+OVR_PUBLIC_FUNCTION(ovrEyeRenderDesc) ovrHmd_GetRenderDesc(ovrHmd hmd, ovrEyeType eyeType, ovrFovPort fov)
+{
+    if (!ovrHmd_GetRenderDescPtr)
+    {
+        static ovrEyeRenderDesc nullEyeRenderDesc;
+        memset(&nullEyeRenderDesc, 0, sizeof(nullEyeRenderDesc));
+        return nullEyeRenderDesc;
+    }
+    return ovrHmd_GetRenderDescPtr(hmd, eyeType, fov);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_CreateDistortionMesh(ovrHmd hmd, ovrEyeType eyeType, ovrFovPort fov,
+                                       unsigned int distortionCaps, ovrDistortionMesh *meshData)
+{
+    if (!ovrHmd_CreateDistortionMeshPtr)
+        return ovrFalse;
+    return ovrHmd_CreateDistortionMeshPtr(hmd, eyeType, fov, distortionCaps, meshData);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_CreateDistortionMeshDebug(ovrHmd hmd, ovrEyeType eyeType, ovrFovPort fov, unsigned int distortionCaps,
+                                           ovrDistortionMesh *meshData, float debugEyeReliefOverrideInMetres)
+{
+    if (!ovrHmd_CreateDistortionMeshDebugPtr)
+        return ovrFalse;
+    return ovrHmd_CreateDistortionMeshDebugPtr(hmd, eyeType, fov, distortionCaps, meshData, debugEyeReliefOverrideInMetres);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_DestroyDistortionMesh(ovrDistortionMesh* meshData)
+{
+    if (!ovrHmd_DestroyDistortionMeshPtr)
+        return;
+    ovrHmd_DestroyDistortionMeshPtr(meshData);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_GetRenderScaleAndOffset(ovrFovPort fov, ovrSizei textureSize, ovrRecti renderViewport,
+                                                    ovrVector2f uvScaleOffsetOut[2])
+{
+    if (!ovrHmd_GetRenderScaleAndOffsetPtr)
+        return;
+    ovrHmd_GetRenderScaleAndOffsetPtr(fov, textureSize, renderViewport, uvScaleOffsetOut);
+}
+
+OVR_PUBLIC_FUNCTION(ovrFrameTiming) ovrHmd_GetFrameTiming(ovrHmd hmd, unsigned int frameIndex)
+{
+    if (!ovrHmd_GetFrameTimingPtr)
+    {
+        static ovrFrameTiming nullFrameTiming;
+        memset(&nullFrameTiming, 0, sizeof(nullFrameTiming));
+        return nullFrameTiming;
+    }
+    return ovrHmd_GetFrameTimingPtr(hmd, frameIndex);
+}
+
+OVR_PUBLIC_FUNCTION(ovrFrameTiming) ovrHmd_BeginFrameTiming(ovrHmd hmd, unsigned int frameIndex)
+{
+    if (!ovrHmd_BeginFrameTimingPtr)
+{
+        static ovrFrameTiming nullFrameTiming;
+        memset(&nullFrameTiming, 0, sizeof(nullFrameTiming));
+        return nullFrameTiming;
+    }
+    return ovrHmd_BeginFrameTimingPtr(hmd, frameIndex);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_EndFrameTiming(ovrHmd hmd)
+{
+    if (!ovrHmd_EndFrameTimingPtr)
+        return;
+    ovrHmd_EndFrameTimingPtr(hmd);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_ResetFrameTiming(ovrHmd hmd, unsigned int frameIndex)
+{
+    if (!ovrHmd_ResetFrameTimingPtr)
+        return;
+    ovrHmd_ResetFrameTimingPtr(hmd, frameIndex);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_GetEyeTimewarpMatrices(ovrHmd hmd, ovrEyeType eye, ovrPosef renderPose, ovrMatrix4f twmOut[2])
+{
+    if (!ovrHmd_GetEyeTimewarpMatricesPtr)
+        return;
+    ovrHmd_GetEyeTimewarpMatricesPtr(hmd, eye, renderPose, twmOut);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_GetEyeTimewarpMatricesDebug(ovrHmd hmd, ovrEyeType eye, ovrPosef renderPose,
+                                                ovrQuatf playerTorsoMotion, ovrMatrix4f twmOut[2], double debugTimingOffsetInSeconds)
+{
+    if (!ovrHmd_GetEyeTimewarpMatricesDebugPtr)
+        return;
+    ovrHmd_GetEyeTimewarpMatricesDebugPtr(hmd, eye, renderPose, playerTorsoMotion, twmOut, debugTimingOffsetInSeconds);
+}
+
+/*
+OVR_PUBLIC_FUNCTION(ovrMatrix4f) ovrMatrix4f_Projection(ovrFovPort fov, float znear, float zfar, unsigned int projectionModFlags)
+{
+    if (!ovrMatrix4f_ProjectionPtr)
+    {
+        static ovrMatrix4f nullMatrix;
+        memset(&nullMatrix, 0, sizeof(nullMatrix));
+        return nullMatrix;
+    }
+    return ovrMatrix4f_ProjectionPtr(fov, znear, zfar, projectionModFlags);
+}
+*/
+
+/*
+OVR_PUBLIC_FUNCTION(ovrMatrix4f) ovrMatrix4f_OrthoSubProjection(ovrMatrix4f projection, ovrVector2f orthoScale,
+                                             float orthoDistance, float hmdToEyeViewOffsetX)
+{
+    if (!ovrMatrix4f_OrthoSubProjectionPtr)
+    {
+        static ovrMatrix4f nullMatrix;
+        memset(&nullMatrix, 0, sizeof(nullMatrix));
+        return nullMatrix;
+    }
+    return ovrMatrix4f_OrthoSubProjectionPtr(projection, orthoScale, orthoDistance, hmdToEyeViewOffsetX);
+}
+*/
+
+OVR_PUBLIC_FUNCTION(double) ovr_GetTimeInSeconds()
+{
+    if (!ovr_GetTimeInSecondsPtr)
+        return 0.;
+    return ovr_GetTimeInSecondsPtr();
+}
+
+/*
+OVR_PUBLIC_FUNCTION(double) ovr_WaitTillTime(double absTime)
+{
+    if (!ovr_WaitTillTimePtr)
+        return 0.;
+    return ovr_WaitTillTimePtr(absTime);
+}
+*/
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_ProcessLatencyTest(ovrHmd hmd, unsigned char rgbColorOut[3])
+{
+    if (!ovrHmd_ProcessLatencyTestPtr)
+        return ovrFalse;
+    return ovrHmd_ProcessLatencyTestPtr(hmd, rgbColorOut);
+}
+
+OVR_PUBLIC_FUNCTION(const char*) ovrHmd_GetLatencyTestResult(ovrHmd hmd)
+{
+    if (!ovrHmd_GetLatencyTestResultPtr)
+        return "(Unable to load LibOVR)";
+    return ovrHmd_GetLatencyTestResultPtr(hmd);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_GetLatencyTest2DrawColor(ovrHmd hmd, unsigned char rgbColorOut[3])
+{
+    if (!ovrHmd_GetLatencyTest2DrawColorPtr)
+        return ovrFalse;
+    return ovrHmd_GetLatencyTest2DrawColorPtr(hmd, rgbColorOut);
+}
+
+OVR_PUBLIC_FUNCTION(void) ovrHmd_GetHSWDisplayState(ovrHmd hmd, ovrHSWDisplayState *hasWarningState)
+{
+    if (!ovrHmd_GetHSWDisplayStatePtr)
+        return;
+    ovrHmd_GetHSWDisplayStatePtr(hmd, hasWarningState);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_DismissHSWDisplay(ovrHmd hmd)
+{
+    if (!ovrHmd_DismissHSWDisplayPtr)
+        return ovrFalse;
+    return ovrHmd_DismissHSWDisplayPtr(hmd);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_GetBool(ovrHmd hmd, const char* propertyName, ovrBool defaultVal)
+{
+    if (!ovrHmd_GetBoolPtr)
+        return ovrFalse;
+    return ovrHmd_GetBoolPtr(hmd, propertyName, defaultVal);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_SetBool(ovrHmd hmd, const char* propertyName, ovrBool value)
+{
+    if (!ovrHmd_SetBoolPtr)
+        return ovrFalse;
+    return ovrHmd_SetBoolPtr(hmd, propertyName, value);
+}
+
+OVR_PUBLIC_FUNCTION(int) ovrHmd_GetInt(ovrHmd hmd, const char* propertyName, int defaultVal)
+{
+    if (!ovrHmd_GetIntPtr)
+        return 0;
+    return ovrHmd_GetIntPtr(hmd, propertyName, defaultVal);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_SetInt(ovrHmd hmd, const char* propertyName, int value)
+{
+    if (!ovrHmd_SetIntPtr)
+        return ovrFalse;
+    return ovrHmd_SetIntPtr(hmd, propertyName, value);
+}
+
+OVR_PUBLIC_FUNCTION(float) ovrHmd_GetFloat(ovrHmd hmd, const char* propertyName, float defaultVal)
+{
+    if (!ovrHmd_GetFloatPtr)
+        return 0.f;
+    return ovrHmd_GetFloatPtr(hmd, propertyName, defaultVal);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_SetFloat(ovrHmd hmd, const char* propertyName, float value)
+{
+    if (!ovrHmd_SetFloatPtr)
+        return ovrFalse;
+    return ovrHmd_SetFloatPtr(hmd, propertyName, value);
+}
+
+OVR_PUBLIC_FUNCTION(unsigned int) ovrHmd_GetFloatArray(ovrHmd hmd, const char* propertyName,
+                                            float values[], unsigned int arraySize)
+{
+    if (!ovrHmd_GetFloatArrayPtr)
+        return 0;
+    return ovrHmd_GetFloatArrayPtr(hmd, propertyName, values, arraySize);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_SetFloatArray(ovrHmd hmd, const char* propertyName,
+                                             float values[], unsigned int arraySize)
+{
+    if (!ovrHmd_SetFloatArrayPtr)
+        return ovrFalse;
+    return ovrHmd_SetFloatArrayPtr(hmd, propertyName, values, arraySize);
+}
+
+OVR_PUBLIC_FUNCTION(const char*) ovrHmd_GetString(ovrHmd hmd, const char* propertyName,
+                                        const char* defaultVal)
+{
+    if (!ovrHmd_GetStringPtr)
+        return "(Unable to load LibOVR)";
+    return ovrHmd_GetStringPtr(hmd, propertyName, defaultVal);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_SetString(ovrHmd hmd, const char* propertyName,
+                                    const char* value)
+{
+    if (!ovrHmd_SetStringPtr)
+        return ovrFalse;
+    return ovrHmd_SetStringPtr(hmd, propertyName, value);
+}
+
+OVR_PUBLIC_FUNCTION(int) ovr_TraceMessage(int level, const char* message)
+{
+    if (!ovr_TraceMessagePtr)
+        return -1;
+
+    return ovr_TraceMessagePtr(level, message);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_StartPerfLog(ovrHmd hmd, const char* fileName, const char* userData1)
+{
+    if (!ovrHmd_StartPerfLogPtr)
+        return ovrFalse;
+    return ovrHmd_StartPerfLogPtr(hmd, fileName, userData1);
+}
+
+OVR_PUBLIC_FUNCTION(ovrBool) ovrHmd_StopPerfLog(ovrHmd hmd)
+{
+    if (!ovrHmd_StopPerfLogPtr)
+        return ovrFalse;
+    return ovrHmd_StopPerfLogPtr(hmd);
+}
+
+
+
+#if defined(_MSC_VER)
+    #pragma warning(pop)
+#endif
+