Konfiguracja Projektu OpenGL glaux

#define WIN32_LEAN_AND_MEAN     // "odchudza" aplikacjê Windows

/*****************************************************

 Chapter 5: Przyk³ad animacji robota

 Programowanie gier w OpenGL
 Kevin Hawkins, Dave Astle


******************************************************/

////// Pliki nag³ówkowe
#include <windows.h>      // standardowy plik nag³ówkowy Windows
#include <GL/gl.h>       // standardowy  plik nag³ówkowy OpenGL
#include <GL/glu.h>       // plik nag³ówkowy biblioteki GLU
#include <GL/glaux.h>      // plik nag³ówkowy pomocniczych funkcji OpenGL

////// Zmenne globalne
float angle = 0.0f; // bie¿¹cy k¹t obrotu kamery
HDC g_HDC; // kontekst urz¹dzenia
bool fullScreen = false;


////// Zmienne robota
float legAngle[ 2 ] = { 0.0f, 0.0f }; // bie¿¹ce k¹ty obrotu nóg i ramion
float armAngle[ 2 ] = { 0.0f, 0.0f };

// DrawCube
// opis: poniewa¿ ka¿dy element robota powstaje przez przekszta³cenie szeœcianu,
//       to do rysowania szeœcianu w danym punkcie bêdziemy u¿ywaæ tej funkcji.

void DrawCube( float xPos, float yPos, float zPos )
{
    glPushMatrix();
    glTranslatef( xPos, yPos, zPos );
    glBegin( GL_POLYGON );
    glVertex3f( 0.0f, 0.0f, 0.0f ); // górna œciana
    glVertex3f( 0.0f, 0.0f, - 1.0f );
    glVertex3f( - 1.0f, 0.0f, - 1.0f );
    glVertex3f( - 1.0f, 0.0f, 0.0f );
    glVertex3f( 0.0f, 0.0f, 0.0f ); // przednia œciana
    glVertex3f( - 1.0f, 0.0f, 0.0f );
    glVertex3f( - 1.0f, - 1.0f, 0.0f );
    glVertex3f( 0.0f, - 1.0f, 0.0f );
    glVertex3f( 0.0f, 0.0f, 0.0f ); // œciana po prawej
    glVertex3f( 0.0f, - 1.0f, 0.0f );
    glVertex3f( 0.0f, - 1.0f, - 1.0f );
    glVertex3f( 0.0f, 0.0f, - 1.0f );
    glVertex3f( - 1.0f, 0.0f, 0.0f ); // œciana po lewej
    glVertex3f( - 1.0f, 0.0f, - 1.0f );
    glVertex3f( - 1.0f, - 1.0f, - 1.0f );
    glVertex3f( - 1.0f, - 1.0f, 0.0f );
    glVertex3f( 0.0f, 0.0f, 0.0f ); // dolna œciana
    glVertex3f( 0.0f, - 1.0f, - 1.0f );
    glVertex3f( - 1.0f, - 1.0f, - 1.0f );
    glVertex3f( - 1.0f, - 1.0f, 0.0f );
    glVertex3f( 0.0f, 0.0f, 0.0f ); // tylnia œciana
    glVertex3f( - 1.0f, 0.0f, - 1.0f );
    glVertex3f( - 1.0f, - 1.0f, - 1.0f );
    glVertex3f( 0.0f, - 1.0f, - 1.0f );
    glEnd();
    glPopMatrix();
}

// DrawArm
// opis: rysuje pojedyncze ramiê robota
void DrawArm( float xPos, float yPos, float zPos )
{
    glPushMatrix();
    glColor3f( 1.0f, 0.0f, 0.0f ); // kolor czerwony
    glTranslatef( xPos, yPos, zPos );
    glScalef( 1.0f, 4.0f, 1.0f ); // ramiê jest prostopad³oœcianem 1x4x1
    DrawCube( 0.0f, 0.0f, 0.0f );
    glPopMatrix();
}

