Sorry your browser is not supported!

CLS
SET DISPLAY MODE 800,600,32
SYNC ON:SYNC RATE 0
HIDE MOUSE
BACKDROP ON:COLOR BACKDROP 0
AUTOCAM OFF

// Double buffer demo
// 16bit version

// INCLUDES ///////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN  
#define INITGUID

#include <windows.h>   // include important windows stuff
#include <windowsx.h> 
#include <mmsystem.h>
#include <iostream.h> // include important C/C++ stuff
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>

#include <ddraw.h>  // directX includes

// DEFINES ////////////////////////////////////////////////

// defines for windows 
#define WINDOW_CLASS_NAME "WINXCLASS"  // class name

#define WINDOW_WIDTH  640              // size of window
#define WINDOW_HEIGHT 480
#define SCREEN_WIDTH  640              // size of screen
#define SCREEN_HEIGHT 480
#define SCREEN_BPP    16               // bits per pixel

// MACROS /////////////////////////////////////////////////

// these read the keyboard asynchronously
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// this builds a 16 bit color value in 5.5.5 format (1-bit alpha mode)
#define _RGB16BIT555(r,g,b) ((b & 31) + ((g & 31) << 5) + ((r & 31) << 10))

// this builds a 16 bit color value in 5.6.5 format (green dominate mode)
#define _RGB16BIT565(r,g,b) ((b & 31) + ((g & 63) << 5) + ((r & 31) << 11))

// TYPES //////////////////////////////////////////////////

typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;

// PROTOTYPES /////////////////////////////////////////////

int Game_Init(void *parms=NULL);
int Game_Shutdown(void *parms=NULL);
int Game_Main(void *parms=NULL);

// GLOBALS ////////////////////////////////////////////////

HWND main_window_handle = NULL; // save the window handle
HINSTANCE main_instance = NULL; // save the instance
char buffer[80];                // used to print text

LPDIRECTDRAW7        lpdd         = NULL;  // dd object
LPDIRECTDRAWSURFACE7 lpddsprimary = NULL;  // dd primary surface
LPDIRECTDRAWSURFACE7 lpddsback    = NULL;  // dd back surface
LPDIRECTDRAWPALETTE  lpddpal      = NULL;  // a pointer to the created dd palette
DDSURFACEDESC2       ddsd;                 // a direct draw surface description struct
DDSCAPS2             ddscaps;              // a direct draw surface capabilities struct
HRESULT              ddrval;               // result back from dd calls

USHORT               *double_buffer = NULL; // the double buffer              

// FUNCTIONS //////////////////////////////////////////////

LRESULT CALLBACK WindowProc(HWND hwnd, 
						    UINT msg, 
                            WPARAM wparam, 
                            LPARAM lparam)
{
// this is the main message handler of the system
PAINTSTRUCT	ps;		   // used in WM_PAINT
HDC			hdc;	   // handle to a device context

// what is the message 
switch(msg)
	{	
	case WM_CREATE: 
        {
		// do initialization stuff here
		return(0);
		} break;

    case WM_PAINT:
         {
         // start painting
         hdc = BeginPaint(hwnd,&ps);

         // end painting
         EndPaint(hwnd,&ps);
         return(0);
        } break;

	case WM_DESTROY: 
		{
		// kill the application			
		PostQuitMessage(0);
		return(0);
		} break;

	default:break;

    } // end switch

// process any messages that we didn't take care of 
return (DefWindowProc(hwnd, msg, wparam, lparam));

} // end WinProc

// WINMAIN ////////////////////////////////////////////////

int WINAPI WinMain(	HINSTANCE hinstance,
					HINSTANCE hprevinstance,
					LPSTR lpcmdline,
					int ncmdshow)
{

WNDCLASS winclass;	// this will hold the class we create
HWND	 hwnd;		// generic window handle
MSG		 msg;		// generic message
HDC      hdc;       // generic dc
PAINTSTRUCT ps;     // generic paintstruct

// first fill in the window class stucture
winclass.style			= CS_DBLCLKS | CS_OWNDC | 
                          CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc	= WindowProc;
winclass.cbClsExtra		= 0;
winclass.cbWndExtra		= 0;
winclass.hInstance		= hinstance;
winclass.hIcon			= LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor		= LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName	= NULL; 
winclass.lpszClassName	= WINDOW_CLASS_NAME;

// register the window class
if (!RegisterClass(&winclass))
	return(0);

// create the window, note the use of WS_POPUP
if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME, // class
						  "WinX Game Console",	 // title
						  WS_POPUP | WS_VISIBLE,
					 	  0,0,	   // x,y
						  WINDOW_WIDTH,  // width
                          WINDOW_HEIGHT, // height
						  NULL,	   // handle to parent 
						  NULL,	   // handle to menu
						  hinstance,// instance
						  NULL)))	// creation parms
