Conceitos de Shaders em OpenGL

Prévia do material em texto

O sombreador de fragmento (fragment shader) é um pequeno programa que é 
executado uma vez para cada pixel renderizado. Ele é chamado quando os 
pixels são realmente renderizados em um buffer de estrutura. O framebuffer 
é uma matriz bidimensional de valores, geralmente mantendo um valor de cor e 
um valor de profundidade para cada pixel da imagem. 
Dito isso, quais dos tipos a seguir não é uma saída válida para um fragment 
shader? 
 
a. 
.ivec4. 
 
b. 
.dvec4. 
Resposta correta. O fragment shaderé representando pela variável FragColor, 
do tipo vec4 (vetor de 4 posições), do tipo unsigned int. Todas as alternativas 
seriam tipos de saídas válidas para um vetor de inteiros desse tipo, com a 
exceção de um dvec4, que é do tipo double, e possui uma instanciação 
numérica diferente de unsigned int. Sua inserção retornaria um erro de C++. 
 
c. 
.vec3. 
 
d. 
.float[4]. 
 
e. 
.unsigned int. 
Feedback 
A resposta correta é: .dvec4. 
Questão 2 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
Os sistemas gráficos modernos oferecem uma enorme flexibilidade na forma 
como a renderização ocorre. A funcionalidade mais simples é obtida 
escrevendo um sombreador de vértice (vertex shader) e de um de fragmento 
(fragment shader). Um sombreador de vértice é um pequeno programa que é 
executado uma vez para cada vértice. As principais entradas para um 
sombreador de vértice são os atributos de um único vértice. Em uma aplicação 
típica, o sombreador de vértice pode receber as coordenadas x, y, z do vértice 
e, talvez, uma coordenada de cor ou textura. O sombreador de vértice pode 
fazer cálculos bastante sofisticados, incluindo alterar os dados por vértice, as 
coordenadas de cor ou textura ou, até, a posição do vértice. A saída principal 
do sombreador de vértice é um valor que fornece as coordenadas x, y do 
vértice nas coordenadas da tela, que também fornece um valor de 
"profundidade" que será usado para o cálculo da superfície oculta. 
Um sombreador de vértice produz outros valores específicos do sombreador, 
como os componentes RGB, vermelho, verde e azul da cor do pixel. 
Dito isso, e considerando os estudos realizados, qual das alternativas a seguir 
descreve um tipo de entrada inválido para um vertex shader? 
 
a. 
.Arrays: vec4[2]. 
 
b. 
.Vetores inteiros do tipo int[2]. 
 
c. 
.Estruturas: struct vertex {vec4 Color; }. 
Resposta correta. O OpenGL não permite o tipo de entrada de estrutura de 
Color para o vertex shader, que é declarado como unsigned int. 
 
d. 
.Vetores Double: dvec4. 
 
e. 
.Vetores inteiros de 3 componentes: vec3. 
Feedback 
A resposta correta é: .Estruturas: struct vertex {vec4 Color; }. 
Questão 3 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
Em OpenGL, os modos de exibição conceitual de pontos, linhas e triângulos 
são descritos no espaço usando coordenadas x, y, z. A ideia crucial é que uma 
superfície tridimensional arbitrária exibida em tela pode ser aproximada por um 
conjunto de triângulos, e suavizada nos vértices desses triângulos por meio de 
técnicas de sombreamento. Existem três modelos para os modos gráficos de 
exibição: (1) pontos de desenho, (2) linhas de desenho e (3) triângulos de 
desenho. Os três modelos são diferentes arquiteturas de hardware para 
exibição gráfica. Os pontos de desenho correspondem ao modelo de uma 
imagem gráfica, como uma matriz de pixels num formato retangular. Por sua 
vez, as linhas de desenho correspondem à exibição vetorial de gráficos. 
Finalmente, o desenho de triângulos corresponde aos métodos usados pelos 
sistemas gráficos mais modernos, que podem exibir imagens tridimensionais. 
Esses modelos são representados em tempo de programação por 
identificadores de layout. 
 
Figura 3: Triângulos e métodos de geração em OpenGL 
Fonte: Elaborada pelo autor. 
 
Dito isso, e considerando os estudos realizados, qual modo não é um 
identificador de layout primitivo de entrada válido? 
 
a. 
.lines. 
 
b. 
.gl_triangles. 
 
c. 
.points. 
 