// DrawHead
// opis: rysuje g³owê robota
void DrawHead( float xPos, float yPos, float zPos )
{
    glPushMatrix();
    glColor3f( 1.0f, 1.0f, 1.0f ); // kolor bia³y
    glTranslatef( xPos, yPos, zPos );
    glScalef( 2.0f, 2.0f, 2.0f ); // g³owa jest szeœcianem 2x2x2
    DrawCube( 0.0f, 0.0f, 0.0f );
    glPopMatrix();
}

// DrawTorso
// opis: rysuje korpus robota
void DrawTorso( float xPos, float yPos, float zPos )
{
    glPushMatrix();
    glColor3f( 0.0f, 0.0f, 1.0f ); // kolor niebieski
    glTranslatef( xPos, yPos, zPos );
    glScalef( 3.0f, 5.0f, 2.0f ); // korpus jest prostopad³oœcianem 3x5x2
    DrawCube( 0.0f, 0.0f, 0.0f );
    glPopMatrix();
}

// DrawLeg
// opis: rysuje pojedyncz¹ nogê robota
void DrawLeg( float xPos, float yPos, float zPos )
{
    glPushMatrix();
    glColor3f( 1.0f, 1.0f, 0.0f ); // kolor ¿ó³ty
    glTranslatef( xPos, yPos, zPos );
    glScalef( 1.0f, 5.0f, 1.0f ); // noga jest prostopad³oœcianem 1x5x1
    DrawCube( 0.0f, 0.0f, 0.0f );
    glPopMatrix();
}

// DrawRobot
// opis: rysuje model robota w punkcie (xpos,ypos,zpos)
void DrawRobot( float xPos, float yPos, float zPos )
{
    static bool leg1 = true; // zmienne okreœlaj¹ce po³o¿enie nóg i ramion
    static bool leg2 = false; // true = przednie, false = tylnie
   
    static bool arm1 = true;
    static bool arm2 = false;
   
    glPushMatrix();
   
    glTranslatef( xPos, yPos, zPos ); // rysuje model robota w okreœlonym punkcie
   
    // rysuje elementy robota
    DrawHead( 1.0f, 2.0f, 0.0f );
    DrawTorso( 1.5f, 0.0f, 0.0f );
    glPushMatrix();
    // w zale¿noœci od po³o¿enia ramienia zwiêksza lub zmniejsza jego k¹t
    if( arm1 )
         armAngle[ 0 ] = armAngle[ 0 ] + 0.1f;
    else
         armAngle[ 0 ] = armAngle[ 0 ] - 0.1f;
   
    // jeœli ramiê osiagnê³o maksymalny k¹t,
    // to zmienia kierunek
    if( armAngle[ 0 ] >= 15.0f )
         arm1 = false;
   
    if( armAngle[ 0 ] <= - 15.0f )
         arm1 = true;
   
    // przesuwa ramiê i obraca je w celu uzyskania efektu ruchu
    glTranslatef( 0.0f, - 0.5f, 0.0f );
    glRotatef( armAngle[ 0 ], 1.0f, 0.0f, 0.0f );
    DrawArm( 2.5f, 0.0f, - 0.5f );
    glPopMatrix();
   
    glPushMatrix();
    // jeœli ramiê porusza siê do przodu, zwiêksza k¹t
    // w przeciwnym razie zmniejsza
    if( arm2 )
         armAngle[ 1 ] = armAngle[ 1 ] + 0.1f;
    else
         armAngle[ 1 ] = armAngle[ 1 ] - 0.1f;
   
    // jeœli ramiê osiagnê³o maksymalny k¹t,
    // to zmienia kierunek
    if( armAngle[ 1 ] >= 15.0f )
         arm2 = false;
   
    if( armAngle[ 1 ] <= - 15.0f )
         arm2 = true;
   
    // przesuwa ramiê i obraca je w celu uzyskania efektu ruchu  
    glTranslatef( 0.0f, - 0.5f, 0.0f );
    glRotatef( armAngle[ 1 ], 1.0f, 0.0f, 0.0f );
    DrawArm( - 1.5f, 0.0f, - 0.5f );
    glPopMatrix();
   
    //DrawArm(-1.5f, 0.0f, -0.5f);
   
    // nogi poruszamy wzglêdem korpusu robota
    // noga 1, czyli prawa noga robota
    glPushMatrix();
   
    // w zale¿noœci od po³o¿enia nogi zwiêksza lub zmniejsza k¹t  
    if( leg1 )
         legAngle[ 0 ] = legAngle[ 0 ] + 0.1f;
    else
         legAngle[ 0 ] = legAngle[ 0 ] - 0.1f;
   
    // jeœli noga osiagnê³a maksymalny k¹t,
    // to zmienia kierunek
    if( legAngle[ 0 ] >= 15.0f )
         leg1 = false;
   
    if( legAngle[ 0 ] <= - 15.0f )
         leg1 = true;
   
    // przesuwa nogê i obraca j¹ w celu uzyskania efektu ruchu   // przesuwa nogê i obraca j¹ w celu uzyskania efektu ruchu  
    glTranslatef( 0.0f, - 0.5f, 0.0f );
    glRotatef( legAngle[ 0 ], 1.0f, 0.0f, 0.0f );
   
    // rysuje nogê
    DrawLeg( - 0.5f, - 5.0f, - 0.5f );
   
    glPopMatrix();
   
    // to samo dla nogi, lewej nogi robota
    glPushMatrix();
   
    if( leg2 )
         legAngle[ 1 ] = legAngle[ 1 ] + 0.1f;
    else
         legAngle[ 1 ] = legAngle[ 1 ] - 0.1f;
   
    if( legAngle[ 1 ] >= 15.0f )
         leg2 = false;
   
    if( legAngle[ 1 ] <= - 15.0f )
         leg2 = true;
   
    glTranslatef( 0.0f, - 0.5f, 0.0f );
    glRotatef( legAngle[ 1 ], 1.0f, 0.0f, 0.0f );
    DrawLeg( 1.5f, - 5.0f, - 0.5f );
   
    glPopMatrix();
    glPopMatrix();
}


