This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

| DirectX8 Graphics Wrapper Submitted by

So I've written a little C++ DirectX8 Graphics Wrapper which load dynamicaly the D3D8.dll file and allow to initialise both FullScreen and Windowed modes easily. The example use the Alias25 Game Library but you can use the wrapper without it.
I've written a big README file with all explantion about the functions so I belive that's not necessary to describe it here. =)
Friendly Pierre.

Currently browsing [dx8wrapper.zip] (20,160 bytes) - [dx8wrapper/src/DX8.cpp] - (4,943 bytes)

    //***************************************************************************
    //**
    //** Alias25 (C) 2000
    //**
    //** File: DX8.CPP
    //**
    //** Date: 25/11/2000
    //**
    //** Author: Pierre Renaux
    //**
    //** Desc: DirectX8 Graphics Wrapper Test
    //**
    //***************************************************************************
    //===========================================================================
    //    IMPLEMENTATION HEADERS
    //===========================================================================
    #include "CDX8Graphics.h"

    //===========================================================================
    //    IMPLEMENTATION PRIVATE DEFINITIONS / ENUMERATIONS / SIMPLE TYPEDEFS
    //===========================================================================
    //===========================================================================
    //    IMPLEMENTATION PRIVATE CLASS PROTOTYPES / EXTERNAL CLASS REFERENCES
    //===========================================================================
    //===========================================================================
    //    IMPLEMENTATION PRIVATE STRUCTURES / UTILITY CLASSES
    //===========================================================================
    //===========================================================================
    //    IMPLEMENTATION REQUIRED EXTERNAL REFERENCES (AVOID)
    //===========================================================================
    //===========================================================================
    //    IMPLEMENTATION PRIVATE FUNCTION PROTOTYPES
    //===========================================================================
    static int osmsg_close(void);

    //===========================================================================
    //    IMPLEMENTATION PRIVATE DATA
    //===========================================================================
    static int done = 0;

    CDX8Graphics *DX8 = NULL;

    //===========================================================================
    //    IMPLEMENTATION PRIVATE FUNCTIONS
    //===========================================================================
    //---------------------------------------------------------------------------
    // Name: osmsg_close()
    // Desc: answer to the OSMSG_CLOSE message.
    //---------------------------------------------------------------------------
    static int osmsg_close(void)
    {
     done = 1;
     return 1;
    }

    //===========================================================================
    //    INTERFACE DATA
    //===========================================================================
    //===========================================================================
    //    INTERFACE FUNCTIONS
    //===========================================================================
    //---------------------------------------------------------------------------
    // Name: main()
    // Desc: The main function.
    //---------------------------------------------------------------------------
    AGL_MAIN int main(int argc, char **argv)
    {
     set_window_title("DirectX 8 Test");

     set_log_file("DX8.log");

     // Add the OSMSG callbacks
     set_osmsg_callback(OSMSG_CLOSE, osmsg_close);

     // We don't need to enumerate the DirectX device because we recreate
     // all these functions for DirectX 8
     if(!init_agl(AGL_WINDOWED))
      sys_error("Unable to init the AGL !");

     // Install the keyboard manager
     if(!install_keyboard())
      sys_error("Unable to install keyboard !");

     // Create the DX8 object
     DX8 = new CDX8Graphics(0, 640, 480);
     if(!DX8)
      sys_error("Unable to create the DX8 object !");

     if(!DX8->AllOk())
      sys_error("Error during the DX8 object creation !");

     // Main loop
     while(!done)
     {
      // Poll timer and keyboard.
      poll_timer_func();
      poll_keyboard();

      // If the escape key is pressed quit the program
      if(key[KEY_ESC])
       done = 1;

      if(keypressed())
      {
       switch(readkey(NULL))
       {
        case KEY_SPACE:
    	     DX8->Switch();
    	     break;
       }
      }

      LPDIRECT3DDEVICE8 Dev = DX8->Dev();
      if(Dev)
      {
       // Clear the backbuffer to a blue color
       Dev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0);

       // Begin the scene
       Dev->BeginScene();

       // Rendering of scene objects can happen here

       // End the scene
       Dev->EndScene();

       // Present the backbuffer contents to the display
       Dev->Present(NULL, NULL, NULL, NULL);
      }
     }

     // Destroy the DX8 object
     delete DX8;

     // Close all and exit.
     close_agl();
     return 0;
    }

    //===========================================================================
    //    INTERFACE CLASS BODIES
    //===========================================================================

    //***************************************************************************
    //**
    //**    END MODULE DX8.CPP
    //**
    //***************************************************************************

