Foro de elhacker.net

Comprensión del OpenGL + API Win32

Hola a tod@s! Soy nuevo en este foro. Soy un chico al que le gusta mucho programar,  y ahora le gustaría más que nada saber como programar con gráficos! Mi duda o petición es ver si me podéis explicar el Hello World del OpenGL + API Win32.

La situación es que yo se la estructura básica de una aplicación Win32, y tambien los fundamentos del OpenGL, pero no se como unir las dos cosas.

Este es el Hello World:

#include <windows.h>
#include <gl/gl.h>
 
LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
void DisableOpenGL(HWND, HDC, HGLRC);
 
 
int WINAPI WinMain(HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine,
                    int nCmdShow)
{
    WNDCLASSEX wcex;
    HWND hwnd;
    HDC hDC;
    HGLRC hRC;
    MSG msg;
    BOOL bQuit = FALSE;
    float theta = 0.0f;
 
    /* register window class */
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_OWNDC;
    wcex.lpfnWndProc = WindowProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = "GLSample";
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);;
 
 
    if (!RegisterClassEx(&wcex))
        return 0;
 
    /* create main window */
    hwnd = CreateWindowEx(0,
                            "GLSample",
                            "OpenGL Sample",
                            WS_OVERLAPPEDWINDOW,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            256,
                            256,
                            NULL,
                            NULL,
                            hInstance,
                            NULL);
 
    ShowWindow(hwnd, nCmdShow);
 
    /* enable OpenGL for the window */
    EnableOpenGL(hwnd, &hDC, &hRC);
 
    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                bQuit = TRUE;
            }
            else
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else
        {
            /* OpenGL animation code goes here */
 
            glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            glClear(GL_COLOR_BUFFER_BIT);
 
            glPushMatrix();
            glRotatef(theta, 0.0f, 0.0f, 1.0f);
 
            glBegin(GL_TRIANGLES);
 
                glColor3f(1.0f, 0.0f, 0.0f);    glVertex2f(0.0f, 1.0f);
                glColor3f(0.0f, 1.0f, 0.0f);    glVertex2f(0.87f, -0.5f);
                glColor3f(0.0f, 0.0f, 1.0f);    glVertex2f(-0.87f, -0.5f);
 
            glEnd();
 
            glPopMatrix();
 
            SwapBuffers(hDC);
 
            theta += 1.0f;
            Sleep (1);
        }
    }
 
    /* shutdown OpenGL */
    DisableOpenGL(hwnd, hDC, hRC);
 
    /* destroy the window explicitly */
    DestroyWindow(hwnd);
 
    return msg.wParam;
}
 
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CLOSE:
            PostQuitMessage(0);
        break;
 
        case WM_DESTROY:
            return 0;
 
        case WM_KEYDOWN:
        {
            switch (wParam)
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                    break;
            }
        }
        break;
 
        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
 
    return 0;
}
 
void EnableOpenGL(HWND hwnd, HDC* hDC, HGLRC* hRC)
{
    PIXELFORMATDESCRIPTOR pfd;
 
    int iFormat;
 
    /* get the device context (DC) */
    *hDC = GetDC(hwnd);
 
    /* set the pixel format for the DC */
    ZeroMemory(&pfd, sizeof(pfd));
 
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
                    PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
 
    iFormat = ChoosePixelFormat(*hDC, &pfd);
 
    SetPixelFormat(*hDC, iFormat, &pfd);
 
    /* create and enable the render context (RC) */
    *hRC = wglCreateContext(*hDC);
 
    wglMakeCurrent(*hDC, *hRC);
}
 
void DisableOpenGL (HWND hwnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hRC);
    ReleaseDC(hwnd, hDC);
}
 

Lo que no entiendo es: Las funciones Enable y disable OpenGL, las estructuras HDC y HRC. Espero que me puedan ayudar! Si no sabéis todo, o no queréis explicar mucho, por favor, explicarme cualquier cosa que sepáis, y así yo podré aprender mucho más!

MUCHAS GRACIAS, ESPERO PODER AYUDAR Y SER AYUDADO TODO LO QUE PUEDA :D

Por simplificartelo un poco digamos que cada ventana de Windows tiene algo llamado "contexto de dispositivo" el cuál es diferente para cada ventana de Windows y dicho contexto es para indicarle que todo lo que dibujes sobre ese contexto va a estar a ser dibujado cuando la ventana tenga "su turno" para dibujar en su "espacio dentro de la pantalla".
Ahora el contexto de opengl es lo mismo pero primero debe relacionarse a una ventana y el contexto del opengl debe estar dentro del mismo "hilo de ejecución" que recibe los mensajes de dibujados de la ventana.
Todo eso Windows lo hace para tener un orden específico a la hora de dibujar cosas en la pantalla...

EDIT: cuando quieras poner algún código en el foro utiliza el botón geshi la próxima vez, sinó algún moderador te va a borrar el mensaje :P


B#

Muchas gracias, amigo! Me he fijado en otros hilos de lo que tu dices, pero no sabia como se añadía xD. Tu explicación me ha gustado, ahora solo me falta lo de inicializar y desactivar el OpenGL!