// Render
// opis: rysuje scenê
void Render()
{
    glEnable( GL_DEPTH_TEST ); // w³¹cza testowanie g³êbi
   
    // do rendering here
    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); // kolor czarny
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // opró¿nia bufoy ekranu i g³êbi
    glLoadIdentity(); // resetuje macierz modelowania
   
    angle = angle + 0.05f; // zwiêksza k¹t kamery
    if( angle >= 360.0f ) // jeœli okr¹¿y³a obiekt, to zeruje licznik
         angle = 0.0f;
   
    glPushMatrix(); // odk³ada bie¿¹c¹ macierz na stos
    glLoadIdentity(); // resetuje macierz
    glTranslatef( 0.0f, 0.0f, - 30.0f ); // przesuniêcie do punktu (0, 0, -30)
    glRotatef( angle, 0.0f, 1.0f, 0.0f ); // obrót robota wzglêdem osi y
    DrawRobot( 0.0f, 0.0f, 0.0f ); // rysuje robota
    glPopMatrix(); // usuwa bie¿¹c¹ macierz
   
    glFlush();
   
    SwapBuffers( g_HDC ); // prze³¹cza bufory
}

// funkcja okreœlaj¹ca format pikseli
void SetupPixelFormat( HDC hDC )
{
    int nPixelFormat; // indeks formatu pikseli
   
    static PIXELFORMATDESCRIPTOR pfd = {
        sizeof( PIXELFORMATDESCRIPTOR ), // rozmiar struktury
        1, // domyœlna wersja
        PFD_DRAW_TO_WINDOW | // grafika w oknie
        PFD_SUPPORT_OPENGL | // grafika OpenGL
        PFD_DOUBLEBUFFER, // podwójne buforowanie
        PFD_TYPE_RGBA, // tryb kolorów RGBA
        32, // 32-bitowy opis kolorów
        0, 0, 0, 0, 0, 0, // nie specyfikuje bitów kolorów
        0, // bez buforu alfa
        0, // nie specyfikuje bitu przesuniêcia
        0, // bez bufora akumulacji
        0, 0, 0, 0, // ignoruje bity akumulacji
        16, // 16-bit bufor z
        0, // bez bufora powielania
        0, // bez buforów pomocniczych
        PFD_MAIN_PLANE, // g³ówna p³aszczyzna rysowania
        0, // zarezerwowane
        0, 0, 0 }; // ingoruje maski warstw
   
    nPixelFormat = ChoosePixelFormat( hDC, & pfd ); // wybiera najbardziej zgodny format pikseli
   
    SetPixelFormat( hDC, nPixelFormat, & pfd ); // okreœla format pikseli dla danego kontekstu urz¹dzenia
}