return(0);

// save the window handle and instance in a global
main_window_handle = hwnd;
main_instance      = hinstance;

// perform all game console specific initialization
Game_Init();

// enter main event loop
while(1)
	{
	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{ 
		// test if this is a quit
        if (msg.message == WM_QUIT)
           break;
	
		// translate any accelerator keys
		TranslateMessage(&msg);

		// send the message to the window proc
		DispatchMessage(&msg);
		} // end if
    
    // main game processing goes here
    Game_Main();

	} // end while

// shutdown game and release all resources
Game_Shutdown();

// return to Windows like this
return(msg.wParam);

} // end WinMain

// WINX GAME PROGRAMMING CONSOLE FUNCTIONS ////////////////

int Game_Init(void *parms)
{
// this function is where you do all the initialization 
// for your game

// create object and test for error
if (DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)!=DD_OK)
   return(0);

// set cooperation level to windowed mode normal
if (lpdd->SetCooperativeLevel(main_window_handle,
           DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN | 
           DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK)
    return(0);

// set the display mode
if (lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,0)!=DD_OK)
   return(0);

// Create the primary surface
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize         = sizeof(ddsd);
ddsd.dwFlags        = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

if (lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL)!=DD_OK)
   return(0);

// allocate memory for the double buffer, notice the SCREEN_BPP/8
// term to take into consideration 16-bit pixels
if ((double_buffer = (USHORT *)malloc(SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8)))==NULL)
   return(0);

// return success
return(1);

} // end Game_Init

///////////////////////////////////////////////////////////

int Game_Shutdown(void *parms)
{
// this function is where you shutdown your game and
// release all resources that you allocated

// first release the primary surface
if (lpddsprimary!=NULL)
   lpddsprimary->Release();
       
// release the directdraw object
if (lpdd!=NULL)
   lpdd->Release();

// free double buffer
if (double_buffer!=NULL)
   free(double_buffer);

// return success
return(1);
} // end Game_Shutdown

///////////////////////////////////////////////////////////

int Game_Main(void *parms)
{
// this is the workhorse of your game it will be called
// continuously in real-time this is like main() in C
// all the calls for you game go here!

USHORT *primary_buffer = NULL, // used to draw
       *dest_ptr       = NULL, // used in line by line copy
       *src_ptr        = NULL; // " "

// check of user is trying to exit
if (KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE))
    PostMessage(main_window_handle, WM_DESTROY,0,0);

// erase double buffer
memset(double_buffer,0, SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8));

// perform game logic...
       

// NONE!!! :)



// copy the double buffer into the primary buffer
memset(&ddsd,0,sizeof(ddsd)); 
ddsd.dwSize = sizeof(ddsd);

// lock the primary surface
lpddsprimary->Lock(NULL,&ddsd, 
              DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);

// get video pointer to primary surfce
primary_buffer = (USHORT *)ddsd.lpSurface;       

// test if memory is linear
if (ddsd.lPitch == SCREEN_WIDTH*(SCREEN_BPP/8))
   {
   // copy memory from double buffer to primary buffer
   memcpy(primary_buffer, double_buffer, SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8));
   } // end if
else
   { // non-linear
   // make copy of source and destination addresses
   dest_ptr = primary_buffer;
   src_ptr = double_buffer;

   // memory is non-linear, copy line by line
   for (int y=0; y<SCREEN_HEIGHT; y++)
       {
       // copy line
       memcpy(dest_ptr, src_ptr, SCREEN_WIDTH*(SCREEN_BPP/8));

       // advance pointers to next line
       // notice division by 2 since lpitch is in bytes and
       // these pointers are USHORT pointers
       // but the screen_width is ok to use on src_ptr
       // since the pointer arithematic will advance the pointer
       // properly
       dest_ptr+=(ddsd.lPitch/2);
       src_ptr+=SCREEN_WIDTH;

       } // end for

   } // end else

