update to OpenVR 1.07 from https://github.com/ValveSoftware/openvr

2017-05-03 08:40:29 -07:00
parent eb7cf38293
commit 1bb133a01f
21 changed files with 2602 additions and 496 deletions
--- a/examples/ThirdPartyLibs/openvr/samples/shared/pathtools.cpp
+++ b/examples/ThirdPartyLibs/openvr/samples/shared/pathtools.cpp
@@ -1,22 +1,27 @@
 //========= Copyright Valve Corporation ============//
+#include "compat.h"
+#include "strtools.h"
 #include "pathtools.h"
-//#include "hmdplatform_private.h"
-//#include "vrcommon/strtools.h"

 #if defined( _WIN32)
 #include <Windows.h>
 #include <direct.h>
 #include <Shobjidl.h>
 #include <KnownFolders.h>
-#elif defined OSX
-#include <mach-o/dyld.h>
-#include <dlfcn.h>
-#include "osxfilebridge.h"
-#define _S_IFDIR S_IFDIR     // really from tier0/platform.h which we dont have yet
-#define _MAX_PATH MAX_PATH   // yet another form of _PATH define we use
-#elif defined(LINUX)
+#include <Shlobj.h>
+
+#undef GetEnvironmentVariable
+#else
 #include <dlfcn.h>
 #include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#endif
+#if defined OSX
+#include <Foundation/Foundation.h>
+#include <AppKit/AppKit.h>
+#include <mach-o/dyld.h>
+#define _S_IFDIR S_IFDIR     // really from tier0/platform.h which we dont have yet
 #endif

 #include <sys/stat.h>
@@ -26,44 +31,54 @@
 /** Returns the path (including filename) to the current executable */
 std::string Path_GetExecutablePath()
 {
-	bool bSuccess = false;
-	char rchPath[ 1024 ];
-	size_t nBuff = sizeof(rchPath);
 #if defined( _WIN32 )
-	bSuccess = ::GetModuleFileNameA(NULL, rchPath, (DWORD)nBuff) > 0;
-#elif defined OSX
-	uint32_t _nBuff = nBuff; 
-	bSuccess = _NSGetExecutablePath(rchPath, &_nBuff) == 0;
-	rchPath[nBuff-1] = '\0';
-#elif defined LINUX
-	ssize_t nRead = readlink("/proc/self/exe", rchPath, nBuff-1 );
-	if ( nRead != -1 )
-	{
-		rchPath[ nRead ] = 0;
-		bSuccess = true;
-	}
-	else
-	{
-		rchPath[ 0 ] = '\0';
-	}
-#else
-	AssertMsg( false, "Implement Plat_GetExecutablePath" );
-#endif
+	wchar_t *pwchPath = new wchar_t[MAX_UNICODE_PATH];
+	char *pchPath = new char[MAX_UNICODE_PATH_IN_UTF8];
+	::GetModuleFileNameW( NULL, pwchPath, MAX_UNICODE_PATH );
+	WideCharToMultiByte( CP_UTF8, 0, pwchPath, -1, pchPath, MAX_UNICODE_PATH_IN_UTF8, NULL, NULL );
+	delete[] pwchPath;

+	std::string sPath = pchPath;
+	delete[] pchPath;
+	return sPath;
+#elif defined( OSX )
+	char rchPath[1024];
+	uint32_t nBuff = sizeof( rchPath );
+	bool bSuccess = _NSGetExecutablePath(rchPath, &nBuff) == 0;
+	rchPath[nBuff-1] = '\0';
 	if( bSuccess )
 		return rchPath;
 	else
 		return "";
+#elif defined LINUX
+	char rchPath[1024];
+	size_t nBuff = sizeof( rchPath );
+	ssize_t nRead = readlink("/proc/self/exe", rchPath, nBuff-1 );
+	if ( nRead != -1 )
+	{
+		rchPath[ nRead ] = 0;
+		return rchPath;
+	}
+	else
+	{
+		return "";
+	}
+#else
+	AssertMsg( false, "Implement Plat_GetExecutablePath" );
+	return "";
+#endif
+
 }

 /** Returns the path of the current working directory */
 std::string Path_GetWorkingDirectory()
 {
 	std::string sPath;
-	char buf[ 1024 ];
 #if defined( _WIN32 )
-	sPath = _getcwd( buf, sizeof( buf ) );
+	wchar_t buf[MAX_UNICODE_PATH];
+	sPath = UTF16to8( _wgetcwd( buf, MAX_UNICODE_PATH ) );
 #else
+	char buf[ 1024 ];
 	sPath = getcwd( buf, sizeof( buf ) );
 #endif
 	return sPath;
@@ -74,37 +89,14 @@ bool Path_SetWorkingDirectory( const std::string & sPath )
 {
 	bool bSuccess;
 #if defined( _WIN32 )
-	bSuccess = 0 == _chdir( sPath.c_str() );
+	std::wstring wsPath = UTF8to16( sPath.c_str() );
+	bSuccess = 0 == _wchdir( wsPath.c_str() );
 #else
 	bSuccess = 0 == chdir( sPath.c_str() );
 #endif
 	return bSuccess;
 }

-std::string Path_GetModulePath()
-{
-#if defined( _WIN32 )
-	char path[32768];
-	HMODULE hm = NULL;
-
-	if (!GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
-		(LPCSTR) &Path_GetModulePath, 
-		&hm))
-	{
-		int ret = GetLastError();
-		fprintf(stderr, "GetModuleHandle returned %d\n", ret);
-		return "";
-	}
-	GetModuleFileNameA(hm, path, sizeof(path));
-	FreeLibrary( hm );
-	return path;
-#else
-	Dl_info dl_info;
-	dladdr((void *)Path_GetModulePath, &dl_info);
-	return dl_info.dli_fname;
-#endif
-}
-
 /** Returns the specified path without its filename */
 std::string Path_StripFilename( const std::string & sPath, char slash )
 {
@@ -151,17 +143,45 @@ std::string Path_StripExtension( const std::string & sPath )
 	return sPath;
 }