// procedura okienkowa
LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    static HGLRC hRC; // kontekst tworzenia grafiki
    static HDC hDC; // kontekst urz¹dzenia
    int width, height; // szerokoœæ i wysokoœæ okna
   
    switch( message )
    {
    case WM_CREATE: // okno jest tworzone
       
        hDC = GetDC( hwnd ); // pobiera kontekst urz¹dzenia dla okna
        g_HDC = hDC;
        SetupPixelFormat( hDC ); // wywo³uje funkcjê okreœlaj¹c¹ format pikseli
       
        // tworzy kontekst tworzenia grafiki i czyni go bie¿¹cym
        hRC = wglCreateContext( hDC );
        wglMakeCurrent( hDC, hRC );
       
        return 0;
        break;
       
    case WM_CLOSE: // okno jest zamykane
       
        // deaktywuje bie¿¹cy kontekst tworzenia grafiki i usuwa go
        wglMakeCurrent( hDC, NULL );
        wglDeleteContext( hRC );
       
        // wstawia komunikat WM_QUIT do kolejki
        PostQuitMessage( 0 );
       
        return 0;
        break;
       
    case WM_SIZE:
        height = HIWORD( lParam ); // pobiera nowe rozmiary okna
        width = LOWORD( lParam );
       
        if( height == 0 ) // unika dzielenia przez 0
        {
            height = 1;
        }
       
        glViewport( 0, 0, width, height ); // nadaje nowe wymairy oknu OpenGL
        glMatrixMode( GL_PROJECTION ); // wybiera macierz rzutowania
        glLoadIdentity(); // resetuje macierz rzutowania
       
        // wyznacza proporcje obrazu
        gluPerspective( 54.0f,( GLfloat ) width /( GLfloat ) height, 1.0f, 1000.0f );
       
        glMatrixMode( GL_MODELVIEW ); // wybiera macierz modelowania
        glLoadIdentity(); // resetuje macierz modelowania
       
        return 0;
        break;
       
        default:
        break;
    }
   
    return( DefWindowProc( hwnd, message, wParam, lParam ) );
}

