dxutil.cpp
资源名称:estereo2.zip [点击查看]
上传用户:fengshi120
上传日期:2014-07-17
资源大小:6155k
文件大小:37k
源码类别:
3D图形编程
开发平台:
C/C++
- //-----------------------------------------------------------------------------
- // File: DXUtil.cpp
- //
- // Desc: Shortcut macros and functions for using DX objects
- //-----------------------------------------------------------------------------
- #ifndef STRICT
- #define STRICT
- #endif // !STRICT
- #include "stdafx.h"
- #include <windows.h>
- #include <mmsystem.h>
- #include <tchar.h>
- #include <stdio.h>
- #include <stdarg.h>
- #include "DXUtil.h"
- #ifdef _DEBUG
- #define new DEBUG_NEW
- #undef THIS_FILE
- static char THIS_FILE[] = __FILE__;
- #endif
- #ifdef UNICODE
- typedef HINSTANCE (WINAPI* LPShellExecute)(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
- #else
- typedef HINSTANCE (WINAPI* LPShellExecute)(HWND hwnd, LPCSTR lpOperation, LPCSTR lpFile, LPCSTR lpParameters, LPCSTR lpDirectory, INT nShowCmd);
- #endif
- #ifndef UNDER_CE
- //-----------------------------------------------------------------------------
- // Name: DXUtil_GetDXSDKMediaPathCch()
- // Desc: Returns the DirectX SDK media path
- // cchDest is the size in TCHARs of strDest. Be careful not to
- // pass in sizeof(strDest) on UNICODE builds.
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_GetDXSDKMediaPathCch( TCHAR* strDest, int cchDest )
- {
- if( strDest == NULL || cchDest < 1 )
- return E_INVALIDARG;
- lstrcpy( strDest, TEXT("") );
- // Open the appropriate registry key
- HKEY hKey;
- LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
- _T("Software\Microsoft\DirectX SDK"),
- 0, KEY_READ, &hKey );
- if( ERROR_SUCCESS != lResult )
- return E_FAIL;
- DWORD dwType;
- DWORD dwSize = cchDest * sizeof(TCHAR);
- lResult = RegQueryValueEx( hKey, _T("DX9J3SDK Samples Path"), NULL,
- &dwType, (BYTE*)strDest, &dwSize );
- strDest[cchDest-1] = 0; // RegQueryValueEx doesn't NULL term if buffer too small
- RegCloseKey( hKey );
- if( ERROR_SUCCESS != lResult )
- return E_FAIL;
- const TCHAR* strMedia = _T("\Media\");
- if( lstrlen(strDest) + lstrlen(strMedia) < cchDest )
- _tcscat( strDest, strMedia );
- else
- return E_INVALIDARG;
- return S_OK;
- }
- #endif // !UNDER_CE
- #ifndef UNDER_CE
- //-----------------------------------------------------------------------------
- // Name: DXUtil_FindMediaFileCch()
- // Desc: Returns a valid path to a DXSDK media file
- // cchDest is the size in TCHARs of strDestPath. Be careful not to
- // pass in sizeof(strDest) on UNICODE builds.
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_FindMediaFileCch( TCHAR* strDestPath, int cchDest, TCHAR* strFilename )
- {
- HRESULT hr;
- HANDLE file;
- TCHAR* strShortNameTmp = NULL;
- TCHAR strShortName[MAX_PATH];
- int cchPath;
- if( NULL==strFilename || NULL==strDestPath || cchDest < 1 )
- return E_INVALIDARG;
- lstrcpy( strDestPath, TEXT("") );
- lstrcpy( strShortName, TEXT("") );
- // Build full path name from strFileName (strShortName will be just the leaf filename)
- cchPath = GetFullPathName(strFilename, cchDest, strDestPath, &strShortNameTmp);
- if ((cchPath == 0) || (cchDest <= cchPath))
- return E_FAIL;
- if( strShortNameTmp )
- lstrcpyn( strShortName, strShortNameTmp, MAX_PATH );
- // first try to find the filename given a full path
- file = CreateFile( strDestPath, GENERIC_READ, FILE_SHARE_READ, NULL,
- OPEN_EXISTING, 0, NULL );
- if( INVALID_HANDLE_VALUE != file )
- {
- CloseHandle( file );
- return S_OK;
- }
- // next try to find the filename in the current working directory (path stripped)
- file = CreateFile( strShortName, GENERIC_READ, FILE_SHARE_READ, NULL,
- OPEN_EXISTING, 0, NULL );
- if( INVALID_HANDLE_VALUE != file )
- {
- _tcsncpy( strDestPath, strShortName, cchDest );
- strDestPath[cchDest-1] = 0; // _tcsncpy doesn't NULL term if it runs out of space
- CloseHandle( file );
- return S_OK;
- }
- // last, check if the file exists in the media directory
- if( FAILED( hr = DXUtil_GetDXSDKMediaPathCch( strDestPath, cchDest ) ) )
- return hr;
- if( lstrlen(strDestPath) + lstrlen(strShortName) < cchDest )
- lstrcat( strDestPath, strShortName );
- else
- return E_INVALIDARG;
- file = CreateFile( strDestPath, GENERIC_READ, FILE_SHARE_READ, NULL,
- OPEN_EXISTING, 0, NULL );
- if( INVALID_HANDLE_VALUE != file )
- {
- CloseHandle( file );
- return S_OK;
- }
- // On failure, just return the file as the path
- _tcsncpy( strDestPath, strFilename, cchDest );
- strDestPath[cchDest-1] = 0; // _tcsncpy doesn't NULL term if it runs out of space
- return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND );
- }
- #endif // !UNDER_CE
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ReadStringRegKeyCch()
- // Desc: Helper function to read a registry key string
- // cchDest is the size in TCHARs of strDest. Be careful not to
- // pass in sizeof(strDest) on UNICODE builds.
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ReadStringRegKeyCch( HKEY hKey, TCHAR* strRegName, TCHAR* strDest,
- DWORD cchDest, TCHAR* strDefault )
- {
- DWORD dwType;
- DWORD cbDest = cchDest * sizeof(TCHAR);
- if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
- (BYTE*)strDest, &cbDest ) )
- {
- _tcsncpy( strDest, strDefault, cchDest );
- strDest[cchDest-1] = 0;
- if( dwType != REG_SZ )
- return E_FAIL;
- return S_OK;
- }
- return E_FAIL;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_WriteStringRegKey()
- // Desc: Helper function to write a registry key string
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_WriteStringRegKey( HKEY hKey, TCHAR* strRegName,
- TCHAR* strValue )
- {
- if( NULL == strValue )
- return E_INVALIDARG;
- DWORD cbValue = ((DWORD)_tcslen(strValue)+1) * sizeof(TCHAR);
- if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_SZ,
- (BYTE*)strValue, cbValue ) )
- return E_FAIL;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ReadIntRegKey()
- // Desc: Helper function to read a registry key int
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ReadIntRegKey( HKEY hKey, TCHAR* strRegName, DWORD* pdwDest,
- DWORD dwDefault )
- {
- DWORD dwType;
- DWORD dwLength = sizeof(DWORD);
- if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
- (BYTE*)pdwDest, &dwLength ) )
- {
- *pdwDest = dwDefault;
- if( dwType != REG_DWORD )
- return E_FAIL;
- return S_OK;
- }
- return E_FAIL;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_WriteIntRegKey()
- // Desc: Helper function to write a registry key int
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_WriteIntRegKey( HKEY hKey, TCHAR* strRegName, DWORD dwValue )
- {
- if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD,
- (BYTE*)&dwValue, sizeof(DWORD) ) )
- return E_FAIL;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ReadBoolRegKey()
- // Desc: Helper function to read a registry key BOOL
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ReadBoolRegKey( HKEY hKey, TCHAR* strRegName, BOOL* pbDest,
- BOOL bDefault )
- {
- DWORD dwType;
- DWORD dwLength = sizeof(BOOL);
- if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
- (BYTE*)pbDest, &dwLength ) )
- {
- *pbDest = bDefault;
- if( dwType != REG_DWORD )
- return E_FAIL;
- return S_OK;
- }
- return E_FAIL;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_WriteBoolRegKey()
- // Desc: Helper function to write a registry key BOOL
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_WriteBoolRegKey( HKEY hKey, TCHAR* strRegName, BOOL bValue )
- {
- if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD,
- (BYTE*)&bValue, sizeof(BOOL) ) )
- return E_FAIL;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ReadGuidRegKey()
- // Desc: Helper function to read a registry key guid
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ReadGuidRegKey( HKEY hKey, TCHAR* strRegName, GUID* pGuidDest,
- GUID& guidDefault )
- {
- DWORD dwType;
- DWORD dwLength = sizeof(GUID);
- if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
- (LPBYTE) pGuidDest, &dwLength ) )
- {
- *pGuidDest = guidDefault;
- if( dwType != REG_BINARY )
- return E_FAIL;
- return S_OK;
- }
- return E_FAIL;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_WriteGuidRegKey()
- // Desc: Helper function to write a registry key guid
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_WriteGuidRegKey( HKEY hKey, TCHAR* strRegName, GUID guidValue )
- {
- if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_BINARY,
- (BYTE*)&guidValue, sizeof(GUID) ) )
- return E_FAIL;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_Timer()
- // Desc: Performs timer opertations. Use the following commands:
- // TIMER_RESET - to reset the timer
- // TIMER_START - to start the timer
- // TIMER_STOP - to stop (or pause) the timer
- // TIMER_ADVANCE - to advance the timer by 0.1 seconds
- // TIMER_GETABSOLUTETIME - to get the absolute system time
- // TIMER_GETAPPTIME - to get the current time
- // TIMER_GETELAPSEDTIME - to get the time that elapsed between
- // TIMER_GETELAPSEDTIME calls
- //-----------------------------------------------------------------------------
- FLOAT __stdcall DXUtil_Timer( TIMER_COMMAND command )
- {
- static BOOL m_bTimerInitialized = FALSE;
- static BOOL m_bUsingQPF = FALSE;
- static BOOL m_bTimerStopped = TRUE;
- static LONGLONG m_llQPFTicksPerSec = 0;
- // Initialize the timer
- if( FALSE == m_bTimerInitialized )
- {
- m_bTimerInitialized = TRUE;
- // Use QueryPerformanceFrequency() to get frequency of timer. If QPF is
- // not supported, we will timeGetTime() which returns milliseconds.
- LARGE_INTEGER qwTicksPerSec;
- m_bUsingQPF = QueryPerformanceFrequency( &qwTicksPerSec );
- if( m_bUsingQPF )
- m_llQPFTicksPerSec = qwTicksPerSec.QuadPart;
- }
- if( m_bUsingQPF )
- {
- static LONGLONG m_llStopTime = 0;
- static LONGLONG m_llLastElapsedTime = 0;
- static LONGLONG m_llBaseTime = 0;
- double fTime;
- double fElapsedTime;
- LARGE_INTEGER qwTime;
- // Get either the current time or the stop time, depending
- // on whether we're stopped and what command was sent
- if( m_llStopTime != 0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
- qwTime.QuadPart = m_llStopTime;
- else
- QueryPerformanceCounter( &qwTime );
- // Return the elapsed time
- if( command == TIMER_GETELAPSEDTIME )
- {
- fElapsedTime = (double) ( qwTime.QuadPart - m_llLastElapsedTime ) / (double) m_llQPFTicksPerSec;
- m_llLastElapsedTime = qwTime.QuadPart;
- return (FLOAT) fElapsedTime;
- }
- // Return the current time
- if( command == TIMER_GETAPPTIME )
- {
- double fAppTime = (double) ( qwTime.QuadPart - m_llBaseTime ) / (double) m_llQPFTicksPerSec;
- return (FLOAT) fAppTime;
- }
- // Reset the timer
- if( command == TIMER_RESET )
- {
- m_llBaseTime = qwTime.QuadPart;
- m_llLastElapsedTime = qwTime.QuadPart;
- m_llStopTime = 0;
- m_bTimerStopped = FALSE;
- return 0.0f;
- }
- // Start the timer
- if( command == TIMER_START )
- {
- if( m_bTimerStopped )
- m_llBaseTime += qwTime.QuadPart - m_llStopTime;
- m_llStopTime = 0;
- m_llLastElapsedTime = qwTime.QuadPart;
- m_bTimerStopped = FALSE;
- return 0.0f;
- }
- // Stop the timer
- if( command == TIMER_STOP )
- {
- if( !m_bTimerStopped )
- {
- m_llStopTime = qwTime.QuadPart;
- m_llLastElapsedTime = qwTime.QuadPart;
- m_bTimerStopped = TRUE;
- }
- return 0.0f;
- }
- // Advance the timer by 1/10th second
- if( command == TIMER_ADVANCE )
- {
- m_llStopTime += m_llQPFTicksPerSec/10;
- return 0.0f;
- }
- if( command == TIMER_GETABSOLUTETIME )
- {
- fTime = qwTime.QuadPart / (double) m_llQPFTicksPerSec;
- return (FLOAT) fTime;
- }
- return -1.0f; // Invalid command specified
- }
- else
- {
- // Get the time using timeGetTime()
- static double m_fLastElapsedTime = 0.0;
- static double m_fBaseTime = 0.0;
- static double m_fStopTime = 0.0;
- double fTime;
- double fElapsedTime;
- // Get either the current time or the stop time, depending
- // on whether we're stopped and what command was sent
- if( m_fStopTime != 0.0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
- fTime = m_fStopTime;
- else
- fTime = GETTIMESTAMP() * 0.001;
- // Return the elapsed time
- if( command == TIMER_GETELAPSEDTIME )
- {
- fElapsedTime = (double) (fTime - m_fLastElapsedTime);
- m_fLastElapsedTime = fTime;
- return (FLOAT) fElapsedTime;
- }
- // Return the current time
- if( command == TIMER_GETAPPTIME )
- {
- return (FLOAT) (fTime - m_fBaseTime);
- }
- // Reset the timer
- if( command == TIMER_RESET )
- {
- m_fBaseTime = fTime;
- m_fLastElapsedTime = fTime;
- m_fStopTime = 0;
- m_bTimerStopped = FALSE;
- return 0.0f;
- }
- // Start the timer
- if( command == TIMER_START )
- {
- if( m_bTimerStopped )
- m_fBaseTime += fTime - m_fStopTime;
- m_fStopTime = 0.0f;
- m_fLastElapsedTime = fTime;
- m_bTimerStopped = FALSE;
- return 0.0f;
- }
- // Stop the timer
- if( command == TIMER_STOP )
- {
- if( !m_bTimerStopped )
- {
- m_fStopTime = fTime;
- m_fLastElapsedTime = fTime;
- m_bTimerStopped = TRUE;
- }
- return 0.0f;
- }
- // Advance the timer by 1/10th second
- if( command == TIMER_ADVANCE )
- {
- m_fStopTime += 0.1f;
- return 0.0f;
- }
- if( command == TIMER_GETABSOLUTETIME )
- {
- return (FLOAT) fTime;
- }
- return -1.0f; // Invalid command specified
- }
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertAnsiStringToWideCch()
- // Desc: This is a UNICODE conversion utility to convert a CHAR string into a
- // WCHAR string.
- // cchDestChar is the size in TCHARs of wstrDestination. Be careful not to
- // pass in sizeof(strDest)
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertAnsiStringToWideCch( WCHAR* wstrDestination, const CHAR* strSource,
- int cchDestChar )
- {
- if( wstrDestination==NULL || strSource==NULL || cchDestChar < 1 )
- return E_INVALIDARG;
- int nResult = MultiByteToWideChar( CP_ACP, 0, strSource, -1,
- wstrDestination, cchDestChar );
- wstrDestination[cchDestChar-1] = 0;
- if( nResult == 0 )
- return E_FAIL;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertWideStringToAnsi()
- // Desc: This is a UNICODE conversion utility to convert a WCHAR string into a
- // CHAR string.
- // cchDestChar is the size in TCHARs of strDestination
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertWideStringToAnsiCch( CHAR* strDestination, const WCHAR* wstrSource,
- int cchDestChar )
- {
- if( strDestination==NULL || wstrSource==NULL || cchDestChar < 1 )
- return E_INVALIDARG;
- int nResult = WideCharToMultiByte( CP_ACP, 0, wstrSource, -1, strDestination,
- cchDestChar*sizeof(CHAR), NULL, NULL );
- strDestination[cchDestChar-1] = 0;
- if( nResult == 0 )
- return E_FAIL;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertGenericStringToAnsi()
- // Desc: This is a UNICODE conversion utility to convert a TCHAR string into a
- // CHAR string.
- // cchDestChar is the size in TCHARs of strDestination
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertGenericStringToAnsiCch( CHAR* strDestination, const TCHAR* tstrSource,
- int cchDestChar )
- {
- if( strDestination==NULL || tstrSource==NULL || cchDestChar < 1 )
- return E_INVALIDARG;
- #ifdef _UNICODE
- return DXUtil_ConvertWideStringToAnsiCch( strDestination, tstrSource, cchDestChar );
- #else
- strncpy( strDestination, tstrSource, cchDestChar );
- strDestination[cchDestChar-1] = ' ';
- return S_OK;
- #endif
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertGenericStringToWide()
- // Desc: This is a UNICODE conversion utility to convert a TCHAR string into a
- // WCHAR string.
- // cchDestChar is the size in TCHARs of wstrDestination. Be careful not to
- // pass in sizeof(strDest)
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertGenericStringToWideCch( WCHAR* wstrDestination, const TCHAR* tstrSource,
- int cchDestChar )
- {
- if( wstrDestination==NULL || tstrSource==NULL || cchDestChar < 1 )
- return E_INVALIDARG;
- #ifdef _UNICODE
- wcsncpy( wstrDestination, tstrSource, cchDestChar );
- wstrDestination[cchDestChar-1] = L' ';
- return S_OK;
- #else
- return DXUtil_ConvertAnsiStringToWideCch( wstrDestination, tstrSource, cchDestChar );
- #endif
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertAnsiStringToGeneric()
- // Desc: This is a UNICODE conversion utility to convert a CHAR string into a
- // TCHAR string.
- // cchDestChar is the size in TCHARs of tstrDestination. Be careful not to
- // pass in sizeof(strDest) on UNICODE builds
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertAnsiStringToGenericCch( TCHAR* tstrDestination, const CHAR* strSource,
- int cchDestChar )
- {
- if( tstrDestination==NULL || strSource==NULL || cchDestChar < 1 )
- return E_INVALIDARG;
- #ifdef _UNICODE
- return DXUtil_ConvertAnsiStringToWideCch( tstrDestination, strSource, cchDestChar );
- #else
- strncpy( tstrDestination, strSource, cchDestChar );
- tstrDestination[cchDestChar-1] = ' ';
- return S_OK;
- #endif
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertAnsiStringToGeneric()
- // Desc: This is a UNICODE conversion utility to convert a WCHAR string into a
- // TCHAR string.
- // cchDestChar is the size in TCHARs of tstrDestination. Be careful not to
- // pass in sizeof(strDest) on UNICODE builds
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertWideStringToGenericCch( TCHAR* tstrDestination, const WCHAR* wstrSource,
- int cchDestChar )
- {
- if( tstrDestination==NULL || wstrSource==NULL || cchDestChar < 1 )
- return E_INVALIDARG;
- #ifdef _UNICODE
- wcsncpy( tstrDestination, wstrSource, cchDestChar );
- tstrDestination[cchDestChar-1] = L' ';
- return S_OK;
- #else
- return DXUtil_ConvertWideStringToAnsiCch( tstrDestination, wstrSource, cchDestChar );
- #endif
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_LaunchReadme()
- // Desc: Finds and opens the readme.txt for this sample
- //-----------------------------------------------------------------------------
- VOID DXUtil_LaunchReadme( HWND hWnd, TCHAR* strLoc )
- {
- #ifdef UNDER_CE
- // This is not available on PocketPC
- MessageBox( hWnd, TEXT("For operating instructions, please open the ")
- TEXT("readme.txt file included with the project."),
- TEXT("DirectX SDK Sample"), MB_ICONWARNING | MB_OK );
- return;
- #else
- bool bSuccess = false;
- bool bFound = false;
- TCHAR strReadmePath[1024];
- TCHAR strExeName[MAX_PATH];
- TCHAR strExePath[MAX_PATH];
- TCHAR strSamplePath[MAX_PATH];
- TCHAR* strLastSlash = NULL;
- lstrcpy( strReadmePath, TEXT("") );
- lstrcpy( strExePath, TEXT("") );
- lstrcpy( strExeName, TEXT("") );
- lstrcpy( strSamplePath, TEXT("") );
- // If the user provided a location for the readme, check there first.
- if( strLoc )
- {
- HKEY hKey;
- LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
- _T("Software\Microsoft\DirectX SDK"),
- 0, KEY_READ, &hKey );
- if( ERROR_SUCCESS == lResult )
- {
- DWORD dwType;
- DWORD dwSize = MAX_PATH * sizeof(TCHAR);
- lResult = RegQueryValueEx( hKey, _T("DX9J3SDK Samples Path"), NULL,
- &dwType, (BYTE*)strSamplePath, &dwSize );
- strSamplePath[MAX_PATH-1] = 0; // RegQueryValueEx doesn't NULL term if buffer too small
- if( ERROR_SUCCESS == lResult )
- {
- _sntprintf( strReadmePath, 1023, TEXT("%s\C++\%s\readme.txt"),
- strSamplePath, strLoc );
- strReadmePath[1023] = 0;
- if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
- bFound = TRUE;
- }
- }
- RegCloseKey( hKey );
- }
- // Get the exe name, and exe path
- GetModuleFileName( NULL, strExePath, MAX_PATH );
- strExePath[MAX_PATH-1]=0;
- strLastSlash = _tcsrchr( strExePath, TEXT('\') );
- if( strLastSlash )
- {
- _tcsncpy( strExeName, &strLastSlash[1], MAX_PATH );
- strExeName[MAX_PATH-1]=0;
- // Chop the exe name from the exe path
- *strLastSlash = 0;
- // Chop the .exe from the exe name
- strLastSlash = _tcsrchr( strExeName, TEXT('.') );
- if( strLastSlash )
- *strLastSlash = 0;
- }
- if( !bFound )
- {
- // Search in "%EXE_DIR%..%EXE_NAME%". This matchs the DirectX SDK layout
- _tcscpy( strReadmePath, strExePath );
- strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
- if( strLastSlash )
- *strLastSlash = 0;
- lstrcat( strReadmePath, TEXT("\") );
- lstrcat( strReadmePath, strExeName );
- lstrcat( strReadmePath, TEXT("\readme.txt") );
- if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
- bFound = TRUE;
- }
- if( !bFound )
- {
- // Search in "%EXE_DIR%"
- _tcscpy( strReadmePath, strExePath );
- lstrcat( strReadmePath, TEXT("\readme.txt") );
- if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
- bFound = TRUE;
- }
- if( !bFound )
- {
- // Search in "%EXE_DIR%.."
- _tcscpy( strReadmePath, strExePath );
- strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
- if( strLastSlash )
- *strLastSlash = 0;
- lstrcat( strReadmePath, TEXT("\readme.txt") );
- if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
- bFound = TRUE;
- }
- if( !bFound )
- {
- // Search in "%EXE_DIR%...."
- _tcscpy( strReadmePath, strExePath );
- strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
- if( strLastSlash )
- *strLastSlash = 0;
- strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
- if( strLastSlash )
- *strLastSlash = 0;
- lstrcat( strReadmePath, TEXT("\readme.txt") );
- if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
- bFound = TRUE;
- }
- if( bFound )
- {
- // GetProcAddress for ShellExecute, so we don't have to include shell32.lib
- // in every project that uses dxutil.cpp
- LPShellExecute pShellExecute = NULL;
- HINSTANCE hInstShell32 = LoadLibrary(TEXT("shell32.dll"));
- if (hInstShell32 != NULL)
- {
- #ifdef UNICODE
- pShellExecute = (LPShellExecute)GetProcAddress(hInstShell32, _TWINCE("ShellExecuteW"));
- #else
- pShellExecute = (LPShellExecute)GetProcAddress(hInstShell32, _TWINCE("ShellExecuteA"));
- #endif
- if( pShellExecute != NULL )
- {
- if( pShellExecute( hWnd, TEXT("open"), strReadmePath, NULL, NULL, SW_SHOW ) > (HINSTANCE) 32 )
- bSuccess = true;
- }
- FreeLibrary(hInstShell32);
- }
- }
- if( !bSuccess )
- {
- // Tell the user that the readme couldn't be opened
- MessageBox( hWnd, TEXT("Could not find readme.txt"),
- TEXT("DirectX SDK Sample"), MB_ICONWARNING | MB_OK );
- }
- #endif // UNDER_CE
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_Trace()
- // Desc: Outputs to the debug stream a formatted string with a variable-
- // argument list.
- //-----------------------------------------------------------------------------
- VOID DXUtil_Trace( TCHAR* strMsg, ... )
- {
- #if defined(DEBUG) | defined(_DEBUG)
- TCHAR strBuffer[512];
- va_list args;
- va_start(args, strMsg);
- _vsntprintf( strBuffer, 512, strMsg, args );
- va_end(args);
- OutputDebugString( strBuffer );
- #else
- UNREFERENCED_PARAMETER(strMsg);
- #endif
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertStringToGUID()
- // Desc: Converts a string to a GUID
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertStringToGUID( const TCHAR* strSrc, GUID* pGuidDest )
- {
- UINT aiTmp[10];
- if( _stscanf( strSrc, TEXT("{%8X-%4X-%4X-%2X%2X-%2X%2X%2X%2X%2X%2X}"),
- &pGuidDest->Data1,
- &aiTmp[0], &aiTmp[1],
- &aiTmp[2], &aiTmp[3],
- &aiTmp[4], &aiTmp[5],
- &aiTmp[6], &aiTmp[7],
- &aiTmp[8], &aiTmp[9] ) != 11 )
- {
- ZeroMemory( pGuidDest, sizeof(GUID) );
- return E_FAIL;
- }
- else
- {
- pGuidDest->Data2 = (USHORT) aiTmp[0];
- pGuidDest->Data3 = (USHORT) aiTmp[1];
- pGuidDest->Data4[0] = (BYTE) aiTmp[2];
- pGuidDest->Data4[1] = (BYTE) aiTmp[3];
- pGuidDest->Data4[2] = (BYTE) aiTmp[4];
- pGuidDest->Data4[3] = (BYTE) aiTmp[5];
- pGuidDest->Data4[4] = (BYTE) aiTmp[6];
- pGuidDest->Data4[5] = (BYTE) aiTmp[7];
- pGuidDest->Data4[6] = (BYTE) aiTmp[8];
- pGuidDest->Data4[7] = (BYTE) aiTmp[9];
- return S_OK;
- }
- }
- //-----------------------------------------------------------------------------
- // Name: DXUtil_ConvertGUIDToStringCch()
- // Desc: Converts a GUID to a string
- // cchDestChar is the size in TCHARs of strDest. Be careful not to
- // pass in sizeof(strDest) on UNICODE builds
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertGUIDToStringCch( const GUID* pGuidSrc, TCHAR* strDest, int cchDestChar )
- {
- int nResult = _sntprintf( strDest, cchDestChar, TEXT("{%0.8X-%0.4X-%0.4X-%0.2X%0.2X-%0.2X%0.2X%0.2X%0.2X%0.2X%0.2X}"),
- pGuidSrc->Data1, pGuidSrc->Data2, pGuidSrc->Data3,
- pGuidSrc->Data4[0], pGuidSrc->Data4[1],
- pGuidSrc->Data4[2], pGuidSrc->Data4[3],
- pGuidSrc->Data4[4], pGuidSrc->Data4[5],
- pGuidSrc->Data4[6], pGuidSrc->Data4[7] );
- if( nResult < 0 )
- return E_FAIL;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: CArrayList constructor
- // Desc:
- //-----------------------------------------------------------------------------
- CArrayList::CArrayList( ArrayListType Type, UINT BytesPerEntry )
- {
- if( Type == AL_REFERENCE )
- BytesPerEntry = sizeof(void*);
- m_ArrayListType = Type;
- m_pData = NULL;
- m_BytesPerEntry = BytesPerEntry;
- m_NumEntries = 0;
- m_NumEntriesAllocated = 0;
- }
- //-----------------------------------------------------------------------------
- // Name: CArrayList destructor
- // Desc:
- //-----------------------------------------------------------------------------
- CArrayList::~CArrayList( void )
- {
- if( m_pData != NULL )
- delete[] m_pData;
- }
- //-----------------------------------------------------------------------------
- // Name: CArrayList::Add
- // Desc: Adds pEntry to the list.
- //-----------------------------------------------------------------------------
- HRESULT CArrayList::Add( void* pEntry )
- {
- if( m_BytesPerEntry == 0 )
- return E_FAIL;
- if( m_pData == NULL || m_NumEntries + 1 > m_NumEntriesAllocated )
- {
- void* pDataNew;
- UINT NumEntriesAllocatedNew;
- if( m_NumEntriesAllocated == 0 )
- NumEntriesAllocatedNew = 16;
- else
- NumEntriesAllocatedNew = m_NumEntriesAllocated * 2;
- pDataNew = new BYTE[NumEntriesAllocatedNew * m_BytesPerEntry];
- if( pDataNew == NULL )
- return E_OUTOFMEMORY;
- if( m_pData != NULL )
- {
- CopyMemory( pDataNew, m_pData, m_NumEntries * m_BytesPerEntry );
- delete[] m_pData;
- }
- m_pData = pDataNew;
- m_NumEntriesAllocated = NumEntriesAllocatedNew;
- }
- if( m_ArrayListType == AL_VALUE )
- CopyMemory( (BYTE*)m_pData + (m_NumEntries * m_BytesPerEntry), pEntry, m_BytesPerEntry );
- else
- *(((void**)m_pData) + m_NumEntries) = pEntry;
- m_NumEntries++;
- return S_OK;
- }
- //-----------------------------------------------------------------------------
- // Name: CArrayList::Remove
- // Desc: Remove the item at Entry in the list, and collapse the array.
- //-----------------------------------------------------------------------------
- void CArrayList::Remove( UINT Entry )
- {
- // Decrement count
- m_NumEntries--;
- // Find the entry address
- BYTE* pData = (BYTE*)m_pData + (Entry * m_BytesPerEntry);
- // Collapse the array
- MoveMemory( pData, pData + m_BytesPerEntry, ( m_NumEntries - Entry ) * m_BytesPerEntry );
- }
- //-----------------------------------------------------------------------------
- // Name: CArrayList::GetPtr
- // Desc: Returns a pointer to the Entry'th entry in the list.
- //-----------------------------------------------------------------------------
- void* CArrayList::GetPtr( UINT Entry )
- {
- if( m_ArrayListType == AL_VALUE )
- return (BYTE*)m_pData + (Entry * m_BytesPerEntry);
- else
- return *(((void**)m_pData) + Entry);
- }
- //-----------------------------------------------------------------------------
- // Name: CArrayList::Contains
- // Desc: Returns whether the list contains an entry identical to the
- // specified entry data.
- //-----------------------------------------------------------------------------
- bool CArrayList::Contains( void* pEntryData )
- {
- for( UINT iEntry = 0; iEntry < m_NumEntries; iEntry++ )
- {
- if( m_ArrayListType == AL_VALUE )
- {
- if( memcmp( GetPtr(iEntry), pEntryData, m_BytesPerEntry ) == 0 )
- return true;
- }
- else
- {
- if( GetPtr(iEntry) == pEntryData )
- return true;
- }
- }
- return false;
- }
- //-----------------------------------------------------------------------------
- // Name: BYTE helper functions
- // Desc: cchDestChar is the size in BYTEs of strDest. Be careful not to
- // pass use sizeof() if the strDest is a string pointer.
- // eg.
- // TCHAR* sz = new TCHAR[100]; // sizeof(sz) == 4
- // TCHAR sz2[100]; // sizeof(sz2) == 200
- //-----------------------------------------------------------------------------
- HRESULT DXUtil_ConvertAnsiStringToWideCb( WCHAR* wstrDestination, const CHAR* strSource, int cbDestChar )
- {
- return DXUtil_ConvertAnsiStringToWideCch( wstrDestination, strSource, cbDestChar / sizeof(WCHAR) );
- }
- HRESULT DXUtil_ConvertWideStringToAnsiCb( CHAR* strDestination, const WCHAR* wstrSource, int cbDestChar )
- {
- return DXUtil_ConvertWideStringToAnsiCch( strDestination, wstrSource, cbDestChar / sizeof(CHAR) );
- }
- HRESULT DXUtil_ConvertGenericStringToAnsiCb( CHAR* strDestination, const TCHAR* tstrSource, int cbDestChar )
- {
- return DXUtil_ConvertGenericStringToAnsiCch( strDestination, tstrSource, cbDestChar / sizeof(CHAR) );
- }
- HRESULT DXUtil_ConvertGenericStringToWideCb( WCHAR* wstrDestination, const TCHAR* tstrSource, int cbDestChar )
- {
- return DXUtil_ConvertGenericStringToWideCch( wstrDestination, tstrSource, cbDestChar / sizeof(WCHAR) );
- }
- HRESULT DXUtil_ConvertAnsiStringToGenericCb( TCHAR* tstrDestination, const CHAR* strSource, int cbDestChar )
- {
- return DXUtil_ConvertAnsiStringToGenericCch( tstrDestination, strSource, cbDestChar / sizeof(TCHAR) );
- }
- HRESULT DXUtil_ConvertWideStringToGenericCb( TCHAR* tstrDestination, const WCHAR* wstrSource, int cbDestChar )
- {
- return DXUtil_ConvertWideStringToGenericCch( tstrDestination, wstrSource, cbDestChar / sizeof(TCHAR) );
- }
- HRESULT DXUtil_ReadStringRegKeyCb( HKEY hKey, TCHAR* strRegName, TCHAR* strDest, DWORD cbDest, TCHAR* strDefault )
- {
- return DXUtil_ReadStringRegKeyCch( hKey, strRegName, strDest, cbDest / sizeof(TCHAR), strDefault );
- }
- HRESULT DXUtil_ConvertGUIDToStringCb( const GUID* pGuidSrc, TCHAR* strDest, int cbDestChar )
- {
- return DXUtil_ConvertGUIDToStringCch( pGuidSrc, strDest, cbDestChar / sizeof(TCHAR) );
- }
- #ifndef UNDER_CE
- HRESULT DXUtil_GetDXSDKMediaPathCb( TCHAR* szDest, int cbDest )
- {
- return DXUtil_GetDXSDKMediaPathCch( szDest, cbDest / sizeof(TCHAR) );
- }
- HRESULT DXUtil_FindMediaFileCb( TCHAR* szDestPath, int cbDest, TCHAR* strFilename )
- {
- return DXUtil_FindMediaFileCch( szDestPath, cbDest / sizeof(TCHAR), strFilename );
- }
- #endif // !UNDER_CE