+/** returns just extension of the provided filename (if any). */
+std::string Path_GetExtension( const std::string & sPath )
+{
+	for ( std::string::const_reverse_iterator i = sPath.rbegin(); i != sPath.rend(); i++ )
+	{
+		if ( *i == '.' )
+		{
+			return std::string( i.base(), sPath.end() );
+		}
+
+		// if we find a slash there is no extension
+		if ( *i == '\\' || *i == '/' )
+			break;
+	}
+
+	// we didn't find an extension
+	return "";
+}

 bool Path_IsAbsolute( const std::string & sPath )
 {
 	if( sPath.empty() )
 		return false;

-	if( sPath.find( ':' ) != std::string::npos )
-		return true;
+#if defined( WIN32 )
+	if ( sPath.size() < 3 ) // must be c:\x or \\x at least
+		return false;

-	if( sPath[0] == '\\' || sPath[0] == '/' )
+	if ( sPath[1] == ':' ) // drive letter plus slash, but must test both slash cases
+	{
+		if ( sPath[2] == '\\' || sPath[2] == '/' )
+			return true;
+	}
+	else if ( sPath[0] == '\\' && sPath[1] == '\\' ) // UNC path
 		return true;
+#else
+	if( sPath[0] == '\\' || sPath[0] == '/' ) // any leading slash
+		return true;
+#endif

 	return false;
 }