// unlock primary buffer
lpddsprimary->Unlock(NULL);

// wait a sec
Sleep(5);

// return success
return(1);
} // end Game_Main

///////////////////////////////////////////////////////////

CLS
SET DISPLAY MODE 800,600,32
SYNC ON:SYNC RATE 0
HIDE MOUSE
BACKDROP ON:COLOR BACKDROP 0
AUTOCAM OFF

// Double buffer demo
// 16bit version

// INCLUDES ///////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN  
#define INITGUID

#include <windows.h>   // include important windows stuff
#include <windowsx.h> 
#include <mmsystem.h>
#include <iostream.h> // include important C/C++ stuff
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>

#include <ddraw.h>  // directX includes

// DEFINES ////////////////////////////////////////////////

// defines for windows 
#define WINDOW_CLASS_NAME "WINXCLASS"  // class name

#define WINDOW_WIDTH  640              // size of window
#define WINDOW_HEIGHT 480
#define SCREEN_WIDTH  640              // size of screen
#define SCREEN_HEIGHT 480
#define SCREEN_BPP    16               // bits per pixel

// MACROS /////////////////////////////////////////////////

// these read the keyboard asynchronously
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// this builds a 16 bit color value in 5.5.5 format (1-bit alpha mode)
#define _RGB16BIT555(r,g,b) ((b & 31) + ((g & 31) << 5) + ((r & 31) << 10))

// this builds a 16 bit color value in 5.6.5 format (green dominate mode)
#define _RGB16BIT565(r,g,b) ((b & 31) + ((g & 63) << 5) + ((r & 31) << 11))

// TYPES //////////////////////////////////////////////////

typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;

// PROTOTYPES /////////////////////////////////////////////

int Game_Init(void *parms=NULL);
int Game_Shutdown(void *parms=NULL);
int Game_Main(void *parms=NULL);

// GLOBALS ////////////////////////////////////////////////

HWND main_window_handle = NULL; // save the window handle
HINSTANCE main_instance = NULL; // save the instance
char buffer[80];                // used to print text

LPDIRECTDRAW7        lpdd         = NULL;  // dd object
LPDIRECTDRAWSURFACE7 lpddsprimary = NULL;  // dd primary surface
LPDIRECTDRAWSURFACE7 lpddsback    = NULL;  // dd back surface
LPDIRECTDRAWPALETTE  lpddpal      = NULL;  // a pointer to the created dd palette
DDSURFACEDESC2       ddsd;                 // a direct draw surface description struct
DDSCAPS2             ddscaps;              // a direct draw surface capabilities struct
HRESULT              ddrval;               // result back from dd calls

USHORT               *double_buffer = NULL; // the double buffer              

// FUNCTIONS //////////////////////////////////////////////

LRESULT CALLBACK WindowProc(HWND hwnd, 
						    UINT msg, 
                            WPARAM wparam, 
                            LPARAM lparam)
{
// this is the main message handler of the system
PAINTSTRUCT	ps;		   // used in WM_PAINT
HDC			hdc;	   // handle to a device context

// what is the message 
switch(msg)
	{	
	case WM_CREATE: 
        {
		// do initialization stuff here
		return(0);
		} break;

    case WM_PAINT:
         {
         // start painting
         hdc = BeginPaint(hwnd,&ps);

         // end painting
         EndPaint(hwnd,&ps);
         return(0);
        } break;

	case WM_DESTROY: 
		{
		// kill the application			
		PostQuitMessage(0);
		return(0);
		} break;

	default:break;

    } // end switch

// process any messages that we didn't take care of 
return (DefWindowProc(hwnd, msg, wparam, lparam));

} // end WinProc

// WINMAIN ////////////////////////////////////////////////