d. 
.triangle_strip. 
Resposta correta. O tipo de dado para triângulos não válido é o 
gl_triangle_strip. Todas as outras opções são tipos de entradas válidos. 
 
e. 
.triangles_adjacency. 
Feedback 
A resposta correta é: .triangle_strip. 
Questão 4 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
Para realizar animação em tempo de programação, basta desenhar uma 
sucessão de cenas estáticas, chamadas quadros, mostrando uma instância no 
tempo. Ou seja, o movimento é apenas uma ilusão visual; A ilusão de 
movimento é obtida exibindo rapidamente quadros sucessivos. Filmes e vídeos 
normalmente têm uma taxa de quadros de 24 ou 48 quadros por segundo. As 
taxas de quadros em gráficos de computador, por sua vez, podem variar com a 
potência do computador e com a complexidade da renderização de gráficos, 
mas geralmente é desejável ter 30 quadros por segundo e, mais idealmente, 
obter 60 quadros por segundo. Essas taxas de quadros são bastante 
adequadas para proporcionar um movimento suave na tela. 
Dito isso, e considerando os estudos realizados, selecione o trecho de código a 
seguir que corresponde ao comando correto para configurar uma taxa de 24 
fps (frames por segundo) em OpenGL: 
 
a. 
.while (!glfwWindowShouldClose(window)) { 
 myRenderScene(); 
 glfwSwapBuffers(window); 
 glfwWaitEventsTimeout(1.0/24.0); 
} 
Resposta correta. O comando exibido mostra a utilização da função 
glWaitEventsTimeout, da biblioteca glfw3, em que se pode definir diversas 
rotinas para diferentes técnicas avançadas em OpenGL, incluindo a de double 
buffering, para animação. 
 
b. 
.while (!glfwWindowShouldClose(window)) { 
 myRenderScene(); 
 glfwSwapBuffers(window); 
 glfwSetFramesPerSecond(24.0/1.0); 
} 
 
c. 
.while (!glfwWindowShouldClose(window)) { 
 myRenderScene(); 
 glfwSwapBuffers(window); 
 glfwWaitEventsTimeout(24.0/1.0); 
} 
 
d. 
.while (!glfwWindowShouldClose(window)) { 
 myRenderScene(); 
 glfwSwapBuffers(window); 
 glfwSetFps(24.0/1.0); 
} 
 
e. 
.while (!glfwWindowShouldClose(window)) { 
 myRenderScene(); 
 glfwSwapBuffers(window); 
 glfwWaitEventsTimeout(1.0/60.0); 
} 
Feedback 
A resposta correta é: .while (!glfwWindowShouldClose(window)) { 
 myRenderScene(); 
 glfwSwapBuffers(window); 
 glfwWaitEventsTimeout(1.0/24.0); 
} 
Questão 5 
Incorreto 
Atingiu 0,00 de 1,00 
Marcar questão 
Texto da questão 
Para que um jogo seja atrativo, são necessários alguns elementos básicos que 
fazem parte da ciência por trás do desenvolvimento de jogos. 
Dito isso, e considerando os estudos realizados, é possível afirmar que não faz 
parte dos cinco elementos do Design de Jogos: 
 
a. 
. as regras. 
 
b. 
.os componentes. 
 
c. 
.o espaço. 
 
d. 
. a mecânica. 
Resposta incorreta. Este elemento faz parte do Design de jogos. Tente 
responder novamente, levando em consideração aqueles elementos que fazem 
parte da estrutura externa do jogo. 
 
e. 
.os recursos. 
Feedback 
A resposta correta é: .os recursos. 
Questão 6 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
Para o desenvolvimento de jogos, design arquiteturais, filmes animados, 
simuladores, efeitos especiais, entre outras aplicações, é necessário um 
processo que aumente a eficiência e, ao mesmo tempo, reduza o custo na 
geração de imagens bi-dimensionais e tri-dimensionais. Isto pode ser feito a 
partir de modelos abstratos por meio de programas de aplicação, e as técnicas 
e funcionalidades utilizadas variam imensamente de acordo com o projeto. 
Dito isso, e considerando os estudos realizados, como se chama o processo de 
gerar imagens bidimensionais a partir de uma cena ou objeto tridimensional? 
 
a. 
.Renderização (rendering). 
Correto! Renderização é o processo de obtenção de um produto final por meio 
de um processamento digital específico. 
 
