Mensajes

¿Entonces, me aconsejáis que me acostumbre a escribir los menúes con código de la WinAPI? Muy esclarecedora tu respuesta, ademas de rápida!

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'...)

Hola, amigo! Te recomiendo una página que te explica todo el C++, la API de Windows, html5 y algo mas muy breve y conciso! La página es esta (pincha aquí)

Espero que te sea de ayuda

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!

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