int WINAPI WinMain(	HINSTANCE hinstance,
					HINSTANCE hprevinstance,
					LPSTR lpcmdline,
					int ncmdshow)
{

WNDCLASS winclass;	// this will hold the class we create
HWND	 hwnd;		// generic window handle
MSG		 msg;		// generic message
HDC      hdc;       // generic dc
PAINTSTRUCT ps;     // generic paintstruct

// first fill in the window class stucture
winclass.style			= CS_DBLCLKS | CS_OWNDC | 
                          CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc	= WindowProc;
winclass.cbClsExtra		= 0;
winclass.cbWndExtra		= 0;
winclass.hInstance		= hinstance;
winclass.hIcon			= LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor		= LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName	= NULL; 
winclass.lpszClassName	= WINDOW_CLASS_NAME;

// register the window class
if (!RegisterClass(&winclass))
	return(0);

// create the window, note the use of WS_POPUP
if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME, // class
						  "WinX Game Console",	 // title
						  WS_POPUP | WS_VISIBLE,
					 	  0,0,	   // x,y
						  WINDOW_WIDTH,  // width
                          WINDOW_HEIGHT, // height
						  NULL,	   // handle to parent 
						  NULL,	   // handle to menu
						  hinstance,// instance
						  NULL)))	// creation parms
return(0);

// save the window handle and instance in a global
main_window_handle = hwnd;
main_instance      = hinstance;

// perform all game console specific initialization
Game_Init();

// enter main event loop
while(1)
	{
	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{ 
		// test if this is a quit
        if (msg.message == WM_QUIT)
           break;
	
		// translate any accelerator keys
		TranslateMessage(&msg);

		// send the message to the window proc
		DispatchMessage(&msg);
		} // end if
    
    // main game processing goes here
    Game_Main();

	} // end while

// shutdown game and release all resources
Game_Shutdown();

// return to Windows like this
return(msg.wParam);

} // end WinMain

// WINX GAME PROGRAMMING CONSOLE FUNCTIONS ////////////////

int Game_Init(void *parms)
{
// this function is where you do all the initialization 
// for your game

// create object and test for error
if (DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)!=DD_OK)
   return(0);

// set cooperation level to windowed mode normal
if (lpdd->SetCooperativeLevel(main_window_handle,
           DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN | 
           DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK)
    return(0);

// set the display mode
if (lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,0)!=DD_OK)
   return(0);

// Create the primary surface
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize         = sizeof(ddsd);
ddsd.dwFlags        = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

if (lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL)!=DD_OK)
   return(0);

// allocate memory for the double buffer, notice the SCREEN_BPP/8
// term to take into consideration 16-bit pixels
if ((double_buffer = (USHORT *)malloc(SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8)))==NULL)
   return(0);

// return success
return(1);

} // end Game_Init

///////////////////////////////////////////////////////////

int Game_Shutdown(void *parms)
{
// this function is where you shutdown your game and
// release all resources that you allocated

// first release the primary surface
if (lpddsprimary!=NULL)
   lpddsprimary->Release();
       
// release the directdraw object
if (lpdd!=NULL)
   lpdd->Release();

// free double buffer
if (double_buffer!=NULL)
   free(double_buffer);

// return success
return(1);
} // end Game_Shutdown

///////////////////////////////////////////////////////////

int Game_Main(void *parms)
{
// this is the workhorse of your game it will be called
// continuously in real-time this is like main() in C
// all the calls for you game go here!

USHORT *primary_buffer = NULL, // used to draw
       *dest_ptr       = NULL, // used in line by line copy
       *src_ptr        = NULL; // " "

// check of user is trying to exit
if (KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE))
    PostMessage(main_window_handle, WM_DESTROY,0,0);

// erase double buffer
memset(double_buffer,0, SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8));

// perform game logic...
       

// NONE!!! :)



// copy the double buffer into the primary buffer
memset(&ddsd,0,sizeof(ddsd)); 
ddsd.dwSize = sizeof(ddsd);

// lock the primary surface
lpddsprimary->Lock(NULL,&ddsd, 
              DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);

// get video pointer to primary surfce
primary_buffer = (USHORT *)ddsd.lpSurface;       

// test if memory is linear
if (ddsd.lPitch == SCREEN_WIDTH*(SCREEN_BPP/8))
   {
   // copy memory from double buffer to primary buffer
   memcpy(primary_buffer, double_buffer, SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8));
   } // end if
else
   { // non-linear
   // make copy of source and destination addresses
   dest_ptr = primary_buffer;
   src_ptr = double_buffer;

   // memory is non-linear, copy line by line
   for (int y=0; y<SCREEN_HEIGHT; y++)
       {
       // copy line
       memcpy(dest_ptr, src_ptr, SCREEN_WIDTH*(SCREEN_BPP/8));

       // advance pointers to next line
       // notice division by 2 since lpitch is in bytes and
       // these pointers are USHORT pointers
       // but the screen_width is ok to use on src_ptr
       // since the pointer arithematic will advance the pointer
       // properly
       dest_ptr+=(ddsd.lPitch/2);
       src_ptr+=SCREEN_WIDTH;

       } // end for

   } // end else

