Computação Gráfica

Prévia do material em texto

Unidade I – Sistemas Gráficos .............................................................. 4 
Arquitetura De Placas Gráficas ...................................................................... 4 
Processador Gráfico ...................................................................................... 5 
Memória Vídeo ............................................................................................. 5 
Ramdac ....................................................................................................... 6 
A Interface Vga Standard:............................................................................. 6 
Bios Vídeos .................................................................................................. 6 
Interface : ................................................................................................... 6 
A Sua Importância no Desempenho Do Projeto .............................................. 7 
Analisar tipos de placa e sua importância dentro da computação 
gráfica. .................................................................................................. 7 
Perfil Doméstico ........................................................................................... 7 
Perfil Profissional Básico................................................................................ 8 
Perfil Gamer ................................................................................................. 8 
Perfil Entusiasta ........................................................................................... 8 
Perfil Profissional Avançado ........................................................................... 8 
Pipeline Gráfico ............................................................................................ 9 
ESPAÇO DO OBJETO .............................................................................. 9 
Object Space: .............................................................................................. 9 
World Space: ............................................................................................... 9 
Camera Space: ............................................................................................. 9 
Clipping Space: ............................................................................................ 9 
Canonical Space: ........................................................................................ 10 
Engine De Renderização (Engine 3D) ........................................................... 10 
Transformações 3D: ................................................................................... 10 
Projeção 3D → 2D ...................................................................................... 11 
Culling: ...................................................................................................... 11 
Clipping: .................................................................................................... 12 
Rasterização: ............................................................................................. 12 
A sua importância para a montagem de sistemas de base. ................ 13 
Montagem De Sistemas De Base ................................................................. 13 
Bibliotecas gráficas mais utilizadas (OpenGL e DirectX) .................... 15 
Introdução ................................................................................................. 15 
A melhor biblioteca gráfica dependendo do seu uso e a sua 
importância dentro da computação gráfica. ....................................... 17 
OpenGl: ..................................................................................................... 17 
DirectX ...................................................................................................... 17 
Unidade II – Funcionamento interno de um Game ............................ 19 
Itrodução As Apis ....................................................................................... 19 
AS API NATIVAS .................................................................................. 19 
A Api Gráfica do Windows ........................................................................... 19 
As Api Nativas ............................................................................................ 19 
Xwindow .................................................................................................... 20 
Qt ............................................................................................................. 20 
GTK ........................................................................................................... 20 
WxWidgets ................................................................................................ 21 
 
 
 
Linguagens básicas para programação em API. ................................. 21 
API ............................................................................................................ 21 
Framework .............................................................................................. 21 
Exemplos de Bibliotecas .............................................................................. 22 
C++ .......................................................................................................... 22 
O Processo de Game Loop .......................................................................... 23 
Como Fazer ............................................................................................... 23 
Na Prática .................................................................................................. 24 
Inicialização/Carregamento ......................................................................... 25 
Game Loop ................................................................................................ 25 
Unload/Shutdown ....................................................................................... 25 
Unidade III – Programando Shaders I ............................................... 25 
Tipos de shaders e suas características .............................................. 25 
Introdução ................................................................................................. 25 
O Pipeline Programável ............................................................................... 27 
Vrsão Shader ............................................................................................. 27 
Geometry Shader ....................................................................................... 28 
Pixel Shader (Fragment Shader) .................................................................. 28 
Efeitos básicos com shaders ............................................................... 29 
Introdução ................................................................................................. 29 
Tipos De Efeitos ......................................................................................... 29 
Iluminação ................................................................................................. 29 
Textura ...................................................................................................... 30 
Operações Matemáticas .............................................................................. 30 
Tansparência ............................................................................................. 31 
Unidade IV – Programando Shaders II ............................................... 31 
Efeitos Avançados Com Shaders .................................................................. 31 
Bibliografia ................................................................................................. 33 
 
 
 
 
Unidade I – Sistemas Gráficos 
Arquitetura de placas gráficas 
A placa gráfica (em inglês graphic adapter), tanbém chamadas de placa vídeo 
ou acelerador gráfico, é o elemento do computador encarregadoconverter os 
dados numéricos e transformar em dados gráficos. 
Os computadores de mais baratos, as placas de vídeo estão incorporadas na 
placa-mãe, não possuem memória dedicada, e por isso utilizam a memória viva 
do sistema, normalmente denomina-se memória compartilhada. 
O papel da placa gráfica era inicialmente o envio de pixéis gráficos para uma 
tela, bem como um conjunto de manipulação de gráficos simples: 
 Deslocação dos blocos; 
 Traçado de linhas; 
 Traçado de polígonos; 
 As placas gráficas recentes estão agora equipadas com processadores 
especializados no cálculo de cenários gráficos complexos em 3D! 
PRINCIPAIS COMPONENTES 
 Processador gráfico; 
 Memória vídeo; 
 RAMDAC; 
 BIOS vídeos. 
 
 
 
 
 
Processador gráfico 
Um processador gráfico (chamado GPU, para Graphical Processing Unit), 
constituindo o coração da placa gráfica e encarregue de tratar as imagens em 
função da resolução e da profundidade de codificação selecionada. 
O GPU é assim um processador especializado possuindo instruções evoluídas de 
tratamento da imagem, nomeadamente em 3D. 
Devido à temperatura que pode atingir o processador gráfico, às vezes tem um 
radiador e um ventilador. 
Memória vídeo 
A memória vídeo encarregada de conservar as imagens tratadas pelo 
processador gráfico antes da afixação. Quanto maior é a quantidade de 
memória vídeo, melhor a placa gráfica poderá gerir texturas aquando da 
afixação de cenas em 3D. Fala-se geralmente de frame buffer para designar a 
parte da memória vídeo que serve para armazenar as imagens antes de 
afixação. 
 
 
 
