[winApi]problem z mgłą

Problem jest następujący:
chciałbym utworzyć w trójwymiarowym pokoju, napisanym za pomocą biblioteki windows, mgłę, która pozniej zostanie oświetlona kilkoma lampami. Problem w tym że już mi pomysłów brakuje. Czy wie ktoś moze w jaki sposób zrealizować takie zadanie. Mgła nie musi być koniecznie zrobiona tylko za pomocą <windows.h>, ale jeśli ktoś wie jak to zrobić z inna biblioteką i połączyć z juz napisanym kodem to prosze o pomoc.

#include <windows.h>
#include <math.h>

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR szCmdLine, int iCmdShow)
{
static TCHAR szAppName[] = TEXT ("HelloWin") ;
HWND hwnd ;
MSG msg ;
WNDCLASS wndclass ;

wndclass.style = CS_HREDRAW | CS_VREDRAW ;
wndclass.lpfnWndProc = WndProc ;
wndclass.cbClsExtra = 0 ;
wndclass.cbWndExtra = 0 ;
wndclass.hInstance = hInstance ;
wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION) ;
wndclass.hCursor = LoadCursor (NULL, IDC_ARROW) ;
wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
wndclass.lpszMenuName = NULL ;
wndclass.lpszClassName = szAppName ;

if (!RegisterClass (&wndclass))
{
MessageBox (NULL, TEXT ("This program requires Windows NT!"),
szAppName, MB_ICONERROR) ;
return 0 ;
}

hwnd = CreateWindow (szAppName, // window class name
TEXT ("The Hello Program"), // window caption
WS_OVERLAPPEDWINDOW, // window style
CW_USEDEFAULT, // initial x position
CW_USEDEFAULT, // initial y position
CW_USEDEFAULT, // initial x size
CW_USEDEFAULT, // initial y size
NULL, // parent window handle
NULL, // window menu handle
hInstance, // program instance handle
NULL) ; // creation parameters

ShowWindow (hwnd, iCmdShow) ;
UpdateWindow (hwnd) ;

while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
}
return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static int cxClient, cyClient;
HDC hdc;
PAINTSTRUCT ps ;
HBRUSH sciany, podloga1, drzwi1, klamka, okno1m, ramka_ok1a, okno2n,
ramka_ok2a;
HPEN hPen;
//sciany
POINT lewa_sciana[5] = {0,0, 8*cxClient/16,2*cyClient/6,
8*cxClient/16,5*cyClient/6, 0,cyClient, 0, 0};

POINT prawa_sciana[5] = {cxClient,0, 7*cxClient/8,2*cyClient/6,
7*cxClient/8,5*cyClient/6, cxClient,cyClient, cxClient,0 };

POINT srodkowa_sciana[5] = {8*cxClient/16,2*cyClient/6, 7*cxClient/8,2*cyClient/6,
7*cxClient/8,5*cyClient/6, 8*cxClient/16,5*cyClient/6,8*cxClient/16,2*cyClient/6 };

//podloga
POINT podloga[5] = {0,cyClient, 8*cxClient/16,5*cyClient/6,
7*cxClient/8,5*cyClient/6, cxClient,cyClient, 0,cyClient};

//drzwi
POINT drzwi[5] = { 14*cxClient/20,5*cyClient/6, 14*cxClient/20,8*cyClient/16,
8*cxClient/14,8*cyClient/16, 8*cxClient/14,5*cyClient/6, 14*cxClient/20,5*cyClient/6};

//okno1
POINT okno1[5] = { 13*cxClient/36,5*cyClient/14, 10*cxClient/36,9*cyClient/28,
10*cxClient/36,18*cyClient/28, 13*cxClient/36,9*cyClient/14, 13*cxClient/36,5*cyClient/14};

//ramka okna1
POINT ramka_ok1[5] = { 25*cxClient/72,21*cyClient/56, 20*cxClient/72,197*cyClient/560,
20*cxClient/72,705*cyClient/1120, 25*cxClient/72,71*cyClient/112, 25*cxClient/72,21*cyClient/56};

//okno2
POINT okno2[5] = { 8*cxClient/36,4*cyClient/14, 2*cxClient/36,55*cyClient/280,
2*cxClient/36,18*cyClient/28, 8*cxClient/36,9*cyClient/14, 8*cxClient/36,4*cyClient/14};

//ramka okna2
POINT ramka_ok2[5] = { 14*cxClient/72,18*cyClient/56, 4*cxClient/72,15*cyClient/56,
4*cxClient/72,69*cyClient/112, 14*cxClient/72,70*cyClient/112, 14*cxClient/72,18*cyClient/56};

