Hola, ¡muy buenas programadores! Hoy estoy buscando a alguien que esté aprendiendo a usar OpenGL y esté interesado en trabajar en equipo conmigo. Porque una parte muy importante de la programación es hacer equipos y así aprender unos de otros. Yo también estoy aprendiendo a usar OpenGL.

Busco personas que sepan C++.

¡MUCHAS GRACIAS POR SU ATENCIÓN! 

Hola, ¡muy buenas forer@s! Hoy os traigo una duda un tanto elemental, es decir, bastante básica a mi parecer.

Me preguntaba si alguien tendría la amabilidad de explicarme este código. He de decir que ando muy perdido en cuanto a librerías en C++, puesto que he pasado de programar con iostream a programar con la API de Windows y OpenGL. Bueno, aquí os dejo el código (me podéis explicar, si queréis, siendo técnicos, para que tengáis que escribir menos):

bool CShader::loadShader(string sFile, int a_iType) 
{ 
   FILE* fp = fopen(sFile.c_str(), "rt"); 
   if(!fp)return false; 
 
   // Get all lines from a file
 
   vector<string> sLines; 
   char sLine[255]; 
   while(fgets(sLine, 255, fp))sLines.push_back(sLine); 
   fclose(fp); 
 
   const char** sProgram = new const char*[ESZ(sLines)]; 
   FOR(i, ESZ(sLines))sProgram[i] = sLines[i].c_str(); 
 
   uiShader = glCreateShader(a_iType); 
 
   glShaderSource(uiShader, ESZ(sLines), sProgram, NULL); 
   glCompileShader(uiShader); 
 
   delete[] sProgram; 
 
   int iCompilationStatus; 
   glGetShaderiv(uiShader, GL_COMPILE_STATUS, &iCompilationStatus); 
 
   if(iCompilationStatus == GL_FALSE)return false; 
   iType = a_iType; 
   bLoaded = true; 
 
   return 1; 
}

Notas:
* No hace falta que me expliqueis esto: uiShader = glCreateShader(a_iType), esto: glShaderSource(uiShader, ESZ(sLines), sProgram, NULL); ni esto: glCompileShader(uiShader);

* Explicad solo lo que sepais, y así todos podrán ayudar y nadie se confundirá

¡MUCHAS GRACIAS POR SU ATENCIÓN Y POR SU AYUDA!

Hola, ¡muy buenas a todos! Hoy os vengo a preguntar una duda. El caso es que estoy traduciendo un documento que trata el OpenGL moderno, pero me he encontrado con un término que se que significa, pero no le encuentro una traducción literal. El término en cuestión es Scan convertion.

Os digo que significa: Es transformar las coordenadas en ventana(flotantes) a coordenadas en ventana (enteras)

Os dejo una imagen bastante descriptiva:



También os dejo la definición literal de la página: The process of taking a triangle in window space and converting it into a number of fragments based on projecting it onto the pixels of the output image


Espero que me puedan ayudar. ¡MUCHAS GRACIAS POR PASAROS!

Hola, amigos! Hoy he decidido cambiar de IDE y compilador (antes usaba code::blocks). Me he cambiado a Visual Studio Express 2013, y tengo una duda sobre los tabuladores.

Cuando yo escribo ":" (sin comillas), me salta un tabulador hacia atras, cosa que no me gusta.

Ejemplo:

switch(Variable) {
    case 1: // De esto pasa a...
        ...
 
        break;
}

switch(Variable) {
case 1: // Esto
    ...
 
    break;
}

Tambien hay otra cosa que no me gusta, y es que despues de un if, while, for o cualquer controlador de flujo, me pone un espacio entre ese if y el parentesis

Ejemplo:

if(Variable > 1) // De esto pasa a...{
    ...
}

if (Variable > 1) // Esto{
    ...
}

Me gustaría ver si me pueden decir como omito estas "autocorrecciones", porque me resultan muy molestas...

Muchas gracias

Hola, ¡muy buenas, foro! He estado buscando mucho por Google un tutorial sobre OpenGL 4.1 usando glext, pero no he encontrado gran cosa en español... Mi petición sería que me pasaseis algún tutorial o algo que conozcais sobre OpenGL (4.1 o 3.3) usando la librería glext.h y wglext.h Y sería maravilloso si se usara solo la API de Windows, no librerías como FreeGlut, o Glew

Por favor, estoy deseando meterme en el mundo de OpenGL, pero Glut, ni glew me gustan porque me quitan demasiado control a mi gusto


¡MUCHAS GRACIAS POR SU COLABORACIÓN!

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:

#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:

#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