@@ -223,6 +243,8 @@ std::string Path_Join( const std::string & first, const std::string & second, ch

 	// only insert a slash if we don't already have one
 	std::string::size_type nLen = first.length();
+	if( !nLen )
+		return second;
 #if defined(_WIN32)
 	if( first.back() == '\\' || first.back() == '/' )
 	    nLen--;
@@ -257,6 +279,41 @@ std::string Path_Join(
 	return Path_Join( Path_Join( Path_Join( Path_Join( first, second, slash ), third, slash ), fourth, slash ), fifth, slash );
 }

+
+std::string Path_RemoveTrailingSlash( const std::string & sRawPath, char slash )
+{
+	if ( slash == 0 )
+		slash = Path_GetSlash();
+
+	std::string sPath = sRawPath;
+	std::string::size_type nCurrent = sRawPath.length();
+	if ( nCurrent == 0 )
+		return sPath;
+
+	int nLastFound = -1;
+	nCurrent--;
+	while( nCurrent != 0 )
+	{
+		if ( sRawPath[ nCurrent ] == slash )
+		{
+			nLastFound = (int)nCurrent;
+			nCurrent--;
+		}
+		else
+		{
+			break;
+		}
+	}
+		
+	if ( nLastFound >= 0 )
+	{
+		sPath.erase( nLastFound, std::string::npos );
+	}
+	
+	return sPath;
+}
+
+
 /** Removes redundant <dir>/.. elements in the path. Returns an empty path if the 
 * specified path has a broken number of directories for its number of ..s */
 std::string Path_Compact( const std::string & sRawPath, char slash )
@@ -336,17 +393,15 @@ std::string Path_Compact( const std::string & sRawPath, char slash )
 	return sPath;
 }

-#define MAX_UNICODE_PATH			32768
-#define MAX_UNICODE_PATH_IN_UTF8	( MAX_UNICODE_PATH * 4 )

 /** Returns the path to the current DLL or exe */
-std::string GetThisModulePath()
+std::string Path_GetThisModulePath()
 {
 	// gets the path of vrclient.dll itself
 #ifdef WIN32
 	HMODULE hmodule = NULL;

-	::GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, reinterpret_cast<LPCTSTR>(GetThisModulePath), &hmodule);
+	::GetModuleHandleEx( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, reinterpret_cast<LPCTSTR>(Path_GetThisModulePath), &hmodule );

 	wchar_t *pwchPath = new wchar_t[MAX_UNICODE_PATH];
 	char *pchPath = new char[ MAX_UNICODE_PATH_IN_UTF8 ];
@@ -361,7 +416,7 @@ std::string GetThisModulePath()
 #elif defined( OSX ) || defined( LINUX )
 	// get the addr of a function in vrclient.so and then ask the dlopen system about it
 	Dl_info info;
-	dladdr( (void *)GetThisModulePath, &info );
+	dladdr( (void *)Path_GetThisModulePath, &info );
 	return info.dli_fname;
 #endif

@@ -379,19 +434,44 @@ bool Path_IsDirectory( const std::string & sPath )
 		sFixedPath.erase( sFixedPath.end() - 1, sFixedPath.end() );

 	// see if the specified path actually exists.
+
+#if defined(POSIX)
 	struct	stat	buf;
-	if ( stat ( sFixedPath.c_str(), &buf ) == -1)
+	if ( stat( sFixedPath.c_str(), &buf ) == -1 )
 	{
 		return false;
 	}

-#if defined(LINUX)
+#if defined( LINUX ) || defined( OSX )
 	return S_ISDIR( buf.st_mode );
 #else
-	return ( buf.st_mode & _S_IFDIR ) != 0;
+	return (buf.st_mode & _S_IFDIR) != 0;
+#endif
+
+#else
+	struct	_stat	buf;
+	std::wstring wsFixedPath = UTF8to16( sFixedPath.c_str() );
+	if ( _wstat( wsFixedPath.c_str(), &buf ) == -1 )
+	{
+		return false;
+	}
+
+	return (buf.st_mode & _S_IFDIR) != 0;
 #endif
 }

+/** returns true if the specified path represents an app bundle */
+bool Path_IsAppBundle( const std::string & sPath )
+{
+#if defined(OSX)
+	NSBundle *bundle = [ NSBundle bundleWithPath: [ NSString stringWithUTF8String:sPath.c_str() ] ];
+	bool bisAppBundle = ( nullptr != bundle );
+	[ bundle release ];
+	return bisAppBundle;
+#else
+	return false;
+#endif
+}

 //-----------------------------------------------------------------------------
 // Purpose: returns true if the the path exists
@@ -402,11 +482,20 @@ bool Path_Exists( const std::string & sPath )
 	if( sFixedPath.empty() )
 		return false;

+#if defined( WIN32 )
+	struct	_stat	buf;
+	std::wstring wsFixedPath = UTF8to16( sFixedPath.c_str() );
+	if ( _wstat( wsFixedPath.c_str(), &buf ) == -1 )
+	{
+		return false;
+	}
+#else
 	struct stat buf;
 	if ( stat ( sFixedPath.c_str(), &buf ) == -1)
 	{
 		return false;
 	}
