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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
DRVMGR.H
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：16k
源码类别：

Windows编程

开发平台：

Visual C++

DRVMGR.H：源码内容
  1. #ifndef DRVMGR_H
  2. #define DRVMGR_H
  3. /*
  4. **-----------------------------------------------------------------------------
  5. **  Name:       DrvMgr.h
  6. **  Purpose:    Creates and manages DD/D3D drivers static info
  7. **
  8. **  Copyright (c) 1995 - 1997 by Microsoft, all rights reserved
  9. **-----------------------------------------------------------------------------
  10. */
  12. /*
  13. **-----------------------------------------------------------------------------
  14. **  Includes
  15. **-----------------------------------------------------------------------------
  16. */
  18. #include "Common.h"
  22. /*
  23. **-----------------------------------------------------------------------------
  24. **  Defines
  25. **-----------------------------------------------------------------------------
  26. */
  28. // DD Driver Flags
  29. #define DDDRV_INIT 0x00000001L
  31. #define DDDRV_VALID 0x00000001L
  32. #define DDDRV_PRIMARY 0x00000002L
  33. #define DDDRV_D3D 0x00000004L
  35. #define DDDRV_MODES_LOADED 0x00000008L
  36. #define DDDRV_DEVICES_LOADED 0x00000010L
  39. // D3D Device Flags
  40. #define D3DDEV_VALID 0x00000001L
  41. #define D3DDEV_FORMATS_LOADED 0x00000002L
  45. /*
  46. **-----------------------------------------------------------------------------
  47. **  Typedefs
  48. **-----------------------------------------------------------------------------
  49. */
  51. // Forward declarations
  52. class DDModeInfo;
  53. typedef DDModeInfo * LPDDModeInfo;
  55. class D3DDevInfo;
  56. typedef D3DDevInfo * LPD3DDevInfo;
  58. class DDDrvInfo;
  59. typedef DDDrvInfo * LPDDDrvInfo;
  61. class DDDrvMgr;
  62. typedef DDDrvMgr * LPDDDrvMgr;
  65. // Enumeration Callback Info
  66. #define ENUM_STOP  0x80000000L
  68. typedef enum {
  69.     ENUM_ERROR    = 0,
  70.     ENUM_FAILURE  = 1,
  71.     ENUM_SUCCESS  = 2
  72. };
  75. // Callback function prototypes
  76. typedef DWORD (*ENUMDDDRVCALLBACK)(LPVOID lpDriver, LPVOID lpData, DWORD dwExtra);
  77. typedef DWORD (*ENUMD3DDEVCALLBACK)(LPVOID lpDevice, LPVOID lpData, DWORD dwExtra);
  79. // Enum Driver Callback Info
  80. typedef struct tagDDDRV_ENUMINFO
  81. {
  82.     void *              lpStart;        // Starting Node
  83.     ENUMDDDRVCALLBACK   fpcbEnum;       // Enumeration Callback function
  84.     DWORD               dwExtra;        // User defined extra data for callback
  85. } DDDRV_ENUMINFO;
  86. typedef DDDRV_ENUMINFO * LPDDDRV_ENUMINFO;
  88. // Enum D3D Device Callback Info
  89. typedef struct tagD3DDEV_ENUMINFO
  90. {
  91.     void *              lpStart;        // Starting Node
  92.     ENUMD3DDEVCALLBACK  fpcbEnum;       // Enumeration Callback function
  93.     DWORD               dwExtra;        // User defined extra data for callback
  94. } D3DDEV_ENUMINFO;
  95. typedef D3DDEV_ENUMINFO * LPD3DDEV_ENUMINFO;
  99. /*
  100. **-----------------------------------------------------------------------------
  101. **  Functions
  102. **-----------------------------------------------------------------------------
  103. */
  105. LPDDDrvInfo ValidateDriver (LPGUID lpDDGuid);
  106. LPDDModeInfo ValidateMode (LPDDDrvInfo lpDriver, DWORD w, DWORD h,
  107.    DWORD bpp, DWORD refresh, LPD3DDevInfo lpFilter);
  108. LPD3DDevInfo ValidateDevice (LPDDDrvInfo lpDriver, LPGUID lpD3DGuid,
  109.      LPDDModeInfo lpFilter);
  111. BOOL GetDesktopMode (LPDDDrvInfo lpDriver, LPGUID lpD3DGuid,
  112.  LPDDModeInfo * lpMode, LPD3DDevInfo * lpDev);
  114. BOOL GetFullscreenMode (LPDDDrvInfo lpDriver,  LPGUID lpD3DGuid,
  115. DWORD w, DWORD h, DWORD bpp, DWORD refresh,
  116.     LPDDModeInfo * lpMode, LPD3DDevInfo * lpDev);
  118. HRESULT ChooseDriverDefaults (LPGUID lpGuidDD, DWORD w, DWORD h,
  119.   DWORD bpp, DWORD refresh, LPGUID lpGuidD3D,
  120.   BOOL fFullScreen, LPDDDrvInfo * lpDriver,
  121.   LPDDModeInfo * lpMode, LPD3DDevInfo * lpDevice);
  123. DWORD FlagsToBitDepth (DWORD dwFlags);
  124. DWORD BitDepthToFlags (DWORD dwBPP);
  125. BOOL  isPalettized (LPDDPIXELFORMAT lpddpf);
  129. /*
  130. **-----------------------------------------------------------------------------
  131. **  Classes
  132. **-----------------------------------------------------------------------------
  133. */
  135. /*
  136. **-----------------------------------------------------------------------------
  137. **  Name:       DDModeInfo
  138. **  Purpose:    DirectDraw Mode info 
  139. **-----------------------------------------------------------------------------
  140. */
  142. class DDModeInfo
  143. {
  144. private:
  145. protected:
  146. public:
  147.     // Data
  148.     DDSURFACEDESC   ddSurfDesc;     // Complete Surface Description
  149. LPDDModeInfo lpPrev; // Prev Node in List
  150. LPDDModeInfo    lpNext; // Next Node In List
  152.     // Constructors
  153.     DDModeInfo (void)
  154.         { 
  155.             ZeroMemory (&ddSurfDesc, sizeof (ddSurfDesc)); 
  156.             ddSurfDesc.dwSize = sizeof (DDSURFACEDESC);
  158. lpPrev = NULL;
  159. lpNext = NULL;
  160.         }
  162.     DDModeInfo (const DDSURFACEDESC & ddDesc)
  163.         { 
  164.             CopyMemory (&ddSurfDesc, (const void *)&ddDesc, sizeof (ddSurfDesc)); 
  165.             ddSurfDesc.dwSize = sizeof (DDSURFACEDESC);
  167. lpPrev = NULL;
  168. lpNext = NULL;
  169.         }
  170.     ~DDModeInfo (void) 
  171. {
  172. lpPrev = NULL;
  173. lpNext = NULL;
  174. }
  176.     // Methods
  177. DWORD GetWidth (void);
  178. DWORD GetHeight (void);
  179. DWORD GetBPP (void);
  180. HRESULT GetMode (DWORD & dwWidth, DWORD & dwHeight, 
  181.  DWORD & dwBPP, DWORD & dwRefresh);
  183. BOOL ModeSupported (LPD3DDevInfo lpDevice);
  185.     BOOL Match (DWORD dwW, DWORD dwH, DWORD dwBPP);
  186.     BOOL Match (const DDSURFACEDESC & ddsd);
  188. BOOL Match (DWORD dwBPP);
  189. BOOL Match (const DDPIXELFORMAT & ddpf);
  190. }; // DDModeInfo
  194. /*
  195. **-----------------------------------------------------------------------------
  196. **  Name:       D3DDevInfo
  197. **  Purpose:    D3D Device/driver info for D3D Driver Manager
  198. ** Notes:
  199. **
  200. ** - The Texture Format is a Mode (both are DDSURFACEDESC wrappers)
  201. **
  202. **-----------------------------------------------------------------------------
  203. */
  205. class D3DDevInfo
  206. {
  207. private:
  208. protected:
  209. public:
  210.     // D3D Device Driver info
  211.     DWORD           fFlags;                 // Flags
  213.     // D3D Info
  214.     GUID            guid;                   // GUID
  215.     LPTSTR          szName; // Driver Name
  216.     LPTSTR          szDesc; // Driver Description
  217.     D3DDEVICEDESC   d3dHalDesc;             // HAL info
  218.     D3DDEVICEDESC   d3dHelDesc;             // HEL info
  220.     // Texture Formats
  221. DWORD cFormats; // Count of Texture Formats
  222.     LPDDModeInfo    lpFormatRoot; // List of Texture Formats (root)
  223. LPDDModeInfo lpFormatTail; // List of Texture Formats (tail)
  225. // Node Info
  226. LPD3DDevInfo lpPrev; // Prev Node
  227. LPD3DDevInfo lpNext; // Next Node
  229.     // Flags
  230.     BOOL isValid (void)     { return (fFlags & DDDRV_VALID); }
  231.     void validOn (void)     { fFlags |= DDDRV_VALID; }
  232.     void validOff (void)    { fFlags &= ~DDDRV_VALID; }
  234.     // Methods
  235.     HRESULT Create (LPGUID lpGuid, LPTSTR lpName, LPTSTR lpDesc,
  236.                     LPD3DDEVICEDESC lpHalDevice,
  237.                     LPD3DDEVICEDESC lpHelDevice);
  238.     void Destroy (void);
  240.     // Constructors 
  241.     D3DDevInfo (void) 
  242.         { 
  243. validOff ();
  244. turnFormatsLoadedOff ();
  246. szName = NULL;
  247. szDesc = NULL;
  249.         ZeroMemory (&d3dHalDesc, sizeof(D3DDEVICEDESC)); 
  250.         d3dHalDesc.dwSize = sizeof (D3DDEVICEDESC);
  252.         ZeroMemory (&d3dHelDesc, sizeof(D3DDEVICEDESC)); 
  253.         d3dHelDesc.dwSize = sizeof (D3DDEVICEDESC);
  255. cFormats = 0L;
  256. lpFormatRoot = NULL;
  257. lpFormatTail = NULL;
  259. lpPrev = NULL;
  260. lpNext = NULL;
  261.         }
  263.     ~D3DDevInfo (void) 
  264. { 
  265. Destroy (); 
  266. }
  269. // Texure Format Methods
  270. BOOL formatsLoaded (void) { return ((fFlags & D3DDEV_FORMATS_LOADED) ? TRUE : FALSE); }
  271. void turnFormatsLoadedOn (void) { fFlags |= D3DDEV_FORMATS_LOADED; }
  272. void turnFormatsLoadedOff (void) { fFlags &= ~D3DDEV_FORMATS_LOADED; }
  274. HRESULT LoadFormats (LPDIRECT3DDEVICE2 lpd3dDevice);
  275. HRESULT DestroyFormats (void);
  277. HRESULT AddFormat (LPDDModeInfo lpFormatNew);
  278. HRESULT DelFormat (LPDDModeInfo lpFormatDel);
  279. DWORD   countFormats (void) { return cFormats; }
  281.     LPDDModeInfo FindFormat (DWORD dwBPP, 
  282.      LPDDModeInfo * lpNextBest,
  283.      LPDDModeInfo lpStartFormat = NULL);
  284.     LPDDModeInfo FindFormat (LPDDPIXELFORMAT lpddsd, 
  285.      LPDDModeInfo * lpNextBest,
  286.      LPDDModeInfo lpStartFormat = NULL);
  288.     DWORD EnumFormats (const D3DDEV_ENUMINFO & eiInfo);
  291.     // Methods
  292.     BOOL isHardware (void);
  293.     BOOL Match (LPGUID lpGuid);
  294.     BOOL Match (LPD3DDEVICEDESC lpHalDesc, LPD3DDEVICEDESC lpHelDesc);
  296. }; // End D3DDevInfo
  301. /*
  302. **-----------------------------------------------------------------------------
  303. **  Name:       DDDrvInfo
  304. **  Purpose:    Encapsulates DD/D3D driver info
  305. **-----------------------------------------------------------------------------
  306. */
  308. class DDDrvInfo
  309. {
  310. private:
  311. protected:
  312. public:
  314.     // Structure info
  315.     DWORD           fFlags;                         // D3D Driver flags
  317.     // Driver Info
  318.     GUID            guid;                           // guid, if any
  319.     LPTSTR          szName; // name
  320.     LPTSTR          szDesc; // description
  322.     // Driver Caps
  323.     DDCAPS          ddHalCaps;                      // Hardware caps
  324.     DDCAPS          ddHelCaps;                      // Emulation caps
  326.     // Mode Info
  327. DWORD cModes; // Count of Modes
  328.     LPDDModeInfo    lpModeRoot; // List of Modes (root)
  329. LPDDModeInfo lpModeTail; // List of Modes (tail)
  331.     // D3D Info
  332. DWORD cDevices; // Count of D3D devices
  333.     LPD3DDevInfo    lpDeviceRoot; // List of D3D Devices (root)
  334. LPD3DDevInfo lpDeviceTail; // List of D3D Devices (tail)
  336. // Node Info
  337. LPDDDrvInfo lpPrev; // Previous node
  338. LPDDDrvInfo lpNext; // Next node
  341.     //
  342.     // Flag Methods
  343.     //
  344.     BOOL isValid (void)     { return (fFlags & DDDRV_VALID); }
  345.     void validOn (void)     { fFlags |= DDDRV_VALID; }
  346.     void validOff (void)    { fFlags &= ~DDDRV_VALID; }
  348.     BOOL isPrimary (void)   { return (fFlags & DDDRV_PRIMARY); }
  349.     void primaryOn (void)   { fFlags |= DDDRV_PRIMARY; }
  350.     void primaryOff (void)  { fFlags &= ~DDDRV_PRIMARY; }
  352.     BOOL isD3D (void)     { return (fFlags & DDDRV_D3D); }
  353.     void d3dOn (void)     { fFlags |= DDDRV_D3D; }
  354.     void d3dOff (void)    { fFlags &= ~DDDRV_D3D; }
  357.     // Methods
  358.     HRESULT Create (LPGUID lpGuid, LPTSTR lpszName, LPTSTR lpszDesc);
  359.     void    Destroy (void);
  361.     // Constructors
  362.     DDDrvInfo (void)
  363.         { 
  364. validOff ();
  365.         
  366. ZeroMemory (&ddHalCaps, sizeof (DDCAPS)); 
  367. ddHalCaps.dwSize = sizeof (DDCAPS);
  369. ZeroMemory (&ddHelCaps, sizeof (DDCAPS)); 
  370. ddHelCaps.dwSize = sizeof (DDCAPS);
  372. cModes  = 0L;
  373. lpModeRoot = NULL;
  374. lpModeTail = NULL;
  376. cDevices = 0L;
  377. lpDeviceRoot = NULL;
  378. lpDeviceTail = NULL;
  380. lpPrev = NULL;
  381. lpNext = NULL;
  382.         }
  384.     ~DDDrvInfo (void) 
  385. { 
  386. Destroy (); 
  387. }
  390. // Mode Methods
  391. BOOL modesLoaded (void) { return ((fFlags & DDDRV_MODES_LOADED) ? TRUE : FALSE); }
  392. void turnModesLoadedOn (void) { fFlags |= DDDRV_MODES_LOADED; }
  393. void turnModesLoadedOff (void) { fFlags &= ~DDDRV_MODES_LOADED; }
  395. HRESULT LoadModes (LPDIRECTDRAW2 lpDD2);
  396. HRESULT DestroyModes (void);
  398. HRESULT AddMode (LPDDModeInfo lpModeNew);
  399. HRESULT DelMode (LPDDModeInfo lpModeDel);
  400. DWORD countModes (void) { return cModes; }
  402.     LPDDModeInfo FindMode (DWORD dwW, DWORD dwH, 
  403.    DWORD dwBPP, DWORD dwRefresh,
  404.    LPDDModeInfo * lpNextBest,
  405.    LPDDModeInfo lpStartMode = NULL);
  406.     LPDDModeInfo FindMode (LPDDSURFACEDESC lpddsd, 
  407.    LPDDModeInfo * lpNextBest,
  408.    LPDDModeInfo lpStartMode = NULL);
  410.     DWORD EnumModes (const DDDRV_ENUMINFO & eiInfo);
  412. // D3D Device Methods
  413. BOOL devicesLoaded (void) { return ((fFlags & DDDRV_DEVICES_LOADED) ? TRUE : FALSE); }
  414. void turnDevicesLoadedOn (void) { fFlags |= DDDRV_DEVICES_LOADED; }
  415. void turnDevicesLoadedOff (void) { fFlags &= ~DDDRV_DEVICES_LOADED; }
  417. HRESULT LoadDevices (LPDIRECT3D2 lpD3D2);
  418. HRESULT DestroyDevices (void);
  420. HRESULT AddDevice (LPD3DDevInfo lpModeNew);
  421. HRESULT DelDevice (LPD3DDevInfo lpModeDel);
  422. DWORD countDevices (void) { return cDevices; }
  424.     LPD3DDevInfo FindDevice (LPGUID lpGuid, LPD3DDevInfo * lpNextBest,
  425.  LPD3DDevInfo lpStart = NULL);
  426.     LPD3DDevInfo FindDevice (LPD3DDEVICEDESC lpHal, LPD3DDEVICEDESC lpHel, 
  427.  LPD3DDevInfo * lpNextBest,
  428.  LPD3DDevInfo lpStart = NULL);
  430.     DWORD EnumDevices (const DDDRV_ENUMINFO & eiInfo);
  432. // Mode <=> Device compatible find functions 
  433.     LPD3DDevInfo FindDeviceSupportsMode (LPGUID lpGuid, 
  434.  LPDDModeInfo lpMode,
  435.      LPD3DDevInfo * lpNextBest,
  436.      LPD3DDevInfo lpStart = NULL);
  437. LPDDModeInfo FindModeSupportsDevice (DWORD dwW, DWORD dwH, 
  438.  DWORD dwBPP, DWORD dwRefresh,
  439.  LPD3DDevInfo lpDevice,
  440.  LPDDModeInfo * lpNextBest,
  441.  LPDDModeInfo lpStart = NULL);
  442.  
  444.     // Methods
  445.     BOOL  Match (LPGUID lpGuid);
  446.     BOOL  Match (LPDDCAPS lpHal, LPDDCAPS lpHel);
  448. LPGUID GetGuid (void);
  450. }; // End class DDDrvInfo
  453.    
  454. /*
  455. **-----------------------------------------------------------------------------
  456. **  Name:       DDDrvMgr
  457. **  Purpose:    Creates and Manages DD/D3D driver info
  458. **  Notes:
  459. **          1.  Modes and D3D Drivers may be incompatible with each other
  460. **              code needs to be added to detect and mark this
  461. **          2.  Need to add code for finding exact and nearest mode matches
  462. **              from requested width, height, pixel format, and refresh rate
  463. **          3.  Need to add code for finding D3D devices from
  464. **-----------------------------------------------------------------------------
  465. */
  467. class DDDrvMgr
  468. {
  469. private:
  470. protected:
  471. public:
  472.     // Static Data
  473.     static DWORD         g_fFlags;                  // Global flags
  474. static DWORD  g_cDrivers; // Count of DD Drivers
  475.     static LPDDDrvInfo  g_lpDriverRoot; // Global list of DD Device Drivers (root)
  476.     static LPDDDrvInfo  g_lpDriverTail; // Global list of DD Device Drivers (tail)
  478.             
  479.     // Data
  480.     LPDDDrvInfo lpCurrDriver; // Pointer to current DD Device driver
  481.     LPDDModeInfo lpCurrMode; // Pointer to current mode in DD driver
  482.     LPD3DDevInfo lpCurrDevice; // Pointer to current D3D device
  483. LPDDModeInfo lpCurrTextureFormat; // Pointer to current Texture Format
  485.     // Static Methods
  486.     static HRESULT Init (void);
  487.     static HRESULT Fini (void);
  489.     static BOOL isInitialized (void)    { return (g_fFlags & DDDRV_INIT); }
  490.     static void initOn (void)           { g_fFlags |= DDDRV_INIT; }
  491.     static void initOff (void)          { g_fFlags &= ~DDDRV_INIT; }
  493. // Driver Methods
  494. static HRESULT LoadDrivers (void);
  495. static HRESULT DestroyDrivers (void);
  497. static HRESULT AddDriver (LPDDDrvInfo lpDrvNew);
  498. static HRESULT DelDriver (LPDDDrvInfo lpDrvDel);
  499. static DWORD countDrivers (void) { return g_cDrivers; }
  501.     static DWORD EnumDrivers (const DDDRV_ENUMINFO & eiInfo);
  503.     static LPDDDrvInfo FindDriver (LPGUID lpGuidDD, LPDDDrvInfo * dwNextBest,
  504.    LPDDDrvInfo lpStart = NULL);
  505.     static LPDDDrvInfo FindDriver (LPDDCAPS lpHalCaps, LPDDCAPS lpHelCaps, 
  506.    LPDDDrvInfo * dwNextBest,
  507.    LPDDDrvInfo lpStart = NULL);
  509.     // Constructors
  510.     DDDrvMgr (void);
  511.     ~DDDrvMgr (void);
  513. // DD info methods
  514.     LPDDDrvInfo GetCurrDriver (void)             
  515. {
  516. return lpCurrDriver;
  517. }
  519.     // Mode Methods
  520.     DWORD countModes (void)              
  521. { 
  522. if (lpCurrDriver)
  523. return lpCurrDriver->countModes ();
  524. return 0L;
  525. }
  527.     LPDDModeInfo GetCurrMode (void)             
  528. {
  529. return lpCurrMode;
  530. }
  532.     // D3D info methods
  533.     DWORD countDevices (void)
  534. { 
  535. if (lpCurrDriver)
  536. return lpCurrDriver->countDevices ();
  537. return 0L;
  538. }    
  540.     LPD3DDevInfo GetCurrDevice (void)
  541. { 
  542. return lpCurrDevice;
  543. }
  545. // Texture Format methods
  546. DWORD countFormats (void)
  547. {
  548. if (lpCurrDevice)
  549. return lpCurrDevice->countFormats ();
  550. return 0L;
  551. }
  553. LPDDModeInfo GetCurrTextureFormat (void)
  554. {
  555. return lpCurrTextureFormat;
  556. }
  557.         
  558. }; // End class DDDrvMgr
  561. /*
  562. **-----------------------------------------------------------------------------
  563. **  End of File
  564. **-----------------------------------------------------------------------------
  565. */
  566. #endif // DRVMGR_H