As placas gráficas são tributárias do tipo de memória utilizada na placa, porque 
o seu tempo de resposta é determinante para a velocidade de afixação das 
imagens, bem como a quantidade de memória, jogando com o número e a 
resolução das imagens que podem ser armazenadas no frame. 
RAMDAC 
O RAMDAC (random access memory digital-analog converter) permite 
converter as imagens numéricas armazenadas no frame proteção em sinais 
analógicos a enviar ao monitor. A frequência do RAMDAC determina as taxas de 
atualização (número de imagens por segundo, exprimido em Hertz - Hz) que a 
placa gráfica pode suportar. 
A interface VGA standard: 
As placas gráficas estão quase sempre equipadas com um conector VGA 15 
pinos (Mini SubD, composto de 3 séries de 5 pinos), geralmente de cor azul, 
permitindo nomeadamente a conexão de uma tela CRT. Este tipo de interface 
permite enviar para as telas 3 sinais analógicos que correspondem às 
componente vermelhas, azuis e verdes da imagem. 
BIOS vídeos 
O BIOS vídeos contém os parâmetros da placa gráfica, nomeadamente os 
modos gráficos que esta suporta. 
Interface : 
Trata-se do tipo de bus utilizado para conectar a placa gráfica à placa-mãe. O 
canal AGP está especialmente previsto para aceitar débitos consideráveis de 
dados, necessário para a afixação de sequências vídeo ou 3D. O bus PCI Expres 
possui melhor desempenho que o canal AGP e deve substituí-lo. 
 
 
 
 
 
A sua importância no desempenho do projeto 
Placa de vídeo, ou aceleradora gráfica, é um componente de um computador 
que envia sinais deste para o monitor, de forma que possam ser apresentadas 
imagens ao utilizador. Normalmente possui memória própria. Nos 
computadores de baixo custo, as placas de vídeo estão incorporadas na placa-
mãe, não possuem memória dedicada, e por isso utilizam a memória viva do 
sistema, normalmente denomina-se memória compartilhada. 
Como a memória viva de sistema é geralmente mais lenta do que as utilizadas 
pelos fabricantes de placas de vídeo, e ainda dividem o barramento com o 
processador e outros periféricos para acessá-la, este método torna o sistema 
mais lento. Isso é notado especialmente quando se usam recursos 
tridimensionais. 
Já em computadores bons e mais sofisticados, o adaptador de vídeo pode ter 
um processador próprio, o GPU ou acelerador gráfico. Trata-se de um 
processador capaz de gerar imagens e efeitos visuais tridimensionais, e acelerar 
os bidimensionais, aliviando o trabalho do processador principal e gerando um 
resultado final melhor e mais rápido. O resultado final normalmente é medido 
considerando-se o número de vezes por segundo que o computador consegue 
redesenhar uma cena, cuja unidade é o FPS (quadros por segundo). 
Analisar tipos de placa e sua importância dentro da 
computação gráfica. 
Perfil doméstico 
Se você é um usuário que utiliza seu computador apenas para navegar na 
internet, criar documentos, ouvir músicas e realizar tarefas simples, saiba que a 
aquisição de uma boa placa de vídeo não é necessária para seu perfil. 
Todas as tarefas que você quiser realizar são possíveis em uma simples placa 
onboard, que você já deve possuir em seu computador. 
 
 
 
 
Perfil profissional básico 
Se você trabalha com edição de imagens e vídeos ou outras tarefas na parte de 
design, não tenha dúvida que uma placa de vídeo offboard é fundamental para 
você. 
 É importante optar pelo menos por uma placa intermediária, visto que alguns 
programas trabalham com ferramentas tridimensionais e podem desfrutar da 
GPU. 
Perfil Gamer 
Como o próprio nome sugere, os usuários que se encaixam neste grupo são 
aqueles que procuram se divertir com os mais diversos tipos de games. 
Obviamente que você não precisa da melhor placa disponível no mercado para 
executar os jogos mais recentes, porém, caso esteja procurando por 
tecnologias recentes, uma placa top talvez seja a mais indicada. 
Perfil entusiasta 
Você adora ter o melhor e não pode viver sem overclock? Então, você é um 
entusiasta! Uma placa com duas GPUs é o mais indicado. Talvez, seja 
interessante até optar por uma configuração SLI ou CrossFire. 
Perfil profissional avançado 
Se você deseja montar um estúdio para edição de vídeos em alta definição ou 
para criação de animações profissionais, então, você se encaixa neste perfil. 
Placas comuns da série GeForce e Radeon não atendem suas necessidades. 
Opte por componentes mais robustos, como a ATI FirePro ou a NVIDIA Quadro. 
 
 
 
 
Pipeline gráfico 
Na computação gráfica 3D, o pipeline de gráficos refere-se a sequência de 
passos utilizados para criar uma representação raster 2D de uma cena 3D. É 
um dos conceitos mais importantes de computação gráfica existentes e é 
importante entendê-lo para dominar as APIs gráficas OpenGL e DirectX, pois 
diversas funções destas APIs agem sobre diferentes estágios do pipeline. 
ESPAÇO DO OBJETO 
Object space: 
Este é o espaço aonde ocorre a modelagem do objeto a partir das primitivas 
geométricas. Neste espaço não há uma importância de qual sistema de 
coordenadas foi adotado e o objeto ainda está modelado em espaços infinitos. 
World space: 
Este espaço engloba todo universos e permite-nos expressar as coordenadas de 
forma absoluta, transição do sistema de coordenadas do objeto para o sistema 
de coordenadas 3D(mundo virtual). 
A sua origem é a posição da câmera. 
Camera space: 
No espaço da câmera iremos escolher o posicionamento da câmera, o alcance 
de visualização e qual será tipo de projeção. Nem sempre a câmera será igual 
as coordenadas e assim precisaremos, transportar a cena para o plano da 
câmera. 
Clipping space: 
Nesse espaço está interligada processamentos gráficos, porquê é neste espaço 
aonde é feito o recorte das primitivas gráfica, e com isso interferindo no 
processos que são feitos durante a geração desse espaço. 
 
 
 
