Temas

Hola, muy buenas de nuevo! Se que soy un poco pesado porque pregunto demasiadas dudas, pero estoy algo "verde" en cuanto a OpenGL se refiere. He estado mirando en el interior de la libreria de OpenGL incluida en mi CodeBlock y me he fijado en esta macro:

Código (cpp) [Seleccionar] Expandir

#define GL_VERSION_1_2   1
#define GL_VERSION_1_3   1

Creo que esta librería está basada en OpenGL 1.3, y ya estamos por la 4.5 xD

Mi duda es como descargo la versión 4.4 de esta librería (Mi tarjeta gráfica soporta hasta OpenGL 4.4)

Espero que me orienten un poco, que estoy muy verde con OpenGL

Muchas gracias por la paciencia!

Hola, muy buenas forer@s! Hoy os quería preguntar si me pudieseis pasar un tutorial sobre OpenGL. Ya se que me vais a decir que busque en Google, pero no he encontrado lo que yo quiero! Lo que me gustaría tener es un tutorial de OpenGL ("el nuevo OpenGL", no el antiguo debido a que lo cambiaron mucho) que explicara el OpenGL, no las funciones. Lo que quiero saber es como funciona el sistema de matrices, tanto en modelado, visión, luz...

Espero haberme aclarado y también espero sus maravillosas respuestas!

Un saludo de alguien que quiere aprender un montón!

Hola, muy buenas foreros! Hoy os quisiera preguntar una duda, probablemente, bastante simple. ¿Podeis decirme que ventajas tiene crear un menú con archivos *.rc y crearlos directamente con la API de Windows? Obviamente, crear un menú con los archivos *.rc es más sencillo (a mi parecer), entonces, para que se usa el otro método?

Espero que haya quedado claro! Muchas gracias por leerlo!




(Espero que esto no sea 'crap'...)

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:

Código (cpp) [Seleccionar] Expandir

#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