CMake es un programa (muy útil). Lo puedes descargar desde https://cmake.org/download/

Si te sirve de algo, yo uso Code::Blocks, y me va muy bien. Mira, te voy a dar los pasos exactos para compilar GLFW usando CMake y Code::Blocks


PROCESO DE COMPILACIÓN DE GLFW  (explicado para CodeBlocks y Windows):
1 - Abre CMake, pincha sobre el botón 'Browse Source' y selecciona la carpeta donde tengas todos los archivos de GLFW (en mi caso, tengo una carpeta en el escritorio llamada glfw, C:\Users\<usuario>\Desktop\glfw)

2 - Pincha sobre el botón  'Browse Build' y seleccionas otra carpeta de salida. En este caso, yo he creado una carpeta en el escritorio llamada glfw_bin. Si te salie que esa carpeta no existe, dale a que si para que automáticamente te cree una.

3 - Pincha sobre 'Configure'. Si te sale un diálogo que te dice que la carpeta de salida no existe, dale a que si para que te la cree automáticamente.

4 - En la lista desplegable, selecciona 'CodeBlocks - MinGW Makefiles', o la opción que más te convenga. Y sobre las opciones de compilador, dale a que use los compiladores nativos ('Use default native compilers')

5 - Dale a 'Finnish'. Tendrás que esperar un rato a que genere el proyecto.

6 - Una vez terminada la espera, asegúrate de que no te haya salido ningún error. En el caso de que haya salido alguno, publícalo en este mismo tema. Si no hay errores, pulsa sobre 'Generate'. De nuevo, al terminar de generarse el proyecto, asegúrate de que no te hayan indicado error.

7 - Ya puedes cerrar CMake. Ahora vente a la carpeta de salida que le indicaste a CMake (en mi caso, era glfw_bin, en el escritorio). En esa carpeta ha de haber un archivo llamado GLFW.cbp. Ábrelo con CodeBlocks.

8 - Ahora vente al menú 'Build', y desde ahí selecciona 'Build'. Tendrás que esperar a que se compile la librería. Te tendría que salir en la parte inferior información sobre la compilación, si no es así, pulsa F2 y se te mostrará. Una vez que haya terminado de compilar, la librería estará lista para su uso. Ahora hay que incluirla en el proyecto.
NOTA: Si te salen errores de 'undefined reference to vk..., no pasa nada. No pasa nada si es undefined reference vk, ten en cuenta el vk!!



INCLUIR LIBRERÍA EN EL PROYECTO (explicado para CodeBlocks y Windows):
1 - Primero vamos a sacar los archivos necesarios de la compilación anterior:
En la carpeta de archivos fuente de GLFW (la carpeta del paso 1), está la carpeta
'include'. Córtala o cópiala (a preferencia tuya) a otra carpeta. Yo la dejé en el escritorio mismo.
En la carpeta donde hemos generado el proyecto (en la carpeta del paso 2 de la compilación), vete a la subcarpeta 'src'. Ahí debe estar el archivo 'libglfw3.a'. Si no lo está, es que no has compilado la librería correctamente. Si está, cópialo al escritorio mismamente.
Yo he creado en el escritorio una carpeta llamada 'lib', y ahí he guardado 'libglfw3.a'.

2 - Una vez tenemos todos los archivos relevantes, podemos eliminar los dos carpetas generadas en el proceso de la compilación (las carpetas que yo llamé 'glfw' y 'glfw_bin'). Una vez eliminadas, creamos un proyecto de consola en CodeBlocks (File -> New -> Project, Console Application ->Go). Este será el proyecto donde puedas usar OpenGL y GLFW. Puedes seleccionar tanto C como C++

3 - Corta los archivos que generamos antes a la carpeta del proyecto

3 - Una vez creado el proyecto, puedes copiar el código que pasé antes a tu archivo main.c/cpp. (Paso opcional pero altamente recomendable)

4 - Ahora vete al menú 'Project' -> 'Build Options'.

5 - Vete a la pestaña 'Search Directories'.

6 - En la pestaña 'Compiler', dale a 'Add' y selecciona el interior de la carpeta 'include'

7 - En la pestaña 'Linker' dale a 'Add'. Selecciona la carpeta en la que esté el archivo 'libglfw3.a'

8 - Ahora vete a la pestaña 'Licker settings'. Donde pone 'Other Licker Options', escribe lo siguiente:
Tanto -lopengl32 como -lgdi32 son exclusivos de Windows.



¡¡AHORA YA DEBERÍA ESTAR TODO LISTO!! Prueba a compilar el código que te pasé antes a ver si no hay errores

CREO que es un motor gráfico. Por ahora, yo no uso motores gráficos, así que se podría decir que en ese tema sabes prácticamente lo mismo que yo, o incluso más.

Si no sabes lo que es un motor gráfico exactamente, es como un conjunto de herramientas que te permiten crear juegos de forma mucho más sencilla, sin tener que programar tanto. Evidentemente, para los temas más "delicados" habrá que programar, pero la programación con los motores gráficos puede ser muy poca. Por eso desaconsejo empezar con estos desde un principio. Si bien es cierto que te pueden ayudar, EN MI OPINIÓN, creo que es mejor empezar desde los cimientos y aprender a programar tus propias herramientas.
REPITO: es opinión mía, es posible perfectamente que me esté equivocando muchísimo, sobre todo porque puede ser una opinión no general.

No tienes porque usar ni GLUT ni la API de windows. También puedes usar GLFW. Te pongo un código de ejemplo para que veas lo simple que es:

#include <stdio.h>
 
#include <glfw\glfw3.h>
 