b. 
.Clipping. 
 
c. 
.Anti-aliasing. 
 
d. 
.Rasteirização (rastering). 
 
e. 
.Smoothing (suavização). 
FeedbackA resposta correta é: .Renderização (rendering). 
Questão 7 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
O termo "sombreamento" (ou shading) significa o processo de deixar a cor ou o 
brilho variar suavemente na superfície. O sombreamento é uma ferramenta 
importante para criar imagens realistas, principalmente quando combinadas 
com modelos de iluminação que calculam cores das propriedades do material e 
das propriedades da luz, ao invés de usar cores definidas explicitamente pelo 
programador. Os programas de sombreamento são assim chamados porque 
foram originalmente destinados ao controle de sombreamento de triângulos. No 
entanto, eles podem ser usados para muitos outros fins. 
Dito isso, e considerando os estudos realizados no e-book da disciplina, é 
correto afirmar que não é um tipo de sombreamento: 
 
a. 
.Bézier shading. 
Resposta correta. Uma superfície de Bézier é definida por um conjunto de 
pontos de controle. Embora seja semelhante à interpolação em muitos 
aspectos, uma diferença fundamental é que a superfície, em geral, não passa 
pelos pontos de controle central, mas é "esticado" na direção deles, como se 
cada um fosse uma força atraente. Eles são visualmente intuitivos e, para 
muitas aplicações, são matematicamente convenientes. 
 
b. 
.Smooth shading. 
 
c. 
.Phong shading. 
 
d. 
.Gouraud shading. 
 
e. 
.Flat shading. 
Feedback 
A resposta correta é: .Bézier shading. 
Questão 8 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
O OpenGL é uma API independente de plataforma (interface de programação 
de aplicativos) para renderização de gráficos 3D. Uma grande vantagem do 
uso do OpenGL é que ele é um padrão do setor amplamente suportado em 
diversos sistemas operacionais, ambientes e plataformas. Para suportar o 
desenho da Computação Gráfica 3D, bibliotecas dessa natureza tratam a tela 
do computador (display) como um espaço de coordenadas euclidiano, 
tridimensional, x-, y- e z-, sendo esta última coordenada a percepção de 
profundidade, ou proximidade do usuário com a imagem ou animação. 
Para projetar gráficos bidimensionais 2D, faz-se necessário o uso de alguns 
artifícios matemáticos e físicos para manipular o espaço de coordenadas. 
Dito isso, os códigos mostrados nas alternativas mostram a construção de uma 
matriz no espaço de coordenadas, representando a construção de um triângulo 
2D, bidimensional, ou seja, plano. Assim, em qual das opções esse triângulo 
ficaria projetado sem a noção de profundidade, ou seja, adequado para um 
jogo em 2D? 
 
a. 
.float verts2[] = { 
0.0, 0.25, 0.5, // Vértice w0 
0.0, 1.25, 1.0, // Vértice w1 
0.0, 0.75, 1.5, // Vértice w2 
0.0, 1.75, 1.8, // Vértice w3 
0.0, 2.0, 3.0, // Vértice w4 
0.0, 1.05, 2.5, // Vértice w5 
}. 
 
b. 
.float verts2[] = { 
0.0, 0.25, 0.5, // Vértice w0 
1.25, 0.0, 1.0, // Vértice w1 
0.75, 1.5, 0.0, // Vértice w2 
0.0, 1.75, 1.8, // Vértice w3 
2.0, 0.0, 3.0, // Vértice w4 
1.05, 2.5, 0.0, // Vértice w5 
}. 
 
c. 
.float verts2[] = { 
0.25, 0.5, 0.0, // Vértice w0 
1.25, 0.0, 1.0, // Vértice w1 
0.0, 0.75, 1.5, // Vértice w2 
1.75, 1.8, 0.0, // Vértice w3 
2.0, 0.0, 3.0, // Vértice w4 
0.0, 1.05, 2.5, // Vértice w5 
}. 
 
d. 
.float verts2[] = { 
0.25, 0.5, 0.0, // Vértice w0 
1.25, 1.0, 0.0, // Vértice w1 
0.75, 1.5, 0.0, // Vértice w2 
1.75, 1.8, 0.0, // Vértice w3 
2.0, 3.0, 0.0, // Vértice w4 
1.05, 2.5, 0.0, // Vértice w5 
0.4, 2.4, 0.0, // Vértice w6 
}. 
Perfeito! Você pensou corretamente e certamente deve ter analisado a relação 
funcional em OpenGL. Para realizar esse ajuste, é necessário zerar as 
coordenadas ‘z' de todos os pontos do triângulo, que são representadas pela 
última informação ponto a ponto da matriz. 
 
