First of all: you need pointers to do any complex programming. Learn them well before you start on real game programming. They become really easy to use, don''t worry about how hard they seem at first.

Next: Learn the Win32 API. You probably want to find your way around it (you don''t need to memorize all of it or anything) before using it in your games. Once you''re familiar with it, learn OpenGL or DirectX.

Some tutorials:
http://www.winprog.org (Win32 API)
http://nehe.gamedev.net (OpenGL)

[Resist Windows XP''s Invasive Production Activation Technology!]

Ahhhh well I wasn''t sure if he was calling DX8 SDK a compiler or saying that he downloaded the SDK AND a new compiler... *shrug*

But in actuality you don''t need VC to program DirectX it will work on any 32-bit C++ compiler as long as you link to the proper libraries and include the proper headers. I think some older versions will work on a 16-bit compiler too. That is not part of the MS monopoly... I will stay out of an imminent flamewar by not stating my choice though... lol

Seeya
Krippy

How DOES one plot a pixel anyway with GDI? I''ve been fooling around with drawing functions, BitBlt, etc., but I can''t figure out how to do anything myself. I''ve been trying to use DIB Sections, but I don''t really know how. I''ve been reading the VC++ help, which actually is helpful, but still haven''t been able figure it out. So does anyone have any resources I could turn to to figure out how?

Utwo, try the allegro game programming library.It does the graphics for you and lots more.There are a lot of examples that come with the library. You can even write windows programs using the old dos coding style.Consider this example program for plotting a pixel :-).

#include //header for pixel-plotting,...
#include
int main()
{
allegro_init(); //initialize the library
set_gfx_mode(GFX_AUTODETECT,640,480,0,0);
/*Finally the most important thing here :-)*/
/*Fill your screen with different pixel-colors*/
for(int i=0;i<640;i++)
{
for(int k=0;k<480;k++)
{
putpixel(screen,i,k,rand()%255);
}
}
....
return 0;
}
END_OF_MAIN();

you can find this library and a lot of games at www.allegro.cc

Using Allegro, while a perfectly valid approach, doesn't answer his question or increase his knowledge. To plot a pixel using plain, vanilla Win32, you need to understand windows (not Windows).

Windows (the OS) represents interactive elements using windows (the constructs). The include file windows.h defines a ton of structures and data types (some included from other include files, and so on). One of the most important of them is a structure called an HWND. An HWND is th code "handle" to a graphical window. Another important one is an HDC, the handle to a Device Context. Every visible window has a device context, which is what you actually draw on.

I'm going to provide very skeletal function declarations here as you can check up the full documentation at msdn.microsoft.com for free. To create a Windows application (I'm sure you already know this, but bear with me), you include windows.h and define the already declared WinMain(...) function. Within your WinMain() you either directly or indirectly (such as through a call to another function of our own) declare and define a window class:

WNDCLASSEX wc;

Fill out the fields with appropriate values and then register the class with Windows. Note that I am omitting every single parameter to every single function!

RegisterClassEx(...);

If this is succesful, you can now create a window (the structure):

HWND hwnd = CreateWindow(...);

You then need to set up a message pump for your window. Windows (the OS) communicates to every running application's windows via messages which tell the app whether the user has clicked the mouse (and which button or buttons) in the window, and so on.

MSG msg;while( GetMessage(...) ){  TranslateMessage();  DispatchMessage();}   

You then end your WinMain() function with a return value, or error processing. This is just a skeletal WinMain(). You now have to define the already declared window procedure function, which you would have specified to the window class (see WNDCLASSEX). It is in this window procedure that you handle messages, such as the one that tell you to redraw your window - WM_PAINT.

LRESULT CALLBACK WndProc(...){  ...  if( msg == WM_PAINT )  {    // do your drawing here  }  ...}   

Since most people like to keep their programs modular, common practice is to do the actual drawing in another function that you'd call from within that if-block above (let's call it OnPaint, for MFC reasons). Within this function you need to get access to your window's device context, create a graphical drawing object and then plot your pixel.

HRESULT OnPaint(...){  // get the window's device context  static HDC paintdc = GetDC( hwnd );  // get a pen to draw with; we'll use a 'stock" pen  HPEN hpen = GetStockObject( WHITE_PEN );  // when we select our object as the current drawing object, it   // returns a pointer to the previous object, which we should  // save so we can restore it when we're done  HPEN hOldPen = SelectObject( hpen );  BeginPaint(...);    // plot your pixel here    MoveTo( &paintdc, x, y, NULL );    LineTo( &paintdc, x, y );  EndPaint(...);}   

That's a simplistic example. There are complete descriptions of all functions, explanations and samples at msdn.microsoft.com, and if you don't have the MSDN Library CD (which I guess you don't, since you se Dev-C++), that should be your best friend while you do Windows programming.


People who can't do shit, talk.
-Dwight Yorke, Manchester United

Edited by - Oluseyi on July 9, 2001 4:56:38 AM

Edited by - Oluseyi on July 9, 2001 4:58:17 AM