// unlock primary buffer
lpddsprimary->Unlock(NULL);

// wait a sec
Sleep(5);

// return success
return(1);
} // end Game_Main

///////////////////////////////////////////////////////////

if (DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)!=DD_OK)
   return(0);

// set cooperation level to windowed mode normal
if (lpdd->SetCooperativeLevel(main_window_handle,
           DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN | 
           DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK)
    return(0);

// set the display mode
if (lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,0)!=DD_OK)
   return(0);

// Create the primary surface
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize         = sizeof(ddsd);
ddsd.dwFlags        = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

if (lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL)!=DD_OK)
   return(0);

// allocate memory for the double buffer, notice the SCREEN_BPP/8
// term to take into consideration 16-bit pixels
if ((double_buffer = (USHORT *)malloc(SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8)))==NULL)
   return(0);

#include <d3d9.h>
#include "d3d9tex.h"

LPDIRECT3D9          g_pD3D         = NULL;
LPDIRECT3D9DEVICE    g_pd3dDevice   = NULL;

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
    // Register the window class.
    WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
                      GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                      "Direct3D Tutorial", NULL };

    RegisterClassEx( &wc );

    // Create the application's window.
    HWND hWnd = CreateWindow( "Direct3D Tutorial", "Direct3D Tutorial 01: CreateDevice",
                              WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
                              GetDesktopWindow(), NULL, wc.hInstance, NULL );

    // The message loop.
    MSG msg;
    while( GetMessage( &msg, NULL, 0, 0 ) )
    {
      TranslateMessage( &msg );
      DispatchMessage( &msg );
    }
}

class CMyD3DApp : public CD3DApp
{
public:
   CMyD3DApp();

private:
   HRESULT ConfirmDevice( D3DCAPS9*, DWORD, D3DFORMAT );
   HRESULT OneTimeInit();
   HRESULT RestoreDeviceObjects();
   HRESULT FrameMove();
   HRESULT Render();

   LPDIRECT3DVERTEXBUFFER9 m_pVB; // VertexBuffer for rendering objects
}

HRESULT CMyD3DApp::OneTimeInit();
{
   //create your objects here
   return S_OK;
}

CMyD3DApp::CMyD3DApp()
{
   //already set by another method but you usually would use this
   // m_strWindowTitle  = _T("Direct3D Example");  // title bar
   m_bUseDepthBuffer = TRUE;                    // maintains basic zbuffer
   m_pVB             = NULL;                    // clear buffer

   // d3d pointer fill
    if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
      return E_FAIL;

    /* the parameters are the global setup
      if you change these then make sure that you also recreate the device
      else they'll do nothing */
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

    // create device
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                       D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                       &d3dpp, &g_pd3dDevice ) ) )
        return E_FAIL;

    D3DBACKBUFFER_TYPE m_d3dBackBuffer;
    ZeroMemory( &m_d3dBackBuffer, sizeof(m_d3dBackBuffer) );
    g_pd3dDevice->GetBackBuffer( NULL, NULL, D3DBACKBUFFER_TYPE_MONO, &m_d3dBackBuffer ); //declare backbuffer
}

HRESULT ConfirmDevice(D3DCAPS9 *pCaps, DWORD dwBehavior,
            D3DFORMAT fmtBackBuffer)
{
   // put in here any special device needs, suchas shader capability check
}

HRESULT CMyD3DApplication::RestoreDeviceObjects()
{
    // Create the vertex buffer... creates buffer size from default pool
    if( FAILED( g_pd3dDevice->CreateVertexBuffer(
                          NUM_VERTS*sizeof(CUSTOMVERTEX),
                          0,
                          D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &m_pVB ) ) )
    {
        return E_FAIL;
    }

    // fills the buffer with render data
    VOID* pVertices;
    if( FAILED( m_pVB->Lock( 0, sizeof(g_Vertices),
     (BYTE**)&pVertices, 0 ) ) )
        return E_FAIL;
    memcpy( pVertices, g_Vertices, sizeof(g_Vertices) );
    m_pVB->Unlock();

    // veiw projection
    D3DXMATRIX matProj;
    FLOAT fAspect = m_d3dBackBuffer.Width / (FLOAT)m_d3dBackBuffer.Height;
    D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, fAspect, 1.0f, 100.0f );
    g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );

    // view matrix
    D3DXMATRIX matView;
    D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3( 0.0f, 1.0f,-4.0f ),
                                  &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
                                  &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
    g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );

    // render defualts
    g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

    return S_OK;
}