Desde o primeiro momento, aonde começamos do espaço do objeto até ao 
espaço do universo, é feita diversas transformações de primitivas. Logo após é 
feito o posicionamento da câmera, que indica o que será virtualizado e que 
posteriormente serão exibidos na tela. 
Canonical space: 
O espaço canônico é o espaço que basicamente faz o mapeamento dos pontos 
para centralizar o volume gerado na etapa anterior para o espaço canônico, 
formandoo Volume Canônico. Já fizemos muitos movimentos nos objetos que 
queremos renderizar e muito provavelmente eles estão distantes da origem. 
Portanto, é nesse espaço que iremos garantir o que será exibido na tela. A tela, 
é composta pelos valores de largura e altura que sempre são positivas e que o 
seu "eixo" é no canto superior esquerdo da tela. 
ENGINE DE RENDERIZAÇÃO (ENGINE 3D) 
O engine 3D será responsável basicamente pelo pipeline gráfico, que é o 
processo de gerar imagens 2D partindo de modelos 3D. Este processo é 
dividido em diversas etapas, sendo as mais importantes: 
 Transformações 3D; 
 Projeção 3D → 2D; 
 Culling; 
 Clipping; 
 Rasterização (iluminação e texturização). 
Transformações 3D: 
Nesta etapa aplica-se o movimento aos modelos 3D. Este movimento consiste 
no seguinte: 
 
 
 