switch (message)
{

case WM_SIZE:
cxClient = LOWORD (lParam);
cyClient = HIWORD (lParam);

return 0;

case WM_PAINT:
hdc= BeginPaint (hwnd, &ps) ;
/*----------------------------------------------------------------------------*/

//rysowanie scian
sciany = CreateSolidBrush (RGB(222, 253, 202));
SelectObject(hdc, sciany);
Polygon(hdc, lewa_sciana, 5);
Polygon(hdc, prawa_sciana, 5);
Polygon(hdc, srodkowa_sciana, 5);

/*----------------------------------------------------------------------------*/

//rysowanie podlogi
SetBkColor(hdc, RGB(122,134,41));
podloga1 = CreateHatchBrush(HS_FDIAGONAL, RGB(22,34,41));

SelectObject(hdc, podloga1);
Polygon(hdc, podloga, 5);

//rysowanie drzwi
drzwi1 = CreateSolidBrush (RGB(208,209,123));
SelectObject(hdc, drzwi1);
Polygon(hdc, drzwi, 5);

//rysowanie klamki
klamka = CreateSolidBrush (RGB(228, 50, 203));
SelectObject(hdc, klamka);
Ellipse(hdc,12*cxClient/20 , 21*cyClient/32, 65*cxClient/112 , 109*cyClient/160 );

/*----------------------------------------------------------------------------*/

//rysowanie okna1
okno1m = CreateSolidBrush (RGB(157, 134, 53));
SelectObject(hdc, okno1m);
Polygon(hdc, okno1, 5);
//ramka okna1
ramka_ok1a = CreateSolidBrush (RGB(166, 200, 240));
SelectObject(hdc, ramka_ok1a);
Polygon(hdc, ramka_ok1, 5);

MoveToEx(hdc, 13*cxClient/36,5*cyClient/14, NULL);
LineTo(hdc, 25*cxClient/72,21*cyClient/56);

MoveToEx(hdc, 13*cxClient/36,9*cyClient/14, NULL);
LineTo(hdc,25*cxClient/72,71*cyClient/112);

/*----------------------------------------------------------------------------*/
//rysowanie okna2
okno2n = CreateSolidBrush (RGB(157, 134, 53));
SelectObject(hdc, okno2n);
Polygon(hdc, okno2, 5);

//ramka okna2
ramka_ok2a = CreateSolidBrush (RGB(166, 200, 240));
SelectObject(hdc, ramka_ok2a);
Polygon(hdc, ramka_ok2, 5);

MoveToEx(hdc, 8*cxClient/36,4*cyClient/14, NULL);
LineTo(hdc, 14*cxClient/72,18*cyClient/56);

MoveToEx(hdc, 8*cxClient/36,9*cyClient/14, NULL);
LineTo(hdc,14*cxClient/72,70*cyClient/112);

/*---------------------------------------------------------------------------*/

EndPaint (hwnd, &ps) ;
return 0 ;

case WM_DESTROY:
DeleteObject(sciany);
DeleteObject(podloga1);
DeleteObject(drzwi1);
DeleteObject(okno1);
DeleteObject(ramka_ok1a);
DeleteObject(okno2);
DeleteObject(ramka_ok2a);
DeleteObject(hPen);
PostQuitMessage (0) ;

return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}

Oto rozwiazanie:

OpenGL lub DirectX :-)

Witam...
Jeśli chcesz zrobić tę mgłę z wykorzystaniem samego pliku windows.h to będziesz się musiał nagimnastykować, no i potem oświetlić..?? nie no nie ma sensu. Ja polecałbym OpenGl, które może współgrać z kodem napisanym w c++ i winapi. Tam również wygodniej narysujesz pokój 3D.
Jest wiele stron opisujących tworzenie mgły właśnie w OpenGl, np. z opengl.pl możesz sciągnąć przykład wyświetlający sześcian i mgłę. Jednak jak chcesz użyć opengl musisz się zaopatrzyć w odpowiednie biblioteki...

Pozdrawiam

Mgła za pomocą windows.h - nóż w kieszeni się otwiera!!!
Bo przypuśćmy, że udało ci się to zrobić (bo to nie jest aż takie trudne) ale co dalej, gdzie tekstury, światła, obroty, translację, animacje itd. Trochę się rozpędziełem, choć tak naprawdę nie wiem, co chcesz zrobić. Twój projekt jest statyczny i jeśli taki ma być to najłatwiej było by otworzyć 3DS Maxa, narysuj to sobie, zapisz do JPEG'a i wio. Jeśli jednak scena ma być dynamiczna, to nawet gdybyś przebrnął przez to całe kodowanie to i tak całość była by .... wolna. Dlatego weź sobie poczytaj o OpenGL'u (łatwiejszy) lub DirectX. OpenGL nie jest trudny, wystarczy znaleźć szkielet, a resztę sobie łatwo wpiszesz.