Notas Rápidas – OpenGL ES. Introducción Parte 5

Operaciones por fragmento

Es la siguiente etapa despues del Fragment Shader. Un fragmento producido por la rasterización con las coordenadas de pantalla (Xw, Yw) que pueden solo modificar el pixel en la locación (Xw, Yw) en el framebuffer.Featured image

Sigue leyendo

Anuncios

Notas Rápidas – OpenGL ES. Introducción Parte 4

Fragment Shader

El Fragment Shader implementa los metodos programables de proposito general para operar los fragmentos salidos de la etapa de rasterizacion. Los tipos de entrada que maneja son:

Variables de diversidad (varying). Las salidas del vertex shader que son generadas por la unidad de rasterización por cada fragmento usando la interpolacion.

Uniformes (uniform). Datos constantes usados por los fragment shaders.

Muestreos (samplers). Un tipo especifico de uniformes que representa la texturas por el fragment shader.

Programa de Shader. Es el código fuente o ejecutable que describe las operaciones que sera ejecutado por sobre el fragmento,

El fragment shader puede ya que descarte el fragmento o genere un color referenciado como gl_FragColor. El color, la profundidad y locacion de coordenadas en pantalla (Xw, Yw) generada por la rasterización convierte las entradas para la etapa de operaciones por fragmento del pipeline de OpenGL ES 2.0.

Entradas y salidas del Fragment ShaderEl siguiente ejemplo de Fragment Shader puede ser acoplado con el Vertex Shader del ejemplo anterior para el dibujado de un triángulo de un sombreado Gouraud.

Un pequeño ejemplo de un Fragment Shader

precision medium float;

varying vec4 v_color;  //Entrada del color del vertice desde el Vertex Shader

void main(void)
{
   gl_FragColor = v_color;  //Aqui se le pasa el valor del color a cada vertice
}

Notas Rápidas – OpenGL ES. Introducción Parte 3

Rasterización

Es la fase donde el primitivo apropiado (point-sprite, línea, o triángulo) es dibujado. Es el proceso donde convierte los primitivos en un conjunto de fragmentos de dos dimensiones, las cuales son procesadas por el Fragment Shader.

Estos fragmentos de dos dimensiones representan los pixeles que pueden ser dibujados en pantalla.

Etapa de rasterizacion del Pipeline de OpenGL ES

Notas Rápidas – OpenGL ES. Introducción Parte 2

Ensamble de primitivos

Primitivo es un objeto geométrico el cual puede ser usado apropiadamente los comandos de dibujado de OpenGL ES.

Éstos pueden ser especificados por un conjunto de atributos de vértices y por tipo de geometría.

Los atributos contienen información que el Vertex Shader usa para calcular posición y otra información que puede pasado al Fragment Shader; como el color o las coordenadas de texturas.

En este estado los vértices que son sombreados, son ensamblados en primitivos geométricos individuales los cuales pueden ser dibujados como un triangulo, linea o un punto-sprite.

Para cada primitivo, se determina cual está dentro de la vista del frustrum (la región 3D que esta visible en la pantalla).

Si el primitivo no esta completamente dentro del frustrum, la parte que no esta a la vista no será cortado. Esto puede hacer que el ensamblado de los primitivos sea más óptimo,

Esto puede ayudar a la optimización del ensamble de triángulos, lineas y puntos-sprites.

Esto puede ayudar a la optimización del ensamble de triángulos, lineas y puntos-sprites.

Si esta complemente fuera, estará descartado.

Es solo una representación de que el primitivo está fuera de pantalla, pero realmente no es ensamblado. En pocas palabras, "si no se ve, no se procesa".

Es solo una representación de que el primitivo está fuera de pantalla, pero realmente no es ensamblado. En pocas palabras, “si no se ve, no se procesa”.

También puedes descartar objetos dependiendo que tan lejos o que tan cercas estén.

Notas Rápidas – OpenGL ES. Introducción Parte 1

Diferencia entre OpenGL y OpenGL ES

El API se OpenGL es más grande y complejo, y OpenGL ES es un API hecho para dispositivos constreñidos. Lo que hace el API de OpenGL ES quite la redundancia del API OpenGL pero a la vez mantiene su compatibilidad. Las características del API de OpenGL ES es la reducción del consumo de energía de los dispositivos e incremento en la velocidad de ejecución de los shaders.

Pipeline o estructura

pipeline

Vertex Shader

Métodos programables de propósitos general para operar vértices.

Para la entrada de datos al Vertex Shader hay:

Atributos (attributes). Son los datos por vértice usando un arreglo de vectores.

Uniformes (uniform). Datos constantes usados por el Vertex shaders.

Muestreos (samplers). Un tipo especifico de uniformes que representa la texturas por el vertex shader. Los samples en un vertex shader son opcionales.

Programa de Shader. Es el código fuente o ejecutable que describe las operaciones que sera ejecutado por el vértice.

Los datos de salidas del Vertex Shader son variables varying (de diversidad).

Son calculadas en la primera etapa de rasterización por cada fragmento y son pasadas como datos de entradas del fragment shader.

El mecanismo usado para generar la variable diversa para cada fragmento de diversos valores asignados ara cada vértice primitivo es llamado interpolación.

vertex_shader

Operaciones de Vertex Shader

  • Posición de matriz
  • Ecuación para generar luces computadas
  • Color por vértice
  • Generar o transformare coordenadas

Ejemplo de un Vertex Shader

// Los uniformes son usados por el vertex shader
uniform mat4 u_mvpMatrix; // Almacena la matriz de 
                          // Modelo-Vista-Proyección. 
                          // Convierte la proyección 
                          // del espacio del modelo 
                          // para normalizar el espacio 
                          // divido

// Atributos de datos de entrada del Vertex Shader
attribute vec4 a_position; // Valor de posición
attribute vec4 a_color; // Entrada del vértice de color
varying vec4 v_color; // Salida del vértice de color

// El punto de entrada donde ejecuta las instrucciones
// del vertex shader.
void main()
{
   v_color = a_color;
   gl_position = u_mvpMatrix * a_position; // Se pasa
                    // la multiplicación del vector de
                    // posición del objeto, lo pasa a 
                    // gl_position. 
}