// punkt, w którym rozpoczyna siê wykonywanie aplikacji
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd )
{
    WNDCLASSEX windowClass; // klasa okna
    HWND hwnd; // uchwyt okna
    MSG msg; // komunikat
    bool done; // znacznik zakoñczenia aplikacji
    DWORD dwExStyle; // rozszerzony styl okna
    DWORD dwStyle; // styl okna
    RECT windowRect;
   
    // zmienne pomocnicze
    int width = 800;
    int height = 600;
    int bits = 32;
   
    //fullScreen = TRUE;
   
    windowRect.left =( long ) 0; // struktura okreœlaj¹ca rozmiary okna
    windowRect.right =( long ) width;
    windowRect.top =( long ) 0;
    windowRect.bottom =( long ) height;
   
    // definicja klasy okna
    windowClass.cbSize = sizeof( WNDCLASSEX );
    windowClass.style = CS_HREDRAW | CS_VREDRAW;
    windowClass.lpfnWndProc = WndProc;
    windowClass.cbClsExtra = 0;
    windowClass.cbWndExtra = 0;
    windowClass.hInstance = hInstance;
    windowClass.hIcon = LoadIcon( NULL, IDI_APPLICATION ); // domyœlna ikona
    windowClass.hCursor = LoadCursor( NULL, IDC_ARROW ); // domyœlny kursor
    windowClass.hbrBackground = NULL; // bez t³a
    windowClass.lpszMenuName = NULL; // bez menu
    windowClass.lpszClassName = L"MojaKlasa";
    windowClass.hIconSm = LoadIcon( NULL, IDI_WINLOGO ); // logo Windows
   
    // rejestruje klasê okna
    if( !RegisterClassEx( & windowClass ) )
         return 0;
   
    if( fullScreen ) // tryb pe³noekranowy?
    {
        DEVMODE dmScreenSettings; // tryb urz¹dzenia
        memset( & dmScreenSettings, 0, sizeof( dmScreenSettings ) );
        dmScreenSettings.dmSize = sizeof( dmScreenSettings );
        dmScreenSettings.dmPelsWidth = width; // szerokoœæ ekranu
        dmScreenSettings.dmPelsHeight = height; // wysokoœæ ekranu
        dmScreenSettings.dmBitsPerPel = bits; // bitów na piksel
        dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
       
        //
        if( ChangeDisplaySettings( & dmScreenSettings, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
        {
            // prze³¹czenie trybu nie powiod³o siê, z powrotem tryb okienkowy
            MessageBox( NULL, L"Prze³¹czenie trybu wyswietlania nie powiod³o siê", NULL, MB_OK );
            fullScreen = FALSE;
        }
    }
   
    if( fullScreen ) // tryb pe³noekranowy?
    {
        dwExStyle = WS_EX_APPWINDOW; // rozszerzony styl okna
        dwStyle = WS_POPUP; // styl okna
        ShowCursor( FALSE ); // ukrywa kursor myszy
    }
    else
    {
        dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // definicja klasy okna
        dwStyle = WS_OVERLAPPEDWINDOW; // styl okna
    }
   
    AdjustWindowRectEx( & windowRect, dwStyle, FALSE, dwExStyle ); // koryguje rozmiar okna
   
    // tworzy okno
    hwnd = CreateWindowEx( NULL, // rozszerzony styl okna
    L"MojaKlasa", // nazwa klasy
    L"Model robota w OpenGL", // nazwa aplikacji
    dwStyle | WS_CLIPCHILDREN |
    WS_CLIPSIBLINGS,
    0, 0, // wspó³rzêdne x,y
    windowRect.right - windowRect.left,
    windowRect.bottom - windowRect.top, // szerokoœæ, wysokoœæ
    NULL, // uchwyt okna nadrzêdnego
    NULL, // uchwyt menu
    hInstance, // instancja aplikacji
    NULL ); // bez dodatkowych parametrów
   
    // sprawdza, czy utworzenie okna nie powiod³o siê (wtedy wartoœæ hwnd równa NULL)
    if( !hwnd )
         return 0;
   
    ShowWindow( hwnd, SW_SHOW ); // wyœwietla okno
    UpdateWindow( hwnd ); // aktualizuje okno
   
    done = false; // inicjuje zmienn¹ warunku pêtli
   
    // pêtla przetwarzania komunikatów
    while( !done )
    {
        PeekMessage( & msg, hwnd, NULL, NULL, PM_REMOVE );
       
        if( msg.message == WM_QUIT ) // aplikacja otrzyma³a komunikat WM_QUIT?
        {
            done = true; // jeœli tak, to koñczy dzia³anie
        }
        else
        {
            Render();
           
            TranslateMessage( & msg ); // t³umaczy komunikat i wysy³a do systemu
            DispatchMessage( & msg );
        }
    }
   
    if( fullScreen )
    {
        ChangeDisplaySettings( NULL, 0 ); // przywraca pulpit
        ShowCursor( TRUE ); // i wskaŸnik myszy
    }
   
    return msg.wParam;
}