开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
dxutil.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：44k
源码类别：

游戏

开发平台：

Visual C++

dxutil.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: DXUtil.cpp
  3. //
  4. // Desc: Shortcut macros and functions for using DX objects
  5. //
  6. // Copyright (c) Microsoft Corporation. All rights reserved
  7. //-----------------------------------------------------------------------------
  8. #include "dxstdafx.h"
  10. #ifdef UNICODE
  11.     typedef HINSTANCE (WINAPI* LPShellExecute)(HWND hwnd, LPCWSTR lpOperation, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd);
  12. #else
  13.     typedef HINSTANCE (WINAPI* LPShellExecute)(HWND hwnd, LPCSTR lpOperation, LPCSTR lpFile, LPCSTR lpParameters, LPCSTR lpDirectory, INT nShowCmd);
  14. #endif
  17. #ifndef UNDER_CE
  18. //-----------------------------------------------------------------------------
  19. // Name: DXUtil_GetDXSDKMediaPathCch()
  20. // Desc: Returns the DirectX SDK media path
  21. //       cchDest is the size in TCHARs of strDest.  Be careful not to 
  22. //       pass in sizeof(strDest) on UNICODE builds.
  23. //-----------------------------------------------------------------------------
  24. HRESULT DXUtil_GetDXSDKMediaPathCch( TCHAR* strDest, int cchDest )
  25. {
  26.     if( strDest == NULL || cchDest < 1 )
  27.         return E_INVALIDARG;
  29.     lstrcpy( strDest, TEXT("") );
  31.     // Open the appropriate registry key
  32.     HKEY  hKey;
  33.     LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
  34.                                 _T("Software\Microsoft\DirectX SDK"),
  35.                                 0, KEY_READ, &hKey );
  36.     if( ERROR_SUCCESS != lResult )
  37.         return E_FAIL;
  39.     DWORD dwType;
  40.     DWORD dwSize = cchDest * sizeof(TCHAR);
  41.     lResult = RegQueryValueEx( hKey, _T("DX9J3SDK Samples Path"), NULL,
  42.                               &dwType, (BYTE*)strDest, &dwSize );
  43.     strDest[cchDest-1] = 0; // RegQueryValueEx doesn't NULL term if buffer too small
  44.     RegCloseKey( hKey );
  46.     if( ERROR_SUCCESS != lResult )
  47.         return E_FAIL;
  49.     const TCHAR* strMedia = _T("\Media\");
  50.     if( lstrlen(strDest) + lstrlen(strMedia) < cchDest )
  51.         _tcscat( strDest, strMedia );
  52.     else
  53.         return E_INVALIDARG;
  55.     return S_OK;
  56. }
  57. #endif // !UNDER_CE
  61. #ifndef UNDER_CE
  62. //-----------------------------------------------------------------------------
  63. // Name: DXUtil_FindMediaFileCch()
  64. // Desc: Trys to find the location of a SDK media file
  65. //       cchDest is the size in TCHARs of strDestPath.  Be careful not to 
  66. //       pass in sizeof(strDest) on UNICODE builds.
  67. //-----------------------------------------------------------------------------
  68. HRESULT DXUtil_FindMediaFileCch( TCHAR* strDestPath, int cchDest, LPCTSTR strFilename )
  69. {
  70.     HRESULT hr;
  71.     TCHAR* strLeafNameTmp = NULL;
  72.     TCHAR strLeafName[MAX_PATH];
  73.     TCHAR strExePath[MAX_PATH];
  74.     TCHAR strExeName[MAX_PATH];
  75.     TCHAR strMediaDir[MAX_PATH];
  76.     TCHAR strSearchPath[MAX_PATH];
  77.     TCHAR* strLastSlash = NULL;
  78.     int cchPath;
  79.     BOOL bFound = FALSE;
  81.     if( NULL==strFilename || NULL==strDestPath || cchDest < 10 )
  82.         return E_INVALIDARG;
  84.     lstrcpy( strDestPath, TEXT("") );
  85.     lstrcpy( strLeafName, TEXT("") );
  87.     // Append current working directory to strFilename and extract the leaf filename 
  88.     cchPath = GetFullPathName(strFilename, MAX_PATH, strSearchPath, &strLeafNameTmp);
  89.     if ((cchPath == 0) || (MAX_PATH <= cchPath))
  90.         return E_FAIL;
  91.     if( strLeafNameTmp )
  92.         lstrcpyn( strLeafName, strLeafNameTmp, MAX_PATH );
  94.     // Search in . 
  95.     if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  96.         bFound = true;
  98.     if( !bFound )
  99.     {
  100.         // Search in .. 
  101.         _sntprintf( strSearchPath, MAX_PATH, TEXT("..\%s"), strLeafName );
  102.         strSearchPath[MAX_PATH-1] = 0;
  103.         if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  104.             bFound = true;
  105.     }
  107.     if( !bFound )
  108.     {
  109.         // Search in ....  
  110.         _sntprintf( strSearchPath, MAX_PATH, TEXT("..\..\%s"), strLeafName );
  111.         strSearchPath[MAX_PATH-1] = 0;
  112.         if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  113.             bFound = true;
  114.     }
  115.     
  116.     if( !bFound )
  117.     {
  118.         // Get the exe name, and exe path
  119.         GetModuleFileName( NULL, strExePath, MAX_PATH );
  120.         strExePath[MAX_PATH-1]=0;
  121.         strLastSlash = _tcsrchr( strExePath, TEXT('\') );
  122.         if( strLastSlash )
  123.         {
  124.             lstrcpyn( strExeName, &strLastSlash[1], MAX_PATH );
  126.             // Chop the exe name from the exe path
  127.             *strLastSlash = 0;
  129.             // Chop the .exe from the exe name
  130.             strLastSlash = _tcsrchr( strExeName, TEXT('.') );
  131.             if( strLastSlash )
  132.                 *strLastSlash = 0;
  133.         }
  135.         // Search in the executable directory
  136.         _sntprintf( strSearchPath, MAX_PATH, _T("%s\%s"), strExePath, strLeafName );
  137.         strSearchPath[MAX_PATH-1] = 0;
  138.         if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  139.             bFound = TRUE;
  141.         if( !bFound )
  142.         {
  143.             // Search in "%EXE_DIR%.."
  144.             _sntprintf( strSearchPath, MAX_PATH, _T("%s\..\%s"), strExePath, strLeafName );
  145.             strSearchPath[MAX_PATH-1] = 0;
  146.             if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  147.                 bFound = TRUE;
  148.         }
  150.         if( !bFound )
  151.         {
  152.             // Search in "%EXE_DIR%...."
  153.             _sntprintf( strSearchPath, MAX_PATH, _T("%s\..\..\%s"), strExePath, strLeafName );
  154.             strSearchPath[MAX_PATH-1] = 0;
  155.             if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  156.                 bFound = TRUE;
  157.         }
  159.         if( !bFound )
  160.         {
  161.             // Search in "%EXE_DIR%..%EXE_NAME%".  This matches the DirectX SDK layout
  162.             _sntprintf( strSearchPath, MAX_PATH, TEXT("%s\..\%s\%s"), strExePath, strExeName, strLeafName );
  163.             strSearchPath[MAX_PATH-1] = 0;
  164.             if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  165.                 bFound = TRUE;
  166.         }
  167.     }
  168.     
  169.     if( !bFound )
  170.     {
  171.         // Get the media dir 
  172.         if( FAILED( hr = DXUtil_GetDXSDKMediaPathCch( strMediaDir, MAX_PATH ) ) )
  173.             return hr;
  175.         // Search in SDK's media dir 
  176.         _sntprintf( strSearchPath, MAX_PATH, TEXT("%s%s"), strMediaDir, strLeafName );
  177.         strSearchPath[MAX_PATH-1] = 0;
  178.         if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
  179.             bFound = TRUE;
  180.     }
  182.     if( bFound )
  183.     {
  184.         // Found the file, so copy the search path to the output buffer
  185.         // and return success
  186.         lstrcpyn( strDestPath, strSearchPath, cchDest );
  187.         return S_OK;
  188.     }
  189.     else
  190.     {
  191.         // On failure, return the file as the path but return an error code
  192.         lstrcpyn( strDestPath, strFilename, cchDest );
  193.         return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND );
  194.     }
  195. }
  196. #endif // !UNDER_CE
  201. //-----------------------------------------------------------------------------
  202. // Name: DXUtil_ReadStringRegKeyCch()
  203. // Desc: Helper function to read a registry key string
  204. //       cchDest is the size in TCHARs of strDest.  Be careful not to 
  205. //       pass in sizeof(strDest) on UNICODE builds.
  206. //-----------------------------------------------------------------------------
  207. HRESULT DXUtil_ReadStringRegKeyCch( HKEY hKey, LPCTSTR strRegName, TCHAR* strDest, 
  208.                                     DWORD cchDest, LPCTSTR strDefault )
  209. {
  210.     DWORD dwType;
  211.     DWORD cbDest = cchDest * sizeof(TCHAR);
  213.     if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType, 
  214.                                           (BYTE*)strDest, &cbDest ) )
  215.     {
  216.         _tcsncpy( strDest, strDefault, cchDest );
  217.         strDest[cchDest-1] = 0;
  218.         return S_FALSE;
  219.     }
  220.     else
  221.     {     
  222.         if( dwType != REG_SZ )
  223.         {
  224.             _tcsncpy( strDest, strDefault, cchDest );
  225.             strDest[cchDest-1] = 0;
  226.             return S_FALSE;
  227.         }   
  228.     }
  230.     return S_OK;
  231. }
  236. //-----------------------------------------------------------------------------
  237. // Name: DXUtil_WriteStringRegKey()
  238. // Desc: Helper function to write a registry key string
  239. //-----------------------------------------------------------------------------
  240. HRESULT DXUtil_WriteStringRegKey( HKEY hKey, LPCTSTR strRegName,
  241.                                   LPCTSTR strValue )
  242. {
  243.     if( NULL == strValue )
  244.         return E_INVALIDARG;
  245.         
  246.     DWORD cbValue = ((DWORD)_tcslen(strValue)+1) * sizeof(TCHAR);
  248.     if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_SZ, 
  249.                                         (BYTE*)strValue, cbValue ) )
  250.         return E_FAIL;
  252.     return S_OK;
  253. }
  258. //-----------------------------------------------------------------------------
  259. // Name: DXUtil_ReadFloatRegKey()
  260. // Desc: Helper function to read a registry key string
  261. //-----------------------------------------------------------------------------
  262. HRESULT DXUtil_ReadFloatRegKey( HKEY hKey, LPCTSTR strRegName, FLOAT* pfDest, FLOAT fDefault )
  263. {
  264.     if( NULL == pfDest )
  265.         return E_INVALIDARG;
  267.     TCHAR sz[256];
  268.     float fResult;
  270.     TCHAR strDefault[256];
  271.     _sntprintf( strDefault, 256, TEXT("%f"), fDefault );
  272.     strDefault[255] = 0;
  273.    
  274.     if( SUCCEEDED( DXUtil_ReadStringRegKeyCch( hKey, strRegName, sz, 256, strDefault ) ) )
  275.     {
  276.         int nResult = _stscanf( sz, TEXT("%f"), &fResult );
  277.         if( nResult == 1 )
  278.         {
  279.             *pfDest = fResult;
  280.             return S_OK;           
  281.         }
  282.     }
  284.     *pfDest = fDefault;
  285.     return S_FALSE;
  286. }
  291. //-----------------------------------------------------------------------------
  292. // Name: DXUtil_WriteFloatRegKey()
  293. // Desc: Helper function to write a registry key string
  294. //-----------------------------------------------------------------------------
  295. HRESULT DXUtil_WriteFloatRegKey( HKEY hKey, LPCTSTR strRegName, FLOAT fValue )
  296. {
  297.     TCHAR strValue[256];
  298.     _sntprintf( strValue, 256, TEXT("%f"), fValue );
  299.     strValue[255] = 0;
  301.     return DXUtil_WriteStringRegKey( hKey, strRegName, strValue );
  302. }
  307. //-----------------------------------------------------------------------------
  308. // Name: DXUtil_ReadIntRegKey()
  309. // Desc: Helper function to read a registry key int
  310. //-----------------------------------------------------------------------------
  311. HRESULT DXUtil_ReadIntRegKey( HKEY hKey, LPCTSTR strRegName, DWORD* pdwDest, 
  312.                               DWORD dwDefault )
  313. {
  314.     DWORD dwType;
  315.     DWORD dwLength = sizeof(DWORD);
  317.     if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType, 
  318.                                           (BYTE*)pdwDest, &dwLength ) )
  319.     {
  320.         *pdwDest = dwDefault;
  321.         return S_FALSE;
  322.     }
  323.     else
  324.     {
  325.         if( dwType != REG_DWORD )
  326.         {
  327.             *pdwDest = dwDefault;
  328.             return S_FALSE;
  329.         }
  330.     }
  332.     return S_OK;
  333. }
  338. //-----------------------------------------------------------------------------
  339. // Name: DXUtil_WriteIntRegKey()
  340. // Desc: Helper function to write a registry key int
  341. //-----------------------------------------------------------------------------
  342. HRESULT DXUtil_WriteIntRegKey( HKEY hKey, LPCTSTR strRegName, DWORD dwValue )
  343. {
  344.     if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD, 
  345.                                         (BYTE*)&dwValue, sizeof(DWORD) ) )
  346.         return E_FAIL;
  348.     return S_OK;
  349. }
  354. //-----------------------------------------------------------------------------
  355. // Name: DXUtil_ReadBoolRegKey()
  356. // Desc: Helper function to read a registry key BOOL
  357. //-----------------------------------------------------------------------------
  358. HRESULT DXUtil_ReadBoolRegKey( HKEY hKey, LPCTSTR strRegName, BOOL* pbDest, 
  359.                               BOOL bDefault )
  360. {
  361.     DWORD dwType;
  362.     DWORD dwLength = sizeof(BOOL);
  364.     if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType, 
  365.                                           (BYTE*)pbDest, &dwLength ) )
  366.     {
  367.         *pbDest = bDefault;
  368.         return S_FALSE;
  369.     }
  370.     else
  371.     {
  372.         if( dwType != REG_DWORD )
  373.         {
  374.             *pbDest = bDefault;
  375.             return S_FALSE;
  376.         }
  377.     }
  379.     return S_OK;
  380. }
  385. //-----------------------------------------------------------------------------
  386. // Name: DXUtil_WriteBoolRegKey()
  387. // Desc: Helper function to write a registry key BOOL
  388. //-----------------------------------------------------------------------------
  389. HRESULT DXUtil_WriteBoolRegKey( HKEY hKey, LPCTSTR strRegName, BOOL bValue )
  390. {
  391.     if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD, 
  392.                                         (BYTE*)&bValue, sizeof(BOOL) ) )
  393.         return E_FAIL;
  395.     return S_OK;
  396. }
  401. //-----------------------------------------------------------------------------
  402. // Name: DXUtil_ReadGuidRegKey()
  403. // Desc: Helper function to read a registry key guid
  404. //-----------------------------------------------------------------------------
  405. HRESULT DXUtil_ReadGuidRegKey( HKEY hKey, LPCTSTR strRegName, GUID* pGuidDest, 
  406.                                GUID& guidDefault )
  407. {
  408.     DWORD dwType;
  409.     DWORD dwLength = sizeof(GUID);
  411.     if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType, 
  412.                                           (LPBYTE) pGuidDest, &dwLength ) )
  413.     {
  414.         *pGuidDest = guidDefault;
  415.         return S_FALSE;
  416.     }
  417.     else
  418.     {
  419.         if( dwType != REG_BINARY )
  420.         {
  421.             *pGuidDest = guidDefault;
  422.             return S_FALSE;
  423.         }
  424.     }
  426.     return S_OK;
  427. }
  432. //-----------------------------------------------------------------------------
  433. // Name: DXUtil_WriteGuidRegKey()
  434. // Desc: Helper function to write a registry key guid
  435. //-----------------------------------------------------------------------------
  436. HRESULT DXUtil_WriteGuidRegKey( HKEY hKey, LPCTSTR strRegName, GUID guidValue )
  437. {
  438.     if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_BINARY, 
  439.                                         (BYTE*)&guidValue, sizeof(GUID) ) )
  440.         return E_FAIL;
  442.     return S_OK;
  443. }
  448. //-----------------------------------------------------------------------------
  449. // Name: DXUtil_Timer()
  450. // Desc: Performs timer opertations. Use the following commands:
  451. //          TIMER_RESET           - to reset the timer
  452. //          TIMER_START           - to start the timer
  453. //          TIMER_STOP            - to stop (or pause) the timer
  454. //          TIMER_ADVANCE         - to advance the timer by 0.1 seconds
  455. //          TIMER_GETABSOLUTETIME - to get the absolute system time
  456. //          TIMER_GETAPPTIME      - to get the current time
  457. //          TIMER_GETELAPSEDTIME  - to get the time that elapsed between 
  458. //                                  TIMER_GETELAPSEDTIME calls
  459. //-----------------------------------------------------------------------------
  460. FLOAT __stdcall DXUtil_Timer( TIMER_COMMAND command )
  461. {
  462.     static BOOL     m_bTimerInitialized = FALSE;
  463.     static BOOL     m_bUsingQPF         = FALSE;
  464.     static BOOL     m_bTimerStopped     = TRUE;
  465.     static LONGLONG m_llQPFTicksPerSec  = 0;
  467.     // Initialize the timer
  468.     if( FALSE == m_bTimerInitialized )
  469.     {
  470.         m_bTimerInitialized = TRUE;
  472.         // Use QueryPerformanceFrequency() to get frequency of timer.  If QPF is
  473.         // not supported, we will timeGetTime() which returns milliseconds.
  474.         LARGE_INTEGER qwTicksPerSec;
  475.         m_bUsingQPF = QueryPerformanceFrequency( &qwTicksPerSec );
  476.         if( m_bUsingQPF )
  477.             m_llQPFTicksPerSec = qwTicksPerSec.QuadPart;
  478.     }
  480.     if( m_bUsingQPF )
  481.     {
  482.         static LONGLONG m_llStopTime        = 0;
  483.         static LONGLONG m_llLastElapsedTime = 0;
  484.         static LONGLONG m_llBaseTime        = 0;
  485.         double fTime;
  486.         double fElapsedTime;
  487.         LARGE_INTEGER qwTime;
  488.         
  489.         // Get either the current time or the stop time, depending
  490.         // on whether we're stopped and what command was sent
  491.         if( m_llStopTime != 0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
  492.             qwTime.QuadPart = m_llStopTime;
  493.         else
  494.             QueryPerformanceCounter( &qwTime );
  496.         // Return the elapsed time
  497.         if( command == TIMER_GETELAPSEDTIME )
  498.         {
  499.             fElapsedTime = (double) ( qwTime.QuadPart - m_llLastElapsedTime ) / (double) m_llQPFTicksPerSec;
  500.             m_llLastElapsedTime = qwTime.QuadPart;
  501.             return (FLOAT) fElapsedTime;
  502.         }
  503.     
  504.         // Return the current time
  505.         if( command == TIMER_GETAPPTIME )
  506.         {
  507.             double fAppTime = (double) ( qwTime.QuadPart - m_llBaseTime ) / (double) m_llQPFTicksPerSec;
  508.             return (FLOAT) fAppTime;
  509.         }
  510.     
  511.         // Reset the timer
  512.         if( command == TIMER_RESET )
  513.         {
  514.             m_llBaseTime        = qwTime.QuadPart;
  515.             m_llLastElapsedTime = qwTime.QuadPart;
  516.             m_llStopTime        = 0;
  517.             m_bTimerStopped     = FALSE;
  518.             return 0.0f;
  519.         }
  520.     
  521.         // Start the timer
  522.         if( command == TIMER_START )
  523.         {
  524.             if( m_bTimerStopped )
  525.                 m_llBaseTime += qwTime.QuadPart - m_llStopTime;
  526.             m_llStopTime = 0;
  527.             m_llLastElapsedTime = qwTime.QuadPart;
  528.             m_bTimerStopped = FALSE;
  529.             return 0.0f;
  530.         }
  531.     
  532.         // Stop the timer
  533.         if( command == TIMER_STOP )
  534.         {
  535.             if( !m_bTimerStopped )
  536.             {
  537.                 m_llStopTime = qwTime.QuadPart;
  538.                 m_llLastElapsedTime = qwTime.QuadPart;
  539.                 m_bTimerStopped = TRUE;
  540.             }
  541.             return 0.0f;
  542.         }
  543.     
  544.         // Advance the timer by 1/10th second
  545.         if( command == TIMER_ADVANCE )
  546.         {
  547.             m_llStopTime += m_llQPFTicksPerSec/10;
  548.             return 0.0f;
  549.         }
  551.         if( command == TIMER_GETABSOLUTETIME )
  552.         {
  553.             fTime = qwTime.QuadPart / (double) m_llQPFTicksPerSec;
  554.             return (FLOAT) fTime;
  555.         }
  557.         return -1.0f; // Invalid command specified
  558.     }
  559.     else
  560.     {
  561.         // Get the time using timeGetTime()
  562.         static double m_fLastElapsedTime  = 0.0;
  563.         static double m_fBaseTime         = 0.0;
  564.         static double m_fStopTime         = 0.0;
  565.         double fTime;
  566.         double fElapsedTime;
  567.         
  568.         // Get either the current time or the stop time, depending
  569.         // on whether we're stopped and what command was sent
  570.         if( m_fStopTime != 0.0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
  571.             fTime = m_fStopTime;
  572.         else
  573.             fTime = GETTIMESTAMP() * 0.001;
  574.     
  575.         // Return the elapsed time
  576.         if( command == TIMER_GETELAPSEDTIME )
  577.         {   
  578.             fElapsedTime = (double) (fTime - m_fLastElapsedTime);
  579.             m_fLastElapsedTime = fTime;
  580.             return (FLOAT) fElapsedTime;
  581.         }
  582.     
  583.         // Return the current time
  584.         if( command == TIMER_GETAPPTIME )
  585.         {
  586.             return (FLOAT) (fTime - m_fBaseTime);
  587.         }
  588.     
  589.         // Reset the timer
  590.         if( command == TIMER_RESET )
  591.         {
  592.             m_fBaseTime         = fTime;
  593.             m_fLastElapsedTime  = fTime;
  594.             m_fStopTime         = 0;
  595.             m_bTimerStopped     = FALSE;
  596.             return 0.0f;
  597.         }
  598.     
  599.         // Start the timer
  600.         if( command == TIMER_START )
  601.         {
  602.             if( m_bTimerStopped )
  603.                 m_fBaseTime += fTime - m_fStopTime;
  604.             m_fStopTime = 0.0f;
  605.             m_fLastElapsedTime  = fTime;
  606.             m_bTimerStopped = FALSE;
  607.             return 0.0f;
  608.         }
  609.     
  610.         // Stop the timer
  611.         if( command == TIMER_STOP )
  612.         {
  613.             if( !m_bTimerStopped )
  614.             {
  615.                 m_fStopTime = fTime;
  616.                 m_fLastElapsedTime  = fTime;
  617.                 m_bTimerStopped = TRUE;
  618.             }
  619.             return 0.0f;
  620.         }
  621.     
  622.         // Advance the timer by 1/10th second
  623.         if( command == TIMER_ADVANCE )
  624.         {
  625.             m_fStopTime += 0.1f;
  626.             return 0.0f;
  627.         }
  629.         if( command == TIMER_GETABSOLUTETIME )
  630.         {
  631.             return (FLOAT) fTime;
  632.         }
  634.         return -1.0f; // Invalid command specified
  635.     }
  636. }
  641. //-----------------------------------------------------------------------------
  642. // Name: DXUtil_ConvertAnsiStringToWideCch()
  643. // Desc: This is a UNICODE conversion utility to convert a CHAR string into a
  644. //       WCHAR string. 
  645. //       cchDestChar is the size in TCHARs of wstrDestination.  Be careful not to 
  646. //       pass in sizeof(strDest) 
  647. //-----------------------------------------------------------------------------
  648. HRESULT DXUtil_ConvertAnsiStringToWideCch( WCHAR* wstrDestination, const CHAR* strSource, 
  649.                                      int cchDestChar )
  650. {
  651.     if( wstrDestination==NULL || strSource==NULL || cchDestChar < 1 )
  652.         return E_INVALIDARG;
  654.     int nResult = MultiByteToWideChar( CP_ACP, 0, strSource, -1, 
  655.                                        wstrDestination, cchDestChar );
  656.     wstrDestination[cchDestChar-1] = 0;
  657.     
  658.     if( nResult == 0 )
  659.         return E_FAIL;
  660.     return S_OK;
  661. }
  666. //-----------------------------------------------------------------------------
  667. // Name: DXUtil_ConvertWideStringToAnsi()
  668. // Desc: This is a UNICODE conversion utility to convert a WCHAR string into a
  669. //       CHAR string. 
  670. //       cchDestChar is the size in TCHARs of strDestination
  671. //-----------------------------------------------------------------------------
  672. HRESULT DXUtil_ConvertWideStringToAnsiCch( CHAR* strDestination, const WCHAR* wstrSource, 
  673.                                      int cchDestChar )
  674. {
  675.     if( strDestination==NULL || wstrSource==NULL || cchDestChar < 1 )
  676.         return E_INVALIDARG;
  678.     int nResult = WideCharToMultiByte( CP_ACP, 0, wstrSource, -1, strDestination, 
  679.                                        cchDestChar*sizeof(CHAR), NULL, NULL );
  680.     strDestination[cchDestChar-1] = 0;
  681.     
  682.     if( nResult == 0 )
  683.         return E_FAIL;
  684.     return S_OK;
  685. }
  690. //-----------------------------------------------------------------------------
  691. // Name: DXUtil_ConvertGenericStringToAnsi()
  692. // Desc: This is a UNICODE conversion utility to convert a TCHAR string into a
  693. //       CHAR string. 
  694. //       cchDestChar is the size in TCHARs of strDestination
  695. //-----------------------------------------------------------------------------
  696. HRESULT DXUtil_ConvertGenericStringToAnsiCch( CHAR* strDestination, const TCHAR* tstrSource, 
  697.                                            int cchDestChar )
  698. {
  699.     if( strDestination==NULL || tstrSource==NULL || cchDestChar < 1 )
  700.         return E_INVALIDARG;
  702. #ifdef _UNICODE
  703.     return DXUtil_ConvertWideStringToAnsiCch( strDestination, tstrSource, cchDestChar );
  704. #else
  705.     strncpy( strDestination, tstrSource, cchDestChar );
  706.     strDestination[cchDestChar-1] = '';
  707.     return S_OK;
  708. #endif   
  709. }
  714. //-----------------------------------------------------------------------------
  715. // Name: DXUtil_ConvertGenericStringToWide()
  716. // Desc: This is a UNICODE conversion utility to convert a TCHAR string into a
  717. //       WCHAR string. 
  718. //       cchDestChar is the size in TCHARs of wstrDestination.  Be careful not to 
  719. //       pass in sizeof(strDest) 
  720. //-----------------------------------------------------------------------------
  721. HRESULT DXUtil_ConvertGenericStringToWideCch( WCHAR* wstrDestination, const TCHAR* tstrSource, 
  722.                                            int cchDestChar )
  723. {
  724.     if( wstrDestination==NULL || tstrSource==NULL || cchDestChar < 1 )
  725.         return E_INVALIDARG;
  727. #ifdef _UNICODE
  728.     wcsncpy( wstrDestination, tstrSource, cchDestChar );
  729.     wstrDestination[cchDestChar-1] = L'';
  730.     return S_OK;
  731. #else
  732.     return DXUtil_ConvertAnsiStringToWideCch( wstrDestination, tstrSource, cchDestChar );
  733. #endif    
  734. }
  739. //-----------------------------------------------------------------------------
  740. // Name: DXUtil_ConvertAnsiStringToGeneric()
  741. // Desc: This is a UNICODE conversion utility to convert a CHAR string into a
  742. //       TCHAR string. 
  743. //       cchDestChar is the size in TCHARs of tstrDestination.  Be careful not to 
  744. //       pass in sizeof(strDest) on UNICODE builds
  745. //-----------------------------------------------------------------------------
  746. HRESULT DXUtil_ConvertAnsiStringToGenericCch( TCHAR* tstrDestination, const CHAR* strSource, 
  747.                                            int cchDestChar )
  748. {
  749.     if( tstrDestination==NULL || strSource==NULL || cchDestChar < 1 )
  750.         return E_INVALIDARG;
  751.         
  752. #ifdef _UNICODE
  753.     return DXUtil_ConvertAnsiStringToWideCch( tstrDestination, strSource, cchDestChar );
  754. #else
  755.     strncpy( tstrDestination, strSource, cchDestChar );
  756.     tstrDestination[cchDestChar-1] = '';
  757.     return S_OK;
  758. #endif    
  759. }
  764. //-----------------------------------------------------------------------------
  765. // Name: DXUtil_ConvertAnsiStringToGeneric()
  766. // Desc: This is a UNICODE conversion utility to convert a WCHAR string into a
  767. //       TCHAR string. 
  768. //       cchDestChar is the size in TCHARs of tstrDestination.  Be careful not to 
  769. //       pass in sizeof(strDest) on UNICODE builds
  770. //-----------------------------------------------------------------------------
  771. HRESULT DXUtil_ConvertWideStringToGenericCch( TCHAR* tstrDestination, const WCHAR* wstrSource, 
  772.                                            int cchDestChar )
  773. {
  774.     if( tstrDestination==NULL || wstrSource==NULL || cchDestChar < 1 )
  775.         return E_INVALIDARG;
  777. #ifdef _UNICODE
  778.     wcsncpy( tstrDestination, wstrSource, cchDestChar );
  779.     tstrDestination[cchDestChar-1] = L'';    
  780.     return S_OK;
  781. #else
  782.     return DXUtil_ConvertWideStringToAnsiCch( tstrDestination, wstrSource, cchDestChar );
  783. #endif
  784. }
  789. //-----------------------------------------------------------------------------
  790. // Name: DXUtil_LaunchReadme()
  791. // Desc: Finds and opens the readme for this sample
  792. //-----------------------------------------------------------------------------
  793. VOID DXUtil_LaunchReadme( HWND hWnd, LPCTSTR strLoc )
  794. {
  795. #ifdef UNDER_CE
  796.     // This is not available on PocketPC
  797.     MessageBox( hWnd, TEXT("For operating instructions, please open the ")
  798.                       TEXT("readme.txt file included with the project."),
  799.                 TEXT("DirectX SDK Sample"), MB_ICONWARNING | MB_OK );
  801.     return;
  802. #endif
  804.     const int NUM_FILENAMES = 2;
  805.     LPCTSTR strFilenames[] = 
  806.     {
  807.         TEXT("readme.htm"),
  808.         TEXT("readme.txt")
  809.     };
  811.     TCHAR strReadmePath[1024];
  812.     TCHAR strExeName[MAX_PATH];
  813.     TCHAR strExePath[MAX_PATH];
  814.     TCHAR strSamplePath[MAX_PATH];
  815.     TCHAR* strLastSlash = NULL;
  817.     for( int i=0; i < NUM_FILENAMES; i++ )
  818.     {
  819.         LPCTSTR strFilename = strFilenames[i];
  820.         bool bSuccess = false;
  821.         bool bFound = false;
  822.         
  823.         lstrcpy( strReadmePath, TEXT("") );
  824.         lstrcpy( strExePath, TEXT("") );
  825.         lstrcpy( strExeName, TEXT("") );
  826.         lstrcpy( strSamplePath, TEXT("") );
  828.         // If the user provided a location for the readme, check there first.
  829.         if( strLoc )
  830.         {
  831.             HKEY  hKey;
  832.             LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
  833.                                         _T("Software\Microsoft\DirectX SDK"),
  834.                                         0, KEY_READ, &hKey );
  835.             if( ERROR_SUCCESS == lResult )
  836.             {
  837.                 DWORD dwType;
  838.                 DWORD dwSize = MAX_PATH * sizeof(TCHAR);
  839.                 lResult = RegQueryValueEx( hKey, _T("DX9J3SDK Samples Path"), NULL,
  840.                                         &dwType, (BYTE*)strSamplePath, &dwSize );
  841.                 strSamplePath[MAX_PATH-1] = 0; // RegQueryValueEx doesn't NULL term if buffer too small
  842.                 
  843.                 if( ERROR_SUCCESS == lResult )
  844.                 {
  845.                     _sntprintf( strReadmePath, 1023, TEXT("%s\C++\%s\%s"), 
  846.                                 strSamplePath, strLoc, strFilename );
  847.                     strReadmePath[1023] = 0;
  849.                     if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  850.                         bFound = TRUE;
  851.                 }
  852.             }
  854.             RegCloseKey( hKey );
  855.         }
  857.         // Get the exe name, and exe path
  858.         GetModuleFileName( NULL, strExePath, MAX_PATH );
  859.         strExePath[MAX_PATH-1]=0;
  861.         strLastSlash = _tcsrchr( strExePath, TEXT('\') );
  862.         if( strLastSlash )
  863.         {
  864.             _tcsncpy( strExeName, &strLastSlash[1], MAX_PATH );
  865.             strExeName[MAX_PATH-1]=0;
  867.             // Chop the exe name from the exe path
  868.             *strLastSlash = 0;
  870.             // Chop the .exe from the exe name
  871.             strLastSlash = _tcsrchr( strExeName, TEXT('.') );
  872.             if( strLastSlash )
  873.                 *strLastSlash = 0;
  874.         }
  876.         if( !bFound )
  877.         {
  878.             // Search in "%EXE_DIR%..%EXE_NAME%".  This matches the DirectX SDK layout
  879.             _tcscpy( strReadmePath, strExePath );
  881.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  882.             if( strLastSlash )
  883.                 *strLastSlash = 0;
  884.             lstrcat( strReadmePath, TEXT("\") );
  885.             lstrcat( strReadmePath, strExeName );
  886.             lstrcat( strReadmePath, TEXT("\") );
  887.             lstrcat( strReadmePath, strFilename );
  888.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  889.                 bFound = TRUE;
  890.         }
  892.         if( !bFound )
  893.         {
  894.             // Search in "%EXE_DIR%..BumpMapping%EXE_NAME%".
  895.             _tcscpy( strReadmePath, strExePath );
  897.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  898.             if( strLastSlash )
  899.                 *strLastSlash = 0;
  900.             lstrcat( strReadmePath, TEXT("\BumpMapping\") );
  901.             lstrcat( strReadmePath, strExeName );
  902.             lstrcat( strReadmePath, TEXT("\") );
  903.             lstrcat( strReadmePath, strFilename );
  904.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  905.                 bFound = TRUE;
  906.         }
  908.         if( !bFound )
  909.         {
  910.             // Search in "%EXE_DIR%..EnvMapping%EXE_NAME%".
  911.             _tcscpy( strReadmePath, strExePath );
  913.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  914.             if( strLastSlash )
  915.                 *strLastSlash = 0;
  916.             lstrcat( strReadmePath, TEXT("\EnvMapping\") );
  917.             lstrcat( strReadmePath, strExeName );
  918.             lstrcat( strReadmePath, TEXT("\") );
  919.             lstrcat( strReadmePath, strFilename );
  920.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  921.                 bFound = TRUE;
  922.         }
  924.         if( !bFound )
  925.         {
  926.             // Search in "%EXE_DIR%..Meshes%EXE_NAME%".
  927.             _tcscpy( strReadmePath, strExePath );
  929.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  930.             if( strLastSlash )
  931.                 *strLastSlash = 0;
  932.             lstrcat( strReadmePath, TEXT("\Meshes\") );
  933.             lstrcat( strReadmePath, strExeName );
  934.             lstrcat( strReadmePath, TEXT("\") );
  935.             lstrcat( strReadmePath, strFilename );
  936.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  937.                 bFound = TRUE;
  938.         }
  940.         if( !bFound )
  941.         {
  942.             // Search in "%EXE_DIR%..StencilBuffer%EXE_NAME%".
  943.             _tcscpy( strReadmePath, strExePath );
  945.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  946.             if( strLastSlash )
  947.                 *strLastSlash = 0;
  948.             lstrcat( strReadmePath, TEXT("\StencilBuffer\") );
  949.             lstrcat( strReadmePath, strExeName );
  950.             lstrcat( strReadmePath, TEXT("\") );
  951.             lstrcat( strReadmePath, strFilename );
  952.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  953.                 bFound = TRUE;
  954.         }
  956.         if( !bFound )
  957.         {
  958.             // Search in "%EXE_DIR%"
  959.             _tcscpy( strReadmePath, strExePath );
  960.             lstrcat( strReadmePath, TEXT("\") );
  961.             lstrcat( strReadmePath, strFilename );
  962.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  963.                 bFound = TRUE;
  964.         }
  966.         if( !bFound )
  967.         {
  968.             // Search in "%EXE_DIR%.."
  969.             _tcscpy( strReadmePath, strExePath );
  970.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  971.             if( strLastSlash )
  972.                 *strLastSlash = 0;
  973.             lstrcat( strReadmePath, TEXT("\") );
  974.             lstrcat( strReadmePath, strFilename );
  975.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  976.                 bFound = TRUE;
  977.         }
  979.         if( !bFound )
  980.         {
  981.             // Search in "%EXE_DIR%...."
  982.             _tcscpy( strReadmePath, strExePath );
  983.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  984.             if( strLastSlash )
  985.                 *strLastSlash = 0;
  986.             strLastSlash = _tcsrchr( strReadmePath, TEXT('\') );
  987.             if( strLastSlash )
  988.                 *strLastSlash = 0;
  989.             lstrcat( strReadmePath, TEXT("\") );
  990.             lstrcat( strReadmePath, strFilename );
  991.             if( GetFileAttributes( strReadmePath ) != 0xFFFFFFFF )
  992.                 bFound = TRUE;
  993.         }
  995.         if( bFound )
  996.         {
  997.             // GetProcAddress for ShellExecute, so we don't have to include shell32.lib 
  998.             // in every project that uses dxutil.cpp
  999.             LPShellExecute pShellExecute = NULL;
  1000.             HINSTANCE hInstShell32 = LoadLibrary(TEXT("shell32.dll"));
  1001.             if (hInstShell32 != NULL)
  1002.             {
  1003.     #ifdef UNICODE
  1004.                 pShellExecute = (LPShellExecute)GetProcAddress(hInstShell32, _TWINCE("ShellExecuteW"));
  1005.     #else
  1006.                 pShellExecute = (LPShellExecute)GetProcAddress(hInstShell32, _TWINCE("ShellExecuteA"));
  1007.     #endif
  1008.                 if( pShellExecute != NULL )
  1009.                 {
  1010.                     if( pShellExecute( hWnd, TEXT("open"), strReadmePath, NULL, NULL, SW_SHOW ) > (HINSTANCE) 32 )
  1011.                         bSuccess = true;
  1012.                 }
  1014.                 FreeLibrary(hInstShell32);
  1015.             }
  1016.         }
  1018.         if( bSuccess )
  1019.             return;
  1020.     }
  1022.     // Tell the user that the readme couldn't be opened
  1023.     MessageBox( hWnd, TEXT("Could not find readme"), 
  1024.                 TEXT("DirectX SDK Sample"), MB_ICONWARNING | MB_OK );
  1025. }
  1031. //-----------------------------------------------------------------------------
  1032. // Name: DXUtil_Trace()
  1033. // Desc: Outputs to the debug stream a formatted string with a variable-
  1034. //       argument list.
  1035. //-----------------------------------------------------------------------------
  1036. VOID DXUtil_Trace( LPCTSTR strMsg, ... )
  1037. {
  1038. #if defined(DEBUG) | defined(_DEBUG)
  1039.     TCHAR strBuffer[512];
  1040.     
  1041.     va_list args;
  1042.     va_start(args, strMsg);
  1043.     _vsntprintf( strBuffer, 512, strMsg, args );
  1044.     va_end(args);
  1046.     OutputDebugString( strBuffer );
  1047. #else
  1048.     UNREFERENCED_PARAMETER(strMsg);
  1049. #endif
  1050. }
  1055. //-----------------------------------------------------------------------------
  1056. // Name: DXUtil_ConvertStringToGUID()
  1057. // Desc: Converts a string to a GUID
  1058. //-----------------------------------------------------------------------------
  1059. HRESULT DXUtil_ConvertStringToGUID( const TCHAR* strSrc, GUID* pGuidDest )
  1060. {
  1061.     UINT aiTmp[10];
  1063.     if( _stscanf( strSrc, TEXT("{%8X-%4X-%4X-%2X%2X-%2X%2X%2X%2X%2X%2X}"),
  1064.                     &pGuidDest->Data1, 
  1065.                     &aiTmp[0], &aiTmp[1], 
  1066.                     &aiTmp[2], &aiTmp[3],
  1067.                     &aiTmp[4], &aiTmp[5],
  1068.                     &aiTmp[6], &aiTmp[7],
  1069.                     &aiTmp[8], &aiTmp[9] ) != 11 )
  1070.     {
  1071.         ZeroMemory( pGuidDest, sizeof(GUID) );
  1072.         return E_FAIL;
  1073.     }
  1074.     else
  1075.     {
  1076.         pGuidDest->Data2       = (USHORT) aiTmp[0];
  1077.         pGuidDest->Data3       = (USHORT) aiTmp[1];
  1078.         pGuidDest->Data4[0]    = (BYTE) aiTmp[2];
  1079.         pGuidDest->Data4[1]    = (BYTE) aiTmp[3];
  1080.         pGuidDest->Data4[2]    = (BYTE) aiTmp[4];
  1081.         pGuidDest->Data4[3]    = (BYTE) aiTmp[5];
  1082.         pGuidDest->Data4[4]    = (BYTE) aiTmp[6];
  1083.         pGuidDest->Data4[5]    = (BYTE) aiTmp[7];
  1084.         pGuidDest->Data4[6]    = (BYTE) aiTmp[8];
  1085.         pGuidDest->Data4[7]    = (BYTE) aiTmp[9];
  1086.         return S_OK;
  1087.     }
  1088. }
  1093. //-----------------------------------------------------------------------------
  1094. // Name: DXUtil_ConvertGUIDToStringCch()
  1095. // Desc: Converts a GUID to a string 
  1096. //       cchDestChar is the size in TCHARs of strDest.  Be careful not to 
  1097. //       pass in sizeof(strDest) on UNICODE builds
  1098. //-----------------------------------------------------------------------------
  1099. HRESULT DXUtil_ConvertGUIDToStringCch( const GUID* pGuidSrc, TCHAR* strDest, int cchDestChar )
  1100. {
  1101.     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}"),
  1102.                pGuidSrc->Data1, pGuidSrc->Data2, pGuidSrc->Data3,
  1103.                pGuidSrc->Data4[0], pGuidSrc->Data4[1],
  1104.                pGuidSrc->Data4[2], pGuidSrc->Data4[3],
  1105.                pGuidSrc->Data4[4], pGuidSrc->Data4[5],
  1106.                pGuidSrc->Data4[6], pGuidSrc->Data4[7] );
  1108.     if( nResult < 0 )
  1109.         return E_FAIL;
  1110.     return S_OK;
  1111. }
  1116. //-----------------------------------------------------------------------------
  1117. // Name: CArrayList constructor
  1118. // Desc: 
  1119. //-----------------------------------------------------------------------------
  1120. CArrayList::CArrayList( ArrayListType Type, UINT BytesPerEntry )
  1121. {
  1122.     if( Type == AL_REFERENCE )
  1123.         BytesPerEntry = sizeof(void*);
  1124.     m_ArrayListType = Type;
  1125.     m_pData = NULL;
  1126.     m_BytesPerEntry = BytesPerEntry;
  1127.     m_NumEntries = 0;
  1128.     m_NumEntriesAllocated = 0;
  1129. }
  1133. //-----------------------------------------------------------------------------
  1134. // Name: CArrayList destructor
  1135. // Desc: 
  1136. //-----------------------------------------------------------------------------
  1137. CArrayList::~CArrayList( void )
  1138. {
  1139.     if( m_pData != NULL )
  1140.         delete[] m_pData;
  1141. }
  1146. //-----------------------------------------------------------------------------
  1147. // Name: CArrayList::Add
  1148. // Desc: Adds pEntry to the list.
  1149. //-----------------------------------------------------------------------------
  1150. HRESULT CArrayList::Add( void* pEntry )
  1151. {
  1152.     if( m_BytesPerEntry == 0 )
  1153.         return E_FAIL;
  1154.     if( m_pData == NULL || m_NumEntries + 1 > m_NumEntriesAllocated )
  1155.     {
  1156.         void* pDataNew;
  1157.         UINT NumEntriesAllocatedNew;
  1158.         if( m_NumEntriesAllocated == 0 )
  1159.             NumEntriesAllocatedNew = 16;
  1160.         else
  1161.             NumEntriesAllocatedNew = m_NumEntriesAllocated * 2;
  1162.         pDataNew = new BYTE[NumEntriesAllocatedNew * m_BytesPerEntry];
  1163.         if( pDataNew == NULL )
  1164.             return E_OUTOFMEMORY;
  1165.         if( m_pData != NULL )
  1166.         {
  1167.             CopyMemory( pDataNew, m_pData, m_NumEntries * m_BytesPerEntry );
  1168.             delete[] m_pData;
  1169.         }
  1170.         m_pData = pDataNew;
  1171.         m_NumEntriesAllocated = NumEntriesAllocatedNew;
  1172.     }
  1174.     if( m_ArrayListType == AL_VALUE )
  1175.         CopyMemory( (BYTE*)m_pData + (m_NumEntries * m_BytesPerEntry), pEntry, m_BytesPerEntry );
  1176.     else
  1177.         *(((void**)m_pData) + m_NumEntries) = pEntry;
  1178.     m_NumEntries++;
  1180.     return S_OK;
  1181. }
  1186. //-----------------------------------------------------------------------------
  1187. // Name: CArrayList::Remove
  1188. // Desc: Remove the item at Entry in the list, and collapse the array. 
  1189. //-----------------------------------------------------------------------------
  1190. void CArrayList::Remove( UINT Entry )
  1191. {
  1192.     // Decrement count
  1193.     m_NumEntries--;
  1195.     // Find the entry address
  1196.     BYTE* pData = (BYTE*)m_pData + (Entry * m_BytesPerEntry);
  1198.     // Collapse the array
  1199.     MoveMemory( pData, pData + m_BytesPerEntry, ( m_NumEntries - Entry ) * m_BytesPerEntry );
  1200. }
  1205. //-----------------------------------------------------------------------------
  1206. // Name: CArrayList::GetPtr
  1207. // Desc: Returns a pointer to the Entry'th entry in the list.
  1208. //-----------------------------------------------------------------------------
  1209. void* CArrayList::GetPtr( UINT Entry )
  1210. {
  1211.     if( m_ArrayListType == AL_VALUE )
  1212.         return (BYTE*)m_pData + (Entry * m_BytesPerEntry);
  1213.     else
  1214.         return *(((void**)m_pData) + Entry);
  1215. }
  1220. //-----------------------------------------------------------------------------
  1221. // Name: CArrayList::Contains
  1222. // Desc: Returns whether the list contains an entry identical to the 
  1223. //       specified entry data.
  1224. //-----------------------------------------------------------------------------
  1225. bool CArrayList::Contains( void* pEntryData )
  1226. {
  1227.     for( UINT iEntry = 0; iEntry < m_NumEntries; iEntry++ )
  1228.     {
  1229.         if( m_ArrayListType == AL_VALUE )
  1230.         {
  1231.             if( memcmp( GetPtr(iEntry), pEntryData, m_BytesPerEntry ) == 0 )
  1232.                 return true;
  1233.         }
  1234.         else
  1235.         {
  1236.             if( GetPtr(iEntry) == pEntryData )
  1237.                 return true;
  1238.         }
  1239.     }
  1240.     return false;
  1241. }
  1246. //-----------------------------------------------------------------------------
  1247. // Name: BYTE helper functions
  1248. // Desc: cchDestChar is the size in BYTEs of strDest.  Be careful not to 
  1249. //       pass use sizeof() if the strDest is a string pointer.  
  1250. //       eg.
  1251. //       TCHAR* sz = new TCHAR[100]; // sizeof(sz)  == 4
  1252. //       TCHAR sz2[100];             // sizeof(sz2) == 200
  1253. //-----------------------------------------------------------------------------
  1254. HRESULT DXUtil_ConvertAnsiStringToWideCb( WCHAR* wstrDestination, const CHAR* strSource, int cbDestChar )
  1255. {
  1256.     return DXUtil_ConvertAnsiStringToWideCch( wstrDestination, strSource, cbDestChar / sizeof(WCHAR) );
  1257. }
  1259. HRESULT DXUtil_ConvertWideStringToAnsiCb( CHAR* strDestination, const WCHAR* wstrSource, int cbDestChar )
  1260. {
  1261.     return DXUtil_ConvertWideStringToAnsiCch( strDestination, wstrSource, cbDestChar / sizeof(CHAR) );
  1262. }
  1264. HRESULT DXUtil_ConvertGenericStringToAnsiCb( CHAR* strDestination, const TCHAR* tstrSource, int cbDestChar )
  1265. {
  1266.     return DXUtil_ConvertGenericStringToAnsiCch( strDestination, tstrSource, cbDestChar / sizeof(CHAR) );
  1267. }
  1269. HRESULT DXUtil_ConvertGenericStringToWideCb( WCHAR* wstrDestination, const TCHAR* tstrSource, int cbDestChar )
  1270. {
  1271.     return DXUtil_ConvertGenericStringToWideCch( wstrDestination, tstrSource, cbDestChar / sizeof(WCHAR) );
  1272. }
  1274. HRESULT DXUtil_ConvertAnsiStringToGenericCb( TCHAR* tstrDestination, const CHAR* strSource, int cbDestChar )
  1275. {
  1276.     return DXUtil_ConvertAnsiStringToGenericCch( tstrDestination, strSource, cbDestChar / sizeof(TCHAR) );
  1277. }
  1279. HRESULT DXUtil_ConvertWideStringToGenericCb( TCHAR* tstrDestination, const WCHAR* wstrSource, int cbDestChar )
  1280. {
  1281.     return DXUtil_ConvertWideStringToGenericCch( tstrDestination, wstrSource, cbDestChar / sizeof(TCHAR) );
  1282. }
  1284. HRESULT DXUtil_ReadStringRegKeyCb( HKEY hKey, LPCTSTR strRegName, TCHAR* strDest, DWORD cbDest, LPCTSTR strDefault )
  1285. {
  1286.     return DXUtil_ReadStringRegKeyCch( hKey, strRegName, strDest, cbDest / sizeof(TCHAR), strDefault );
  1287. }
  1289. HRESULT DXUtil_ConvertGUIDToStringCb( const GUID* pGuidSrc, TCHAR* strDest, int cbDestChar )
  1290. {
  1291.     return DXUtil_ConvertGUIDToStringCch( pGuidSrc, strDest, cbDestChar / sizeof(TCHAR) );
  1292. }
  1294. #ifndef UNDER_CE
  1295. HRESULT DXUtil_GetDXSDKMediaPathCb( TCHAR* szDest, int cbDest )
  1296. {
  1297.     return DXUtil_GetDXSDKMediaPathCch( szDest, cbDest / sizeof(TCHAR) );
  1298. }
  1300. HRESULT DXUtil_FindMediaFileCb( TCHAR* szDestPath, int cbDest, LPCTSTR strFilename )
  1301. {
  1302.     return DXUtil_FindMediaFileCch( szDestPath, cbDest / sizeof(TCHAR), strFilename );
  1303. }
  1304. #endif // !UNDER_CE