Need help - trying to write a basic renderer

[Ikke]

Hi everybody,

As the subject says, I'm trying to write a very basic renderer, but I've
stumbled upon a problem.

Basically, I create a window (1024x768), and draw a small circle on it,
which I then move five pixels to the right every second.

It all works fine (sort of), but as soon as the circle moves, the
background is no longer black, and becomes white. I have absolutely no
idea why - can anybody please shed some light on this?

Here is my code:
--- begin ---
#include <windows.h>

/* Declare Windows procedure */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/* Make the class name into a global variable */
char szClassName[ ] = "CodeBlocksWindowsApp";

int x;
int mov;

int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nCmdShow)
{
HWND hwnd; /* This is the handle for our window */
MSG messages; /* Here messages to the application are
saved */
WNDCLASSEX wincl; /* Data structure for the windowclass */

/* The Window structure */
wincl.hInstance = hThisInstance;
wincl.lpszClassName = szClassName;
wincl.lpfnWndProc = WindowProcedure; /* This function is called
by windows */
wincl.style = CS_DBLCLKS; /* Catch double-clicks */
wincl.cbSize = sizeof (WNDCLASSEX);

/* Use default icon and mouse-pointer */
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
wincl.lpszMenuName = NULL; /* No menu */
wincl.cbClsExtra = 0; /* No extra bytes after
the window class */
wincl.cbWndExtra = 0; /* structure or the window
instance */
/* Use Windows's default colour as the background of the window */
wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

/* Register the window class, and if it fails quit the program */
if (!RegisterClassEx (&wincl))
return 0;

/* The class is registered, let's create the program*/
hwnd = CreateWindowEx (
0, /* Extended possibilites for variation */
szClassName, /* Classname */
"Code::Blocks Template Windows App", /* Title Text */
WS_OVERLAPPEDWINDOW, /* default window */
CW_USEDEFAULT, /* Windows decides the position */
CW_USEDEFAULT, /* where the window ends up on the screen
*/
1024, /* The programs width */
768, /* and height in pixels */
HWND_DESKTOP, /* The window is a child-window to
desktop */
NULL, /* No menu */
hThisInstance, /* Program Instance handler */
NULL /* No Window Creation data */
);

/* Make the window visible on the screen */
ShowWindow (hwnd, nCmdShow);

int tick;
int delta = GetTickCount();

x = 100;
mov = 5;

MSG msg; /* Here messages to the application are
saved */
// Clear out the message structure
ZeroMemory(&msg, sizeof(MSG));

while (msg.message != WM_QUIT)
{
// Check to see if any messages are waiting in the queue
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// Translate the message and dispatch it to WindowProc()
TranslateMessage(&msg);
DispatchMessage(&msg);
}

InvalidateRect (hwnd, NULL, TRUE);
UpdateWindow (hwnd); // This will call your WM_PAINT response

tick = GetTickCount();
if (tick > (delta + 1000))
{
x += mov;
delta = tick;
}
}

/* The program return-value is 0 - The value that PostQuitMessage()
gave */
return messages.wParam;
}


/* This function is called by the Windows function DispatchMessage() */
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam,
LPARAM lParam)
{
switch (message) /* handle the messages */
{
case WM_PAINT:
{
HDC hdc;
PAINTSTRUCT ps;
hdc = BeginPaint(hwnd, &ps);

// black out the background
HBRUSH blackBrush = CreateSolidBrush(RGB(0, 0, 0));

RECT rct;
rct.left=0;
rct.right=1024;
rct.top=0;
rct.bottom=768;

FillRect(hdc, &rct, blackBrush);

// Draw a white ellipse
HPEN whitePen = CreatePen(PS_SOLID, 1, RGB(0, 255, 0));
SelectObject(hdc, whitePen);
Ellipse(hdc, (int) x - 10, (int) 100 - 10, (int) x + 10, (int)
100 + 10);

EndPaint(hwnd, &ps);
return 0;
}

case WM_ERASEBKGND:
{
// Prevent the background from being erased prior to calling
WM_PAINT
return 1;
}

case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message
queue */
break;
default: /* for messages that we don't deal
with */
return DefWindowProc (hwnd, message, wParam, lParam);
}

return 0;
}
--- end ---

The application also suffers a lot from "flicker", I know - I've found
some resources on double buffering and, while they help, I left them out
of the example to simplify it.

Any help, ideas and suggestions are really appreciated!!

Thanks,

Ikke

 

[red floyd]

[off topic redacted]

Your question involves "how do I use the Win32 API properly?", and
as such, the answer can be found in the FAQ. Please see FAQ 5.9.

http://www.parashift.com/c++-faq-lite/how-to-post.html#faq-5.9

 

[Michael Doubez]

[off topic redacted]

Your question involves "how do I use the Win32 API properly?", and
as such, the answer can be found in the FAQ.  Please see FAQ 5.9.

http://www.parashift.com/c++-faq-lite/how-to-post.html#faq-5.9

I've checked the FAQ, and there's no mention of either Win32 nor API,
that's why I asked here.

AFAIS the link to FAQ 5.9 gives you a list of USENET group that might
best fit your demand (in particular comp.os.ms-
windows.programmer.misc)

It would have been a lot nicer if you'd just mentioned the correct group to
post this question in - it would have saved time for the both  of us.

I don't see why he would take the time to select the group that might
answer your question when you didn't.

Your question might be related to win32 but also to graphic
programming or something else.

Frankly, "sod off" would have been more helpful.

But it would have been less instructive: now you know this group is
for C++ language question only and that there are numerous group from
which you can find experts (in their own domain).