e. 
.float verts2[] = { 
0.25, 0.0, 0.5, // Vértice w0 
1.25, 0.0, 1.0, // Vértice w1 
0.75, 0.0, 1.5, // Vértice w2 
1.75, 0.0, 1.8, // Vértice w3 
2.0, 0.0, 3.0, // Vértice w4 
1.05, 0.0, 2.5, // Vértice w5 
}. 
Feedback 
A resposta correta é: .float verts2[] = { 
0.25, 0.5, 0.0, // Vértice w0 
1.25, 1.0, 0.0, // Vértice w1 
0.75, 1.5, 0.0, // Vértice w2 
1.75, 1.8, 0.0, // Vértice w3 
2.0, 3.0, 0.0, // Vértice w4 
1.05, 2.5, 0.0, // Vértice w5 
0.4, 2.4, 0.0, // Vértice w6 
}. 
Questão 9 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
Problemas de aliasing surgem ao converter entre representações analógicas e 
digitais, ou ao converter entre diferentes representações digitais de resolução. 
Um exemplo simples são as linhas irregulares que resultam ao desenhar uma 
linha reta em pixels de uma matriz retangular. Esses problemas de aliasing 
podem ser particularmente perturbadores para cenas animadas. 
Uma maneira simples de reduzir drasticamente os problemas de aliasing em 
um programa OpenGL é incluir as duas linhas a seguir para ativar o antialiasing 
de multisampling (MSAA): 
glfwWindowHint(GLFW_SAMPLES,4); // Invoca o MSAA 
glEnable(GL_MULTISAMPLE); 
Considerando estas informações, qual o principal recurso que um jogo que 
utiliza a técnica de multisampling vai consumir do computador? 
 
a. 
.Um monitor Full HD. 
 
b. 
.Capacidade de Processamento da CPU. 
 
c. 
.Memória de Hard Drive. 
 
d. 
.Capacidade de Processamento da GPU. 
 
e. 
.Memória de Acesso Randomico (RAM). 
Resposta correta. Devido ao fato de utilizar quatro valores de cores e 
profundidade por pixel, a única forma de realizar a alocação da memória a ser 
utilizada no anti-aliasing 
de várias amostras (multisampling) é por meio de alocação dinâmica de 
memória em tempo de execução. Mesmo que o processamento do código se 
dê na GPU, o principal recurso sendo consumido é o da memória, 
principalmente para animações complexas. 
Feedback 
A resposta correta é: .Memória de Acesso Randomico (RAM). 
Questão 10 
Correto 
Atingiu 1,00 de 1,00 
Marcar questão 
Texto da questão 
As entradas para o sombreador de fragmento correspondem aos valores 
específicos do sombreador emitidos pelo sombreador de vértice. Por padrão, 
cada entrada desse tipo no shader de fragmento é calculada como uma média 
dos valores específicos do shader correspondente, produzidos pelo shader de 
vértice. Ou seja, ao renderizar um triângulo, uma entrada para o shader de 
fragmento é uma média das saídas dos shaders de vértice para os três vértices 
do triângulo. 
Assim, por que o fragment shaderé necessário na triangularização para o 
OpenGL? 
 
a. 
.Para calcular a cor necessária para suavizar a imagem, pixel por pixel. 
Resposta correta. Também conhecido como pixel shader, a função principal do 
sombreador de fragmento é calcular a cor suavizada de cada pixel a ser 
exibido no triângulo. Ele é chamado quando os pixels são renderizados em 
um buffer de estrutura. 
 
b. 
.Para calcular a cor necessária para suavizar a imagem, nos pontos de cada 
vértice. 
 
c. 
.Para invocar os pixels renderizados em um buffer de estrutura (framebuffer). 
 
d. 
.Para calcular a melhor posição para os pontos do triângulo e para fazer 
adaptações na imagem, se necessário. 
 
e. 
.Para dividir a imagem em fragmentos e as sombrearem. 
Feedback 
A resposta correta é: .Para calcular a cor necessária para suavizar a imagem, 
pixel por pixel.