OpenGL Win32

//Program sablon - pt. Win32

#include <windows.h>
#include <windowsx.h>
#include <gl\glos.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glaux.h>
#include <stdio.h>
#include <string.h>

static int mmx,mmy,unghi_,a_,b_;
static HGLRC hRC;
static HDC hDC;
static GLfloat nRange=100.0f;
double x=0.1,y=0.1;
int lx=25,ly=30;
// se seteaza formatul punctului adica - caracteristicile
//mediului grafic folosit de OpenGL
void SetDCPixelFormat(HDC hDC)
        {
        int nPixelFormat;
        static PIXELFORMATDESCRIPTOR pfd = {
                sizeof(PIXELFORMATDESCRIPTOR),  // Dimensiunea structurii PIXELFORMAT...
                1,                              // Versiunea acestei structuri
                PFD_DRAW_TO_WINDOW |             // Deseneaza in fereastra si nu intr-un bitmap
                PFD_SUPPORT_OPENGL |            // Fereastra compatibila cu OpenGL
                PFD_DOUBLEBUFFER,               // Se foloseste modul dublu-buffer
                PFD_TYPE_RGBA,                  // Culoare punctului respecta standardul RGBA
                24,                             // Culoare este pastrate pe 24 de biti
                0,0,0,0,0,0,                    // nespecificati
                0,0,                            // nespecificati
                0,0,0,0,0,                      // nespecificati
                32,                             // Precizia bufferului de adancime
                0,                              // nespecificat
                0,                              // nespecificat
                PFD_MAIN_PLANE,                 // Deseneaza in planul principal
                0,                              // nespecificat
                0,0,0 };                   // nespecificati

         // Se alege formatul punctului,cel mai apropiat de setarile din -pfd-
         nPixelFormat = ChoosePixelFormat(hDC, &pfd);
         // Se precizeaza formatul punctului
         SetPixelFormat(hDC, nPixelFormat, &pfd);
         }
