home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / directx / pplane / drvmgr.h < prev    next >
C/C++ Source or Header  |  1997-07-14  |  16KB  |  569 lines
  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. */
  11.  
  12. /*
  13. **-----------------------------------------------------------------------------
  14. **  Includes
  15. **-----------------------------------------------------------------------------
  16. */
  17.  
  18. #include "Common.h"
  19.  
  20.  
  21.  
  22. /*
  23. **-----------------------------------------------------------------------------
  24. **  Defines
  25. **-----------------------------------------------------------------------------
  26. */
  27.  
  28. // DD Driver Flags
  29. #define DDDRV_INIT                0x00000001L
  30.     
  31. #define DDDRV_VALID                0x00000001L
  32. #define DDDRV_PRIMARY            0x00000002L
  33. #define DDDRV_D3D                0x00000004L
  34.  
  35. #define DDDRV_MODES_LOADED        0x00000008L
  36. #define DDDRV_DEVICES_LOADED    0x00000010L
  37.  
  38.  
  39. // D3D Device Flags
  40. #define D3DDEV_VALID            0x00000001L
  41. #define D3DDEV_FORMATS_LOADED    0x00000002L
  42.  
  43.  
  44.  
  45. /*
  46. **-----------------------------------------------------------------------------
  47. **  Typedefs
  48. **-----------------------------------------------------------------------------
  49. */
  50.  
  51. // Forward declarations
  52. class DDModeInfo;
  53. typedef DDModeInfo * LPDDModeInfo;
  54.  
  55. class D3DDevInfo;
  56. typedef D3DDevInfo * LPD3DDevInfo;
  57.  
  58. class DDDrvInfo;
  59. typedef DDDrvInfo * LPDDDrvInfo;
  60.  
  61. class DDDrvMgr;
  62. typedef DDDrvMgr * LPDDDrvMgr;
  63.  
  64.  
  65. // Enumeration Callback Info
  66. #define ENUM_STOP  0x80000000L
  67.  
  68. typedef enum {
  69.     ENUM_ERROR    = 0,
  70.     ENUM_FAILURE  = 1,
  71.     ENUM_SUCCESS  = 2
  72. };
  73.  
  74.  
  75. // Callback function prototypes
  76. typedef DWORD (*ENUMDDDRVCALLBACK)(LPVOID lpDriver, LPVOID lpData, DWORD dwExtra);
  77. typedef DWORD (*ENUMD3DDEVCALLBACK)(LPVOID lpDevice, LPVOID lpData, DWORD dwExtra);
  78.  
  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;
  87.  
  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;
  96.  
  97.  
  98.  
  99. /*
  100. **-----------------------------------------------------------------------------
  101. **  Functions
  102. **-----------------------------------------------------------------------------
  103. */
  104.  
  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);
  110.  
  111. BOOL GetDesktopMode (LPDDDrvInfo lpDriver, LPGUID lpD3DGuid,
  112.                      LPDDModeInfo * lpMode,    LPD3DDevInfo * lpDev);
  113.  
  114. BOOL GetFullscreenMode (LPDDDrvInfo lpDriver,  LPGUID lpD3DGuid,
  115.                         DWORD w, DWORD h, DWORD bpp, DWORD refresh,
  116.                         LPDDModeInfo * lpMode,    LPD3DDevInfo * lpDev);
  117.  
  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);
  122.  
  123. DWORD FlagsToBitDepth (DWORD dwFlags);
  124. DWORD BitDepthToFlags (DWORD dwBPP);
  125. BOOL  isPalettized (LPDDPIXELFORMAT lpddpf);
  126.  
  127.  
  128.  
  129. /*
  130. **-----------------------------------------------------------------------------
  131. **  Classes
  132. **-----------------------------------------------------------------------------
  133. */
  134.  
  135. /*
  136. **-----------------------------------------------------------------------------
  137. **  Name:       DDModeInfo
  138. **  Purpose:    DirectDraw Mode info 
  139. **-----------------------------------------------------------------------------
  140. */
  141.  
  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
  151.  
  152.     // Constructors
  153.     DDModeInfo (void)
  154.         { 
  155.             ZeroMemory (&ddSurfDesc, sizeof (ddSurfDesc)); 
  156.             ddSurfDesc.dwSize = sizeof (DDSURFACEDESC);
  157.  
  158.             lpPrev = NULL;
  159.             lpNext = NULL;
  160.         }
  161.  
  162.     DDModeInfo (const DDSURFACEDESC & ddDesc)
  163.         { 
  164.             CopyMemory (&ddSurfDesc, (const void *)&ddDesc, sizeof (ddSurfDesc)); 
  165.             ddSurfDesc.dwSize = sizeof (DDSURFACEDESC);
  166.  
  167.             lpPrev = NULL;
  168.             lpNext = NULL;
  169.         }
  170.     ~DDModeInfo (void) 
  171.         {
  172.             lpPrev = NULL;
  173.             lpNext = NULL;
  174.         }
  175.  
  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);
  182.  
  183.     BOOL ModeSupported (LPD3DDevInfo lpDevice);
  184.  
  185.     BOOL Match (DWORD dwW, DWORD dwH, DWORD dwBPP);
  186.     BOOL Match (const DDSURFACEDESC & ddsd);
  187.  
  188.     BOOL Match (DWORD dwBPP);
  189.     BOOL Match (const DDPIXELFORMAT & ddpf);
  190. }; // DDModeInfo
  191.  
  192.  
  193.  
  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. */
  204.  
  205. class D3DDevInfo
  206. {
  207. private:
  208. protected:
  209. public:
  210.     // D3D Device Driver info
  211.     DWORD           fFlags;                 // Flags
  212.  
  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
  219.  
  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)
  224.  
  225.     // Node Info
  226.     LPD3DDevInfo    lpPrev;                    // Prev Node
  227.     LPD3DDevInfo    lpNext;                    // Next Node
  228.  
  229.     // Flags
  230.     BOOL isValid (void)     { return (fFlags & DDDRV_VALID); }
  231.     void validOn (void)     { fFlags |= DDDRV_VALID; }
  232.     void validOff (void)    { fFlags &= ~DDDRV_VALID; }
  233.  
  234.     // Methods
  235.     HRESULT Create (LPGUID lpGuid, LPTSTR lpName, LPTSTR lpDesc,
  236.                     LPD3DDEVICEDESC lpHalDevice,
  237.                     LPD3DDEVICEDESC lpHelDevice);
  238.     void Destroy (void);
  239.  
  240.     // Constructors 
  241.     D3DDevInfo (void) 
  242.         { 
  243.         validOff ();
  244.         turnFormatsLoadedOff ();
  245.  
  246.         szName = NULL;
  247.         szDesc = NULL;
  248.  
  249.         ZeroMemory (&d3dHalDesc, sizeof(D3DDEVICEDESC)); 
  250.         d3dHalDesc.dwSize = sizeof (D3DDEVICEDESC);
  251.  
  252.         ZeroMemory (&d3dHelDesc, sizeof(D3DDEVICEDESC)); 
  253.         d3dHelDesc.dwSize = sizeof (D3DDEVICEDESC);
  254.  
  255.         cFormats = 0L;
  256.         lpFormatRoot = NULL;
  257.         lpFormatTail = NULL;
  258.  
  259.         lpPrev = NULL;
  260.         lpNext = NULL;
  261.         }
  262.  
  263.     ~D3DDevInfo (void) 
  264.         { 
  265.         Destroy (); 
  266.         }
  267.  
  268.     
  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; }
  273.  
  274.     HRESULT LoadFormats (LPDIRECT3DDEVICE2 lpd3dDevice);
  275.     HRESULT DestroyFormats (void);
  276.  
  277.     HRESULT AddFormat (LPDDModeInfo lpFormatNew);
  278.     HRESULT DelFormat (LPDDModeInfo lpFormatDel);
  279.     DWORD   countFormats (void) { return cFormats; }
  280.  
  281.     LPDDModeInfo FindFormat (DWORD dwBPP, 
  282.                              LPDDModeInfo * lpNextBest,
  283.                              LPDDModeInfo lpStartFormat = NULL);
  284.     LPDDModeInfo FindFormat (LPDDPIXELFORMAT lpddsd, 
  285.                              LPDDModeInfo * lpNextBest,
  286.                              LPDDModeInfo lpStartFormat = NULL);
  287.  
  288.     DWORD EnumFormats (const D3DDEV_ENUMINFO & eiInfo);
  289.  
  290.  
  291.     // Methods
  292.     BOOL isHardware (void);
  293.     BOOL Match (LPGUID lpGuid);
  294.     BOOL Match (LPD3DDEVICEDESC lpHalDesc, LPD3DDEVICEDESC lpHelDesc);
  295.  
  296. }; // End D3DDevInfo
  297.  
  298.  
  299.  
  300.  
  301. /*
  302. **-----------------------------------------------------------------------------
  303. **  Name:       DDDrvInfo
  304. **  Purpose:    Encapsulates DD/D3D driver info
  305. **-----------------------------------------------------------------------------
  306. */
  307.  
  308. class DDDrvInfo
  309. {
  310. private:
  311. protected:
  312. public:
  313.  
  314.     // Structure info
  315.     DWORD           fFlags;                         // D3D Driver flags
  316.  
  317.     // Driver Info
  318.     GUID            guid;                           // guid, if any
  319.     LPTSTR          szName;                            // name
  320.     LPTSTR          szDesc;                            // description
  321.  
  322.     // Driver Caps
  323.     DDCAPS          ddHalCaps;                      // Hardware caps
  324.     DDCAPS          ddHelCaps;                      // Emulation caps
  325.  
  326.     // Mode Info
  327.     DWORD            cModes;                            // Count of Modes
  328.     LPDDModeInfo    lpModeRoot;                        // List of Modes (root)
  329.     LPDDModeInfo    lpModeTail;                        // List of Modes (tail)
  330.  
  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)
  335.  
  336.     // Node Info
  337.     LPDDDrvInfo        lpPrev;                            // Previous node
  338.     LPDDDrvInfo        lpNext;                            // Next node
  339.  
  340.  
  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; }
  347.  
  348.     BOOL isPrimary (void)   { return (fFlags & DDDRV_PRIMARY); }
  349.     void primaryOn (void)   { fFlags |= DDDRV_PRIMARY; }
  350.     void primaryOff (void)  { fFlags &= ~DDDRV_PRIMARY; }
  351.  
  352.     BOOL isD3D (void)     { return (fFlags & DDDRV_D3D); }
  353.     void d3dOn (void)     { fFlags |= DDDRV_D3D; }
  354.     void d3dOff (void)    { fFlags &= ~DDDRV_D3D; }
  355.  
  356.  
  357.     // Methods
  358.     HRESULT Create (LPGUID lpGuid, LPTSTR lpszName, LPTSTR lpszDesc);
  359.     void    Destroy (void);
  360.  
  361.     // Constructors
  362.     DDDrvInfo (void)
  363.         { 
  364.         validOff ();
  365.         
  366.         ZeroMemory (&ddHalCaps, sizeof (DDCAPS)); 
  367.         ddHalCaps.dwSize = sizeof (DDCAPS);
  368.  
  369.         ZeroMemory (&ddHelCaps, sizeof (DDCAPS)); 
  370.         ddHelCaps.dwSize = sizeof (DDCAPS);
  371.  
  372.         cModes  = 0L;
  373.         lpModeRoot = NULL;
  374.         lpModeTail = NULL;
  375.  
  376.         cDevices = 0L;
  377.         lpDeviceRoot = NULL;
  378.         lpDeviceTail = NULL;
  379.  
  380.         lpPrev = NULL;
  381.         lpNext = NULL;
  382.         }
  383.  
  384.     ~DDDrvInfo (void) 
  385.         { 
  386.         Destroy (); 
  387.         }
  388.  
  389.  
  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; }
  394.  
  395.     HRESULT LoadModes (LPDIRECTDRAW2 lpDD2);
  396.     HRESULT DestroyModes (void);
  397.  
  398.     HRESULT AddMode (LPDDModeInfo lpModeNew);
  399.     HRESULT DelMode (LPDDModeInfo lpModeDel);
  400.     DWORD countModes (void) { return cModes; }
  401.  
  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);
  409.  
  410.     DWORD EnumModes (const DDDRV_ENUMINFO & eiInfo);
  411.  
  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; }
  416.  
  417.     HRESULT LoadDevices (LPDIRECT3D2 lpD3D2);
  418.     HRESULT DestroyDevices (void);
  419.  
  420.     HRESULT AddDevice (LPD3DDevInfo lpModeNew);
  421.     HRESULT DelDevice (LPD3DDevInfo lpModeDel);
  422.     DWORD countDevices (void) { return cDevices; }
  423.  
  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);
  429.  
  430.     DWORD EnumDevices (const DDDRV_ENUMINFO & eiInfo);
  431.  
  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.                                          
  443.  
  444.     // Methods
  445.     BOOL  Match (LPGUID lpGuid);
  446.     BOOL  Match (LPDDCAPS lpHal, LPDDCAPS lpHel);
  447.  
  448.     LPGUID GetGuid (void);
  449.  
  450. }; // End class DDDrvInfo
  451.  
  452.  
  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. */
  466.  
  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)
  477.  
  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
  484.  
  485.     // Static Methods
  486.     static HRESULT Init (void);
  487.     static HRESULT Fini (void);
  488.  
  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; }
  492.  
  493.     // Driver Methods
  494.     static HRESULT LoadDrivers (void);
  495.     static HRESULT DestroyDrivers (void);
  496.  
  497.     static HRESULT AddDriver (LPDDDrvInfo lpDrvNew);
  498.     static HRESULT DelDriver (LPDDDrvInfo lpDrvDel);
  499.     static DWORD countDrivers (void) { return g_cDrivers; }
  500.  
  501.     static DWORD EnumDrivers (const DDDRV_ENUMINFO & eiInfo);
  502.  
  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);
  508.  
  509.     // Constructors
  510.     DDDrvMgr (void);
  511.     ~DDDrvMgr (void);
  512.  
  513.     // DD info methods
  514.     LPDDDrvInfo GetCurrDriver (void)             
  515.         {
  516.         return lpCurrDriver;
  517.         }
  518.  
  519.     // Mode Methods
  520.     DWORD countModes (void)              
  521.         { 
  522.         if (lpCurrDriver)
  523.             return lpCurrDriver->countModes ();
  524.         return 0L;
  525.         }
  526.  
  527.     LPDDModeInfo GetCurrMode (void)             
  528.         {
  529.         return lpCurrMode;
  530.         }
  531.  
  532.     // D3D info methods
  533.     DWORD countDevices (void)
  534.         { 
  535.         if (lpCurrDriver)
  536.             return lpCurrDriver->countDevices ();
  537.         return 0L;
  538.         }    
  539.  
  540.     LPD3DDevInfo GetCurrDevice (void)
  541.         { 
  542.         return lpCurrDevice;
  543.         }
  544.  
  545.     // Texture Format methods
  546.     DWORD countFormats (void)
  547.         {
  548.         if (lpCurrDevice)
  549.             return lpCurrDevice->countFormats ();
  550.         return 0L;
  551.         }
  552.  
  553.     LPDDModeInfo GetCurrTextureFormat (void)
  554.         {
  555.         return lpCurrTextureFormat;
  556.         }
  557.         
  558. }; // End class DDDrvMgr
  559.  
  560.  
  561. /*
  562. **-----------------------------------------------------------------------------
  563. **  End of File
  564. **-----------------------------------------------------------------------------
  565. */
  566. #endif // DRVMGR_H
  567.  
  568.  
  569.