Currently browsing [dx8wrapper.zip] (20,160 bytes) - [dx8wrapper/src/CDX8Graphics.cpp] - (19,979 bytes)

    //***************************************************************************
    //**
    //** Alias25 (C) 2000
    //**
    //** File: CDX8GRAPHICS.CPP
    //**
    //** Date: 25/11/2000
    //**
    //** Author: Pierre Renaux
    //**
    //** Desc: DirectX8 Graphics Wrapper Functions
    //**
    //***************************************************************************
    //===========================================================================
    //    IMPLEMENTATION HEADERS
    //===========================================================================
    #include "CDX8Graphics.h"

    //===========================================================================
    //    IMPLEMENTATION PRIVATE DEFINITIONS / ENUMERATIONS / SIMPLE TYPEDEFS
    //===========================================================================
    #ifndef __AGAMELIB_H__
     #include <stdio.h>
     #include <stdarg.h>

     static void write_error(char *str, ...)
     {
      va_list ap;
      char buf[1024];

      va_start(ap, str);
      vsprintf((char*)buf, (char*)str, ap);
      va_end(ap);

      OutputDebugString(buf);
     }
    #endif

    //===========================================================================
    //    IMPLEMENTATION PRIVATE CLASS PROTOTYPES / EXTERNAL CLASS REFERENCES
    //===========================================================================
    //===========================================================================
    //    IMPLEMENTATION PRIVATE STRUCTURES / UTILITY CLASSES
    //===========================================================================
    // Structure used to represent an adpater
    typedef struct DX8GRAPHIC_ADAPTER
    {
     // Gfx Modes
     U32             num_mode;
     D3DDISPLAYMODE *modes;
     // Identifier structure
     D3DADAPTER_IDENTIFIER8 id;
     // Device Caps
     D3DCAPS8        caps;
    } DX8GRAPHIC_ADAPTER;

    //===========================================================================
    //    IMPLEMENTATION REQUIRED EXTERNAL REFERENCES (AVOID)
    //===========================================================================
    /* Game Library reference */
    #ifdef __AGAMELIB_H__
    extern "C"
    {
     extern HWND agl_wnd;
     extern int wnd_windowed;
     extern BOOL wnd_paint_back;
    }
    #endif

    //===========================================================================
    //    IMPLEMENTATION PRIVATE FUNCTION PROTOTYPES
    //===========================================================================
    //===========================================================================
    //    IMPLEMENTATION PRIVATE DATA
    //===========================================================================
    //===========================================================================
    //    IMPLEMENTATION PRIVATE FUNCTIONS
    //===========================================================================
    //===========================================================================
    //    INTERFACE DATA
    //===========================================================================
    //===========================================================================
    //    INTERFACE FUNCTIONS
    //===========================================================================
    //===========================================================================
    //    INTERFACE CLASS BODIES
    //===========================================================================
    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::CDX8Graphics()
    // Desc: Constructor, load the D3D8.DLL file.
    //---------------------------------------------------------------------------
    CDX8Graphics::CDX8Graphics(HWND wnd)
    {
     Initialise(wnd);
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::CDX8Graphics()
    // Desc: Constructor which allow you to specify directly a gfx mode to
    //       initialise and the window to use.
    //---------------------------------------------------------------------------
    CDX8Graphics::CDX8Graphics(HWND wnd, U32 adapter, int w, int h, D3DFORMAT pixformat, U32 behavior)
    {
     Initialise(wnd);
     if(AllOk())
     {
      mp_all_ok = Gfx(adapter, w, h, pixformat, behavior);
     }
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::CDX8Graphics()
    // Desc: Constructor which allow you to specify directly a gfx mode to
    //       initialise.
    //---------------------------------------------------------------------------
    CDX8Graphics::CDX8Graphics(U32 adapter, int w, int h, D3DFORMAT pixformat, U32 behavior)
    {
     Initialise();
     if(AllOk())
     {
      mp_all_ok = Gfx(adapter, w, h, pixformat, behavior);
     }
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::~CDX8Graphics()
    // Desc: Destructor, destroy all created objects, devices and unload the DLL.
    //---------------------------------------------------------------------------
    CDX8Graphics::~CDX8Graphics()
    {
     Uninitialise();
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::Initialise()
    // Desc: Initialise the class.
    //---------------------------------------------------------------------------
    void CDX8Graphics::Initialise(HWND wnd)
    {
     // Set the default values of all members
     mp_all_ok = FALSE;

     mpUpdateInfo();

     mp_d3d_obj = NULL;
     mp_d3d_dev = NULL;

     mp_num_adapter = 0;
     mp_adapters = NULL;

     // Load the D3D8 Dll
     mp_d3d8_dll = LoadLibrary("D3D8.DLL");
     if(!mp_d3d8_dll)
     {
      write_error("CDX8Graphics::Initialise() - Unable to load D3D8.DLL !");
      return;
     }

     // Get the needed address functions
     mpDirect3DCreate8 = (LPDIRECT3D8(WINAPI*)(UINT))GetProcAddress(mp_d3d8_dll, "Direct3DCreate8");
     if(!mpDirect3DCreate8)
     {
      write_error("CDX8Graphics::Initialise() - Unable to get the Direct3DCreate8 procedure address !");
      return;
     }

     // Create the Direct3D object
     mp_d3d_obj = mpDirect3DCreate8(D3D_SDK_VERSION);
     if(!mp_d3d_obj)
     {
      write_error("CDX8Graphics::Initialise() - Unable to create the IDirect3D8 object !");
      return;
     }

     // Enumerate hardware
     if(!mpEnumerateHardware())
     {
      write_error("CDX8Graphics::Initialise() - Unable to enumerate hardware !");
      return;
     }

     // Set the current HWND to use
    #ifdef __AGAMELIB_H__
     mp_wnd = wnd ? wnd : agl_wnd;
    #else
     if(!wnd)
     {
      write_error("CDX8Graphics::Initialise() - No Window passed to the initialiser !");
      return;
     }
     mp_wnd = wnd;
    #endif

     // All is ok so put the state variable at TRUE.
     mp_all_ok = TRUE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::Uninitialise()
    // Desc: Initialise the class.
    //---------------------------------------------------------------------------
    void CDX8Graphics::Uninitialise()
    {
     // Free the adpater list
     if(mp_adapters)
     {
      for(U32 i = 0; i < mp_num_adapter; i++)
      {
       if(mp_adapters[i].modes)
       {
        delete mp_adapters[i].modes;
    	mp_adapters[i].modes = NULL;
       }
      }
      delete mp_adapters;
     }

     // Free the D3D device
     if(mp_d3d_dev)
     {
      mp_d3d_dev->Release();
      mp_d3d_dev = NULL;
     }

     // Free the D3D object
     if(mp_d3d_obj)
     {
      mp_d3d_obj->Release();
      mp_d3d_obj = NULL;
     }

     // Free the DLL
     if(mp_d3d8_dll)
     {
      FreeLibrary(mp_d3d8_dll);
      mp_d3d8_dll = NULL;
      mpDirect3DCreate8 = NULL;
     }

     // Set the window ptr to NULL
     mp_wnd = NULL;

     // All is not yet ok ;)
     mp_all_ok = FALSE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::Gfx(U32 adapter, int w, int h, D3DFORMAT pixformat)
    // Desc: Setup the gfx mode.
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::Gfx(U32 adapter, int w, int h, D3DFORMAT pixformat, U32 behavior)
    {
     if(!AdapterCapsWindowed(adapter))
      pixformat = mpDesktopMode();

     if(pixformat == D3DFMT_UNKNOWN)
     {
      return mpWindowedInit(adapter, w, h, behavior);
     }

     return mpFullScreenInit(adapter, w, h, pixformat, behavior);
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::Switch()
    // Desc: Switch between fullscreen and windowed mode.s
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::Switch(BOOL fullscreen)
    {
     if(!AdapterCapsWindowed(mp_current_adapter))
      return FALSE;

     if(fullscreen == 2)
      fullscreen = mp_fullscreen ? FALSE : TRUE;

     if(fullscreen)
      return Gfx(mp_current_adapter, mp_w, mp_h, mp_pixformat);
     else
      return Gfx(mp_current_adapter, mp_w, mp_h);
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::NumAdapter()
    // Desc: Return the number of D3D adapter.
    //---------------------------------------------------------------------------
    U32 CDX8Graphics::NumAdapter()
    {
     return mp_num_adapter;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::AdapterInfo()
    // Desc: Return informations about an adapter.
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::AdapterInfo(U32 i, D3DCAPS8 *caps, char *name, char *desc)
    {
     if(i >= mp_num_adapter)
      return FALSE;

     if(name)
      strncpy(name, mp_adapters[i].id.Driver, MAX_DEVICE_IDENTIFIER_STRING);
     if(desc)
      strncpy(desc, mp_adapters[i].id.Description, MAX_DEVICE_IDENTIFIER_STRING);
     if(caps)
      memcpy(caps, &mp_adapters[i].caps, sizeof(D3DCAPS8));

     return TRUE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::AdapterNumMode()
    // Desc: Return the number of gfx mode of an adpater.
    //---------------------------------------------------------------------------
    U32 CDX8Graphics::AdapterNumMode(U32 i)
    {
     if(i >= mp_num_adapter)
      return 0;

     return mp_adapters[i].num_mode;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::AdapterMode()
    // Desc: Enumerate a gfx mode of an adapter.
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::AdapterMode(U32 i, U32 imode, int *w, int *h, D3DFORMAT *format)
    {
     if(i >= mp_num_adapter)
      goto error;

     if(imode >= mp_adapters[i].num_mode)
      goto error;

     if(w) *w = mp_adapters[i].modes[imode].Width;
     if(h) *h = mp_adapters[i].modes[imode].Height;
     if(format) *format = mp_adapters[i].modes[imode].Format;

     return TRUE;

    error:;
     if(w) *w = 0;
     if(h) *h = 0;
     if(format) *format = D3DFMT_UNKNOWN;
     return FALSE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::AdapterCapsWindowed()
    // Desc: Return TRUE if the specifed adapter can render in windowed
    //       mode.
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::AdapterCapsWindowed(U32 i)
    {
     D3DCAPS8 caps;

     if(AdapterInfo(i, &caps))
     {
      if((caps.Caps2 & D3DCAPS2_CANRENDERWINDOWED) == D3DCAPS2_CANRENDERWINDOWED)
       return TRUE;
     }

     return FALSE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpEnumerateHardware()
    // Desc: Enumerate present harware.
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::mpEnumerateHardware()
    {
     U32 i, j, num_hal;

     if(!mp_d3d_obj)
      return FALSE;

     // Get the number of adpaters
     mp_num_adapter = mp_d3d_obj->GetAdapterCount();
     if(mp_num_adapter < 1)
     {
      write_error("CDX8Graphics::mpEnumerateHardware() - No adapter detected !");
      return FALSE;
     }

     // Alloc the adapters array
     mp_adapters = new DX8GRAPHIC_ADAPTER[mp_num_adapter];
     if(!mp_adapters)
     {
      write_error("CDX8Graphics::mpEnumerateHardware() - Unable to alloc mp_adapters !");
      return FALSE;
     }

     // Gets Adapter identifier and gfx modes
     for(i = 0, num_hal = 0; i < mp_num_adapter; i++)
     {
      if(FAILED(mp_d3d_obj->GetAdapterIdentifier(i, D3DENUM_NO_WHQL_LEVEL, &mp_adapters[num_hal].id)))
      {
       write_error("CDX8Graphics::mpEnumerateHardware() - Unable to adapter identifier [%d] !", i);
       return FALSE;
      }

      if(FAILED(mp_d3d_obj->GetDeviceCaps(i, D3DDEVTYPE_HAL, &mp_adapters[num_hal].caps)))
      {
       write_error("CDX8Graphics::mpEnumerateHardware() - Unable to get HAL caps of an adapter [%d] !", i);
       continue;
      }

      mp_adapters[num_hal].num_mode = mp_d3d_obj->GetAdapterModeCount(i);
      mp_adapters[num_hal].modes = new D3DDISPLAYMODE[mp_adapters[num_hal].num_mode];
      if(!mp_adapters[num_hal].modes)
      {
       write_error("CDX8Graphics::mpEnumerateHardware() - Unable to alloc mp_adapters[%d].modes !", i);
       return FALSE;
      }

      for(j = 0; j < mp_adapters[num_hal].num_mode; j++)
      {
       mp_d3d_obj->EnumAdapterModes(i, j, &mp_adapters[num_hal].modes[j]);
      }

      num_hal++;
     }

     if(num_hal < 1)
     {
      write_error("CDX8Graphics::mpEnumerateHardware() - No HAL device detected !", i);
      return FALSE;
     }

     return TRUE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpDesktopMode()
    // Desc: Return the Dektop gfx mode.
    //---------------------------------------------------------------------------
    D3DFORMAT CDX8Graphics::mpDesktopMode(int *w, int *h)
    {
     D3DDISPLAYMODE dm;  // Used to get the current gfx mode.

     // First, get the desktop display mode
     if(FAILED(mp_d3d_obj->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &dm)))
     {
      write_error("CDX8Graphics::mpDesktopMode() - Unable to get the current display mode !");
      return D3DFMT_UNKNOWN;
     }

     if(w) *w = dm.Width;
     if(h) *h = dm.Height;

     return dm.Format;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpCheckUpBeforeGfxInitialisation()
    // Desc: Reset all variables that need to be, before a gfx mode
    //       initialisation.
    //---------------------------------------------------------------------------
    void CDX8Graphics::mpCheckUpBeforeGfxInitialisation()
    {
     // Free the D3D device
     if(mp_d3d_dev)
     {
      mp_d3d_dev->Release();
      mp_d3d_dev = NULL;
     }

     // Reset the info vars.
     mpUpdateInfo();
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpWindowedStyle()
    // Desc: Change the style and the size of the window to use a windowed gfx
    //       mode.
    //---------------------------------------------------------------------------
    void CDX8Graphics::mpWindowedStyle(int w, int h)
    {
     RECT r;
     int style;

    #ifdef __AGAMELIB_H__
     wnd_paint_back = 0;
     wnd_windowed = 1;
    #endif

     style = GetWindowLong(mp_wnd, GWL_STYLE);
     style &= ~(WS_BORDER | WS_SIZEBOX);
     style |= WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU;
     SetWindowLong(mp_wnd, GWL_STYLE, style);

     SetRect(&r, 0, 0, w, h);
     AdjustWindowRectEx(&r,
    	                GetWindowLong(mp_wnd,GWL_STYLE),
    					GetMenu(mp_wnd) != NULL,
    					GetWindowLong(mp_wnd,GWL_EXSTYLE));

     SetWindowPos(mp_wnd, HWND_NOTOPMOST,
    			  (GetSystemMetrics(SM_CXSCREEN)-w)/2,
    			  (GetSystemMetrics(SM_CYSCREEN)-h)/2,
    			  r.right-r.left, r.bottom-r.top, 0);
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpFullScreenStyle()
    // Desc: Change the style and the size of the window to use a fullscreen gfx
    //       mode.
    //---------------------------------------------------------------------------
    void CDX8Graphics::mpFullScreenStyle(int w, int h)
    {
     RECT r;
     int style;

    #ifdef __AGAMELIB_H__
     wnd_paint_back = 0;
     wnd_windowed = 0;
    #endif

     style = GetWindowLong(mp_wnd, GWL_STYLE);
     style &= ~(WS_BORDER | WS_MINIMIZEBOX | WS_SYSMENU | WS_SIZEBOX | WS_CAPTION);
     SetWindowLong(mp_wnd, GWL_STYLE, style);

     SetRect(&r, 0, 0, w, h);
     AdjustWindowRectEx(&r,
    	                GetWindowLong(mp_wnd,GWL_STYLE),
    					GetMenu(mp_wnd) != NULL,
    					GetWindowLong(mp_wnd,GWL_EXSTYLE));

     SetWindowPos(mp_wnd, HWND_NOTOPMOST,
    			  (GetSystemMetrics(SM_CXSCREEN)-w)/2,
    			  (GetSystemMetrics(SM_CYSCREEN)-h)/2,
    			  r.right-r.left, r.bottom-r.top, 0);

    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpWindowedInit()
    // Desc: Initialise a windowed gfx mode. Return FALSE if failed,
    //       otherwise TRUE.
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::mpWindowedInit(U32 adapter, int w, int h, U32 behavior)
    {
     D3DFORMAT pixformat;
     D3DPRESENT_PARAMETERS pp;  // Used to create the D3D device.

     mpCheckUpBeforeGfxInitialisation();

     // Change the window size and style to match with the requested mode
     mpWindowedStyle(w, h);

     // Get the Desktop color format
     pixformat = mpDesktopMode();

     // Initialise the pp structure
     ZeroMemory(&pp, sizeof(D3DPRESENT_PARAMETERS));
     pp.Windowed = TRUE;                    // Use windowed mode
     pp.SwapEffect = D3DSWAPEFFECT_DISCARD; // Use DISCARD swapping method
     pp.BackBufferFormat = pixformat;       // Use the same pixel format as the
                                            // current display mode.

     // Now create the D3D device with the same value as in the DX8Doc tutorial.
     // Will be modified !
     if(FAILED(mp_d3d_obj->CreateDevice(adapter, D3DDEVTYPE_HAL, mp_wnd,
                                        behavior,
                                        &pp, &mp_d3d_dev)))
     {
      write_error("CDX8Graphics::mpWindowedInit() - Unable to create the D3D device !");
      return FALSE;
     }

     // Finally update the gfx mode informations
     mpUpdateInfo(adapter, w, h, pixformat, FALSE);

     return TRUE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpFullScreenInit()
    // Desc: Initialise a fullscreen gfx mode. Return FALSE if failed,
    //       otherwise TRUE.
    //---------------------------------------------------------------------------
    BOOL CDX8Graphics::mpFullScreenInit(U32 adapter, int w, int h, D3DFORMAT pixformat, U32 behavior)
    {
     D3DPRESENT_PARAMETERS pp;  // Used to create the D3D device.

     mpCheckUpBeforeGfxInitialisation();

     // Change the window size and style to match with the requested mode
     mpFullScreenStyle(w, h);

     // Initialise the pp structure
     ZeroMemory(&pp, sizeof(D3DPRESENT_PARAMETERS));
     pp.Windowed = FALSE;                   // Use fullscreen mode
     pp.SwapEffect = D3DSWAPEFFECT_DISCARD; // Use DISCARD swapping method
     pp.BackBufferWidth = w;
     pp.BackBufferHeight = h;
     pp.BackBufferFormat = pixformat;       // Use the same pixel format as the
                                            // current display mode.

     // Now create the D3D device with the same value as in the DX8Doc tutorial.
     // Will be modified !
     if(FAILED(mp_d3d_obj->CreateDevice(adapter, D3DDEVTYPE_HAL, mp_wnd,
                                        behavior,
                                        &pp, &mp_d3d_dev)))
     {
      write_error("CDX8Graphics::mpWindowedInit() - Unable to create the D3D device !");
      return FALSE;
     }

     // Finally update the gfx mode informations
     mpUpdateInfo(adapter, w, h, pixformat, TRUE);

     return TRUE;
    }

    //---------------------------------------------------------------------------
    // Name: CDX8Graphics::mpUpdateInfo()
    // Desc: Update the info variables.
    //---------------------------------------------------------------------------
    void CDX8Graphics::mpUpdateInfo(U32 adapter, int w, int h, D3DFORMAT pixformat, BOOL fullscreen)
    {
     mp_current_adapter = adapter;
     mp_w = w;
     mp_h = h;
     mp_pixformat = pixformat;
     mp_fullscreen = fullscreen;
    }

    //***************************************************************************
    //**
    //**    END MODULE CDX8GRAPHICS.CPP
    //**
    //***************************************************************************

Currently browsing [dx8wrapper.zip] (20,160 bytes) - [dx8wrapper/src/CDX8Graphics.h] - (6,108 bytes)

    #ifndef __CDX8Graphics_H__
    #define __CDX8Graphics_H__
    //***************************************************************************
    //**
    //** Alias25 (C) 2000
    //**
    //** File: CDX8Graphics.h
    //**
    //** Date: 25/11/2000
    //**
    //** Author: Pierre Renaux
    //**
    //** Desc: DirectX8 Graphics Wrapper
    //**
    //***************************************************************************
    //===========================================================================
    //    INTERFACE REQUIRED HEADERS
    //===========================================================================
    #include "agamelib.h"     // Comment it if you don't want to use
                              // the game library.
    #include <windows.h>
    #include <d3d8.h>

    //===========================================================================
    //    INTERFACE DEFINITIONS / ENUMERATIONS / SIMPLE TYPEDEFS
    //===========================================================================
    #ifndef __AGAMELIB_H__
     #define U32 unsigned long
    #endif

    //===========================================================================
    //    INTERFACE CLASS PROTOTYPES / EXTERNAL CLASS REFERENCES
    //===========================================================================
    //===========================================================================
    //    INTERFACE STRUCTURES / UTILITY CLASSES
    //===========================================================================
    //===========================================================================
    //    INTERFACE DATA DECLARATIONS
    //===========================================================================
    //===========================================================================
    //    INTERFACE FUNCTION PROTOTYPES
    //===========================================================================
    //===========================================================================
    //    INTERFACE OBJECT CLASS DEFINITIONS
    //===========================================================================
    // CDX8Graphics
    class CDX8Graphics
    {
    // Public functions /////////////////////////////////////////////////////////
    public:
     CDX8Graphics(HWND wnd = NULL);
     CDX8Graphics(HWND wnd, U32 adapter, int w, int h, D3DFORMAT pixformat = D3DFMT_UNKNOWN,
    	          U32 behavior = D3DCREATE_SOFTWARE_VERTEXPROCESSING);
     CDX8Graphics(U32 adapter, int w, int h, D3DFORMAT pixformat = D3DFMT_UNKNOWN,
    	          U32 behavior = D3DCREATE_SOFTWARE_VERTEXPROCESSING);
     ~CDX8Graphics();

     // Initialise
     void Initialise(HWND wnd = NULL);

     // Uninitialise
     void Uninitialise(void);

     // Return true if the object has been well initialised by the constructor
     // and Initialise.
     BOOL AllOk() { return mp_all_ok; }

     // Change the current video mode
     BOOL Gfx(U32 adapter, int w, int h, D3DFORMAT pixformat = D3DFMT_UNKNOWN,
    	          U32 behavior = D3DCREATE_SOFTWARE_VERTEXPROCESSING);

     // Switch between fullscreen and windowed mode
     BOOL Switch(BOOL fullscreen = 2);

     // Return the D3DDevice8 object
     LPDIRECT3DDEVICE8 Dev() { return mp_d3d_dev; }

     // Enumeration functions
     U32  NumAdapter();
     BOOL AdapterInfo(U32 i, D3DCAPS8 *caps, char *name = NULL, char *desc = NULL);
     U32  AdapterNumMode(U32 i);
     BOOL AdapterMode(U32 i, U32 imode, int *w, int *h, D3DFORMAT *format);

     // Quick Caps test functions
     BOOL AdapterCapsWindowed(U32 i);

     // Return the informations about the current gfx mode
     U32 W() { return mp_w; }
     U32 H() { return mp_h; }
     D3DFORMAT PixelFormat() { return mp_pixformat; }
     BOOL FullScreen()   { return mp_fullscreen; }
     U32 CurrentAdapter()    { return mp_current_adapter; }

     // Virtual Member to deal with window's focus lost/gain
     virtual int SwitchIn(void)  { return 1; }
     virtual int SwitchOut(void) { return 1; }

    // Private functions ////////////////////////////////////////////////////////
    private:
     // Enumerate present hardware.
     BOOL mpEnumerateHardware();

     // Return the desktop display mode
     D3DFORMAT mpDesktopMode(int *w = NULL, int *h = NULL);

     // Change the style and the size of the window to use a windowed gfx mode.
     void mpWindowedStyle(int w, int h);

     // Change the style and the size of the window to use a fullscreen gfx mode.
     void mpFullScreenStyle(int w, int h);

     // Reset all variables that need to be, before a gfx mode initialisation.
     void mpCheckUpBeforeGfxInitialisation();

     // Initialise a windowed gfx mode and show the window
     BOOL mpWindowedInit(U32 adapter, int w, int h, U32 behavior);

     // Initialise a fullscreen gfx
     BOOL mpFullScreenInit(U32 adapter, int w, int h, D3DFORMAT pixformat, U32 behavior);

     // Update the info variables
     void mpUpdateInfo(U32 adapter=0, int w=0, int h=0, D3DFORMAT pixformat=D3DFMT_UNKNOWN, BOOL fullscreen=FALSE);

    // Public data //////////////////////////////////////////////////////////////
    public:

    // Private Data /////////////////////////////////////////////////////////////
    private:
     BOOL  mp_all_ok;   // To be sure that all is ok
     HWND      mp_wnd;      // The used window
     HINSTANCE mp_d3d8_dll; // The D3D8 DLL

     // Informations about the current gfx mode.
     U32       mp_w;
     U32       mp_h;
     D3DFORMAT mp_pixformat;
     BOOL  mp_fullscreen;

     // Current adapter index
     U32       mp_current_adapter;

     // Adapter array
     U32       mp_num_adapter;
     struct DX8GRAPHIC_ADAPTER *mp_adapters;

     // Dynamicaly loaded DX8 functions
     IDirect3D8 *(WINAPI *mpDirect3DCreate8)(UINT SDKVersion);

     // DirectX8 Objects
     LPDIRECT3D8             mp_d3d_obj; // Used to create the D3DDevice
     LPDIRECT3DDEVICE8       mp_d3d_dev; // Our rendering device
    };

    //===========================================================================
    //    INTERFACE TRAILING HEADERS
    //===========================================================================

    //***************************************************************************
    //**
    //**    END HEADER CDX8Graphics.h
    //**
    //***************************************************************************
    #endif // __CDX8Graphics_H__

The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.