A cada passo do jogo uma matriz irá acumulando o resultado de todos os 
movimentos que o objeto sofreu ao longo de seu histórico. Antes de visualizar a 
cena, será aplicada esta matriz sobre cada vértice que o compõem, 
posicionando-o no local que lhe corresponde naquele instante; 
Projeção 3D → 2D: 
Os vértices que compõem o objeto são coordenadas 3D, porém a imagem do 
modelo deverá ser desenhada numa superfície bidimensional (tela do 
computador). Nesta etapa, os vértices do modelo serão projetados sobre o 
plano de projeção da câmera. É comum encontrar esta etapa do pipeline junto 
com a etapa de transformações 3D, pois em última instância realizar esta 
projeção consiste numa aplicação de matriz de transformação também. 
Culling: 
Existem inúmeras formas de otimizar o processamento gráfico de um jogo. 
Uma destas consiste nos métodos de culling (Cull em inglês significa "refugo, 
escolher, selecionar de dentro de um grupo"). Assim, o que as técnicas de 
culling terão de fazer é saber escolher polígonos adequadamente, de forma que 
numa determinada situação, estejam presentes apenas aqueles que realmente 
importam para a visualização a partir do ponto em que a câmera se encontra. 
Pode-se pensar também da seguinte forma: quais dos polígonos de uma cena 
deverão ser enviados para o pipeline da placa gráfica? Obviamente não se 
deseja enviar algum que não terá nenhuma influência na visualização, mas até 
que ponto é simples realizar esta escolha, de forma rápida. Existem muitos 
algoritmos que farão este tipo de escolha. 
Em muitos casos a eficiência deste procedimento estará atrelada ao tipo de 
agrupamento e ordem de polígonos (um terreno possui uma distribuição de 
polígonos completamente diferente de que um personagem ou do que um 
labirinto). O culling pode ser feito em qualquer estágio do pipeline gráfico. 
 
 
 
Entretanto, é preferível eliminar os polígonos que não interessam o quanto 
antes para evitar processamento desnecessário sob polígonos que futuramente 
poderão ser eliminados. 
Vale a pena ressaltar que um método de culling não anula outro: podem-se ter 
os efeitos somados em muitos casos. 
Clipping: 
Ao projetar polígonos sobre o plano de projeção da câmera, alguns polígonos 
cairão totalmente dentro da área da tela e outros cairão parcialmente dentro, 
ou seja, apenas uma parte do polígono estará na tela de projeção. Para estes 
polígonos é necessário realizar o clipping (recorte), que consiste em criar novas 
arestas e vértices; 
Rasterização: 
Finalmente, a última etapa do processo de renderização consiste em preencher 
os polígonos adequadamente, aplicando o material com o qual estão definidos. 
Inicialmente poder-se-ia pensar em fazer este processo através de um cálculo 
de iluminação para cada um dos pixels (per pixel) do interior de um polígono. 
Entretanto isto seria demasiadamente caro em termos computacionais. Para 
viabilizar este processo realiza-se uma interpolação (rasterização) entre a cor 
de cada um dos vértices que compõem o polígono. Desta forma, o cálculo de 
iluminação é feito apenas para cada vértice (per vertex) visível da malha. Esta 
rasterização também poderia demandar bastante tempo de processamento, 
pois apesar de ser algo simples de ser feito, existem pixels numa tela. 
(processo realizado por um hardware específico a placa gráfica, ou GPU – 
Graphic Processor Unit.) 
 
 
 
A sua importância para a montagem de sistemas de base. 
Montagem de sistemas de base 
O processo básico de geração de imagens tridimensionais por computador para 
aplicações em tempo real ou interativas, amplamente conhecido por pipeline de 
visualização. Trata-se de uma estratégia de visualização que proporciona um 
compromisso razoável velocidade de desenho versus realismo. 
O propósito desta técnica consiste em criar uma projeção 2D da cena 
tridimensional, tomando em linha de conta a iluminação e a perspectiva de 
visualização. O processo assume como entrada uma cena tridimensional, 
consistindo de objetos descritos por polígonos1, fontes de luz e parâmetros de 
visualização, e à qual vai ser aplicada uma sequência de andares de cálculo: 
1 - Atravessar a base de dados que contém o modelo matemático da cena; 
2 - Aplicar o modelo de reflexão local de acordo com o algoritmo de 
sombreamento; 
3 - Aplicar as transformações geométricas de acordo com a posição e a direção 
de um observador; 
4 - Eliminar as faces escondidas (operação designada por back-faces culling); 
5 - Executar o recorte e opcionalmente a transformação perspectiva; 
6 - Calcular os pixéis que irão ser ativados (scan-conversion); 
7 - Calcular a cor de cada um dos pixéis (algoritmo incremental de 
sombreamento); 
8 - Remover as superfícies ocultas; 
9 - Implementar eventuais efeitos visuais (ex: mapeamento de texturas, 
transparências, sombras); 
10 - Filtrar os ruídos (anti-aliasing); 
 
 
 
11 - Escrever a informação respeitante aos pixels na memória de imagem para 
visualização (implementa implicitamente a projeção 2D). 
O fluxo de atividade entre o processo de atravessamento da base de dados da 
cena e a visualização da imagem numa tela pode ser agrupado em dois grandes 
blocos funcionais distintos: 
O bloco dos cálculos geométricos (passos 2, 3, 4 e 5) que fundamentalmente 
converte as primitivas gráficas descritas em coordenadas do Mundo em 
primitivas descritas em coordenadas de tela. 
O bloco de rasterização (passos 6, 7, 8, 9, 10) que converte informação 
geométrica em pixels na tela com informação de cor. 
O processamento geométrico opera no Espaço-Objeto e a rasterização opera 
no Espaço-Imagem. 
Como se referiu anteriormente, a visualização de cenas tridimensionais numa 
tela bidimensional implica a execução de uma projeção. 
Saliente-se que a execução dos passos 1 a 10 envolve operações 
tridimensionais, ou seja, operações onde é necessário conhecer 
obrigatoriamente as três coordenadas, como, por exemplo, a profundidade, 
para poder resolver o problema da visibilidade. 
Deste modo, a projeção é realizada implicitamente apenas no passo 11 quando 
se guarda a informação de cor dos pixéis, pois só aqui se acede à informação 
em x e y, através do acesso à memória de imagem. 
 
 
 
 
 
 
Bibliotecas gráficas mais utilizadas (OpenGL e DirectX) 
Introdução 
De maneira errônea, muitas pessoas acreditam que Computação Gráfica é 
saber usar programas para editar fotos ou trabalhar com desenhos vetoriais, 
tais como PhotoShop, Core Draw, 3DStudio… no entanto isso seria limitar a 
área ao simples uso de aplicações com finalidades específica para criação e 
manipulação de figuras, desenhos, cores, texturas. 
Atualmente todas as áreas da computação dependem de aplicações gráficas de 
alto desempenho. Isso requer naturalmente, grandes recursos de hardware 
para processar estes ambientes e interfaces, além naturalmente da necessidade 
de programadores experientes para lidar com as mais diversas bibliotecas e 
tecnologias existentes. 
A Computação Gráfica é uma área da Ciência da Computação dedicada ao 
estudo e desenvolvimento de técnicase algoritmos para geração de imagens, 
bem como análise e manipulação das mesmas. 
Está presente em diversas áreas do conhecimento, que vão desde aplicações 
para Engenharia em projetos e modelagem de objetos, simuladores e na 
criação de jogos eletrônicos. 
A Computação Gráfica surge somente após a criação de periféricos gráficos de 
entrada e saída, pois antes as informações eram representadas somente por 
meio de caracteres alfanuméricos. A quantidade de cálculos matemáticos em 
aplicações gráficas necessita de muita memória e recursos de processamento 
em termos de velocidade. 
Para aproveitar melhor a capacidade de hardware e facilitar a criação de 
aplicações gráficas, o mais comum é que programadores utilizem bibliotecas 
prontas que trazem uma infinidade de funcionalidades rotinas comuns. 
 
 
 
No caso específico da Computação Gráfica, programadores necessitam de 
rotinas gráficas para elaborar rapidamente programas sem ter a preocupação 
de desenvolver algoritmos básicos, tais como um segmento de reta, inclinação, 
preenchimento de objetos e etc. 
A Open Graphics Library – OpenGL pode ser compreendida como um 
conjunto de rotinas gráficas e de modelagem que facilita o desenvolvimento de 
aplicações gráficas, sejam elas bidimensionais ou tridimensionais. 
A OpenGL é gerenciada por um consórcio independente formado em 1992 
formado por diversas empresas tais como 3DLabs, Apple, NVIDIA, SGI, ORACLE 
(SUN), Microsoft e diversas outras. A OpenGL se trata de uma API para a 
criação de programas gráficos 2D e 3D multiplataforma que serve tanto para 
estações de trabalho potentes ou computadores pessoais. Seu funcionamento é 
semelhante a uma biblioteca da linguagem de programação C. 
Um programa ou aplicação baseado em OpenGL pode ser escrito em alguma 
linguagem de programação que utiliza uma ou mais rotinas da biblioteca 
OpenGL. 
Para facilitar o desenvolvimento de aplicações gráficas, há algumas bibliotecas 
que nos auxiliam com diversas funções para criar janelas e gerenciar eventos. 
As mais utilizadas são a GLU e a GLUT. 
A GLU (OpenGL Utility Library) é mais comum e instalada com a OpenGL. 
Seguem uma rígida padronização nos nomes das funções, sendo utilizado 
sempre o prefixo glu. Destacamos que é usada na definição de matrizes para 
projeção e orientação da visualização, mapeamento de coordenadas e desenho 
de superfícies quadráticas. 
 
 
 
A GLUT (OpenGL Utility Toolkit) foi desenvolvida para facilitar o 
desenvolvimento de interfaces. É um kit de ferramentas independente de 
plataforma que inclui alguns elementos de GUI (Graphical User Interface). Com 
a CLUT podemos por exemplo criar menus pop-ups, gerenciar eventos de 
teclado, mouse. Entendemos que a GLUT encapsula a complexidade das APIs 
dos vários sistemas de janelas que existem hoje em dia. 
A melhor biblioteca gráfica dependendo do seu uso e a sua 
importância dentro da computação gráfica. 
OpenGl: 
OpenGL é definida como "um programa de interface para hardware gráfico". Na 
verdade, OpenGL é uma biblioteca de rotinas gráficas e de modelagem, bi (2D) 
e tridimensional (3D), extremamente portável e rápida. Usando OpenGL é 
possível criar gráficos 3D com uma qualidade visual próxima de um ray tracer. 
Entretanto, a maior vantagem na sua utilização é a rapidez, uma vez que 
usa algoritmos cuidadosamente desenvolvidos e otimizados pela Silicon 
Graphics, Inc., líder mundial em Computação Gráfica e Animação. 
DirectX 
DirectX é um Conjunto de APIs multimídia da Microsoft para Windows. É 
composto por diversas APIs como DirectInput, directSound, direct3D, 
além de alguns outros. É muito utilizado em diversos aplicativos para Windows 
(uma vez que não é multiplataforma) sendo jogo um tipo desses aplicativos 
A versão mais atual da API Direct3D, a principal dentre as que vem com a API é 
a 11. Nas edições atuais algumas APIs foram depreciadas e por isso não são 
inclusas com o DirectX, sendo uma delas a DirectSound. 
 
 
 
 
Como a evolução da Computação Gráfica depende da evolução do hardware, 
recentemente, as novas gerações de placas gráficas possibilitaram o 
desenvolvimento de várias aplicações e um grande avanço em muitas áreas da 
CG. Por exemplo, os jogos eletrônicos hoje apresentam imagens com alto grau 
de realismo, além de permitir a conexão de jogadores através da Internet. 
Muitas imagens podem ser geradas em tempo real devido à possibilidade de 
programar o hardware gráfico. Isso também tem beneficiado a área de 
visualização, que, em geral, trabalha com uma grande quantidade de dados 
que pode ser armazenada na memória das placas gráficas. 
Por isso, a programação de hardware gráfico tem sido uma área em grande 
evolução. A Unidade de Processamento Gráfico – do inglês “Graphics Processing 
Unit"(GPU) foi desenvolvida inicialmente como um hardware destinado a 
aumentar a eficiência e o poder de processamento gráfico para tarefas de 
renderização. 
Hoje, a GPU apresenta-se como um hardware de processamento versátil e de 
alto poder de computação. 
Tornou-se uma possibilidade real na busca por soluções para processamento 
em grandes volumes de dados, seja como complemento, seja como alternativa 
ao uso de CPUs multicore ou de sistemas distribuídos. 
A utilização da GPU em computações de propósito geral é de especial interesse, 
uma vez que para diversas aplicações, ainda não existem formulações 
sequenciais suficientemente rápidas de serem computadas. 
 
 
 
Unidade II – Funcionamento interno de um Game 
 
INTRODUÇÃO AS APIS 
Existem muitas bibliotecas de programação de uma interface gráfica para um 
software. E a portabilidade, a rapidez de execução, a velocidade e o custo de 
desenvolvimento, a estabilidade e a licença de seu software dependerão da sua 
escolha de biblioteca de gráfica. 
AS API NATIVAS 
A Api gráfica do Windows 
 
Alguns sistemas implementam sua interface gráfica no próprio sistema 
operacional, é o caso do Windows cuja parte gráfica se encontra dentro do 
núcleo do sistema operacional. Como mencionado anteriormente, a interface 
gráfica do Windows não é implementada no nível do usuário, mas no nível do 
kernel, que tem a vantagem de obter interfaces de rápida execução. 
No entanto, o uso direto da API (Application Programming Interface ou 
Interface de Programação de Aplicativos) do Windows também tem muitas 
desvantagens: 
AS API NATIVAS 
Esta API tem pouca abstração, o gerenciamento da IHC (Interação humano-
computador) é feito através do uso de funções de baixo nível. 
Desenvolver uma IHC com esta API vai demorar mais e pode esconder alguns 
bugs. No entanto, uma biblioteca, cuja abordagem é de baixo nível poderá, 
eventualmente, permitir mais possibilidades em gráficos. Esta API não é 
portátil. O seu software não pode ser usado fora do Windows, a menos que 
você use a emulação. 
 
 
 
Você pode usar esta API em C ou C++ usando os MFC e, claro, em vários 
idiomas. Note que a programação de interfaces gráficas como uso da API do 
Windows é, muitas vezes, mais confortáveis com IDE como o Microsoft Visual 
C++. 
Xwindow 
É uma biblioteca de terceiros, mas como ela se situa na base do sistema IHC, 
em alguns Sistemas Operacionais como o Linux/Unix. Você pode usar 
XWindows para desenvolver interfaces gráficas, mas ainda neste caso você 
corre o risco de ter uma biblioteca com pouca abstração e que, portanto, 
exigirá mais tempo de desenvolvimento. 
Por outro lado, você obterá um software totalmente portátil: XWindow também 
existe no Windows. Outro ponto importante, algumas implementações do 
Xwindow são livres (XFree, XOrg). 
Qt 
Qt é uma biblioteca gráfica portátil, disponível para o Unix/Linux e o Windows. 
Ele é conhecido por ter uma arquitetura confortável. Qt é destinado ao uso em 
C++, mas você também pode usá-lo com muitas outras linguagens (C/Python, 
etc ...). Como exemplo de Qt, basta ver o desktop KDE no Linux ou no softwareAmarok. 
GTK 
Como a Qt, GTK é uma biblioteca livre e portátil. Também é apreciada. O 
software Gimp, por exemplo, foi feito com a Gtk. Outro exemplo é o desktop 
Gnome usado no Linux. Gtk foi escrita em C mas pode ser utilizada em várias 
outras linguagens. 
 
 
 
WxWidgets 
Sua particularidade é a de produzir janelas com a mesma aparência como se 
ela tivesse sido programada usando a API nativa do sistema. 
Linguagens básicas para programação em API. 
API 
Uma API (Aplicação Programável Interface, ou “interface de programação” ou 
“interface para o acesso programado às aplicações) é um conjunto de funções 
que permitem aceder aos serviços de uma aplicação, através de uma linguagem 
de programação. Uma API permite fornecer um certo nível de abstração ao 
programador, o que quer dizer que ela mascara a complexidade do acesso a 
um sistema ou a uma aplicação, propondo um jogo de funções standard das 
quais só os parâmetros e os valores devolvidos são conhecidos. 
Assim, por analogia com um automóvel, o motorista não tem de conhecer o 
funcionamento mecânico do motor de um veículo para poder conduzi-lo. 
Apenas uma interface, composto por um volante, pedais, quatro piscas, faróis 
de nevoeiro, buzina, etc. lhe é acessível: trata-se, de certa maneira, da 
interface proposta ao utilizador. 
Graças ao API, um programador não tem, por conseguinte, de se preocupar 
com a forma como uma aplicação distante funciona, nem com a maneira como 
as funções foram aplicadas para poder utilizá-las num programa. Uma API pode 
estar disponível para uma linguagem específica ou estar disponível para várias 
linguagens de programação. 
Framework 
O termo “Aplication Framework” (traduzam “Quadro de aplicação”, “planos de 
aplicação” ou “base de aplicação”) designa um conjunto estruturado de API, 
organizado num ambiente de execução. 
 
 
 
O termo “Aplicação Framework” é utilizado geralmente sob a forma abreviada 
de “Framework” 
Exemplos de bibliotecas 
 
– OpenGL: conjunto de funções para desenhar diretamente no buffer da 
placa de vídeo; 
– OpenCV: conjunto de funções para processamento de imagem e visão 
computacional; 
– OpenAL: conjunto de funções para processamento, síntese e execução 
de áudio. 
 
Na prática, para usar uma biblioteca basta incluir uma chamada para ela 
no início do código, por exemplo: 
 
Para usar OpenGL em C ou C++ devemos ter uma linha no início do código 
assim: 
#include “GL/gl.h” 
“gl.h” é uma INTERFACE de programação que contém declarada todas as 
funções de OpenGL que você pode usar no seu programa. 
 
A diferença entre uma biblioteca e um aplicativo é que: 
 
 Um aplicativo tem um executável (arquivos binários no Linux ou “.exe” 
no windows) e 
 Uma biblioteca não tem, pois ela é só um conjunto de funções pré-
compiladas (no linux arquivos. O, no windows arquivos .dll) 
Não faz sentido bibliotecas serem executadas do nada, elas devem ter suas 
funções chamadas por aplicativos. 
C++ 
Linguagem de programação compilada multi-paradigma (seu suporte inclui 
linguagem imperativa, orientada a objetos e genérica) e de uso geral. A 
linguagem é considerada de médio nível, pois combina características de 
linguagens de alto e baixo níveis. Desde os anos 1990 é uma das linguagens 
comerciais mais populares, sendo bastante usada também na academia por seu 
grande desempenho e base de utilizadores. 
 
 
 
Bjarne Stroustrup desenvolveu o C++ (originalmente com o nome C com 
classes) em 1983 no Bell Labs como um adicional à linguagem C. 
Novas características foram adicionadas com o tempo, como funções virtuais, 
sobrecarga de operadores, herança múltipla, gabaritos e tratamento de 
exceções. Após a padronização ISO realizada em 1998 e a posterior revisão 
realizada em 2003, uma nova versão da especificação da linguagem foi lançada 
em dezembro de 2014, conhecida informalmente como C++ 
O Processo de Game Loop 
É a estrutura base de qualquer implementação de Jogo Digital e deve ser 
corretamente estruturado para que tenhamos o comportamento correto em 
nosso Jogo. 
 
“O personagem está parado esperando que o usuário acione alguma 
coisa para que ele possa executar, mas o jogo está acontecendo...” 
 
A partir da visão do personagem, nos mostra que para que as coisas fluam 
dentro do jogo não é necessário nenhum evento externo. 
O fluxo do jogo segue na linha do tempo atualizando o estado de cada objeto, 
independentemente de qualquer comando. Essaé a ideia de Game Loop. 
COMO FAZER 
Olhando o referencial do programador, vamos formalizar a ideia de Game Loop 
e transforma-la em um pseudo-código. Primeiramente podemos perceber que o 
Game Loop é executado incessantemente e que a única situação em que ele 
para, é quando o jogo não está em execução. Uma estrutura que formaliza 
essa ideia do ponto de vista das linguagens de programação são os laços de 
repetição. 
 
Um exemplo prático bem simplório seria: 
 
 
 
 
O comando onEnterFrame no actionScript. 
onEnterFrame=function(){ 
código que se repetirá durante a espera de um 
comando 
} 
 
Outro seria um laço de while 
While (jogo_parado){ 
código que se repetirá durante a espera de um 
comando 
Incrementa algo 
} 
O CONCEITO 
 
enquanto (oJogoEstaRodando) 
inicio 
 calcule a proxima posicao do inimigo com base na atual 
 se (o inimigo atingiu a parede) 
 inverta a direção 
 senão 
 assume a posicao calculada 
 fim se 
 pinte a situacao de jogo atual 
 espere 40 milisegundos 
fim 
 
NA PRÁTICA 
 
while (isRunning) { 
 game.processLogics(); 
 game.renderGraphics(); 
 sleep(40); 
} 
O método sleep 
public void sleep(int millis) { 
 try { 
 Thread.sleep(millis); 
 } catch (InterruptedException e) {} 
} 
 
O ciclo de vida de um jogo 
 
Um jogo normalmente passa pelas seguintes fases: 
 
 
 
 Inicialização/Carregamento; 
 Game Loop; 
 Unload/Shutdown. 
Inicialização/Carregamento 
Define os valores padrão e preliminares, consulta e inicializa informações 
baseadas no usuário, carrega os conteúdos gráficos e os não gráficos, etc. 
Game Loop 
Executa a lógica de repetição do jogo e os cálculos de layout e renderização. 
Unload/Shutdown 
Salva o estado atual, libera e descarrega conteúdos, etc. 
Unidade III – Programando Shaders I 
Tipos de shaders e suas características 
INTRODUÇÃO 
Até pouco tempo atrás, pelos idos de 2003, predominava a renderização gráfica 
pelas GPUs através do pipeline fixo, pelo qual passa todo o dado de uma 
aplicação gráfica 3D que usava efetivamente uma placa de vídeo. Apesar de 
rápido e com a velocidade crescendo a cada dia, tal processo apresentava 
limitações, uma vez que não era possível ter um controle fino sobre o dado que 
era passado pelo pipeline, sendo que estes se sujeitavam aos algoritmos 
internos realizados na renderização e presentes dentro da própria GPU. 
 
 
 
Com a necessidade de realismo e desempenhos combinados crescendo sempre, 
motivada pela demanda dos consumidores quer sejam eles usuários comuns de 
aplicações gráficas, quer sejam pesquisadores científicos, muitos métodos 
haviam surgido para aumentar o realismo na imagem, vários deles através da 
renderização de multipasse. Entretanto, isto não foi o suficiente e a disputa 
comercial aliada aos rápidos avanços na área de computação gráfica, tiveram 
como consequência o surgimento dos shaders, ou seja, o nascimento das 
primeiras placas de vídeo com pipeline programável. 
Destas placas a primeira placa de vídeo com alguma presença de shaders foi a 
Geforce 3 TI que possibilitava ao desenvolvedor programar um vertex shader. 
Obviamente, que como era uma tecnologia nova, ela enfrentava uma série de 
limitações que com o tempo foram superadas ou, minimizadas. 
Seguindo o modelo criado pela Geforce 3 TI, outras placas de vídeo começaram 
a incorporar shaders em sua arquitetura, dando maior flexibilidade e controle 
do programador sobre os programas gráficos produzidos.Não demorou muito para que o DirectX 8 introduzisse suporte a shaders e para 
que o OpenGL 1.4 o fizesse também na forma de uma extensão padronizada 
pela ARB (Architeture Review Board), organização que era responsável na 
época pela decisão quanto aos rumos do OpenGL. Contudo, ainda que tal 
flexibilidade fosse possível, o código para que fosse possível manipulá-la era um 
tipo de Assembly, padronizado pela ARB. Porém, ainda que padronizado o 
assembly da placa de vídeo, como de qualquer outro hardware, é programação 
em baixo nível, sendo propensa a erros. 
Dessa dificuldade surgiram pesquisas que culminaram nas invenções das 
linguagens de shading de alto nível CG, HLSL, GLSL, as quais baseavam suas 
estruturas no C e, conseqüentemente retiravam uma grande parte da 
complexidade da implementação, bem como, diminui o tempo de aprendizagem 
da linguagem, por se basear numa linguagem amplamente conhecida e 
difundida, o C. 
 
 
 
Assim desde 2003 até 2009, ano da presente publicação muitos avanços 
ocorreram como o aprimoramento dos pixeis e vertex shaders, a criação do 
shader de geometria, a unificação dos shaders nas placas de vídeo mais 
modernas e o amplo interesse acadêmico na GPU e o possível uso desta para 
uso não apenas de aplicações gráfica, mas de aplicações de propósito geral, 
GPGPU (General Purpose GPU). 
O PIPELINE PROGRAMÁVEL 
O pipeline programável nada mais é do que a repetição dos eventos que 
ocorrem no pipeline fixo, mas com um controle mais fino pela parte do 
programador, já que permite que este programe certos estágios do pipeline, 
alterando a saída que resultaria deste em sua versão fixa. Para isto existem três 
tipos de shader. O vertex shader, o geometry shader e o pixel shader. 
Cada um deles será explicado mais adiante com suas características, a fim de 
expor a funcionalidade de cada um, deixando claro porquê é usado e como é 
usado. 
 VERTEX SHADER 
Tem por responsabilidade substituir o processo de manipulação dos vértices 
presente no pipeline fixo, permitindo ao programador manipular as 
transformações geométricas, o posicionamento e cor dos vértices, bem como o 
processo de iluminação e geração de coordenas de textura na parte dos 
vértices. Diante de suas responsabilidades o vertex shader é extensivamente 
usado, estando presente nos mais variados tipos de algoritmos aplicados ao 
programa em si e, portanto, tem importância fundamental no contexto do 
pipeline programável. Frente a esta posição ele vêm sofrendo constantes 
avanços, evoluindo junto e, em paralelo, aos outros shaders, à medida que o 
hardware evolui. 
 
 
 
 
GEOMETRY SHADER 
O Geometry Shader não tem correspondência no pipeline fixo de renderização. 
Sua principal função é a de criar ou remover vértices, permitindo um maior 
controle na geometria que passa pelo pipeline programável, aumentando ou 
diminuindo o nível de detalhe de acordo com o necessário, permitindo com que 
uma enorme variedade de efeitos sejam possíveis, como melhor interpolação 
de vértices com a adição de novos vértices quando necessário, renderização de 
silhueta, entre outros. Apesar de ser flexível e capaz de uma série de efeitos 
interessantes o Geometry Shader é relativamente novo, sendo incluído na API 
DirectX em sua versão 10, no ano de 2006, este shader é ineficiente se 
comparado com os outros e deve ser usado cuidadosamente para que se tire 
proveito de seus benefícios e o resultado seja um shader eficiente em sua 
tarefa. 
PIXEL SHADER (FRAGMENT SHADER) 
Para dar mais poder de expressão e flexibilidade aos artistas e programadores 
as linguagens de shading foram inventadas. As primeiras delas eram offline, 
uma vez que para a época (1995) era proibitiva a renderização em tempo real 
com código de shading programável. Assim softwares como o Renderman e 
XXX foram inteiramente produzidas para se utilizarem renderização por 
software. Com o tempo foram inventadas outras linguagens para o mesmo fim 
até que finalmente surgissem as linguagens de shading para shaders de Placas 
de vídeo renderizando em tempo real. 
 
 
 
bbEfeitos básicos com shaders 
INTRODUÇÃO 
Efeitos são entidades que podem encapsular vários shaders diferentes, além de 
configurações dos estados do pipeline fixos necessárias para a execução do 
mesmo. Em cada efeito é possível criar uma ou mais técnicas, que são 
utilizadas na renderização das malhas. Cada técnica criada deve definir quais 
shaders serão utilizados para o processamento de vértices, geometria e pixels. 
Isso permite, por exemplo, que duas técnicas diferentes possam utilizar um 
mesmo processamento de vértices, mas possuam diferentes processamentos de 
pixels. A técnica a ser utilizada na renderização de um objeto pode ser 
escolhida em tempo de execução de acordo, por exemplo, com os recursos do 
hardware gráfico do usuário. 
 TIPOS DE EFEITOS 
 Iluminação; 
 Texturas; 
 Operações matemáticas. 
 ILUMINAÇÃO 
Teoria – Phong Lighting - Esta técnica para o cálculo de iluminação foi 
desenvolvida por Bui Tuong Phong na universidade de Utah em 1973. Na época 
de sua concepção ela foi considerada radical (pois era simples demais 
comparado com os modelos da época), entretanto hoje é o mais utilizado em 
aplicações de tempo real. 
 
 
 
 O modelo Phong é essencialmente uma aproximação empírica de um sistema 
de iluminação local (sistemas que consideram apenas a luz que incide 
diretamente nos objetos). Ele descreve como uma superfície reflete a luz, 
sendo uma combinação da reflexão difusa, da reflexão especular e da reflexão 
ambiente. Para uma explicação mais física (incluindo conceitos de Irradiancia, 
radiancia ... ) recomendo a segunda parte do livro Principles of Digital Image 
Synthesis. 
TEXTURA 
Uma das primeiras formas de acrescentar detalhes em uma renderização sem 
acrescentar geometrias é através da utilização de texturas. Geralmente uma 
textura é uma imagem 2D composta por texels (texture elements) que é 
aplicada sobre um triângulo. Esta definição restringe uma gama de aplicações 
interessantes que podemos fazer, por este motivo textura para este tutorial 
deve ser vista por uma visão mais geral: É uma função que mapeia uma 
coordenada n-dimensional a uma informação de 4 componentes que pode 
representar uma cor. 
OPERAÇÕES MATEMÁTICAS 
Na fase de modelagem são definidas as formas geométricas, bem como suas 
posições e proporções. Ou seja, o espaço virtual é confeccionado considerando, 
principalmente, o dimensionamento físico dos objetos que constituem a cena. 
Após a modelagem, torna-se necessário aplicar um conjunto de algoritmos que 
melhorem a impressão visual da cena, ou seja, deve-se aplicar um acabamento 
final para que a imagem possua características foto-realísticas, aproximando o 
ambiente virtual do real. Dessa maneira, há sensação de imersão de um 
usuário em um jogo ou em um aplicativo gráfico qualquer (daí a necessidade 
de um bom posicionamento e movimentação da câmera virtual). 
 
 
 
Para criar esse realismo são utilizados algoritmos de textura como bump 
mapping, parallax mapping e displacement maping. Além disso, também podem 
ser utilizados algoritmos de iluminação global, como radiosidade ou ray-tracing, 
ou até mesmo o acréscimo de efeitos na iluminação local, como técnicas para 
gerar sombras, refração e outros.Esta última etapa é essencial para obter uma 
alta qualidade na cena, porém o custo computacional é muito alto dificultando a 
criação de projetos que necessitam de tonalização em tempo real. 
TRANSPARÊNCIAS 
Para criar esse realismo são utilizados algoritmos de textura como bump 
mapping, parallax mapping e displacement maping. Além disso, também podem 
ser utilizados algoritmos de iluminação global, como radiosidade ou ray-tracing, 
ou até mesmo o acréscimo de efeitos na iluminação local, como técnicas para 
gerar sombras, refração e outros. 
Esta última etapa é essencial para obter uma alta qualidadena cena, porém o 
custo computacional é muito alto dificultando a criação de projetos que 
necessitam de tonalização em tempo real. 
Unidade IV – Programando Shaders II 
Efeitos avançados com shaders 
TIPOS DE EFEITOS 
 Reflexos; 
 Contornos; 
 Vector-shaders; 
 Screen-space; 
 Post-processing. 
 
 
 
 
 
Reflexos: 
Cria efeitos de reflexo, junto com o efeito de iluminação. 
Contornos: 
Detecta e modifica os contornos em tempo real. 
Vertex shader : 
Manipula vértices e consequentemente o formato de objetos. Esses vértices são 
então enviados para os geometry shaders. 
Screen-space: (Mapeamento de espaço na tela) 
Mapeamento de espaço na tela é uma técnica para projetar texturas planas da 
câmera. A configuração do nó para isso é bastante simples. 
O nó da posição da tela indica a posição do pixel atual que está sendo 
processado, no espaço da tela. Ele é definido como "lado a lado" para evitar 
que se estenda por toda a tela. 
Post-processing: (pós-processamento) 
Esta configuração possui efeitos diferentes para cada jogo. O mais comum são 
efeitos de luz como o "bloom" (que é quando a luz se espalha suavemente 
pelo cenário) ou o "motion blur" (que simula o borrão de luz quando há 
movimentos rápidos). 
Outro efeito deste parâmetro é a simulação da mudança de luz quando se 
passa de um ambiente muito escuro para um muito iluminado, como aquele 
clarão que nos deixa cego até nossos olhos se acostumarem, e vice-versa. 
 
 
 
 
BIBLIOGRAFIA 
HUGHES, John F. et al. Computer graphics: principles and practice. Pearson 
Education, 2013. 
LENGYEL, Eric. Mathematics for 3D game programming and computer graphics. 
Cengage Learning, 2012. 
BORESKOV, Alexey; SHIKIN, Evgeniy. Computer Graphics: From Pixels to 
Programmable Graphics Hardware. CRC Press, 2013. 
BIBLIOGRAFIA COMPLEMENTAR: 
BUCKLAND, Mat. Programing AI By Example. Texas: Wordware Publishing, Inc., 
2005. 521 p. 
LUNA, Frank D. Introduction to 3D game programming with DirectX 10. Jones & 
Bartlett Publishers, 2008. 
WRIGHT, Richard S. et al. OpenGL SuperBible: comprehensive tutorial and 
reference. Pearson Education, 2010.