int main() {
    GLFWwindow *window = NULL; // Con esta variable nos referiremos a la ventana
 
    // Inicializamos la librería GLFW
    if(GL_TRUE != glfwInit()) {
        fprintf(stdout, "Error inicializando GLFW\n");
        return -1;
    }
 
    // Creamos ventana de dimensiones 800x600
    window = glfwCreateWindow(800, 600, "Titulo de ventana", NULL, NULL);
    if(NULL == window) {
        fprintf(stdout, "Error creando ventana de GLFW\n");
        return -1;
    }
 
    // Color de fondo: blanco
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
 
    // Bucle del juego/programa
    while(GL_FALSE == glfwWindowShouldClose(window)) {
        // Actualizamos eventos (ratón, teclado, maximizar ventana, cerrar ventana...)
        glfwPollEvents();
        // Limpiamos búfer
        glClear(GL_COLOR_BUFFER_BIT);
 
        // Dibujamos triángulo
        glColor3f(1.0f, 0.0f, 0.0f); // Color del triángulo: rojo
        glBegin(GL_TRIANGLES);
        glVertex2f(-1.0f, -1.0f);
        glVertex2f( 1.0f, -1.0f);
        glVertex2f( 0.0f,  1.0f);
        glEnd();
 
        // Actualizamos el búfer de pantalla
        glfwSwapBuffers(window);
    }
 
    // Cerramos programa liberando memoria
    glfwTerminate();
    return 0;
}

El código parece más complicado de lo que es porque tiene bastantes comentarios. Se podría hacer incluso más simple.

A parte de lo simple que es empezar con GLFW, esta API es muy buena, muy extensa y está MUY BIEN documentada, así que si ocurre un error respecto a GLFW, es muy raro que no encuentres solución si lo buscas en Internet.


Yo no tengo experiencia en sistemas Linux, por lo que solo te puedo dar consejos sobre Windows.

Aquí tienes un tutorial de cómo compilar GLFW manualmente:
http://www.glfw.org/docs/latest/compile.html

Una vez que hayas compilado GLFW, lo único que tienes que hacer es añadir las dependencias a tu proyecto.

Si estás usando la consola, y estás usando MinGW, este comando te servirá si has compilado GLFW estáticamente:

Si has compilado GLFW dinámicamente, entonces el comando sería:


Ten en cuenta que tienes que tener algo de experiencia con esto de las librerías. Sin embargo, si no tienes demasiada, te presento un tutorial:

http://learnopengl.com/#!Getting-started/Creating-a-window

¡Espero haber sido de ayuda!

La mayoría de errores parecen ser porque en alguna parte olvidaste un punto y coma. Lo único que te puedo decir es que te asegures de incluir la librería GLU y que declares globalmente o localmente la variable 'aspecto'. Sin tener el código fuente completo, es lo máximo que puedo decir.

Por cierto, te aconsejo este tutorial. Usa OpenGL moderno, así que si quieres pasar del OpenGL antiguo al relativamente moderno, te aconsejo seguir este tutorial:

http://learnopengl.com/

No es 'glPerspective', es 'gluPerspective'. Esta función no es de OpenGL, sino que es de una librería llamada glu:

https://www.opengl.org/sdk/docs/man2/xhtml/gluPerspective.xml

Está claro que solo se ve la cara amarilla, pues es la última que dibujas y es la que tiene la profundidad más pequeña (-1.0) según indicas. El cuadrado amarillo se ve grande porque ocupas toda la pantalla. Tienes que tener en cuenta que las coordenadas de cortado están en el rango [-1.0, 1.0], es decir, toda coordenada dentro de este rango será dibujada, y si la coordenada es -1.0 o 1.0, eso significa que está en un extremo de la zona de dibujado.

Si lo que quieres es añadir perspectiva, tendrás que jugar con las matrices. En OpenGL antiguo, existen 2 matrices fundamentales para transformar las posiciones de los vértices, está la matriz de modelado y visionado, y está la matriz de proyección. La matriz de modelado y visionado sirve fundamentalmente  para "modelar" tus vértices, es decir, trasladarlos, rotarlos, escalarlos, además sirve para el manejo de la cámara... y la matriz de proyección sirve para delimitar el área visible de tu programa. Por ejemplo, puedes crear una matriz ortográfica usando librerías como glu, para crear un juego 2D, o puedes usar la matriz de proyección en perspectiva para crear un juego tridimensional.

Aun diciendo todo esto, no estoy acostumbrado al OpenGL antiguo porque en las versiones más recientes de este, se han descatalogado la mayoría de funcionalidades de las versiones de OpenGL 3.0 hacia atrás. Por esto mismo te aconsejo aprender OpenGL 3.3 en su perfil core (es decir, en modo moderno). Es más complicado de aprender, pero te enteras mucho mejor de lo que estás haciendo y es mucho más optimizable.

No sé si será imposible o no, pero yo me quedé cerca XDD:



Por cierto, bien programado

Bueeno. Me responderé a mi mismo xD. Aunque haya dejado la pregunta aquí, tenía tanta curiosidad que seguí investigando. La respuesta la he descubierto aquí:
http://c.conclase.net/curso/index.php?cap=014#inicio

Lo que pasa es que el operador *, para declarar variables, es especial (como otros pocos). Lo que tiene de especial es que se evalúa de derecha a izquierda, y si hay varios operadores con la misma prioridad que el *, se evalúan de derecha a izquierda, por lo que, en efecto, el último asterisco tiene más prioridad que el primero, porque es el que está más a la derecha.

Sé que lo he explicado un poco mal, así que recomiendo ver la página que he puesto