PES_2_5

Función para mostrar los gráficos en pantalla

void display(GLFWwindow* window, double currentTime); Esta función limpia el búfer de profundidad y la pantalla, y luego dibuja un triángulo utilizando el programa de shaders activo.

• Parámetros:

  • window: Un puntero a la ventana de GLFW donde se está renderizando.
  • currentTime: El tiempo actual del sistema, que puede ser usado para animaciones o cálculos dependientes del tiempo.

• Descripción detallada:

  • Se limpia el búfer de profundidad utilizando glClear(GL_DEPTH_BUFFER_BIT) para asegurar que la nueva escena se dibuje sin interferencias de objetos previamente renderizados.
  • Se establece el color de limpieza (negro en este caso) con glClearColor(0.0, 0.0, 0.0, 1.0) para limpiar el fondo de la pantalla con el color especificado antes de dibujar.
  • Se activa el programa de shaders configurado previamente mediante glUseProgram(renderingProgram), que contiene los shaders de vértices y fragmentos.
  • Finalmente, se dibuja un triángulo utilizando glDrawArrays(GL_TRIANGLES, 0, 3), donde GL_TRIANGLES indica que los vértices forman un triángulo y el segundo y tercer argumento indica el primer vértice y el número de vértices a dibujar.

Vertex Shader:

Este vertex shader en GLSL está diseñado para calcular la posición de los vértices en el espacio de recorte, basándose en el identificador del vértice (gl_VertexID). Utiliza la versión 4.10 de GLSL.

Estructura del vertex shader:

#version 410
void main(void) {
    if (gl_VertexID == 0) gl_Position = vec4(0.25, -0.25, 0.0, 1.0);
    else if (gl_VertexID == 1) gl_Position = vec4(-0.25, -0.25, 0.0, 1.0);
    else gl_Position = vec4(0.25 , 0.25, 0.0, 1.0);
}

• Directiva de versión:

  • #version 410: Especifica que el shader utiliza la versión 4.10 de GLSL, permitiendo el uso de características disponibles en esa versión.

• Función principal:

  • void main(void): Es la función principal del vertex shader, que se ejecuta para cada vértice de entrada. Aquí se establece la posición del vértice en el espacio de recorte.

• Identificación del vértice:

  • gl_VertexID: Es una variable incorporada de GLSL que contiene el identificador del vértice actual. Se usa para diferenciar entre los vértices y establecer posiciones específicas para cada uno.

• Condicionales para la posición:

  • if (gl_VertexID == 0): Si el identificador del vértice es 0, la posición del vértice se establece en las coordenadas (0.25, -0.25, 0.0, 1.0), que corresponde a la esquina inferior derecha del triángulo.
  • else if (gl_VertexID == 1): Si el identificador del vértice es 1, la posición se establece en (-0.25, -0.25, 0.0, 1.0), que corresponde a la esquina inferior izquierda.
  • else: Si el identificador es otro (específicamente, 2 en un triángulo), la posición se establece en (0.25, 0.25, 0.0, 1.0), que corresponde a la esquina superior derecha.

• Asignación de posición:

  • gl_Position: Es la variable de salida estándar en los vertex shaders que determina la posición del vértice en el espacio de recorte. Cada posición es especificada como un vector de 4 dimensiones vec4, donde los primeros tres componentes representan las coordenadas espaciales (x, y, z) y el cuarto componente representa el factor de homogeneización (w).

• Descripción detallada:

  • Este vertex shader asigna posiciones específicas a los vértices de un triángulo en función de su identificador (gl_VertexID). Dependiendo del valor de gl_VertexID, se establecen las posiciones en el espacio de recorte de OpenGL, creando un triángulo formado por tres vértices en las posiciones definidas. Los vértices resultantes forman un triángulo en las siguientes coordenadas:
    1. Vértice 0: (0.25, -0.25) (abajo a la derecha).
    2. Vértice 1: (-0.25, -0.25) (abajo a la izquierda).
    3. Cualquier otro vértice (en este caso, el 2): (0.25, 0.25) (arriba a la derecha).

Estos vértices son luego procesados en la etapa de rasterización para generar los fragmentos del triángulo.

Fragment Shader:

Este es un fragment shader simple que se encarga de establecer el color de cada fragmento generado por la etapa de rasterización. El shader está escrito en GLSL y utiliza la versión 4.10.

#version 410
out vec4 color;
void main(void)
{
    color = vec4(0.0, 0.0, 1.0, 1.0);
}

• Directiva de versión:

  • #version 410: Especifica que el shader utiliza la versión 4.10 de GLSL (OpenGL Shading Language). Esto asegura que el código siga las reglas de esa versión.

• Declaración de salida:

  • out vec4 color;: Declara una variable de tipo vec4 llamada color que se utilizará para almacenar el valor de salida del fragment shader. Cada componente de vec4 representa los valores RGBA (rojo, verde, azul, alfa) que definen el color final de cada fragmento.

• Función principal:

  • void main(void): Es la función principal del fragment shader. Aquí se define lo que hará el shader cuando se ejecute para cada fragmento.

• Asignación de color:

  • color = vec4(0.0, 0.0, 1.0, 1.0);: Asigna el valor RGBA al color de salida. En este caso:
  • 0.0: Componente roja (red) con valor 0.
  • 0.0: Componente verde (green) con valor 0.
  • 1.0: Componente azul (blue) con valor 1, lo que significa que el fragmento será completamente azul.
  • 1.0: Componente alfa (alpha), que define la opacidad del color. Un valor de 1.0 indica que el color es completamente opaco.

• Descripción detallada:

Este shader establece el color de cada fragmento que pasa por él como un color azul completamente opaco (vec4(0.0, 0.0, 1.0, 1.0)). El valor de salida se almacena en la variable color, que luego será utilizado para renderizar en pantalla el color de los fragmentos.