GLsizei width0=800,height0=800;
GLint etapa=0,a=0,b=0,contor=0;
int roteste_on=0;
//functia principala de desenare
//orice se doreste a fi desenat prin OpenGL se introduce in corpul acestei functii
void CALLBACK deseneaza(void)
{

    glClearColor(0.0f,0.0f,0.0f,1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    glRecti(x,y,x+lx,y+ly);
    //introduceti aici codul pentru desenarea unei scene
    glFlush();


}
//functia care este apelata la redimensionarea ferestrei
void CALLBACK resizefunc(GLsizei w,GLsizei h)
{
    if (w==0)   w=1;
    if (h==0)   h=1;
    glViewport(0,0,w,h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    GLsizei w2,h2;
    if (w>h){
        w2=nRange*w/h;
        h2=nRange;
    }else
    {
        w2=nRange;
        h2=nRange*h/w;
    }
    glOrtho(-w2,w2,-h2,h2,-nRange,nRange);
    glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

}
void CALLBACK ActiuneStanga(void)
{
    // se introduce codul care se doreste a fi apelat
    // la apasarea tastei spre stanga

}
void CALLBACK ActiuneDreapta(void)
{
    // se introduce codul care se doreste a fi apelat
    // la apasarea tastei spre dreapta

}
void CALLBACK ActiuneSus(void)
{
    // se introduce codul care se doreste a fi apelat
    // la apasarea tastei in sus

}
void CALLBACK ActiuneJos(void)
{
    // se introduce codul care se doreste a fi apelat
    // la apasarea tastei in jos

}
void CALLBACK ActiuneBaraDeSpatiu(void)
{
    // se introduce codul care se doreste a fi apelat
    // la apasarea tastei bara de spatiu

}

// functie ce se repeta in permanenta la un interval de timp
// precis definit
void CALLBACK Repeta(void)
{
    //se introduce codul care se doreste a fi repetat la intervale periodice
}
//Corpul functie pentru procesare mesajelor de sistem

LRESULT CALLBACK WndProc(
                         HWND    hWnd, // fereastra care primeste mesajul
                         UINT    message,//codul mesajului
                         WPARAM  wParam,// primul parametru al mesajului
                         LPARAM  lParam // al doilea parametru al mesajului
                         )
        {

        switch (message)
                  {
                  // mesaj trimis la crearea ferestrei
                  case WM_CREATE:
                          // salvam dispozitivul de context al ferestrei in hDC
                          hDC = GetDC(hWnd);

                          // stabilim formatul punctului
                          SetDCPixelFormat(hDC);

                          // creem un dispozitiv de context de prelucrare OpenGL -hRC- compatibil
                          // cu dispozitivul de context al ferestrei curente -hDC-
                          hRC = wglCreateContext(hDC);
                          // asociem,legam, interconectam dispozitivul OpenGL -hRC-
                          // cu dispozitivul ferestrei -hDC-
                          wglMakeCurrent(hDC, hRC);

                          // creem o temporizare care genereaza un mesaj de temporizare
                          // la fiecare 5 ms
                          SetTimer( hWnd, // fereastra careia ii asociem temporizarea
                                    10000,// codul temporizarii
                                    5,// valoare intervalului de temporizare in milisecunde
                                    NULL // nefolosit
                                    );
                          break;

        // mesaj trimis la inchiderea ferestrei
        case WM_DESTROY:
                // dezactivam temporizarea
                KillTimer(hWnd,101);

                // deselectam, dezasociem dispozitivul de context al ferestrei
                // fata de dispozitivul de prelucrare OpenGL prin resetare lui cu NULL
                wglMakeCurrent(hDC,NULL);


                // stergem dispozitivul de prelucrare OpenGL
                wglDeleteContext(hRC);

                // Incheiem aplicatia dupa ce fereastra este inchisa
                PostQuitMessage(0);
                break;

        // mesaj trimis la redimensionarea ferestrei
        case WM_SIZE:
                // trimitem spre prelucrare parametrii mesajului functiei
                // de redimensionare a ferestrei
                resizefunc(
                             LOWORD(lParam), // lungimea ferestrei
                             HIWORD(lParam) // inaltimea ferestrei
                        );
                break;

        // mesaj trimis la atingerea momentului precizat de temporizare
        case WM_TIMER:
                {
                // functie de prelucrare repetitiva
                Repeta();
                // comanda de redesenare a ferestrei
                InvalidateRect(hWnd,NULL,FALSE);
                }
                break;

        // mesaj trimis la desenarea ferestrei
        case WM_PAINT:
                {
                // functia de desenare
                deseneaza();

                // copiem din bufferul de dispozitiv al OpenGL in bufferul
                // de dispozitiv al ferestrei
                SwapBuffers(hDC);
               // verificam fereastra
               ValidateRect(hWnd,NULL);
               }
               break;
        // mesaj trimis la apasare unei taste
        case WM_KEYDOWN:
            {
//           char s[100];
             long keydata;
             keydata=(lParam & 0xFF0000)/0x10000;
             switch (keydata)
             {
            case 75://tasta spre stanga
                ActiuneStanga();
                break;
            case 77://tasta spre dreapta
                ActiuneDreapta();
                break;
            case 72://tasta in sus
                ActiuneSus();
                break;
            case 80://tasta in jos
                ActiuneJos();
                break;
            case 57://tasta bara de spatiu
                ActiuneBaraDeSpatiu();
                break;
             }

            }
            break;
          // mesaj trimis la miscarea pointerului de mouse
        case WM_MOUSEMOVE:
            {
              int mx,my;
              mx=LOWORD(lParam);// coordonata pe x a pointerului
              my=HIWORD(lParam);// coordonata pe y a pointerului
              // detectare tinerii apasate a butonului de mouse stang in timpul miscarii pointerului

              if (wParam==MK_LBUTTON)
              {
                  //a=a_+(mmy-y)*2;
                  //b=b_+(mmx-x)*2;
                  x=mx-300;
                  y=300-my;
                  deseneaza();
              }
            }break;
          // mesaj trimis la apasarea butonul stang al mouse-ului
        case WM_LBUTTONDOWN:

            {
              int mx,my;
              mx=LOWORD(lParam);
              my=HIWORD(lParam);
              a_=a;
              b_=b;
              mmx=x+mx;
              mmy=y+my;
            }
            break;
        // mesaj trimis la apasarea butonul drept al mouse-ului
        case WM_RBUTTONDOWN:
            {

            }
            break;
       // mesaj trimis la apasarea butonul din mijloc al mouse-ului
        case WM_MBUTTONDOWN:
            {

            }
            break;


       default:   // orice mesaj neprocesat este recirculat
                  // prin comportamentul functiei de tratare implicita a mesajelor
    return (DefWindowProc(hWnd, message, wParam, lParam));

       }
return (0L);
}
//titlul ferestrei
char windowtitle[]="Aplicatie OpenGL in Win32";

// functia pricipala a programului
int APIENTRY WinMain(
                       HINSTANCE       hInstance, // instanta programului
                       HINSTANCE       hPrevInstance,//instanta precedenta de program
                       LPSTR           lpCmdLine,// sirul de carctere scris la linia de comanda
                       int             nCmdShow)
       {
        MSG            msg;            // mesaj windows standard
        WNDCLASS       wc;             // clasa de ferestre windows
        HWND           hWnd;           // fereastra windows standard
           // Specificare parametrilor obiectului de fereastra
        wc.style               = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc         = (WNDPROC) WndProc;
        wc.cbClsExtra          = 0;
        wc.cbWndExtra          = 0;
        wc.hInstance           = hInstance;
        wc.hIcon               = NULL;
        wc.hCursor             = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground       = NULL;
        wc.lpszMenuName        = NULL;
        wc.lpszClassName       =(LPCTSTR)windowtitle;

        // Inregistrare ferestrei in sistemul de operare
        if(RegisterClass(&wc) == 0)
                return FALSE;
        // Crearea ferestrei principale a aplicatiei
           hWnd = CreateWindow(
                    (LPCTSTR)windowtitle,
                       (LPCTSTR)windowtitle,
                       WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
                       100, 100,
                       width0, height0,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);
        // daca fereastra nu a fost creata se iese
        if(hWnd == NULL)
                return FALSE;

        // se afiseaza fereastra creata
        ShowWindow(hWnd,SW_SHOW);
        // se actualizeaza continutul ferestrei
        UpdateWindow(hWnd);

        // se proceseaza mesajele catre fereastra intr-o bucla
        while( GetMessage(&msg, NULL, 0, 0))
                {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
                }
        return msg.wParam;
        }