+#endif

 	return true;
 }
@@ -475,11 +564,9 @@ unsigned char * Path_ReadBinaryFile( const std::string &strFilename, int *pSize
 #if defined( POSIX )
 	f = fopen( strFilename.c_str(), "rb" );
 #else
-	errno_t err = fopen_s(&f, strFilename.c_str(), "rb");
-	if ( err != 0 )
-	{
-		f = NULL;
-	}
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	// the open operation needs to be sharable, therefore use of _wfsopen instead of _wfopen_s
+	f = _wfsopen( wstrFilename.c_str(), L"rb", _SH_DENYNO );
 #endif
 	
 	unsigned char* buf = NULL;
@@ -508,6 +595,68 @@ unsigned char * Path_ReadBinaryFile( const std::string &strFilename, int *pSize
 	return buf;
 }

+uint32_t  Path_ReadBinaryFile( const std::string &strFilename, unsigned char *pBuffer, uint32_t unSize )
+{
+	FILE *f;
+#if defined( POSIX )
+	f = fopen( strFilename.c_str(), "rb" );
+#else
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	errno_t err = _wfopen_s( &f, wstrFilename.c_str(), L"rb" );
+	if ( err != 0 )
+	{
+		f = NULL;
+	}
+#endif
+
+	uint32_t unSizeToReturn = 0;
+
+	if ( f != NULL )
+	{
+		fseek( f, 0, SEEK_END );
+		uint32_t size = (uint32_t)ftell( f );
+		fseek( f, 0, SEEK_SET );
+
+		if ( size > unSize || !pBuffer )
+		{
+			unSizeToReturn = (uint32_t)size;
+		}
+		else
+		{
+			if ( fread( pBuffer, size, 1, f ) == 1 )
+			{
+				unSizeToReturn = (uint32_t)size;
+			}
+		}
+
+		fclose( f );
+	}
+
+	return unSizeToReturn;
+}
+
+bool Path_WriteBinaryFile(const std::string &strFilename, unsigned char *pData, unsigned nSize)
+{
+	FILE *f;
+#if defined( POSIX )
+	f = fopen(strFilename.c_str(), "wb");
+#else
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	errno_t err = _wfopen_s( &f, wstrFilename.c_str(), L"wb" );
+	if (err != 0)
+	{
+		f = NULL;
+	}
+#endif
+
+	size_t written = 0;
+	if (f != NULL) {
+		written = fwrite(pData, sizeof(unsigned char), nSize, f);
+		fclose(f);
+	}
+
+	return written = nSize ? true : false;
+}

 std::string Path_ReadTextFile( const std::string &strFilename )
 {
@@ -520,7 +669,7 @@ std::string Path_ReadTextFile( const std::string &strFilename )
 		return "";

 	// convert CRLF -> LF
-	int outsize = 1;
+	size_t outsize = 1;
 	for (int i=1; i < size; i++)
 	{
 		if (buf[i] == '\n' && buf[i-1] == '\r') // CRLF
@@ -529,7 +678,7 @@ std::string Path_ReadTextFile( const std::string &strFilename )
 			buf[outsize++] = buf[i]; // just copy
 	}

-	std::string ret((char *)buf, (char *)(buf + outsize));
+	std::string ret((char *)buf, outsize);
 	delete[] buf;
 	return ret;
 }
@@ -541,7 +690,8 @@ bool Path_WriteStringToTextFile( const std::string &strFilename, const char *pch
 #if defined( POSIX )
 	f = fopen( strFilename.c_str(), "w" );
 #else
-	errno_t err = fopen_s(&f, strFilename.c_str(), "w");
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	errno_t err = _wfopen_s( &f, wstrFilename.c_str(), L"w" );
 	if ( err != 0 )
 	{
 		f = NULL;
@@ -557,4 +707,113 @@ bool Path_WriteStringToTextFile( const std::string &strFilename, const char *pch
 	}

 	return ok;
-}
+}
+
+bool Path_WriteStringToTextFileAtomic( const std::string &strFilename, const char *pchData )
+{
+	std::string strTmpFilename = strFilename + ".tmp";
+
+	if ( !Path_WriteStringToTextFile( strTmpFilename, pchData ) )
+		return false;
+
+	// Platform specific atomic file replacement
+#if defined( _WIN32 )
+	std::wstring wsFilename = UTF8to16( strFilename.c_str() );
+	std::wstring wsTmpFilename = UTF8to16( strTmpFilename.c_str() );
+	if ( !::ReplaceFileW( wsFilename.c_str(), wsTmpFilename.c_str(), nullptr, 0, 0, 0 ) )
+	{
+		// if we couldn't ReplaceFile, try a non-atomic write as a fallback
+		if ( !Path_WriteStringToTextFile( strFilename, pchData ) )
+			return false;
+	}
+#elif defined( POSIX )
+	if ( rename( strTmpFilename.c_str(), strFilename.c_str() ) == -1 )
+		return false;
+#else
+#error Do not know how to write atomic file
+#endif
+
+	return true;
+}
+
+
+#if defined(WIN32)
+#define FILE_URL_PREFIX "file:///"
+#else
+#define FILE_URL_PREFIX "file://"
+#endif
+
+// ----------------------------------------------------------------------------------------------------------------------------
+// Purpose: Turns a path to a file on disk into a URL (or just returns the value if it's already a URL)
+// ----------------------------------------------------------------------------------------------------------------------------
+std::string Path_FilePathToUrl( const std::string & sRelativePath, const std::string & sBasePath )
+{
+	if ( !strnicmp( sRelativePath.c_str(), "http://", 7 )
+		|| !strnicmp( sRelativePath.c_str(), "https://", 8 )
+		|| !strnicmp( sRelativePath.c_str(), "file://", 7 ) )
+	{
+		return sRelativePath;
+	}
+	else
+	{
+		std::string sAbsolute = Path_MakeAbsolute( sRelativePath, sBasePath );
+		if ( sAbsolute.empty() )
+			return sAbsolute;
+		return std::string( FILE_URL_PREFIX ) + sAbsolute;
+	}
+}
+
+// -----------------------------------------------------------------------------------------------------
+// Purpose: Strips off file:// off a URL and returns the path. For other kinds of URLs an empty string is returned
+// -----------------------------------------------------------------------------------------------------
+std::string Path_UrlToFilePath( const std::string & sFileUrl )
+{
+	if ( !strnicmp( sFileUrl.c_str(), FILE_URL_PREFIX, strlen( FILE_URL_PREFIX ) ) )
+	{
+		return sFileUrl.c_str() + strlen( FILE_URL_PREFIX );
+	}
+	else
+	{
+		return "";
+	}
+}
+
+
+// -----------------------------------------------------------------------------------------------------
+// Purpose: Returns the root of the directory the system wants us to store user documents in
+// -----------------------------------------------------------------------------------------------------
+std::string GetUserDocumentsPath()
+{
+#if defined( WIN32 )
+	WCHAR rwchPath[MAX_PATH];
+
+	if ( !SUCCEEDED( SHGetFolderPathW( NULL, CSIDL_MYDOCUMENTS | CSIDL_FLAG_CREATE, NULL, 0, rwchPath ) ) )
+	{
+		return "";
+	}
+
+	// Convert the path to UTF-8 and store in the output
+	std::string sUserPath = UTF16to8( rwchPath );
+
+	return sUserPath;
+#elif defined( OSX )
+	@autoreleasepool {
+		NSArray *paths = NSSearchPathForDirectoriesInDomains( NSDocumentDirectory, NSUserDomainMask, YES );
+		if ( [paths count] == 0 )
+		{
+			return "";
+		}
+		
+		return [[paths objectAtIndex:0] UTF8String];
+	}
+#elif defined( LINUX )
+	// @todo: not solved/changed as part of OSX - still not real - just removed old class based steam cut and paste
+	const char *pchHome = getenv( "HOME" );
+	if ( pchHome == NULL )
+	{
+		return "";
+	}
+	return pchHome;
+#endif
+}
+