HRESULT CMyD3DApplication::FrameMove()
{
    // edit this matrix to alter the current object
    D3DXMATRIX matWorld;
    g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );

    return S_OK;
}

HRESULT CMyD3DApplication::Render()
{
    // clear & set background to black
    g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
      D3DCOLOR_XRGB(0,0,0), 1.0f, 0L );

    // start rendering
    if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
    {
        g_pd3dDevice->SetStreamSource( 0, m_pVB, sizeof(CUSTOMVERTEX) );
        g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
        g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLEFAN, 0, NUM_TRIS );
        g_pd3dDevice->EndScene();
        g_pd3dDevice->Present( NULL, NULL, NULL, NULL ); // sync
    }

    return S_OK;
}

LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
        case WM_DESTROY:
            PostQuitMessage( 0 );
            return 0;

        case WM_PAINT:
            Render();
            ValidateRect( hWnd, NULL );
            return 0;
    }

    return DefWindowProc( hWnd, msg, wParam, lParam );
}

VOID Cleanup()
{
    if( g_pd3dDevice != NULL)
        g_pd3dDevice->Release();
    if( g_pD3D != NULL)
        g_pD3D->Release();
}

#include "allegro.h"

int main() {

	allegro_init();
	set_color_depth(32);
	set_gfx_mode(GFX_AUTODETECT_FULLSCREEN,800,600,0,0);
		
	allegro_exit();	
	return 0;
}
END_OF_MAIN();

Imports System
Imports System.Drawing
Imports System.Windows.Forms
Imports Microsoft.DirectX
Imports Microsoft.DirectX.Direct3D


Namespace DeviceTutorial
    Public Class CreateDevice
        Inherits Form
        ' Our global variables for this project
        Private device As device = Nothing 


        Public Sub New()
            ' Set the initial size of our form
            Me.ClientSize = New System.Drawing.Size(400, 300)
            ' And it's caption
            Me.Text = "D3D Tutorial 01: CreateDevice"
        End Sub 'New


        Public Function InitializeGraphics() As Boolean
            Try
                ' Now let's setup our D3D stuff
                Dim presentParams As New PresentParameters()
                presentParams.Windowed = True
                presentParams.SwapEffect = SwapEffect.Discard
                device = New Device(0, DeviceType.Hardware, Me, CreateFlags.SoftwareVertexProcessing, presentParams)
                Return True
            Catch e As DirectXException
                Return False
            End Try
        End Function 'InitializeGraphics

        Private Sub Render()
            If device Is Nothing Then
                Return
            End If
            'Clear the backbuffer to a blue color
            device.Clear(ClearFlags.Target, System.Drawing.Color.Blue, 1.0F, 0)
            'Begin the scene
            device.BeginScene()

            ' Rendering of scene objects can happen here
            'End the scene
            device.EndScene()
            device.Present()
        End Sub 'Render

        Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
            Me.Render() ' Render on painting
        End Sub 'OnPaint

        Protected Overrides Sub OnKeyPress(ByVal e As System.Windows.Forms.KeyPressEventArgs)
            If Asc(e.KeyChar) = CInt(System.Windows.Forms.Keys.Escape) Then
                Me.Close() ' Esc was pressed
            End If
        End Sub 'OnKeyPress

        Protected Overrides Sub OnLoad(ByVal e As System.EventArgs)
            ' Show and select the form
            Me.Show()
            Me.Select()
        End Sub 'OnLoad


        '<summary>
        'The main entry point for the application.
        '</summary>
        Shared Sub Main()

            Dim frm As New CreateDevice()
            If Not frm.InitializeGraphics() Then ' Initialize Direct3D
                MessageBox.Show("Could not initialize Direct3D.  This tutorial will exit.")
                Return
            End If
            frm.Show()

            While frm.Created
                frm.Render()
                Application.DoEvents()
            End While
        End Sub 'Main

        Private Sub InitializeComponent()

        End Sub
    End Class 'CreateDevice
End Namespace 'DeviceTutorial