Programação com OpenGL/Modern OpenGL Tutorial 03: diferenças entre revisões

Nós passaremos as coordenadas usando um '''attribute''', assim iremos colocar novos atributos para as cores.

Vamos modificar nossas variáveis globais:

GLuint vbo_triangle, vbo_triangle_colors;

GLint attribute_coord2d, attribute_v_color;

 

e nosso ''init_resources'':

GLfloat triangle_colors[] = {

1.0, 1.0, 0.0,

return 0;

}

 

Agora em nosso <code>onDisplay</code>, nós iremos passar 1(uma) cor RGB para cada 3 vértices. vou escolher amarelo, azul e vermelho, mas fique a vontade para escolher suas cores favoritas :)

glEnableVertexAttribArray(attribute_v_color);

glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle_colors);

0 // deslocamento do primeiro elemento.

);

 

Vamos chamar o OpenGL apenas para completar o atributo, e terminar nossa função:

glDisableVertexAttribArray(attribute_v_color);

 

Por ultimo, declararemos isto ao nosso vertex shader:

attribute vec3 v_color;

 

Neste ponto, ao rodarmos o programa, teremos isto:

 

em triangle.v.glsl:

attribute vec2 coord2d;

attribute vec3 v_color;

f_color = v_color;

}

 

em triangle.f.glsl:

varying vec3 f_color;

void main(void) {

gl_FragColor = vec4(f_color.x, f_color.y, f_color.z, 1.0);

}

 

(Nota: se estamos usando a GLES2, verifique a seção de portabilidade abaixo.)

 

Para entender melhor a função ''glVertexAttribPointer'', vamos misturar vários atributos em uma única array(ordenação):

GLfloat triangle_attributes[] = {

0.0, 0.8, 1.0, 1.0, 0.0,

glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle);

glBufferData(GL_ARRAY_BUFFER, sizeof(triangle_attributes), triangle_attributes, GL_STATIC_DRAW);

 

No <code>glVertexAttribPinter</code> o 5 elemento é uma ''stride'', para dizer ao OpenGL quando cada atributo será configurado - em nosso caso 5 floats:

glEnableVertexAttribArray(attribute_coord2d);

glEnableVertexAttribArray(attribute_v_color);

(GLvoid*) (2 * sizeof(GLfloat)) // descolocamento do primeiro elemento.

);

 

Ele funciona da mesma forma!

 

Um alternativa por esporte:

struct attributes {

GLfloat coord2d[2];

(GLvoid*) offsetof(struct attributes, v_color) // offset

...

 

Note que usamos <code>offsetof</code> para especificar a primeira cor do offset.

Vamos dizer que nós queremos definir a transparência global do triângulo pelo código C. tal qual acontece com os attributes, nós precisamos declaro isto.

em uma global no código C:

GLint uniform_fade;

Depois de declararmos isto no código C (ainda após a linkagem do programa)

const char* uniform_name;

uniform_name = "fade";

return 0;

}

 

Note: Poderiamos até atingir um array especifica de elementos no código de shader com <code>uniform_name</code>, e.g. <code>"my_array[1]"</code>!

 

Além disto, para o uniform, nó também definiremos explicitamente o valor da non-varying. Vamos requisitar, em <code>onDisplay</code>, que o triangulo deve ser um pouco opaco:

glUniform1f(uniform_fade, 0.1);

 

Agora nós podemos usar esta variável em nosso fragment shader:

varying vec3 f_color;

uniform float fade;

gl_FragColor = vec4(f_color.x, f_color.y, f_color.z, fade);

}

 

Nota: se você não usar uniform em seus código, o <code>glGetUniformLocation</code> não vai enxergar nada, e vai falhar.

 

Nós podemos especificar a precisão para cada variável.

varying lowp vec3 f_color;

uniform lowp float fade;

 

ou, nós podemos declarar a precisão padrão:

precision lowp float;

varying vec3 f_color;

uniform float fade;

 

Infelizmente os precision hints não funciona no OpenGL 2.1 tradicional, então nós vamos incluir apenas no GLES2.

 

Nós já pré-especificamos um directiva de processamento para o macro através da função utilitária <code>create_shader</code>:

#define GLES2

 

Agora podemos melhorar nosso carregamento de shader para isto definiremos um precisão padrão no GLES2, e ignoraremos o identificador de precisão no OpenGL 2.1(assim ainda podemos definir um precisão para uma variável especifica se precisarmos):

GLuint res = glCreateShader(type);

const GLchar* sources[] = {

source };

glShaderSource(res, 3, sources, NULL);

 

Lembrando que o compilador GLSL poderá contar as linhas pré-especificados enquanto mostra mensagens de erro, Ajustando a <code>#line 0</code> infelizmente não reiniciara o contagem de linha do compilador

No ''main'', vamos declarar a função "idle", depois <code>glutDisplayFunc(...)</code>:

 

glutIdleFunc(idle);

 

Vamos adicionar a nova função ociosa.

 

void idle()

{

glutPostRedisplay();

}

 

também removeremos a chamada para <code>glUniform1f</code> da <code>onDisplay</code>

 

e por ultimo, nós vamos fazer uma declaração de um biblioteca aritmética do C.

#include <math.h>

no Makefile deixe assim:

LDLIBS=-lglut -lGLEW -lGL '''-lm'''