Manual de Apoio 2010

Computação GráficaManual de Apoio2010Luís Filipe Lobo

Conteúdo1 Introdução 51.1 A caminho do 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.2 Efeitos 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.3 Transformações Geométricas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.3.1 Eye Coordinates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.3.2 Viweing Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.3.3 Modeling Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3.4 Projection Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3.5 Viewport Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Princípios Básicos de Programação 3D 112.1 Sistemas de Coordenadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.1.1 Coordenadas Cartesianas - 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.1.2 Viewport - Mapeamento de coordenadas para pixels . . . . . . . . . . . . . . . . . . . . . 112.1.3 O Vertex (vértice) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.1.4 Coordenadas Cartesianas 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.2 Projecções: 3D → 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.2.1 Projecções Ortogonais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.2.2 Projecções em Perspectiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 Introdução ao OpenGL 153.1 O pipeline OpenGL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.2 Tipos de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.2.1 Nomes de Funções - Convenção . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.3 JOGL - Java OpenGL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.4 The State Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.5 O pipeline de Transformações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.5.1 Matriz Modelview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.5.2 A Matriz Identidade (Identity Matrix) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.6 Projecções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.7 Câmaras e Actores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 Primitivas Geométricas e Buffers 244.1 O ponto 3D - (Vertex) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2 Primitivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2.1 Pontos: GL POINTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.2.2 Linhas: GL LINES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264.2.3 Tiras de Linha: GL LINE STRIP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.2.4 Loops de Linha: GL LINE LOOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.2.5 Padrões de Linha:GL LINE STIPPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.2.6 Triângulos: GL TRIANGLES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.2.7 Tiras de Triângulos:GL TRIANGLE STRIP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.2.8 Triangle Fans:GL TRIANGLE FANS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.3 Outras Primitivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.3.1 Quadriláteros: GL QUADS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.3.2 Tiras de Quadrados:GL QUAD STRIP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344.3.3 Polígonos: GL POLYGON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344.3.4 Preenchimento de Polígonos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341

4.3.5 Regras na Criação de Polígonos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.3.6 Sub-divisão de Arestas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.4 Buffers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.4.1 Buffer de Profundidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.4.2 Scissors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 Cores, Materiais e Luzes 395.1 Cor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395.1.1 Modos de Display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405.2 Utilização de Cores no OpenGL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425.2.1 Shading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425.3 Cores no Mundo Real . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.3.1 Luz Ambiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.3.2 Luz Difusa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.3.3 Luz Especular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.3.4 Luz de Modo Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.4 Materiais no Mundo Real . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.5 Adição de Luzes ao Cenário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465.6 Fontes de Luz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485.6.1 Configurando uma Fonte de luz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535.7 Efeitos de Iluminação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545.7.1 Luz Especular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545.7.2 Normal Averaging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555.7.3 Especificando um Spotlight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565.7.4 Tesselation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576 Cores e Materiais (Continuação) 586.1 Blending . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586.1.1 Combinação de Cores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586.1.2 Alteração da Equação de Blending . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616.2 Antialiasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626.2.1 Multisampling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636.3 Nevoeiro (Fog) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636.4 Accumulation Buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657 Imagens no OpenGL 687.1 Bitmaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687.2 Pixmaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707.3 Operações com Pixels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717.4 Outras Operações com Imagens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 748 Mapeamento de Texturas 788.1 Carregamento de Texturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 788.1.1 Pipeline do Carregamento de Imagens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798.1.2 Utilizando o Color Buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798.1.3 Actualização de Texturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 808.2 Mapeamento de Texturas à Geometria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818.3 Exemplo de Textura 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828.4 Texture Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848.5 Parametrização de Texturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 858.5.1 Filtering Básico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 858.5.2 Texture Wrap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868.5.3 Mipmapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868.5.4 Mipmap Filtering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878.5.5 Geração de níveis de Mipmapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878.5.6 Geração de Mipmaps por Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888.5.7 Level Of Detail (LOD) Bias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 898.6 Texture Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892

9 Mapeamento de Texturas: Conceitos Avançados 909.1 Cor Secundária . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 909.2 Anisotropic Filtering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 909.3 Compressão de Texturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 929.4 Geração de Coordenadas de Texturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 939.4.1 Oject Linear Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 939.4.2 Eye Linear Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 949.4.3 Sphere Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 959.5 Cube Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 959.5.1 Carregamento do Cube Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 959.5.2 Utilização dos Cube Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9810 Curvas e Superfícies 10010.1 Superfícies Incorporadas no OpenGL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10010.1.1 Configuração de Superfícies Quádricas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10110.1.2 Desenho de Superfícies Quádricas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10210.2 Curvas de Bézier e Superfícies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10410.2.1 Representação Paramétrica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10510.2.2 Pontos de Control (control points) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10510.2.3 Continuidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10610.2.4 Evaluators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10610.2.5 Superfícies 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10810.2.6 Luzes e Vectores Normais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10911 Conceitos Avançados 11111.1 Display Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11111.1.1 Prós e Contras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112A Exemplos 113A.1 Exemplo Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113B Tabelas 114B.1 Formato de Imagem (pixmap) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114B.2 Tipo de Dados (pixmap) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115C Código Fonte 116C.1 Example0.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116C.2 Imaging.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118C.3 Pyramid.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122C.4 TexGen.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126C.5 CubeMap.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131C.6 SnowMan.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136C.7 Bezier2D.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139C.8 Bezier3D.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141C.9 BezierLighting.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1443

ConvençõesNa medida dos possíveis foram traduzidos os nomes de inglês para português. No entanto, para o desenvolvimentocom a API OpenGL, algumas palavras chave são de grande relevo na língua original, o inglês.Para facilitar a localização de métodos nas classes JOGL, estes são apresentados sob a forma:Classe . metodo ( Tipo1 arg1 , ... , TipoN argN );ReferênciasOs apontamentos foram elaborados com base nas referências:• OpenGL Superbible [?]4

Capítulo 1Introdução1.1 A caminho do 3DOs objectos tri-dimensionais podem ser mostrados ou descritos com recurso a três medidas: largura, altura eprofundidade. Nos dispositivos gráficos, superfícies inevitavelmente 2D, a forma de dar a sensação de profundidadeé conseguida pela introdução de perspectiva (Figura 1.1).Figura 1.1: Wireframe de um cubo 3DA visão humana obtém a percepção tridimensional pela utilização de dois olhos. O nosso cérebro recebeduas imagens bidimensionais ligeiramente diferentes por serem recebidas em ângulos diferentes (Figura 1.2). Asduas imagens são então combinadas numa só com o objectivo de produzir uma única imagem, mas desta veztridimensional.Figura 1.2: Visão tridimensionalÀ medida que um determinado objecto se afasta, o ângulo (θ) entre as duas imagens vai diminuindo.Normalmente os dispositivos gráficos que simulam o efeito de realismo 3D (estereoscópicos) utilizam duas imagensdiferentes para cada olho.Os dispositivos gráficos flat utilizam o mesmo mecanismo que a natureza providencia para que pessoas comum único olho possam ver a três dimensões. O “artefacto” utilizado para conseguir este efeito é, com efeito, aperspectiva. Para além deste artefacto, mesmo com um único olho, o nosso cérebro continua a conseguir discernirprofundidade, em grande parte devido aos efeitos presentes nos objectos.5

1.2 Efeitos 3DUma palavra a ter em mente na computação gráfica é rendering. Rendering consiste na conversão da descriçãode um objecto tridimensional numa imagem no ecrã. Os efeitos seguintes são aplicados aquando do rendering deuma imagem.Perspective : A perspectiva refere-se aos ângulos entre as linhas que levam à ilusão de estarmos napresença de três dimensões.Color and Shading: A colocação de cores nas várias faces do cubo, permite replicar níveis de escuridão(shading), reafirmando o aspecto de um objecto sólido.(a)Light & Shadows: Ainda com a utilização de cores é possível dar às superfícies a sensação de iluminação.Adicionando sombra avançamos um passo no caminho do realismo.(b)Texture Mapping: A maneira brute-force de alcançar realismo, pode passar pela adição de mais polígonos(mais detalhe) à imagem, no entanto, á custa de processamento adicional. Outra forma de obter o mesmoefeito, passa pela utilização de imagens nas faces dos objectos - texture mapping.– A imagem fornecida para utilizar é chamada de texture– Cada elemento da imagem que é aplicado numa face é chamado texel– O processo esticar a imagem à face do objecto é denominada de filteringFog: A adição de nevoeiro poderá contribuir para a credibilidade da imagem.6

Blenging & Transparency: Blending consiste na mistura de objectos ou cores. Através da sobreposiçãode imagens ou objectos, é possível dar a sensação de transparência ou reflexão.Antialiasing: O Aliasing é provocado pelo processo de rastering nos monitores. Um processo semelhanteao blenging dos pixels com a cor de fundo confere-lhe um aspecto suave.1.3 Transformações GeométricasAs transformações geométricas em OpenGL são efectuadas por intermédio de operações matriciais. Transformaçõesconsecutivas resultam na multiplicação de várias matrizes. Deste modo, duas transformações consecutivas sãoacumulativas.As transformações geométricas podem ser de três tipos: viewing, modeling e projection.A terminologia utilizada no OpenGL para as transformações é:ViewingEspecificação da Localização do Observador (ou câmara)ModelingLocalização de Objectos na CenaModelViewDualidade de transformações Viewing e ModelingProjectionModificações no clip e size do volume (clipping volume) da cenaViewportRelacionado com a escala do output final para o utilizador1.3.1 Eye CoordinatesAs coordenadas do olho representam um ponto virtual absoluto (independente de qualquer transformada), ondeestá localizado o observador.Na Figura 1.3a, olhamos o nosso sistema cartesiano 3D de frente (o eixo-z não é visível). Na Figura 1.3b oeixo-x e eixo-y foram rodados. À medida que o valor de z aumenta, os objectos ficam mais perto do observador.1.3.2 Viweing TransformationsAs primeiras transformações a serem executadas, são as relacionadas com o ponto para onde o observador está aolhar.Por omissão, a nossa cena contém um observador localizado no ponto O 0 = [x = 0, y = 0, z = 0] e a direcçãodo olhar aponta para a parte negativa do eixo z de tal forma que os objectos desenhados com z > 0 ficamsituados nas costas do utilizador.7

Figura 1.3: Duas perspectivas diferentes (eye coordinates)1.3.3 Modeling TransformationsEste tipo de transformações (Figura 1.4), são aplicadas aos objectos no nosso model (modelo 3D).Figura 1.4: Transformações do Modelo (modeling)A ordem das transformações dita o aspecto final da nossa cena uma vez que as transformações são acumulativas.Na Figura 1.5 é mostrada a diferença na ordem da aplicação de duas transformações, ainda que com os mesmosvalores.Dualidade Model/ViewingA dualidade é utilizada porque no fim de contas, transformações efectuadas no model ou no viewing têm umefeito semelhante. A diferença é entre mover a referência das coordenadas na nossa direcção (Figura 1.6a) ouaproximarmos-nos da referência (Figura 1.6b), o que representa o mesmo resultado.Basicamente, uma transformação viewing é semelhante a uma transformação modeling que aplicamos a umobjecto virtual - o observador.1.3.4 Projection TransformationsAs transformações feitas ao sistema de projecções configuram o volume da área visível da nossa cena.Os principais tipos de projecções são:Orthographic ProjectionNeste tipo de projecção os objectos são desenhados no ecrã usando linhas paralelas para a definiçãoda perspectiva, o que implica que os objectos apresentam todos tamanho semelhante independentemente dadistância.Perspective ProjectionA aparência dos objectos é mais semelhante à realidade. Objectos mais distantes aparecem mais pequenosque objectos mais próximo. Neste perspectiva, linhas paralelas convergem num ponto distante.8

Figura 1.5: Transformações: rotação/translação e translação/rotaçãoFigura 1.6: Dualidade Model/ViewingFigura 1.7: esquerda: Ortogonal, direita: Perspectiva9

1.3.5 Viewport TransformationsNo final do pipeline das transformações, obtemos uma imagem 2D que terá que ser mostrada na nossa janela.As transformações de viewport definem a porção do nosso “universo” 3D que é desenhada na janela e onde.10

Capítulo 2Princípios Básicos de Programação 3D2.1 Sistemas de CoordenadasAntes de ser possível colocar um objecto numa cena é preciso um quadro de referência. Num dispositivo flat alocalização é feita com recurso a dois valores, um deles normalmente refere-se à distância desde o lado esquerdo eo outro refere-se à distância desde o topo do ecrã.Nas APIs 3D, existem vários sistemas de coordenadas. Ao inicializar a nossa cena o sistema de coordenadasescolhido, define a forma como os valores fornecidos são mapeados em pixels no ecrã.2.1.1 Coordenadas Cartesianas - 2DO sistema de coordenadas 2D mais utilizado é o sistema cartesiano. O sistema é composto por uma coordenadasx que define a distância horizontal à origem ([x = 0, y = 0]) e uma coordenada y que define a distância vertical àorigem (Figura 2.1).Figura 2.1: Plano CartesianoClipping de CoordenadasAntes de começarmos a desenhar pontos e linhas é necessário dizer à API que zona do sistema cartesiano deveráaparecer na janela. Esta zona é normalmente denominada de clipping region (Figura 2.2).2.1.2 Viewport - Mapeamento de coordenadas para pixelsRaramente as coordenadas cartesianas do nosso sistema, correspondem ao tamanho em pixels da janelas. Énecessário fazer um mapeamento da zona visível do nosso sistema de coordenadas para o espaço mostrado empixels na janela. Este mapeamento é chamado de viewport.Na Figura 2.3 o tamanho do viewport é o dobro da área de clipping. Na Figura 2.4 o clipping volume, ocupaapenas uma zona da janela.11

Figura 2.2: Duas zonas de clipping diferentesFigura 2.3: Viewport com o dobro da área de clippingFigura 2.4: Viewport com a mesma dimensão da área de clipping12

2.1.3 O Vertex (vértice)Um objecto numa imagem, pode ser decomposto em formas mais pequenas normalmente denominadas deprimitives. As primitives podem ser entidades ou superfícies (pontos, linhas, planos ou polígonos) no espaço. Ocubo nas imagens da introdução, são compostos de seis faces quadradas. Cada canto destes quadrados, ou dequalquer outra primitive é denominado de vertex. Cada vertex é representado por uma coordenada. O processode construir geometria em 3D, consiste num jogo de liga-os-pontos.2.1.4 Coordenadas Cartesianas 3DNas coordenadas cartesianas 3D, ao sistema bidimensional, adicionamos profundidade. Um terceiro eixo (z) éperpendicular aos eixos x e y. A Figura 2.5 mostra o nosso sistema cartesiano com uma rotação (y é rodadopara a esquerda, x rodado para baixo), caso contrário o eixo z não estaria visível.Figura 2.5: Coordenadas Cartesianas 3D2.2 Projecções: 3D → 2DPor mais que tentemos convencer o olho da sensação de imagem 3D, o nosso display será 2D. O nosso sistema3D é mostrado em 2D com ajuda de trigonometria e operações matriciais simples.As coordenadas 3D são “achatadas” ou projectadas numa superfície 2D (o fundo da janela). O resultadoobtido é semelhante ao de pintar os contornos de um objecto num vidro de uma janela (Figura 2.6).O tipo de projecção especifica como o volume deve ser transformado na janela.Figura 2.6: Projecção 2D de uma imagem 3D2.2.1 Projecções OrtogonaisNuma projecção ortogonal, o volume visível é definido com recurso a uma superfície rectangular. Qualquerobjecto fora do volume não é desenhado. Os objectos aparentam todos o mesmo aspecto, independentemente daprofundidade em que se encontram.A Figura 2.7 ilustra o volume visível (viewing volume) definido especificando os clipping planes - far, near,left, right, top e bottom. O conjunto das projecções dos planos são então projectados numa imagem 2D.13

Figura 2.7: O clipping volume de uma projecção ortogonal2.2.2 Projecções em PerspectivaUma projecção em perspectiva é em tudo semelhante à ortogonal. Os objectos mais distantes são, no entantomais pequenos, dando a sensação de profundidade. O viewing volume é parecido com uma pirâmide com a partesuperior cortada. A forma resultante é denominada frustrum (Figura 2.8). Esta projecção é a que confere ummaior realismo.Figura 2.8: O clipping volume (frustrum) de uma projecção em perspectiva14

Capítulo 3Introdução ao OpenGLO OpenGL pode ser definido como uma interface de software para dispositivos gráficos. Consiste de uma bibliotecagráfica de 3D e modeling. É altamente portable (suportada em vários sistemas operativos e dispositivos). Tirapartido da aceleração hardware (onde disponível), conseguindo níveis de desempenho elevados.Mais do que uma linguagem ou uma simples API, define um standard.3.1 O pipeline OpenGLO processo de desenho com recurso a OpenGL, é feito com recurso a um conjunto de passos (stages). O nomepipeline sintetiza numa palavra esta topologia (Figura 3.1).Figura 3.1: Versão simplificada do pipeline OpenGLOs comandos feitos com recurso à API são colocados num fila denominada command buffer (dados dosvértices (vertex), texturas, . . . ). Quando é dada uma ordem de processamento ao buffer (flush), quer de formaprogramática ou pelo driver, os dados são passados ao passo seguinte na pipeline.No passo transform and lighting, são efectuadas as transformações matemáticas e geométricas que permitemo cálculo da localização e orientação dos nossos pontos e objectos.Na fase de rasterização a imagem é criada a partir dos dados de geometria, textura e cor do passo anterior.A imagem resultante é então colocada no frame buffer que pode ser considerado como a memória do nossodispositivo gráfico que finalmente a coloca no ecrã.3.2 Tipos de DadosA fim de garantir portabilidade, o OpenGL define os seus próprios tipos de dados (data types). Ao fazê-lo,permite ao developer, abstrair-se dos pormenores relacionados com os compiladores de cada sistema operativo.A cada tipo de dados corresponde um sufixo. Este sufixo será utilizado a fim de identificar o tipo de dadosde cada função da API. A Tabela 3.1 mostra os tipos de dados, a sua representação em C e o sufixo utilizado nanomenclatura OpenGL.3.2.1 Nomes de Funções - ConvençãoAs funções OpenGL seguem uma nomenclatura que ajuda na identificação da biblioteca, comando, número deargumentos e tipo de dados a utilizar nesses argumentos (Figura 3.2), segundo a sintaxe:< biblioteca >< comando >< argumentos >< tipo >O exemplo em cima é uma função da biblioteca gl, o comando Color, que recebe 3 argumentos do tipo float(f).15

Tipo Interno OpenGL Tipo em C SufixoGLbyte signed char bGLshort short sGLint, GLsizei long lGLfloat, GLclampf float fGLdouble, GLclampd double dGLubyte, GLboolean unsigned char ubGLushort unsigned short usGLuint, GLenum, GLbitfield unsigned long uiTabela 3.1: Tipos de dados OpenGLFigura 3.2: Função OpenGL3.3 JOGL - Java OpenGLO JOGL é um binding para a API OpenGL desenvolvido em Java. Um binding representa uma forma de utilizarfuncionalidades de uma biblioteca (nativa ou não) do sistema operativo com base numa linguagem diferente daque foi utilizada nessa biblioteca. Para o caso do JOGL, a biblioteca OpenGL (ficheiro .dll no Windows, .so noLinux) do sistema é disponibilizada na linguagem de programação Java.Uma das formas mais comuns de utilizar a API consiste na criação de uma classe que implementa a interfaceGLEventListener. Esta interface define os métodos:void init ( GLAutoDrawable drawable );void dispose ( GLAutoDrawable drawable );void display ( GLAutoDrawable drawable );void reshape ( GLAutoDrawable drawable ,int x, int y,int width , int height );init(GLAutoDrawable drawable)Este método será invocado imediatamente depois de o contexto OpenGL ser inicializado. Normalmente éutilizado para inicializar a nossa cena, tal como configurar luzes.dispose(GLAutoDrawable drawable)Este método é invocado aquando da libertação de recursos no contexto OpenGL. A chamada tem lugarimediatamente antes de o contexto OpenGL ser destruído.display(GLAutoDrawable drawable)Invocado pelo contexto OpenGL para inicializar o processo de rendering. No caso de double buffering (ver . . . ),a chamada a este método troca automaticamente os buffers.16

eshape(GLAutoDrawable drawable, int x, int y, int width, int height)Chamada sempre que a janela (ou componente) contendo o viewport, são redimensionados. Permite a actualizaçãoe ajuste do viewport ou da visualização em geral, de forma a adequá-lo ao novo tamanho da janela.3.4 The State MachineO desenho em OpenGL é conseguido com a ajuda de um conjunto de variáveis e atributos que vão sendo definidosao longo da execução. No entanto, não é fácil ao developer estar consciente de todos esses elementos aquando daadição de nova geometria.Estes elementos fazem parte estado no pipeline. O OpenGL funciona como uma máquina de estados quepermite gerir o estado destes elementos.Utilizando a máquina de estados, o OpenGL permite que no mesmo desenho possamos ter, por exemplo,objectos desenhados com lighting e outros sem lighting activando e desactivando uma simples flag.gl. glEnable (GL. GL_LIGHTING );// ...// draw geometry with lightinggl. glDisable (GL. GL_LIGHTING );// ...// draw geometry without lightingA verificação do estado de uma determinada flag pode ser feito com recurso a gl.glIsEnabled(flag).3.5 O pipeline de TransformaçõesAs transformações mais comuns são feitas na projection matrix e na modelview matrix.O caminho desde as coordenadas de simples vertex até à imagem no ecrã está descrito na Figura 3.3.Figura 3.3: Pipeline de transformações de vérticesNo primeiro passo, cada vector é convertido numa matrix 1 × 4, contento as coordenadas [x, y, z] e um factorde escala 1 . O vertex é então multiplicado pela matriz de transformações Modelview, que contém as transformadasrelacionadas com o observador. O resultado é multiplicado pela matriz de transformações Projection, o queelimina todos os objectos fora do nosso volume de clipping 2 . No passo seguinte, as coordenadas resultantes sãodivididas pelo factor w do vertex, com o objectivo de normalizar as coordenadas.1 Utilizado nas funções de vectores com 4 argumentos, ex.: glVertex4f(x, y, z, w)2 O que representa uma mais-valia em termos de processamento17

O passo final consiste no mapeamento do nosso sistema de coordenadas a um plano 2D pelas transformaçõesna matriz de transformações Viewport.3.5.1 Matriz ModelviewFelizmente para os utilizadores da API OpenGL, uma grande parte das transformadas é disponibilizada sob aforma de um conjunto de funções de alto nível. Ainda que estas funções de alto nível permitam ao utilizadorabstrair-se das operações matemáticas, existe a possibilidade de efectuar operações avançadas com matrizesespecíficas 1TranslationFunção de Translação:GL. glTranslatef (float x, float y, float z)A função recebe como argumentos os valores da translação no x, y e z. O pseudo-código seguinte é ilustradona Figura 3.4.GL2 gl = drawable . getGL (). getGL2 ();GLUT glut = new GLUT ();// Translacao de y =10gl. glTranslatef (0f, 10f, 0f);// Desenhar o cubo ...glut . glutWireCube (10 f);Figura 3.4: TranslationRotationFunção de Rotação:GL. glRotatef (float angle ,float x, float y, float z)A função recebe como argumentos, o ângulo de rotação. Os valores x, y e z, representam um eixo arbitráriosobre o qual deve ser feita a rotação 2 . O pseudo-código seguinte é ilustrado na Figura 3.5.GL2 gl = drawable . getGL (). getGL2 ();GLUT glut = new GLUT ();// Rodar 45 em Torno do vector Vr =[1 ,1 ,1]gl. glRotatef (45f, 1f, 1f, 1f);1 Consultar na referência da API - glLoadMatrix*2 Por exemplo: para obter um eixo perpendicular ao eixo − y basta fornecer o vector V y =[0f, 1f, 0f]18

Desenhar o cubo ...glut . glutWireCube (10 f);Figura 3.5: RotationScalingFunção de Escala:GL. glScalef (float x, float y, float z)A função recebe como argumentos os factores de escala em cada um dos eixos x, y e z. O pseudo-códigoseguinte é ilustrado na Figura 3.6.GL2 gl = drawable . getGL (). getGL2 ();GLUT glut = new GLUT ();// Escalar x =2*x, y =1* x e z =2* zgl. glScalef (2f, 1f, 2f);// Desenhar o cubo ...glut . glutWireCube (10 f);Figura 3.6: Scale3.5.2 A Matriz Identidade (Identity Matrix)Ao tentar conseguir o resultado na Figura 3.7, podemos ser tentados a escrever o código:GL2 gl = drawable . getGL (). getGL2 ();GLUT glut = new GLUT ();// Translate y =1019

Figura 3.7: Duas Esferasgl. glTranslatef (0f, 10f, 0f);// Desenhar a primeira esferaglut . glutSolidSphere (1f, 15 , 15);// Translate x =10gl. glTranslatef (10f, 0f, 0f);// Desenhar a segunda esferaglut . glutSolidSphere (1f, 15 , 15);No entanto, o resultado final será mais parecido com o da Figura 3.8.Figura 3.8: Duas Esferas (continuação)Isto deve-se ao facto de as transformações no pipeline OpenGL serem acumulativas. O que aconteceu de facto foiuma translação de 10 no eixo-y seguida do desenho da primeira esfera (tudo correcto), depois movemos-nos 10 noeixo-x sem voltar à origem, o que provocou que a esfera final aparecesse com uma translação de [x = 10, y = 10].Para obter o efeito da Figura 3.7, é preciso repor o sistema de coordenadas original (uma espécie de reset).Isto pode ser obtido pelo carregamento da indentity matrix. O nosso código ficaria então mais parecido com:GL2 gl = drawable . getGL (). getGL2 ();GLUT glut = new GLUT ();// Escolher a Matriz de Transformacoes// MODELVIEW e fazer um reset inicialgl. glMatrixMode ( GL2 . GL_MODELVIEW );gl. glLoadIdentity ();// Translate y =10gl. glTranslatef (0f, 10f, 0f);// Desenhar a primeira esferaglut . glutSolidSphere (1f, 15 , 15);20

eset !gl. glLoadIdentity ();// Translate x =10gl. glTranslatef (10f, 0f, 0f);// Desenhar a segunda esferaglut . glutSolidSphere (1f, 15 , 15);3.6 ProjecçõesOrthographic ProjectionsA perspectiva ortogonal consiste de um volume com os lados todos iguais (Figura 2.7). Este tipo de projecção éutilizada normalmente em software CAD, onde é necessária uma percepção das dimensões reais dos objectos. Noentanto, a sua aproximação à realidade é um pouco vaga (Figura 3.9).(a)Figura 3.9: Ortogonal- Normal/Lado/FrenteA função que permite configurar uma projecção ortogonal, tem o seguinte protótipo:GL2 . glOrtho (double left , double right ,double bottom , double top ,double near , double far)Os argumentos representam as distância até à origem do sistema de coordenadas das faces - esquerda (left),direita (right), fundo (bottom), topo (top), a face mais próxima (near) e mais distante (far) do observador(Figura 3.10).Figura 3.10: Projecção OrtogonalO volume de desenho (viweing volume), corresponde ao volume compreendido entre os 6 planos do cubo.Perspective ProjectionsAo contrário da perspectiva ortogonal, numa projecção de perspectiva, os objectos mais distantes são “encolhidos”.O viewing volume é agora uma espécie de pirâmide com a parte superior cortada - denominada frustrum (Figura3.11).21

Figura 3.11: FrustrumA definição deste frustrum pode ser feita com recurso à função glPerspective 1 :GL. glPerspective (double fovy , fouble aspect ,double zNear , doule zFar);Os parâmetros da função são o campo de visão (field of view) expresso em graus (ângulo vertical), o aspectratio da altura e largura e as distâncias ao plano mais próximo e mais afastado do volume de visualização(viewing volume), como mostra a Figura 3.12.Figura 3.12: Frustrum utilizando glPerspectivePodemos comparar a diferença em relação à perspectiva ortogonal, analisando a Figura 3.13.(a)Figura 3.13: Perspectiva - Normal/Lado/Frente3.7 Câmaras e ActoresAgora que temos o nosso cenário configurado, seria interessante conseguirmos movimentar-nos, nós os observadores.O conceito de câmara ou actor não existe realmente no OpenGL, o nome serve apenas como metáfora parafacilitar a compreensão do conceito.A forma de mimetizarmos esta funcionalidade passa pela utilização da função glLookAt:GLU . gluLookAt (float eyex , float eyey , float eyez ,float atx , float aty , float atz ,float upx , float upy , float upz);1 Existe a função glFrustrum, no entanto a função glPerspective é mais intuitiva22

Figura 3.14: glLookAtOs argumentos desta função são, a posição do observador - Eye(x, y, z), o ponto para o qual o observadorestá a olhar At(x, y, z) e o vector que determina qual a direcção vertical do observador V UP (x, y, z) (Figura3.14).23

Capítulo 4Primitivas Geométricas e BuffersUtilizando ferramentas ou bibliotecas de desenho gráfico convencionais, o elemento mais básico é o pixel.Basicamente colocamos um determinado pixel na tela com uma determinada cor e uma posição específica.Desenhar em OpenGL é um pouco diferente, não desenhamos numa determinada específica no ecrã, mas simem coordenadas no nosso viewing volume. A forma como a nossa cena aparece no ecrã está a cargo do OpenGL.As secções seguintes descrevem como são desenhadas as varias primitivas geométricas com recurso à APIOpenGL.4.1 O ponto 3D - (Vertex)A função utilizada para desenhar um ponto 3D na nossa cena é a função glVertex. O ponto desenhado dependedo número de argumentos e tipo utilizados na função.Figura 4.1: Ponto P (50,50,50)Por exemplo, para obter o ponto na Figura 4.1, podemos utilizar:gl. glVertex3f (50f, 50f, 0f);Ou ainda:gl. glVertex2f (50f, 50f);Podemos ainda especificar o factor de escala w (por omissão 1f) utilizando o código:gl. glVertex4f (50f, 50f, 0f, 1f);4.2 PrimitivasUm vertex por si só no espaço, não tem grande significado. Um ponto pode representar a intersecção de duaslinhas ou curvas ou então o canto de um polígono ou sólido.24

A forma como um conjunto de pontos é interpretado no nosso espaço 3D é chamada de primitiva. O OpenGLtem 10 tipos de primitivas.Para desenhar com uma determinada primitiva, utilizamos a função glBegin para iniciar, desenhamos osnossos pontos e terminamos utilizando o glEnd para terminar a utilização da primitiva.Para desenhar vários tipos de primitivas, teremos que utilizar vários blocos glBegin/glEnd, por exemplo:gl. glBegin ( GL_POINTS );gl. glVertex3f (0.0f, 0.0f, 0.0 f);gl. glVertex3f (50.0f, 50.0f, 50.0 f);gl. glEnd ();4.2.1 Pontos: GL POINTSEsta primitiva é a mais simples de todas: pontos. Os vértices desenhados dentro de um bloco GL POINTS,aparecem como pontos.Figura 4.2: Desenho utilizando a primitiva GL POINTSO código utilizado para obter a Figura 4.2 será:float GL_PI = 3.1415 f;// Comecar a Desenhar Pontosgl. glBegin ( GL2 . GL_POINTS );float angle , x, y, z = -50.0 f;for ( angle =0f; angle

Figura 4.3: Explicação da espiral de pontosfloat [] step = new float [1];gl. glGetFloatv ( GL2 . GL_POINT_SIZE_GRANULARITY , step , 0);O array size (float[] de tamanho 2) irá conter os valores mínimo (P S min = size[0]) e máximo (P S max =size[1]) possíveis para o tamanho de um ponto, o array step (float[] de tamanho 1) irá conter o valor dadiferença mínima (P S step =step[0]) possível entre tamanhos do ponto.Os valor passado à função glPointSize, deverá estar compreendido entre P S min e P S max , sendo a diferençamínima entre eles de P S step .Assim ao utilizar o código em baixo em conjunto com os arrays do exemplo anterior, obtemos a Figura 4.4.float GL_PI = 3.1415 f;float angle , x, y, z = -50.0 f;float psize = sizes [0];for ( angle =0f; angle

Figura 4.4: Pontos com vários tamanhosgl. glVertex3f (50.0f, 50.0f, 50.0 f);gl. glEnd ();Porque as linhas são só desenhadas entre 2 pontos, ao utilizar um número ímpar de pontos, o último éignorado. O código em baixo ilustra o desenho com o uso da primitiva GL LINES:float z = 0.0f, angle , x, y;// Comecar Linhasgl. glBegin ( GL2 . GL_LINES );for ( angle = 0.0 f; angle

Figura 4.5: Desenho com GL LINESFigura 4.6: Tiras de Linhas: GL LINE STRIPFigura 4.7: Loops de Linhas: GL LINE LOOP28

A Figura 4.7 mostra os mesmos vértices da Figura 4.6 desenhados com a primitiva GL LINE LOOP.Exemplo: Aproximação a Curvas com recurso a Tiras de LinhaUtilizando o exemplo da Figura 4.2, onde desenhamos uma espiral de pontos e substituindo a primitiva GL POINTSpela primitiva GL LINE STRIP, podemos fazer uma aproximação a uma espiral. Ao diminuir o espaço entre ospontos podemos tornar a sensação de curva ainda mais real.float GL_PI = 3.1415 f;// Comecar a Tiras de Linhagl. glBegin ( GL2 . GL_LINE_STRIP );float angle , x, y, z = -50.0 f;for ( angle =0f; angle

float y, curwidth = widths [0];gl. glColor3f (1f, 1f, 1f);for (y= -90f; y

Figura 4.10: Padrão Stipple}gl. glLineStipple ( factor ++ , pattern );// Comecar Linhasgl. glBegin ( GL2 . GL_LINE_STRIP );gl. glVertex2f ( -80f, y);gl. glVertex2f (80f, y);// Terminar Linhasgl. glEnd ();O pattern 0x5555 é um valor hexadecimal, que em binário representa 0101010101010101, o que resultaránuma linha dotted. À medida que o ciclo avança vamos aumentando o factor, pelo que a linha passa de dottedpara dashed de forma progressiva, como mostra a Figura 4.11.Figura 4.11: Desenho com recurso a stippling4.2.6 Triângulos: GL TRIANGLESAté aqui as formas criadas com recurso às primitivas de pontos e linhas, não contém qualquer preenchimento.Para desenhar superfícies sólidas com preenchimento é necessário utilizar polígonos.Um polígono é uma forma fechada que pode estar ou não preenchida com a cor actual de preenchimento. EmOpenGL, todo o desenho de sólidos assenta na composição baseada em polígonos.O polígono mais simples possível é o triângulo e pode ser desenhado com recurso à primitiva GL TRIANGLES.gl. glBegin ( GL2 . GL_TRIANGLES );31

gl. glVertex2f (0f, 0f); // V 0gl. glVertex2f (25f, 25f); // V 1gl. glVertex2f (50f, 0f); // V 2gl. glVertex2f ( -50f, 0f); // V 3gl. glVertex2f ( -75f, 50f); // V 4gl. glVertex2f ( -25f, 0f); // V 5gl. glEnd ();O código acima desenha dois triângulos preenchidos com a cor de preenchimento actual (definida por glColor)no plano x, y (Figura 4.12).Figura 4.12: Desenho de TriângulosWindingA ordem pela qual os vértices são desenhados, define o lado para que está virado o polígono por eles definido.Assim o primeiro triângulo (V 0 , V 1 , V 2 ) é desenhado no sentido dos ponteiros do relógio (clockwise) está decostas para o observador, enquanto que o segundo triângulo (V 3 , V 4 , V 5 ) foi desenhado no sentido inverso(counterclockwise), está de frente para o observador (Figura 4.13).Figura 4.13: WindingO conceito de winding é importante quando estamos a preencher um determinado polígono com característicasdiferentes à frente e atrás.Para alterar o comportamento do winding podemos forçar o caminho clockwise a representar a face de umpolígono activando a flag GL CW:gl. glEnable ( GL2 . GL_CW );Para restaurar o comportamento por omissão activamos a flag GL CCW.4.2.7 Tiras de Triângulos:GL TRIANGLE STRIPO desenho da maioria das superfícies consiste num conjunto de triângulos. O desenho dessas superfícies pode serfacilitado pela utilização da primitiva de desenho de triângulos GL TRIANGLE STRIP. Os triângulos são desenhadosentre os vértices à medida que eles são especificados (Figura 4.14).32

Figura 4.14: Tiras de TriângulosNo caso do GL TRIANGLE STRIP, o winding é forçado para counterclockwise independentemente da ordem dedesenho.Uma vantagem evidente deste método de desenho é o facto de, depois dos três primeiros vértices, o desenhode triângulos adicionais só precisa de mais um vértice por triângulo.4.2.8 Triangle Fans:GL TRIANGLE FANSNesta primitiva, os triângulos são desenhados em volta de um ponto central, definido pelo primeiro vértice aser desenhado (V 0 ). Depois dos primeiros três vértices definirem o primeiro triângulo, todos os restantes sãodefinidos com apenas um vértice (Figura 4.15).Figura 4.15: Triangle Fans4.3 Outras PrimitivasA utilização de triângulos na construção de objectos em OpenGL é preferida pelo facto da maior parte do hardwareacelerar o seu desenho. No entanto a utilização de outras formas que não o triângulo poderá ser pertinente.4.3.1 Quadriláteros: GL QUADSA primitiva GL QUADS permite desenhar um polígono quadrilátero com recurso a quatro vértices. Os vérticesteriam que ser complanares (Figura 4.16).Figura 4.16: Quadriláteros33

4.3.2 Tiras de Quadrados:GL QUAD STRIPDa mesma forma que a primitiva GL TRIANGLE SRTIP, a primitiva GL QUAD STRIP permite desenhar uma tira dequadriláteros pela adição de vértices aos quatro primeiros (Figura 4.17).Figura 4.17: Tiras de Quadriláteros4.3.3 Polígonos: GL POLYGONEsta primitiva permite o desenho de polígonos com um número variado de lados. No entanto, a restrição dosvértices serem complanares mantém-se (Figura 4.18).Figura 4.18: Desenho de PolígonosEsta restrição pode ser evitada pela utilização da primitiva GL TRIANGLE FAN em lugar da utilização daprimitiva GL POLYGON.4.3.4 Preenchimento de PolígonosAs duas formas mais utilizadas para preenchimento de polígonos são, a utilização de cores sólidas ou a aplicaçãode texturas. No entanto, da mesma forma que utilizámos os padrões de preenchimento de linhas, podemosutilizar padrões de preenchimento (stippling) de polígonos.O padrão é agora definido por uma matriz on/off de 32 × 32 bits (Figura 4.19).Para construir a máscara que vai ser utilizada para fazer o stippling utilizamos um array de 32 × 4 bytes 1 .Em vez de um array bidimensional é utilizado um array simples.O padrão pode ser aplicado activando o stippling de polígonos e utilizando um array do tipo descrito emcima:byte [] pattern = {0x00 , 0x00 , 0x00 , 0 x00...0x00 , 0x00 , 0x10 , 0 x00};gl. glEnable ( GL2 . GL_POLYGON_STIPPLE );gl. glPolygonStipple ( pattern );Mais uma vez o array é definido ao contrário, sendo o bit menos significativo, o primeiro bit da imagem, ouseja, a primeira linha corresponde à última linha da imagem.1 1byte = 8bit =⇒ 32 × 4byte =⇒ 32 × 32bit34

Figura 4.19: Padrão de Preenchimento de PolígonosFigura 4.20: Exemplo de Stippling de Polígonos35

4.3.5 Regras na Criação de Polígonos1. A primeira regra a ter em mente na construção de polígonos é que, todos os seus vértices devem residir nomesmo plano. Um polígono não pode “dobrar-se” no espaço (Figura 4.21).Figura 4.21: Polígonos Planos/Não-planosEsta primeira regra pende a favor da utilização de triângulos na definição dos nossos polígonos, uma vezque matematicamente um plano é definido por três pontos.2. Outra regra diz que os segmentos do polígono não devem intersectar-se e o polígono deve ser convexo. Opolígono é convexo quando qualquer linha que o atravesse sai e entra apenas uma vez no polígono (Figura4.22).Figura 4.22: Polígonos válidos e inválidos4.3.6 Sub-divisão de ArestasApesar de o OpenGL só conseguir desenhar polígonos convexos, existem situações em que polígonos não-convexosfazem sentido, por exemplo ao desenhar uma estrela. A primeira estrela da Figura 4.23 não é convexa, mas aodividirmos o polígono em vários triângulos obtemos uma figura convexa válida.Figura 4.23: Polígonos não ConvexosA fim de evitar que as linhas (edges) no interior da segunda estrela sejam visíveis podemos a edge flag. Estaflag é activa/inactiva pela função glEdgeFlag(boolean enable). Esta função diz ao OpenGL se os segmentosseguintes são considerados arestas do polígono.4.4 BuffersO OpenGL não desenha realmente as primitivas no ecrã, utiliza antes um buffer buffer de cor, inicialmenteinvisível, que posteriormente é colocado no ecrã. Chamamos aos dois buffers de cor, o front buffer (o que seencontra actualmente no ecrã) e o back buffer (o que está a ser desenhado).36

No JOGL a configuração do display é feita alterando as capacidades na classe GLDrawable 1 . As capacidadesactuais do display podem ser consultadas utilizando:public class MyGl implements GLEventListener {...@Overridepublic void init ( GLAutoDrawable drawable ) {GLCapabilities cap = drawable . getChosenGLCapabilities ();boolean db = cap . getDoubleBuffered ();...}...}O double buffering encontra-se activo por omissão. Pode no entanto ser activado ou desactivado utilizando ocódigo:GLCapabilities cap = drawable . getChosenGLCapabilities ();// Desactivar o double buffercap . setDoubleBuffered ( false );A troca de buffers pode ser conseguida utilizando a função GLDrawable.swapBuffers() 2 .Utilizando Buffer TargetsÉ possível desenhar directamente no front buffer dizendo ao OpenGL qual o buffer de destino (target) para asprimitivas que estamos actualmente a desenhar, utilizando:gl. glDrawBuffer ( int mode );Especificando GL2.GL FRONT, desenhamos directamente no front buffer, utilizando GL2.GL BACK, remetemoso desenho para o back buffer. Outra forma de desenhar directamente no front buffer passa pela desactivação dodouble buffering.Ao desenhar com recurso a um único buffer é aconselhável a utilização da função glFlush ou glFinish paraforçar o pipeline a processar a lista de comandos no buffer.4.4.1 Buffer de ProfundidadeO OpenGL suporta mais buffers para além dos buffers de cor. Um deles é o depth buffer que em vez de armazenarvalores de cor, armazena valores de profundidade.O teste de profundidade faz corresponder a cada elemento de cor no color buffer, um valor de profundidadeno depth buffer.Para utilizar o buffer de profundidade usamos o código:gl. glEnable ( GL2 . GL_DEPTH_TEST );Para desactivar temporariamente o teste de profundidade sem descartar os valores actualmente no buffer,podemos utilizar:gl. glDepthMask ( false );Utilizando true em vez de false, podemos reactivar o teste de profundidade.4.4.2 ScissorsAfim de optimizar recursos, pode ser pertinente desenhar apenas uma porção do ecrã. O OpenGL permite definira zona rectangular do ecrã que é renderizada.O rectângulo pode ser definido activando o scissor test com recurso à função glEnable(GL2.GL SCISSOR TEST)e definindo a o seu rectângulo, utilizando a função:GL2 . glScissor ( int x, int y, int width , int height );Os valores x e y especificam o canto inferior direito do rectângulo. Os valores width e height definem alargura e altura do rectângulo.1 No caso da interface GLEventListener, os métodos recebem uma instância de um GLAutoDrawable que é do tipo GLDrawablepor herança2 Quando o double buffering está activo, isto é feito de forma automática37

GL2 gl = drawable . getGL (). getGL2 ();// Activar o Scissor Testgl. glEnable ( GL2 . GL_SCISSOR_TEST );gl. glClearColor (1f, 0f, 0f, 0f);gl. glScissor (50 , 50 , 200 , 200));gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT );gl. glClearColor (1f, 1f, 0f, 0f);gl. glScissor (120 , 120 , 60 , 60);gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT );// Desactivar o Scissor Testgl. glDisable ( GL2 . GL_SCISSOR_TEST );gl. glFlush ();O código em cima, define uma scissor box inicial com o canto inferior direito [x, y] = [50, 50] e com a largurae altura de 200. Seguidamente a cor de fundo é “limpa” de vermelho. Uma scissor box mais pequena é entãodefinida e pintada de amarelo (Figura 4.24).Figura 4.24: Scissor Test38

Capítulo 5Cores, Materiais e Luzes5.1 CorA cor é simplesmente um comprimento de onda da luz visível aos nossos olhos. A luz é uma onda que viaja peloespaço como uma onda num lago, no entanto é modelada, na física, como uma partícula, como uma gota deágua que cai no chão.A luz vista como uma ondaA luz visível ao nosso olho é realmente uma mistura de diferentes tipos de luz. O que caracteriza cada tipo deluz, é o seu comprimento de onda (Figura 5.1).Figura 5.1: Medida do Comprimento de OndaO espectro visível ao olho humano varia desde os 390 manómetros (luz violeta) e os 720 nanómetros (luzvermelha) (Figura 5.2). Os termos ultra-violeta e infra-vermelho referem-se ao espectro fora do espectro visível.Figura 5.2: Espectro de Luz Visível39

A luz vista como uma partículaA cor que vemos nos objectos é realmente a soma de todas os comprimentos de onda de luz que o objectoconsegue reflectir. Por exemplo, o branco é a soma de todos os comprimentos de onda do espectro, enquanto queo preto é a ausência de luz (pelo menos da luz visível).Dependendo do tipo e quantidade de átomos de uma superfície, esta reflecte um determinado comprimentode onda dos fotões de luz que a bombardeiam e absorve os restantes. Cada um destes fotões tem também umcomprimento de onda associado (dai a dualidade onda/partícula), o somatório dos comprimentos de onda daspartículas reflectidas confere a cor visível aos nossos olhos (Figura 5.3).Figura 5.3: Partículas (fotões) reflectidos dos materiaisA retina do olho humano é “excitada” pelo conjunto de fotões reflectidos pelas superfícies e o cérebrointerpreta-os como luz. As células fotossensíveis da nossa retina são sensíveis a três tipos de comprimento deonda - o vermelho, o verde e o azul. A mistura de quantidades diferentes das três componentes resulta na corinterpretada pelo nosso cérebro (Figura 5.4).Figura 5.4: Interpretação da cor pelo olho humanoComputador → Gerador de FotõesA geração de cores num computador utilizando várias intensidade de Red, Green e Blue (RGB), faz agora algumsentido. Os nossos monitores são compostos de pequenos elementos contendo as três componentes de cor (RGB).Ao mudar as intensidades das várias cores, obtemos a palete de cores visível (Figura 5.5).5.1.1 Modos de DisplayHoje em dia, graças aos fabricantes dos sistemas operativos, o desenho nos dispositivos gráficos é feito comrecurso a uma camada de virtualização, chamada de driver gráfico, que permite, por intermédio de uma API (talcomo o OpenGL), desenhar no ecrã sem ter que conhecer os pormenores do hardware.No entanto, devemos ter presentes algumas palavras chaves na utilização destas APIs.40

Figura 5.5: Computador → Gerador de FotõesResoluçãoAs resoluções mais usadas nos monitores actuais varia entre os 640x480 e os 1920x1080 (full hd). Devemoster sempre em conta o tamanho da janela e ajustar o nosso clipping volume e viewport de forma a manter aimagem que o utilizador visualiza coerente. É de esperar que à medida que a janela é aumentada, a resoluçãodos objectos será maior.Profundidade de CorDa mesma forma que mais resolução significa uma imagem mais detalhada, o aumento nos níveis de cor disponíveis(color depth) deverá aumentar a claridade da nossa imagem.Ao utilizar a API OpenGL devemos ter em mente três profundidades de cor:• 4-bit: 16 níveis de cor• 8-bit: 256 níveis de cor• 24-bit: A cor de cada pixel é definida com recurso a 3 componentes de 8-bit (8 + 8 + 8 = 25), o queproporciona mais de 16 milhões de coresA maioria do hardware gráfico actual tem aceleração para os 24-bit de profundidade de cor.Os 16-bit e 32-bit de profundidade foram em tempos utilizados como uma forma de optimizar o desempenho,uma vez que permitem o alinhamento mais eficiente em memória (endereço de 32-bit). No entanto, 32-bit nãosignifica um aumento do número de cores, mas sim um desperdício de 8-bit de memória.41

5.2 Utilização de Cores no OpenGLPodemos representar todas as cores possíveis com a utilização de um cubo, mapeando as componentes Red,Green e Blue nos eixos x, y e z respectivamente (Figura 5.6).Figura 5.6: RGB ColorspaceNa origem ([x, y, z] = [0, 0, 0]) encontra-se o preto, no ponto [x, y, z] = [255, 255, 255] encontra-se o branco enos extremos do cubo em cada um dos eixos encontram-se as cores vermelho (x), verde (y) e azul (z).Alterando a Cor utilizada para desenharA função utilizada para alterar a cor utilizada para desenho é a função:GL2 . glColor ( red , green , blue [, alpha ]);Na nome da função, o representa o número de argumentos. No caso de ser 3, a cor será definida com astrês componentes RGB, no caso de ser 4, é especificado o valor adicional alpha que define o nível de transparência.O no nome na função especifica o tipo de argumento, que poderá ser b, d, f, i, s, ub, ui, or us, querepresentam respectivamente, byte, double, float, integer, short, unsigned byte, unsigned integer, andunsigned short.A grande maioria dos programas em OpenGL utilizam o glColor3f que permite especificar a intensidadede cor entre 0f e 1f (1f = intensidade máxima de cor). No entanto é possível representar, por uma questão deconveniência, o valor da cor entre 0 e 255, utilizando por exemplo:gl. glColor3ub (0 , 255 , 128);No entanto, o seu uso é desaconselhado, uma vez que, a tendência no futuro aponta para adição de maisníveis de intensidade (> 255). O OpenGL na realidade representa os níveis de cor internamente utilizando umfloat, pelo que forçar a utilização de glColor3ub, implica um passo adicional para a conversão.5.2.1 ShadingFigura 5.7: Shading de uma linha42

Ao utilizar a função glColor estamos a dizer ao OpenGL que cor deve ser utilizada para os vértices desenhadosa seguir. No entanto, todas as primitivas para além do ponto contém mais do que um vértice. A forma comosão desenhados os pontos intermédios dos vértices, nessas primitivas, por exemplo para uma linha, depende domodelo de shading escolhido.A Figura 5.7 mostra como as cores são seleccionadas no caminho entre dois vértices de uma linha, onde oprimeiro é preto e o segundo é branco. Pela análise da figura, podemos concluir que a linha aparecerá como umgradiente de preto para branco.O shading de polígonos é um pouco mais complexo. Um triângulo pode ser também desenhado dentro docubo RGB Colorspace, como mostra a Figura 5.8(a).(a) Cores dos vértices nos eixos de cor(b) Triângulo RGBA imagem 5.8(b), pode ser obtida com o código:GL2 gl = drawable . getGL (). getGL2 ();...// Utilizar smooth shadinggl. glShadeModel ( GL2 . GL_SMOOTH );gl. glBegin ( GL2 . GL_TRIANGLE_STRIP );// Vermelhogl. glColor3f (1f, 0f, 0f);gl. glVertex3f (40f, 0f, 0f);// Verdegl. glColor3f (0f, 1f, 0f);gl. glVertex3f (0f, 60f, 0f);// Azulgl. glColor3f (0f, 0f, 1f);gl. glVertex3f ( -40f, 0f, 0f);gl. glEnd ();Figura 5.8: Triângulo no RGB ColorspaceO modelo por omissão de shading no OpenGL é o GL2.GL SMOOTH, no qual a transição entre as cores é adescrita em cima. O outro modelo é o GL2.GL FLAT, no qual a cor da superfície utilizada corresponde à cor doultimo vértice, com a excepção das primitivas GL POLYGON, onde a cor utilizada é do primeiro vértice.Para alterar o shading model utilizado pelo OpenGL, podemos utilizar a função:gl. glShadeModel ( int model );Utilizando como argumento uma das constantes GL2.GL SMOOTH ou GL2.GL FLAT.43

5.3 Cores no Mundo RealO shading dos objectos no mundo real não se resume apenas aos valores RGB das cores. Ao preenchermossuperfícies com cores, os nossos modelos estão longe de parecer reais (Figura 5.9).Figura 5.9: Objecto preenchido com cores diferentes em cada polígonoO OpenGL simula de forma bastante aproximada as condições de luz num ambiente real. Com a excepção dosobjectos que emitem luz própria, todos eles são afectados por três tipos de luz: ambiente, difusa e especular.5.3.1 Luz AmbienteA luz ambiente não tem direccionalidade. As superfícies dos objectos de uma cena são afectadas de forma igual euniforme (Figura 5.10). O resultado de uma cena com uma luz ambiente é semelhante aos exemplos ilustradosaté agora onde a cor é uniforme.Figura 5.10: Objecto iluminado com luz ambiente5.3.2 Luz DifusaA luz difusa provém de uma direcção específica mas é reflectida de maneira uniforme pelas superfícies em váriosângulos (Figura 5.11). No entanto, as superfícies iluminadas directamente, são mais claras que as ilmunidadascom um determinado ângulo. Um bom exemplo de luz difusa é uma lâmpada fluorescente.Figura 5.11: Objecto iluminado com Luz Difusa44

5.3.3 Luz EspecularA luz especular vem de uma direcção em especifico, é reflectida de maneira uniforme, mas o feixe da sua reflexãocontinua a ser direccional (Figura 5.12). Os objectos afectados por luz especular costumam mostrar um pontomais iluminado, onde a luz incide com mais intensidade.Figura 5.12: Objecto iluminado com Luz Especular5.3.4 Luz de Modo GeralNenhuma cena é composta de um único tipo de luz, é antes composta pelo conjunto das vaŕias componentes comvárias intensidades. A titulo de exemplo, imaginemos um feixe de laser vermelho num quarto escuro. O feixepoderá ser comparado com a luz especular, as partículas de pó que reflectem parte da luz do laser podem serconsideradas luz difusa e o matizado vermelho nas paredes do quarto pode ser comparado com a luz ambiente.Da mesma forma que a cor, os vários tipos de luz têm um valor RGBA associado 1 . Assim por exemplo parao laser vermelho poderíamos ter os valores na Tabela 5.1.Red Green Blue AlphaSpecular 0.99 0.0 0.0 1.0Diffuse 0.10 0.0 0.0 1.0Ambient 0.05 0.0 0.0 1.0Tabela 5.1: Distribuição de Luz e Cor de um Laser VermelhoPela interpretação da tabela, podemos concluir que o laser vermelho tem uma forte componente especular,uma pequena componente difusa e pouquíssima componente de luz ambiente. O mais certo é que, a presença departículas, gere uma componente difusa de luz, induzindo luz ambiente no compartimento.As componentes difusa e ambiente são muito semelhantes na natureza e são normalmente combinadas.5.4 Materiais no Mundo RealA forma como os materiais aparecem no mundo real depende dum conjunto de factores, no entanto, os maisdeterminantes tem a ver com a sua cor, e as condições de iluminação que o rodeiam. Assim, por exemplo, umabola azul reflecte a maior parte dos comprimentos de onda azuis e absorve grande parte dos outros.Na maioria dos cenários, a luz é branca, no entanto mudando a luz para amarelo, por exemplo, a nossa bolateria uma cor escura (ou mesmo preto) uma vez que absorve tudo que não seja azul.Propriedades dos MateriaisQuando utilizamos luzes, não definimos o material de um determinado polígono só pela cor, dizemos antes, qual acor da luz que eles reflectem. Os materiais podem reflectir luz especular de uma determinada cor e absorver todaa luz difusa da mesma cor, ou ao contrário. Outra propriedade que é definida nos materiais, é a sua capacidadede gerar luz própria.Adição de Luz aos MateriaisNão existe nenhuma regra (como a do RGB Colorspace) para ajudar a definir as propriedades ideais de luzes emateriais. Normalmente os resultados são conseguidos com alguma prática e análise.1 Para efeitos de luz o alpha é ignorado45

Ao desenhar objectos, o OpenGL decide qual a cor para cada pixel. Cada vértice das nossas primitivas temum valor RGB diferente baseado no efeito conjunto das 3 componentes de luz ambiente, difusa e especularmultiplicado pela reflectividade ambiente, difusa e especular do material.Calculo do Efeito das luzesO cálculo do RGB das três componentes de luz é feito de forma similar. No entanto, a direccionalidade das luzesdifusa e especular depende do ângulo de incidência da luz.O cálculo do RGB obtido a partir da incidência da luz (ambiente neste caso) com o RGB (0.5, 0.5, 0.5)numa superfície com propriedades reflectivas da luz ambiente (0.5, 1.0, 0.5) pode ser calculado da seguinteforma;Ou seja,RGB reflected = RGB light × RGB materialRGB reflected = (0.5, 0.5, 0.5) × (0.5, 1.0, 0.5) = (0.25, 0.5, 0.25)Figura 5.13: Compontente de luz ambiente de um Objecto5.5 Adição de Luzes ao CenárioA fim de consolidar os conceitos teóricos nas secções anteriores, e antes de avançarmos com mais conceitos, épertinente contextualizá-los no OpenGL.Activação a LuzPara utilizar a luz no OpenGL activamos a flag GL LIGHTING:gl. glEnable ( GL2 . GL_LIGHTING );gl. glColor3f (0.75f, 0.75f, 0.75 f);gl. glBegin ( GL2 . GL_TRIANGLES );gl. glVertex3f (60f, -40, 0f);gl. glVertex3f ( -60f, -40f, 0f);gl. glVertex3f (0f, 40f, 0f);gl. glEnd ();Ao activar a flag GL LIGHTING, o OpenGL determina a cor de cada vértice com base nos parâmetros dosmateriais. Como ainda não foram definidos quaisquer parâmetros dos materiais, os objectos no nosso cenárioaparecem escuros e sem qualquer luz (Figura 5.14).Configuração do Modelo de LightingO primeiro passo depois de activar o cálculo de luzes é configurar o modelo de lighting. As três componentes deluz que afectam o nosso modelo de lighting são definidos com recurso à função:glLightModelfv ( int mode , float [] params , int offset );46

Figura 5.14: Polígono sem parâmetros de materiais definidosO argumento mode permite-nos seleccionar qual a(s) componente(s) que estamos a configurar. O segundoargumento é um array contendo os valores RGBA da luz 1 .Para definir a componente de luz ambiente utilizamos a variável GL LIGHT MODEL AMBIENT, como mostra oexemplo:gl. glEnable ( GL2 . GL_LIGHTING );float [] ambientLight = new float [] {1f, 1f, 1f, 1f};gl. glLightModelfv ( GL2 . GL_LIGHT_MODEL_AMBIENT , ambientLight , 0);Configuração das Propriedades dos MateriaisA configuração das propriedades dos materiais é feita antes de os desenhar, definindo as cores que estes reflectempara cada componente. Isto pode ser feito com recurso à função:glMaterialfv ( int face , int pname , float [] params , int offset )O parâmetro face define qual a face que toma os valores que estamos a definir:• GL FRONT: Frente• GL BACK: Trás• GL FRONT AND BACK: Ambas as facesO parâmetro pname define qual a propriedade que estamos a configurar e pode tomar os valores:• GL AMBIENT, GL DIFFUSE, GL SPECULAR: Luz ambiente, difusa e especular• GL AMBIENT AND DIFFUSE: Componentes ambiente e difusa (tomarão os mesmos valores).• GL EMISSION: Luz própria do objecto.O seguinte exemplo mostra uma possível utilização da função glMaterial:float gray [] = { 0.75f, 0.75f, 0.75f, 1.0 f };gl. glMaterialfv ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE , gray , 0);Na maior parte das vezes, a luz ambiente e difusa tomam valores semelhantes, para tal a flag GL AMBIENT AND DIFFUSEé utilizada. A nossa imagem terá agora o aspecto da Figura 5.15.A segunda forma de atribuir propriedades aos materiais é activando o color tracking. Com o color tracking,dizemos ao OpenGL para utilizar as cores definidas com recurso a glColor.Para activar o color tracking, activamos a flag GL COLOR MATERIAL:glEnable ( GL2 . GL_COLOR_MATERIAL );Da mesma forma utilizamos a função glColorMaterial para definir a face e a componente de luz afectada:glColorMaterial ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE );1 O parâmetro offset é específico do binding JOGL. No contexto deste documento tomará sempre o valor 0.47

Figura 5.15: Polígono após definição com glMaterialJuntando tudo no mesmo bloco de código obtemos:...// No metodo init (...)gl. glEnable ( GL2 . GL_LIGHTING );float [] ambientLight = new float [] {1f, 1f, 1f, 1f};gl. glLightModelfv ( GL2 . GL_LIGHT_MODEL_AMBIENT , ambientLight , 0);gl. glEnable ( GL2 . GL_COLOR_MATERIAL );...// No metodo display (...)gl. glColorMaterial ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE );gl. glColor3f (0.75f, 0.75f, 0.75 f);gl. glBegin ( GL2 . GL_TRIANGLES );gl. glVertex3f (60f, -40, 0f);gl. glVertex3f ( -60f, -40f, 0f);gl. glVertex3f (0f, 40f, 0f);gl. glEnd ();O resultado final da utilização do GL COLOR MATERIAL, será semelhante ao obtido definindo o material paracada polígono individual (Figura 5.15).A Figura 5.16 mostra os resultados para vários níveis da luz ambiente num objecto mais complexo.5.6 Fontes de LuzNum cenário real, as fontes de luz podem ser variadas. Para além da cor e intensidade, são providas de umalocalização e direccionalidade. Com o OpenGL é possível definir 8 fontes de luzes independentes com umalocalização no nosso viewing volume.Ao especificar uma luz, dizemos ao OpenGL a sua localização e para onde se dirige. Ao especificar umaluz direccional, esta incide nos objectos com um determinado ângulo, que determina a forma como o objectoé iluminado. A fim de conseguir calcular o shading (as sombras) numa superfície, o OpenGL deve conhecer oângulo de incidência da luz.A luz incide numa superfície com um determinado ângulo (A) e é reflectida com outro ângulo (B) em direcçãoao observador (Figura 5.17). Estes ângulos são utilizados em conjunto com as propriedades dos materiais, paradeterminar a cor aparente de cada vértice. Posteriormente pela utilização de smooth shading (GL SMOOTH), édada a sensação de iluminação do polígono.Se tivermos em consideração que cada polígono é definido por um conjunto de pontos, determinar o ânguloque a luz faz com um ponto pode representar uma dificuldade 1 . Para resolver esse problema, cada ponto teráque conter informação acerca do vector que define a sua orientação vertical (upward).1 O segundo ângulo (B) pode tomar uma infinidade de valores possíveis48

(a) ambientList = .8, .8, .8 (b) ambientList = .4, .4, .4Figura 5.16: Vários níveis de Luz AmbienteFigura 5.17: Reflexão da Luz nos Objectos49

Vectores Normais às SuperfíciesO vector normal (normal vector) de uma determinada superfície, é um vector que começa num ponto imaginárioalgures na superfície fazendo um ângulo recto com esta (Figura 5.18).Figura 5.18: Vectores Normais (2D e 3D)É possível especificar normais para os polígonos gerados pelas primitivas OpenGL. No entanto, pode fazersentido especificar normais para pontos em particular, por exemplo, no caso em que a normal não é totalmenteperpendicular ao polígono.Especificação da NormalA Figura 5.19 mostra um plano paralelo ao plano xy no espaço 3D. O vector normal poderá será definido pelovector entre o ponto (1, 1, 0) e qualquer outro ponto (acima deste) na recta que o atravessa, como por exemplo oponto (1, 10, 0).Figura 5.19: Exemplo de um vector normal a uma superfíciePara especificar o vector normal do exemplo seriam necessários 2 pontos. No OpenGL é possível especificaro vector normal utilizando apenas um ponto, para tal, movemos o vector para a origem (0, 0, 0), subtraindo oprimeiro ponto ao segundo, obtendo:V normal = V (1,10,10) − V (1,1,0) = V (0,9,0)O ângulo do vector normal inicial mantém-se no vector entre a origem e nosso novo ponto (Figura 5.20).O vector normal pode ser associado a uma superfície utilizando a função glNormal, como mostra o exemplo:gl. glBegin ( GL_TRIANGLES );gl. glNormal3f (0.0f, -1.0f, 0.0 f);gl. glVertex3f (0.0f, 0.0f, 60.0 f);gl. glVertex3f ( -15.0f, 0.0f, 30.0 f);gl. glVertex3f (15.0f ,0.0f ,30.0 f);gl. glEnd ();50

Figura 5.20: Vector Normal movido para a OrigemNo exemplo, a função glNormal3f especifica o vector normal à superfície definida pelos três vectoressubsequentes (neste caso um triângulo), na direcção do eixo-y negativo. Os vectores são desenhados emcounterclock-wise quando vistos do lado para que aponta o vector, de forma a manter o winding coerente.Vectores Normais UnitáriosTodos os vectores normais no OpenGL, devem ser vectores unitários (de comprimento 1). Podemos converterqualquer vector para um vector unitário obtendo o seu cumprimento e dividindo as componentes nos 3 eixos poresse cumprimento:x 1 =Length = √ x 2 + y 2 + z 2xLength , y y1 =Length , z z1 =LengthV 1 = (x 1 , y 1 , z 1 )O processo de tornar um vector unitários denomina-se de normalização de vectores.A fim de evitar os cálculos, podemos dizer ao OpenGL para converter automaticamente as nossas normaispara vectores unitários, activando a flag:glEnable ( GL2 . GL_NORMALIZE );No entanto, isto tem um custo no desempenho. A melhor solução será efectuar o pré-cálculo dos vectoresnormais já normalizados.Sem mais configuração, a transformação efectuada pela função glScale, altera, junto com a geometria, otamanho das normais definidas para os nossos polígonos. Para evitar esse efeito podemos activar a flag:glEnable ( GL2 . GL_RESCALE_NORMALS );Junto com este documento, foi criado um projecto do eclipse contendo classes de auxílio à programaçãoOpenGL. Uma dessas classes é a classe GlTools que contém um conjunto de funções úteis. Uma dessas funções éa função:GLVector GlTools . normalizeVector ( GLVector v);Esta função recebe como argumento um vector (classe GLVector) e devolve uma instância normalizada dovector fornecido.51

Figura 5.21: Um vector normal não trivialFigura 5.22: Produto Vectorial52

Determinando a NormalNo caso da Figura 5.21 o vector normal não é tão óbvio.A determinação de um vector normal pode ser feita utilizando 2 vectores (ou 3 pontos) do plano que representaa superfície (Figura 5.22). O produto vectorial desses vectores é um vector perpendicular à superfície.Tomando o vector V 1 ( P ⃗ 1 P 2 ) e V 2 ( P ⃗ 1 P 3 ), o produto vectorial (V P = V 1 × V 2 ) pode ser obtido utilizando afórmula:x P = y 1 × z 2 − y 2 × z 1y P = x 1 × z 2 − x 2 × z 1z P = x 1 × y 2 − x 2 × y 1Mais uma vez, com o fim de facilitar o cálculo, foi criado código para facilitar esta tarefa:GLVector v1 = new GLVector (1f, 2f, 3f);GLVector v2 = new GLVector (4f, 5f, 6f);GLVector vp = v1. crossProduct (v2 );O exemplo acima, cria dois vectores (v1 e v2) e utiliza a função crossProduct da instância v1 para criar ovector vp com o resultado do produto vectorial.5.6.1 Configurando uma Fonte de luzConhecidos que estão os requisitos para a iluminação de polígonos, podemos adicionar luzes ao nosso cenário. Aconfiguração de luzes é feita utilizando a função:glLightfv ( int light , int pname , float [] params , int offset );A criação de um ponto de luz pode ser feita da seguinte forma:// na funcao init (...)float [] ambientLight = { 0.1f, 0.1f, 0.1f, 1.0 f };float [] diffuseLight = { 0.4f, 0.4f, 0.4f, 1.0 f };// Configurar e Activar a Luz 0gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_AMBIENT , ambientLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_DIFFUSE , diffuseLight , 0);gl. glEnable ( GL2 . GL_LIGHT0 );// na funcao display (...)// Posicionar a luz no cenariofloat lightPos [] = { -50.f, 50.0f, 100.0f, 1.0 f };gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , lightPos );Os arrays ambientLight[] e diffuseLight[] contém o RGBA das componentes ambiente e difusa da luz.O array lightPos[] define a posição da luz. A posição da luz é definida na ModelView Matrix uma vez queé um objecto geométrico, daí ser posicionada normalmente na função display(). Quando o último valor daposição da luz é 1f, o array define a posição da luz, quando o seu valor é 0, a luz encontra-se na direcção dovector lightPos[], mas no infinito.Ao desenhar os polígonos dos nossos objectos é necessário definir os vectores normais. Para facilitar o cálculodos vectores normais foi criada uma função na classe GlTools, que pode ser utilizada da seguinte forma:// Criar uma lista de vectoresGLTVectorList vPoints = new GLTVectorList ();vPoints . add (15.0f, 0.0f, 30.0 f);vPoints . add (0.0f, 15.0f, 30.0 f);vPoints . add (0.0f, 0.0f, 60.0 f);// Obter o vector normal ao planoGLVector vNormal = GlTools . getNormalVector ( vPoints );gl. glNormal3fv ( vNormal . toArray () , 0); // 0 -> ignorarvPoints . draw ();A classe GLTVectorList fornece uma forma simples de criar listas de vectores. O vector normal pode serobtido com a função GlTools.getNormalVector que recebe como argumento a lista de vectores criada. Ocálculo é feito com base nos primeiros 3 vectores adicionados na lista. Para utilizar nas funções do OpenGL,53

classe GLVector fornece o método toArray como forma simples de converter a instância actual para um arrayde float.Depois de aplicada a nossa fonte de luz, a imagem da Figura 5.16(b) toma o aspecto da Figura 5.23.Figura 5.23: Imagem com Fonte de LuzSugestão A fim de aumentar o desempenho da nossa aplicação e uma vez que a geometria normalmente éconhecida à partida, seria boa ideia guardar a lista de vectores (polígonos) e suas normais à priori e apenasdesenhá-los no momento oportuno.5.7 Efeitos de IluminaçãoA luz ambiente e difusa são suficientes no caso de estarmos a modelar superfícies que não têm componenteespecular da luz, tais como, madeira, papel, carvão, ou semelhantes.No entanto, em superfícies tais como a pele e metálicas em geral, é desejável a componente especular. Aoadicionar esta componente podemos dar brilho às superfícies, tal como o brilho numa esfera colorida de vidro.5.7.1 Luz EspecularPodemos adicionar luz especular à fonte de luz definida anteriormente da seguinte forma:// metodo init (...)float [] specularLight = { 1f, 1f, 1f, 1f };...gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_SPECULAR , specularLight , 0);O array specularLight[] especifica uma componente especular muito brilhante na nossa fonte de luz (luzbranca RBG=[255, 255, 255]). Seguidamente, utilizando a função glLightfv adicionamos à luz GL LIGHT0 acomponente especular.A seguir é necessário definir a forma como o nosso objecto reflecte a luz especular, o que pode ser feito com ocódigo:// metodo display (...)// Definir a componente especular dos objectos ...float [] specref = { 1.0f, 1.0f, 1.0f, 1.0 f };gl. glMaterialfv ( GL2 . GL_FRONT , GL2 . GL_SPECULAR , specref , 0);// .. com um valor alto de brilhogl. glMateriali ( GL2 . GL_FRONT , GL2 . GL_SHININESS , 128);...Mantendo o color tracking activo, as cores utilizadas são as definidas pela função glColor. O array specref[]define os valores RGBA para a reflexão especular. Utilizando a cor branca, dizemos que as superfícies reflectem54

praticamente todas as cores da componente especular. Utilizamos depois este array na propriedade GL SPECULARna face GL FRONT dos nossos objectos (Figura 5.24).Figura 5.24: Adição de Luz EspecularExpoente EspecularPara obter o efeito de brilho nas zonas onde a luz especular incide e sombra à medida que nos afastamos,alteramos a propriedade GL SHININESS na face do objecto:gl. glMateriali ( GL2 . GL_FRONT , GL2 . GL_SHININESS , 128);Esta função define o chamado expoente especular dos materiais. Basicamente define o quão pequeno é o focoda luz. Com o valor próximo de 0, o foco é grande e provocando uma incidência semelhante à difusa/ambiente.À medida que aumentamos o valor, a nossa luz vai ficando mais “focada” provocando um ponto de luz maisdefinido. O valor do GL SHININESS pode variar entre 1 e 128.5.7.2 Normal AveragingA técnica de normal averaging é um tweaking que permite dar a ilusão de uma superfície suave (smooth) aindaque seja composta por polígonos planos, como o exemplo da Figura 5.25.Figura 5.25: Esfera composta de quads e triângulosSe especificarmos as normais aos polígonos, o que vamos obter é uma superfície parecida com um diamante.No entanto, se especificarmos as “verdadeiras” normais, ou seja, nos vértices, o OpenGL interpola de forma suaveatravés da superfície dos polígonos. O resultado é a ilusão de uma superfície suave.A Figura 5.26 ilustra as diferenças entre as normais aos polígonos e aos vértices. No segundo caso as normaissão perpendiculares à superfície real do circulo.55

(a) Normais perpendiculares a cada face(b) Normais perpendiculares a cada vérticeFigura 5.26: Normal AveragingCalcular este tipo de normal para uma esfera é relativamente simples, uma vez que todas as normais passampelo seu centro. No entanto, para superfícies mais complexas o cálculo é feito com base nas normais de váriospolígonos que partilham o vértice em questão. A normal resultante é a média destas normais, daí o nome normalaveraging.5.7.3 Especificando um SpotlightPara transformarmos uma fonte de luz num Spotlight basta adicionar-lhe direccionalidade e definir a sua abertura.Podemos conseguir esse efeito utilizando o código:// algures no init (...)gl. glLightf ( GL2 . GL_LIGHT0 , GL2 . GL_SPOT_CUTOFF , 30f);// algures no display (...)float [] spotDir = { -1f, -1f, 0f};gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_SPOT_DIRECTION , spotDir , 0);O efeito conseguido com a adição de um spotlight será semelhante ao da Figura 5.27.Figura 5.27: Adição de um Spotlight56

A propriedade GL SPOT CUTOFF define o ângulo de abertura do nosso spotlight, conforme mostra a Figura5.28.Figura 5.28: Ângulo do cone do SpotlightA propriedade GL SPOT DIRECTION define a direcção do spot segundo um vector normalizado. Neste caso ovector (−1, −1, 0) diz que o nosso spot aponta no sentido negativo dos eixos x e y e faz um ângulo de 45 o com oeixo-y para esquerda.5.7.4 TesselationO conjunto de polígonos que descrevem uma superfície denomina-se de tesselation. Quanto maior for o nível detesselation mais realistas parecem as nossas curvas no caso da esfera. A Figura 5.29 mostra duas esferas comnúmeros diferentes de polígonos.Figura 5.29: Tesselation57

Capítulo 6Cores e Materiais (Continuação)Os exemplos constantes daqui para a frente, serão baseados no código fornecido junto com este item, na classeExample0 (Apêndice C.1). O exemplo contém um torus, definições básicas de luz e um chão como mostra aFigura 6.1.Figura 6.1: Example06.1 BlendingJá vimos que o OpenGL armazena os valores de cor no buffer de cor (em circustâncias normais) na altura derenderizar. Já vimos também que o mesmo acontece à informação da profundidade de cada um dos elementos(depth buffer). Quando activamos o teste de profundidade (depth test), um elemento substitui outro, apenas seestiverem mais perto no clipping volume ao utilizador.No caso do blending estas regras não se aplicam:glEnable ( GL2 . GL_BLEND );Quando activo, novas cores são combinadas com as que existem actualmente no buffer de cor. Esta combinaçãoé feita com base num conjunto de critérios.6.1.1 Combinação de CoresA terminologia utilizada para as cores é:• destination color: Valores RGBA da cor que se encontra actualmente no buffer de cor• source color: Valores RGBA da cor do elemento que vai interagir com a destination color58

A forma como estas duas componentes interagem é controlada pela equação de blending:C f = (C S ∗ S) + (C D ∗ D)Em que C f é a cor resultante, C S é a source color, C D é a cor de destino, S e D são os factores de blendingde origem e destino. Estes factores são configurados com a função:glBlendFunc ( int source_function , int destination_function );Os valores possíveis para os factores estão enumerados na Tabela 6.1.Function RGB Blend Factors Alpha Blend FactorGL ZERO (0, 0, 0) 0GL ONE (1, 1, 1) 1GL SRC COLOR (R S , G S , B S ) A SGL ONE MINUS SRC COLOR (1, 1, 1)–(R S , G S , B S ) 1–AsGL DST COLOR (R D , G D , B D ) A DGL ONE MINUS DST COLOR (1, 1, 1)–(Rd, Gd, Bd) 1–A DGL SRC ALPHA (A S , A S , A S ) A SGL ONE MINUS SRC ALPHA (1, 1, 1)–(As, As, As) 1–A SGL DST ALPHA (Ad, Ad, Ad) AdGL ONE MINUS DST ALPHA (1, 1, 1)–(Ad, Ad, Ad) 1–AdGL CONSTANT COLOR (Rc, Gc, Bc) AcGL ONE MINUS CONSTANT COLOR (1, 1, 1)–(Rc, Gc, Bc) 1–AcGL CONSTANT ALPHA (Ac, Ac, Ac) AcGL ONE MINUS CONSTANT ALPHA (1, 1, 1)–(Ac, Ac, Ac) 1–AcGL SRC ALPHA SATURATE (f, f, f) f=min(AS ,1−A D ) 1Tabela 6.1: Factores de Blending do OpenGLComo os valores RGBA são floats (0 ❀ 1) as operações de soma e subtracção continuam a gerar valoresválidos.Ao seleccionar uma das opções GL CONSTANT COLOR, GL ONE MINUS CONSTANT COLOR, GL CONSTANT ALPHA, eGL ONE MINUS CONSTANT ALPHA, podemos introduzir uma cor constante no blending. A cor inicialmente é black(rgba(0, 0, 0, 0)), para alterar essa cor utilizamos:glBlendColor ( float red , float green , float blue , float alpha );Um exemplo comum de configuração da função de blending poderia ser:glBlendFunc ( GL2 . GL_SRC_ALPHA , GL2 . GL_ONE_MINUS_SRC_ALPHA );Neste caso a source color (RGBA) seria multiplicada pelo seu valor alpha (GL SRC ALPHA). A destinationcolor seria multiplicada por 1 menos o valor do seu alpha (GL ONE MINUS SRC ALPHA). O resultado final seria asoma das duas cores. Por exemplo:C S = rgba (0 , 0, 1, .5) ⇒ GL_SRC_ALPHA ⇒ S = 0.5C D = rgba (1 , 0, 0, 0) ⇒ GL_ONE_MINUS_SRC_ALPHA ⇒ D = 1 - 0.5Como C f = (C S ∗ S) + (C D ∗ D) temos:C f = ( Blue * 0.5) + ( Red * 0.5)Para o exemplo a cor final será uma mistura das duas cores (vermelho + azul). Quanto maior for o valor S,maior será o valor da source color na mistura.O blending é normalmente utilizado para conseguir a ilusão de transparência. Tal ilusão pode ser conseguida,ligando o blending ao desenhar o objecto transparente. O código em baixo utiliza a estrutura do Example0adicionando um segundo torus com blending:// Limpar o fundo da janela com a cor definidagl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );gl. glMaterialfv ( GL2 . GL_FRONT , GL2 . GL_SPECULAR , fBrightLight , 0);gl. glPushMatrix ();gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , fLightPos . toArray () , 0);59

Desenhar um Torus Verdegl. glColor4f (0 , 1f, 0, .5f);drawWorld (gl );// Desenhar um Torus Vermelho com Blendinggl. glPushMatrix ();gl. glTranslatef (.1f, 0, .3f);gl. glEnable ( GL2 . GL_BLEND );gl. glBlendFunc ( GL2 . GL_SRC_ALPHA , GL2 . GL_ONE_MINUS_SRC_ALPHA );gl. glColor4f (1f, 0, 0,drawWorld (gl );.5f);gl. glDisable ( GL2 . GL_BLEND );gl. glPopMatrix ();gl. glColor4f (0.60f, .40f, .10f, .5f);GlUtil . drawGround ( FloorSize , 1f);gl. glPopMatrix ();O resultado do código em cima será o da Figura 6.2.Figura 6.2: Exemplo de BlendingModificando ligeiramente o código anterior, podemos obter a sensação de reflexão:gl. glPushMatrix ();// Desenhar a luz Invertida ( mirror Y)gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , fLightPos . mirrorY (). toArray () , 0);// Desenhar a reflexao do Torusgl. glPushMatrix ();// Ao utiliza y=-1 estamos a inverter a imagemgl. glScalef (1f, -1f, 1f);gl. glFrontFace ( GL2 . GL_CW ); // Estamos InvertidosdrawWorld (gl );gl. glFrontFace ( GL2 . GL_CCW ); // Reporgl. glPopMatrix ();// Desenhar o Nosso chao , mas agora transparentegl. glDisable ( GL2 . GL_LIGHTING );gl. glEnable ( GL2 . GL_BLEND );gl. glBlendFunc ( GL2 . GL_SRC_ALPHA , GL2 . GL_ONE_MINUS_SRC_ALPHA );gl. glColor4f (.5f, .5f, .5f, .5f);GlUtil . drawGround ( FloorSize , 1f);60

gl. glDisable ( GL2 . GL_BLEND );gl. glEnable ( GL2 . GL_LIGHTING );// Desenhar a luz no local correctogl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , fLightPos . toArray () , 0);// Desenhar um Torus Verdegl. glColor4f (0 , 1f, 0, .5f);drawWorld (gl );gl. glPopMatrix ();O código acima desenha inicialmente o torus debaixo do chão com a geometria invertida sobre o eixo-y(glScalef(0, -1f, 0)). Porque a geometria está invertida é preciso redefinir a forma como é deterinhada aface dos polígonos, utilizando glFrontFace(GL CW). Da mesma forma o nosso ponto de luz tem que ser colocadona posição inversa, de forma a manter a iluminação dos objectos coerentes. Seguidamente activamos o blendinge desenhamos o nosso chão com um alpha de .5f. Finalmente repomos a posição da luz e desenhamos o toruscom a geometria em posição. O resultado obtido é o da Figura 6.3.Figura 6.3: Ilusão de Reflexão utilizando Blending6.1.2 Alteração da Equação de BlendingA equação mostrada anteriormente:C f = (C S ∗ S) + (C D ∗ D)é a queação por omissão. Podemos, no entanto, escolher de entre um conjunto de equações possíveis para adeterminação do blending, utilizando o seguinte código:glBlendEquation ( int equation );As equações possíveis para a determinação do blending são as descritas na Tabela 6.2.ModeFunctionGL FUNC ADD (default) C f = (C S × S) + (C D × D)GL FUNC SUBTRACT C f = (C S × S) − (C D × D)GL FUNC REVERSE SUBTRACT C f = (C S × D) − (C D × S)GL MIN C f = min(C S , C D )GL MAX C f = max(C S , C D )Tabela 6.2: Factores de Blending do OpenGL61

Da mesma forma que deifinimos a função de blending para os valores RGBA source e destination utilizandoglBlendFunc, podemos utilizar a função glBlendFuncSeparate para especificar funções diferentes também parao cálculo dos factores alpha:glBlendFuncSeparate ( int srcRGB , int dstRGB , int srcAlpha , int dstAlpha );Sendo o srcRGB a função para o source color, o dstRGB a função para o destination color. Os valoressrcAlpha e dstAlpha permitem definir as funções para o source e destination alpha respectivamente.6.2 AntialiasingNa maior parte dos casos, fragmentos individuais da nossa renderização, consistem de pixeis no ecrã. Estespixeis são quadrados (ou quase), podendo quebrar a sensação de realismo. O OpenGL permite definir flags quemisturam as bordas de pontos, linhas e polígonos com a vizinhança, suavizando os contornos dos objectos.Para tal, é preciso activar primeiro o blending e definir as funções para o source e destination color. Depoispodemos activar as flags: GL POINT SMOOTH (pontos), GL LINE SMOOTH (linhas) e GL POLYGON SMOOTH (polígonos).A Figura 6.4 mostra dois circulos, sendo o de fora desenhado sem antialiasing e o de dentro desenhado comantialiasing.(a) Circulos Com/Sem Antialiasing(b) ZoomFigura 6.4: AntialiasingO código para conseguir o resultado da Figura 6.4(a) poderia ser:gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT );float x, y;gl. glLineWidth (5f);// Desenhar o Primeiro Circulo Sem Antialiasinggl. glBegin ( GL2 . GL_LINE_LOOP );for ( float a =0; a < 2f * GlTools . GL_PI ; a += .1f) {x = ( float ) Math . sin (a) / 2f;y = ( float ) Math . cos (a) / 2f;gl. glVertex3f (x, y, 0);}gl. glEnd ();// Activar o Blending / Antialiasing e Desenhar o Circulo de Dentrogl. glEnable ( GL2 . GL_BLEND );gl. glBlendFunc ( GL2 . GL_SRC_ALPHA , GL2 . GL_ONE_MINUS_SRC_ALPHA );// Suavizar as linhasgl. glEnable ( GL2 . GL_LINE_SMOOTH );62

gl. glHint ( GL2 . GL_LINE_SMOOTH_HINT , GL2 . GL_NICEST );// Desenhar o Circulo de Dentro com Antialiasinggl. glBegin ( GL2 . GL_LINE_LOOP );for ( float a =0; a < 2f * GlTools . GL_PI ; a += .1f) {x = ( float ) Math . sin (a) / 2.2 f;y = ( float ) Math . cos (a) / 2.2 f;gl. glVertex3f (x, y, 0);}gl. glEnd ();gl. glDisable ( GL2 . GL_LINE_SMOOTH );gl. glDisable ( GL2 . GL_BLEND );O código em cima desenha um circulo sem antialiasing, depois activa o blending e activa o antialiasing paraas linhas (GL LINE SMOOTH) e desenha o circulo mais pequeno. Adicionalmente o algoritmo escolhido para oantialiasing foi o que tem melhor aspecto final utilizando glHint(GL NICEST). Os algoritmos disponíveis para ocálculo do antialiasing são GL NICEST e GL FASTEST, sendo que o último tem um resultado visual mais fracoainda que seja mais rápido.6.2.1 MultisamplingApesar do aspecto visual ser melhorado pela utilização de antialiasing, esta não é a melhor escolha para tornaros objectos na cena mais realísticos. O GL POLYGON SMOOTH não é suportado em todas as plataformas e comoutiliza o blending termiamos que desenhar todas as nossa primitivas da frente para trás.Uma adição ao OpenGL 1 permite endereçar esta “problema”. O multisampling consiste num buffer adicional.Neste buffer os pixeis de cada primitiva são amostrados 2 várias vezes, sendo o resultado mostrado como umúnico pixel.Se o nosso contexto OpenGL suportar multisampling, podemos activá-lo utilizando:glEnable ( GL2 . GL_MULTISAMPLE );Figura 6.5: Normal vs Multisampling6.3 Nevoeiro (Fog)O OpenGL suporta a adição de nevoeiro ao cenário. A técnica utilizada pelo OpenGL para dar a sensação defog consiste no blending de uma cor específica com a geometria no final de toda a computação. A quantidadede blending dessa cor (alias: nevoeiro) com cada objecto do cenário depende da distância desse objecto aoobservador.A introdução de nevoeiro pode tornar ainda mais real a sensação de profundidade, uma vez que a visibilidadedos objectos é menor à medida que se afastam, o que acontece no mundo real. Podemos activar o nevoeiroutilizando:glEnable ( GL2 . GL_FOG );1 Para versões > 1.32 sampled63

Figura 6.6: NevoeiroA configuração do nevoeiro é feita utilizando uma das versões da função glFog:glFogi ( int pname , int param );glFogf ( int pname , float param );glFogiv ( int pname , int [] params , int offset );glFogfv ( int pname , float [] params , int offset );Onde o primeiro argumento (pname) escolhe a propriedade que estamos a alterar e o segundo argumentodefine o novo valor para a propriedade.Para configurar o nevoeiro utilizando uma determinada cor, que começa a afectar a geometria à distância 1fdo observador, terminando em 30f e utilizando uma variação linear utilizamos:float [] fLowLight = { 0.25f, 0.25f, 0.25f, 1.0 f };...// Definir a cor do Nevoeirogl. glFogfv ( GL2 . GL_FOG_COLOR , fLowLight , 0);// A que distancia os objectos comecao a ser afectadosgl. glFogf ( GL2 . GL_FOG_START , 1.0 f);// Ponto onde o nevoeiro toma conta completamentegl. glFogf ( GL2 . GL_FOG_END , 30.0 f);// Equacao do calculo do Nevoeirogl. glFogi ( GL2 . GL_FOG_MODE , GL2 . GL_LINEAR )Analisando em mais detalhe o código temos:gl. glFogfv ( GL2 . GL_FOG_COLOR , fLowLight , 0);No exemplo (Figura 6.6) podemos observar que o nevoeiro toma a cor do fundo. A cor do nevoeiro é definidaalterando o parâmetro GL FOG COLOR e fornecendo um array contendo os valores RGB.// A que distancia os objectos comecao a ser afectadosgl. glFogf ( GL2 . GL_FOG_START , 1.0 f);// Ate onde vai o nevoeirogl. glFogf ( GL2 . GL_FOG_END , 30.0 f);O parâmetro GL FOG START especifica a que distância do observador o nevoeiro começa a ter efeito sobre osobjectos. O parâmetro GL FOG END define o ponto a partir do qual o nevoeiro toma completamente a cor dosobjectos.// Equacao do calculo do Nevoeirogl. glFogi ( GL2 . GL_FOG_MODE , GL2 . GL_LINEAR )A transição entre o GL FOG START e o GL FOG END é controlada pelo GL FOG MODE, que no exemplo estáconfigurada para GL LINEAR. A fog equation define o factor de nevoeiro entre 0 e 1, à medida que o objecto sedesloca entre o inicio e o fim do nevoeiro.64

Fog Mode Fog EquationGL LINEAR f = end–cend–startGL EXP f = e –d×cGL EXP2 f = e –(d×c)2Tabela 6.3: Fog EquationsA Tabela 6.4 descreve as equações para as várias equações possíveis.Onde c é a distância ao observador, start é o valor de GL FOG START e end é o valor de GL FOG END. O valord é a densidade do nevoeiro, que pode ser configurada alterando o parâmetro GL FOG DENSITY:glFogf ( GL2 . GL_FOG_DENSITY ,0.5 f);Para GL LINEAR o valor da densidade não tem qualquer efeito, no entanto, para GL EXP e GL EXP2 este valoraltera o resultado final do nevoeiro.A Figura 6.7 mostra a forma como cada equação faz variar o nevoeiro entre o inicio e o fim para umadensidade de 0.5.Figura 6.7: Equações da Densidade do NevoeiroO modo como o OpenGL determina a distância a profundidade do nevoeiro para cada elemento no cenáriopode ser alterada utilizando o parâmetro GL FOG COORD SRC. Dois valores podem ser utilizados:• GL FRAGMENT DEPTH: Utiliza a profundidade do objecto como valor da distância. Permite obter melhoresresultados.• GL FOG COORD (valor por omissão): Faz a interpolação do nevoeiro entre vértices, o que permite um cálculomais rápido.A alteração deste parâmetro pode ser feita utilizando:glFogi ( GL2 . GL_FOG_COORD_SRC , GL2 . GL_FRAGMENT_DEPTH );// ouglFogi ( GL2 . GL_FOG_COORD_SRC , GL2 . GL_FOG_COORD );6.4 Accumulation BufferEm adição aos buffers de cor, profundidade e stencil 1 , o OpenGL contém um buffer especial que nos permitearmazenar os valores do buffer de cor em vez de os enviar para o ecrã. Um conjunto de operações permitemacumular várias iterações do buffer de cor, que pode então ser mostrado no ecrã.O comportamento do buffer de acumulação pode ser controlado pela função:glAccum ( int operation , float value );O primeiro argumento especifica a operação de acumulação a realizar e o segundo valor especifica um factorde escala para a operação. A operações possíveis estão enumeradas na Tabela ??.Devido à quantidade de operações de memória e processador necessários para realizar este tipo de operações,poucas aplicações em tempo-real utilizam este buffer. No entanto, os efeitos visuais conseguidos podem ser deum realismo surpreendente. Por exemplo, é possível recriar vários tipos de blur que podem simular os efeitos deprofundidade encontrados nas câmaras de vídeo e fotográficas.O efeito na Figura 6.8 pode ser conseguido utilizando:1 A ser analisado futuramente65

OperationGL ACCUMGL LOADGL MULTGL ADDGL RETURNDescriptionEscala os valores actuais do buffer de cor e adiciona-os ao buffer de acumulaçãoEscala os valores actuais do buffer de cor e substitui os valores actuais do buffer de acumulaçãoEscala os valores actuais do buffer e armazena-os no buffer de acumulaçãoEscala os valores actuais do buffer e adiciona os aos valores actualmente no buffer de acumulaçãoEscala os valores actuais do buffer e armazena-os no buffer de corTabela 6.4: Fog EquationsFigura 6.8: Efeito blur utilizando buffer de acumulação66

float xoff = 0f;// Desenhar os objectos 10x movendo -os progressivamente para a esquerdafor ( int pass = 0; pass < 10; pass ++) {}xoff += .05 f;gl. glPushMatrix ();gl. glTranslatef (xoff , 0, 0);gl. glColor3f (0 , 1f, 0);drawWorld (gl );gl. glPopMatrix ();// Desenhar o chaogl. glColor4f (0.60f, .40f, .10f, .5f);GlUtil . drawGround ( FloorSize , 1f);if( pass == 0)gl. glAccum ( GL2 . GL_LOAD , 0.5 f); // Copiar buffer de corelse// Acumular o buffer de cor actual com o accum buffergl. glAccum ( GL2 . GL_ACCUM , 0.5 f * (.5 f / pass ));// Despejar o buffer de acumulacao no buffer de corgl. glAccum ( GL2 . GL_RETURN , 1.0 f);67

Capítulo 7Imagens no OpenGL7.1 BitmapsO aspecto visual de um bitmap não é o ideal, ainda que seja perfeitamente possível identificar os objectos nelecontidos (Figura 7.1(a)). No OpenGL os bitmaps podem ser utilizados para máscaras (polygon stippling), fontes ecaracteres e dithering a duas cores.(a) Bitmap(b) PixmapFigura 7.1: Imagem BitmapA imagem da Figura 7.1(b), contém 256 níveis de cinzento, sendo denominada de pixmap.Figura 7.2: Imagem CampfirePodemos descrever a imagem utilizada anteriormente para o stippling de polígonos (Figura 7.2), sob a formade um array de 4 bytes × 32 (32 × 32 bit). Os valores no array de bytes estão em hexadecimal. Como podemosobservar, os valores no array estão invertidos, ou seja, a primeira linha do array representa a última linha dobitmap.68

ByteBuffer fire = ByteBuffer . wrap ( new byte [] {( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0xc0 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x01 , ( byte ) 0xf0 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x07 , ( byte ) 0xf0 ,( byte ) 0x0f , ( byte ) 0x00 , ( byte ) 0x1f , ( byte ) 0xe0 ,( byte ) 0x1f , ( byte ) 0x80 , ( byte ) 0x1f , ( byte ) 0xc0 ,( byte ) 0x0f , ( byte ) 0xc0 , ( byte ) 0x3f , ( byte ) 0x80 ,( byte ) 0x07 , ( byte ) 0xe0 , ( byte ) 0x7e , ( byte ) 0x00 ,( byte ) 0x03 , ( byte ) 0xf0 , ( byte ) 0xff , ( byte ) 0x80 ,( byte ) 0x03 , ( byte ) 0xf5 , ( byte ) 0xff , ( byte ) 0xe0 ,( byte ) 0x07 , ( byte ) 0xfd , ( byte ) 0xff , ( byte ) 0xf8 ,( byte ) 0x1f , ( byte ) 0xfc , ( byte ) 0xff , ( byte ) 0xe8 ,( byte ) 0xff , ( byte ) 0xe3 , ( byte ) 0xbf , ( byte ) 0x70 ,( byte ) 0xde , ( byte ) 0x80 , ( byte ) 0xb7 , ( byte ) 0x00 ,( byte ) 0x71 , ( byte ) 0x10 , ( byte ) 0x4a , ( byte ) 0x80 ,( byte ) 0x03 , ( byte ) 0x10 , ( byte ) 0x4e , ( byte ) 0x40 ,( byte ) 0x02 , ( byte ) 0x88 , ( byte ) 0x8c , ( byte ) 0x20 ,( byte ) 0x05 , ( byte ) 0x05 , ( byte ) 0x04 , ( byte ) 0x40 ,( byte ) 0x02 , ( byte ) 0x82 , ( byte ) 0x14 , ( byte ) 0x40 ,( byte ) 0x02 , ( byte ) 0x40 , ( byte ) 0x10 , ( byte ) 0x80 ,( byte ) 0x02 , ( byte ) 0x64 , ( byte ) 0x1a , ( byte ) 0x80 ,( byte ) 0x00 , ( byte ) 0x92 , ( byte ) 0x29 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0xb0 , ( byte ) 0x48 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0xc8 , ( byte ) 0x90 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x85 , ( byte ) 0x10 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x03 , ( byte ) 0x00 , ( byte ) 0x00 ,( byte ) 0x00 , ( byte ) 0x00 , ( byte ) 0x10 , ( byte ) 0 x00});Os bitmaps são desenhados no ecrã recorrendo ao raster dos seus bits. Precisamos então de dizer ao OpenGLqual será a posição em que deve ser feito o raster da nossa imagem, com recurso à função glRasterPos. A funçãoglRasterPos é pode receber 2 ou 3 argumentos, sendo que na primeira o eixo z toma o valor 0. O exemplomostra uma possível utilização da função:gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );// Bitmap de cor Verdegl. glColor3f (0.0f, 1.0f, 0.0 f);for ( int i =0; i < 16; i ++) {// Definir coordenadas do Rastergl. glRasterPos3d (i - 5, 1, i - 5);// Desenhar o bitmap 32 x32 no array de bytesgl. glBitmap (32 , 32 , 0f, 0f, 0, 0, fire );}gl. glColor3f (.5f, .5f, .5f);GlUtil . drawGround ( GL2 . GL_LINE_STRIP ,20f, 1f);No exemplo em cima, são desenhados 16 bitmaps percorrendo uma diagonal que atravessa o ponto (0, 0, 0).O nosso bitmap é desenhado utilizando a função:glBitmap (int width , int height ,float xorig , float yorig ,float xmove , float ymove ,ByteBuffer bitmap );O width e height referem-se ao tamanho em bits do bitmap, no nosso caso 32×32, o xorig e o yorigreferem-se ao offset x e y em relação à posição raster, o xmove e o ymove definem a posição de raster quandoo desenho terminar e o parâmetro bitmap contém os dados a desenhar. Os bits a 1 no nosso bitmap serão69

transformados em fragmentos (pixel) com a cor actualmente definida, os 0 não afectaram as cores actualmenteno color buffer.O resultado do código em cima pode ser visualizado na Figura 7.3.Figura 7.3: Utilização de glBitmap/glRasterPosAs coordenadas da função glRasterPos são afectadas pela projecção e posição do observador. Se quisermosque o nosso bitmap seja mostrado sempre na mesma posição no ecrã, independentemente do projecção eobservador, devemos utilizar a função glWindowPos, por exemplo:gl. glColor3f (1.0f, 0.0f, 0.0 f);// colocar o raster o canto inferior esquerdo do ecragl. glWindowPos2i (10 , 10);gl. glBitmap (32 , 32 , 0f, 0f, 0, 0, fire );7.2 PixmapsOs pixmaps são de maior utilidade nos sistemas full-color. O seu layout na memória é parecido ao dos bitmaps,no entanto, cada pixel pode conter mais do que um bit de informação. Cada pixel pode conter informação acercada intensidade (referida normalmente como luminance) ou acerca dos componentes de cor.Um pixmap pode ser desenhado a partir da posição actual do raster utilizando a função:void glDrawPixels (int width , int height ,int format , int type ,Buffer pixels )Os primeiros dois argumentos (width/height) referem-se ao tamanho do pixmap em pixels. O argumentoformat refere-se à forma como a informação está disposta, normalmente referido como formato da imagem (verTabela B.1). O argumento type define o tipo de dados na informação e o último argumento contém a informaçãoda imagem 1 . Ao contrário da função glBitmap, a posição de raster não é alterada.Os formatos GL STENCIL INDEX e GL DEPTH COMPONENT, são utilizados para ler e escrever informação nosstencil e depth buffers.O argumento type define o tipo de dados armazenados no nosso pixmap. Os valores possíveis para o tipo dedados estão descritos na Tabela B.2 2 .1 No JOGL, em vez de arrays é recomendada a utilização de buffers - http://java.sun.com/developer/technicalArticles/releases/nio/2 Na tabela estão omissos os packed RGB value, para mais informação consultar - http://www.opengl.org/registry/specs/EXT/packed_pixels.txt70

O exemplo em baixo utiliza numa primeira instância o ClassLoader 1 do Java para ler um ficheiro e a classeTGAImage para utilizar o ficheiro como uma imagem (targa neste exemplo). Posteriormente o método getDatada classe TGAImage permite-nos obter uma referência para a informação (pixmap) contida na imagem sob aforma de um ByteBuffer.class Pixmap implements GLEventListener {}private TGAImage img ;private ByteBuffer bb;// ...@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// ...try {InputStream stream = getClass (). getResourceAsStream (" fire . tga ");img = TGAImage . read ( stream );bb = img . getData ();stream . close ();} catch ( IOException e) {// Tratar do erro ...}}// ...O bloco try { ... } catch(Exception e) { ... } permite ao nosso programa estar preparado no casoda leitura do ficheiro não ser bem sucedida. Este bloco é denominado de exception handling no Java 2 .Dentro do try o nosso programa lê o ficheiro fire.tga que deverá estar contido no mesmo package da classePixmap.Basta agora no método display() da nossa classe mostrar o pixmap de acordo com a posição do raster.// Definir a posicao do rastergl. glRasterPos2i ( img . getWidth ()*3/4 , img . getHeight ()*3/4);// Redimensionar e inverter a imagemgl. glPixelZoom ( -.5f, -.5f);// Desenhar a Imagem no ByteBuffergl. glDrawPixels (img . getWidth () , img . getHeight () , // Tamanho da imagemimg . getGLFormat () , // Pixel FormatGL2 . GL_UNSIGNED_BYTE , bb );// Restaurargl. glPixelZoom (1f, 1f);O resultado do código em cima, pode ser visualizado na Figura 7.4. A função glPixelZoom(float xzoom,float yzoom) permite alterar a escala utilizada para desenhar os pixels. Utilizando xzoom/yzoom negativos,estamos a inverter a ordem utilizada para desenhar os pixels, pelo que a posição do raster tem que ser reajustada.7.3 Operações com PixelsAté agora temos estado a escrever para os buffers (color, depth, . . . ), no entanto pode ser útil ler a informaçãocontida nestes buffers ou mesmo copiá-la entre eles. A informação para ler a informação dos pixels funcionacomo a função glDrawPixels só que no sentido inverso.glReadPixels (int x, int y,int width , int height ,int format , int type ,Buffer pixels )1 Ver detalhes em http://download.oracle.com/javase/6/docs/technotes/guides/lang/resources.html2 Ver mais detalhes em http://download.oracle.com/javase/tutorial/essential/exceptions/71

Figura 7.4: Utilização de glDrawPixels/glPixelZoomOs argumentos x, y, width e height, definem o rectângulo a copiar 1 . O format e type são o formato e otipo de dados utilizados para armazenar o conteúdo do buffer na variável de saída pixels. Independentementeda forma como a informação está armazenada no color buffer, o OpenGL encarrega-se de fazer as conversõesnecessárias.Pode ser útil ainda copiar informação dentro do mesmo buffer. Para tal definimos o canto inferior esquerdo(com glRasterPos/glWindowPos) da zona a copiar. A função para efectuar a cópia é:glCopyPixels (int x, int y,int width , int height ,int type);Mais uma vez, o x, y, width e height, definem o rectângulo de origem. O argumento type diz o que estamosa copiar, podendo tomar o valor GL COLOR para copiar do color buffer, GL DEPTH para copiar do depth buffer ouGL STENCIL para copiar do stencil buffer.Por omissão estas operações de cópia realizam-se no back buffer em contextos com suporte para doublebuffering, ou no front buffer em contextos com single buffer. Para alterar a fonte ou destino para a cópia,utilizamos:glDrawBuffer ( int destination );glReadBuffer ( int source );O argumento destination da função glDrawBuffer, especifica onde os pixels são escritos pelas operaçõesglDrawPixels/glCopyPixels. O argumento source da função glReadBuffer especifica a fonte para os pixelslidos nas operações glReadPixels/glCopyPixels. Os valores possíveis para os argumentos source/destinationpoderão ser: GL NONE, GL FRONT, GL BACK, GL FRONT AND BACK, GL FRONT LEFT, GL FRONT RIGHT, . . .Um caso prático de utilização das operações com pixels seria, por exemplo, armazenar o conteúdo do colorbuffer actual num ficheiro de imagem. A fim de ilustrar os conceitos explicados nesta secção, exemplificamoscomo isso poderia ser feito:// Ler o valor READ BUFFER actual// ( para repor mais tarde )IntBuffer lastBuffer = IntBuffer . allocate (1);gl. glGetIntegerv ( GL2 . GL_READ_BUFFER , lastBuffer );// Vamos ler o FRONT BUFFER1 sendo x e y o canto inferior esquerdo72

gl. glReadBuffer ( GL2 . GL_FRONT );// O ByteBuffer output ira armazenar temporariamente// a nossa imagemByteBuffer output = ByteBuffer . allocate ( width * height * 3); // RGBgl. glReadPixels (0, 0, // Canto inferior esquerdowidth , height , // Tamanho a lerGL2 . GL_BGR , // Formato Blue , Green , Red ( targa )GL2 . GL_UNSIGNED_BYTE , // Tipo de dados unsigned byteoutput);// Criar um TGA a partir do ByteBufferTGAImage img = TGAImage . createFromData ( width , height , false , false , output );try {img . write ("c:/ my.tga "); // Guardar a imagem no disco} catch ( IOException e) {// Falha ao escrever o ficheiro}// Restaurar o read buffer anteriorgl. glReadBuffer ( lastBuffer . get (0));A função glGet(int pname, ...) 1 permite-nos obter informação das variáveis do OpenGL (nestecaso o buffer de leitura actual - GL READ BUFFER). No JOGL a maior parte das funções que retornam valores,utilizam subclasses de Buffer (neste caso IntBuffer) para os armazenar. É importante no nosso códigoOpenGL, restaurarmos, na medida do possível, o estado anterior das coisas, daí obtermos o lastBuffer e serfeita a sua reposição no fim do bloco de código, utilizando glReadBuffer(lastBuffer.get(0)). Seguidamenteespecificamos que o buffer para leitura será o que se encontra visível (GL FRONT):gl. glReadBuffer ( GL2 . GL_FRONT );Inicializamos um ByteBuffer com o tamanho da janela (width×height) multiplicado por 3, uma vez quevamos armazenar as três componentes de cor RGB, ficando então width×height×3.ByteBuffer output = ByteBuffer . allocate ( width * height * 3);Os ficheiros targa armazenam a informação da cor na ordem BGR (Blue, Green, Red), pelo que o formatodos dadosm especificado é GL BGR. O seguinte código copia o conteúdo do front buffer e coloca-o no nossoByteBuffer.gl. glReadPixels (0, 0, // Canto inferior esquerdowidth , height , // Tamanho a lerGL2 . GL_BGR , // Formato Blue , Green , Red ( targa )GL2 . GL_UNSIGNED_BYTE , // Tipo de dados unsigned byteoutput);Finalmente, criamos uma instância de TGAImage com base no ByteBuffer output, utilizando a função:TGAImage . createFromData (int width , int height , // Tamanho da imagemboolean hasAlpha , // Formato contem alphaboolean topToBottom , // A imagem esta armazenada "ao contrario "ByteBuffer output // ByteBuffer com os dados);Esta função é utilizada da seguinte forma:TGAImage img = TGAImage . createFromData ( width , height , false , false , output );Finalmente para armazenar a nossa imagem no disco fazemos:img . write ("c:/ my.tga ")A imagem my.tga irá conter o conteúdo do nosso front buffer.1 http://www.opengl.org/sdk/docs/man/xhtml/glGet.xml73

7.4 Outras Operações com ImagensPara além das operações descritas, o OpenGL suporta ainda um conjunto de operações especiais aquando datransferência da informação dos pixels para e do color buffer.Abaixo discutimos algumas das operações possíveis, bem como o código necessário para consegui-las (códigocompleto no Apêndice C.2). O progama inicial para a demonstração desta funcionalidade utiliza uma projecçãoortogonal configurada com a função:glOrtho2D (double left , double right ,double bottom , double top);Em que left/right são as coordenadas dos clipping planes verticais, e bottom/top são as coordenadasdos clipping planes horizontais. Os valores de zNear/zFar especificados na função glOrtho tomam os valores0 e 1 respectivamente.A nossa projecção ortogonal irá coincidir com o tamanho da janela e do viewport. O método reshape(...)terá o seguinte aspecto:public void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {// Viewport coincide com a janelagl. glViewport (0 , 0, width , height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();// Configurar a projeccao ortogonalglu . gluOrtho2D (0 , width , 0, height );}// ...À semelhança do que aconteceu com o exemplo na secção anterior, será carregado o ficheiro horse.tga comrecurso ao ClassLoader do Java e à função TGAImage.read(...) para a variável de classe img e lidos os bytespara um ByteBuffer (bb).A imagem (Figura 7.5) será mostrada no método display(...) utilizando:gl. glDrawPixels (img . getWidth () , img . getHeight () ,img . getGLFormat () ,GL2 . GL_UNSIGNED_BYTE , bb );Figura 7.5: Imaging.java mostranto horse.tgaOs blocos de código seguinte mostram como podemos implementar os efetios GaussianBlur, Sharpen, Emboss,Invert e Brighten. Alguns dos efeitos são aplicados utilizando matrizes de convolução, que permitem obter ovalor de cor de um pixel com base nos que se encontram nas suas imediações 1 .O OpenGL permite aplicar este tipo de matrizes às imagens utilizando a função:1 Mais detalhes e exemplos em http://manual.gimp.org/en/plug-in-convmatrix.html74

glConvolutionFilter2D (int target , int internalFormat ,int width , int height ,int format , int type ,Buffer image );Em que o target toma o valor GL2.GL CONVOLUTION 2D, o internalFormat indica o formato interno danossa matriz de convolução (para o nosso caso GL2.GL RGB), width/height especificam o tamanho da matriz,format indica o formato dos pixels na imagem de destino, type especifica o tipo de dados da imagem e imagecontém a informação da imagem.Gaussian BlurPara aplicar o efeito de gaussian blur (Figura 7.6) podemos utilizar a seguinte matriz de convolução:⎛1 2 1⎞⎝ 2 4 2 ⎠1 2 1Para tal utilizamos o seguinte código:// Matriz ( convolution kernel ) para efectuar gaussian blurfloat norm = 16f; // normalizacao : somatorio dos valores da matrizFloatBuffer mGaussian = FloatBuffer . wrap ( new float [] {1f/norm , 2f/norm , 1f/norm ,2f/norm , 4f/norm , 1f/norm ,1f/norm , 2f/norm , 1f/ norm});// Aplicar a matrizgl. glConvolutionFilter2D (GL2 . GL_CONVOLUTION_2D , GL2 . GL_RGB , 3, 3,GL2 . GL_LUMINANCE , GL2 . GL_FLOAT , mGaussian);// Activar convolucao 2Dgl. glEnable ( GL2 . GL_CONVOLUTION_2D );// Mostrargl. glDrawPixels (img . getWidth () , img . getHeight () ,img . getGLFormat () , GL2 . GL_UNSIGNED_BYTE , bb );// Desactivar convolucao 2Dgl. glDisable ( GL2 . GL_CONVOLUTION_2D );Figura 7.6: Gaussian BlurA forma de aplicar outras matrizes é semelhante. Apenas mudamos o último argumento da funçãoglConvolutionFilter2D de mGaussian para a matriz criada. Como tal interessa apenas referir quais asmatrizes utilizadas e como foram inicializadas.75

EmbossA matriz utilizada para o efeito emboss (Figura 7.7) poderá ser:⎛2 0 0⎞⎝ 0 −1 0 ⎠0 0 −1Inicializada com:// Matriz ( convolution kernel ) para efectuar embossFloatBuffer mEmboss = FloatBuffer . wrap ( new float [] {2.0f, 0.0f, 0.0f,0.0f, -1.0f, 0.0f,0.0f, 0.0f, -1.0f});Figura 7.7: EmbossSharpenA matriz utilizada para o efeito sharpen (Figura 7.8) poderá ser:⎛0 −1 0⎞⎝ −1 5 −1 ⎠0 −1 0Inicializada com:// Matriz ( convolution kernel ) para efectuar o sharpenFloatBuffer mSharpen = FloatBuffer . wrap ( new float [] {0.0f, -1.0f, 0.0f,-1.0f, 5.0f, -1.0f,0.0f, -1.0f, 0.0 f});BrightenA operação de brighten na imagem pode ser implementada de forma simples. Mudando para a matriz de corutilizando:gl. glMatrixMode ( GL2 . GL_COLOR );... podemos utilizar a função glScale uma vez que as transformações são agora operadas na matriz de cor,como mostra o exemplo:76

Figura 7.8: Sharpen// Mudar para o matrix mode Colorgl. glMatrixMode ( GL2 . GL_COLOR );// Aumentar todas as cores em 50%gl. glScalef (2f, 2f, 2f);// Voltar ao ModelViewgl. glMatrixMode ( GL2 . GL_MODELVIEW );77

Capítulo 8Mapeamento de TexturasNa computação gráfica convencional, cada elemento de um pixmaps corresponde a um elemento no ecrã, daí onome de picture element (alias pixel). No entanto, quando mapeados a primitivas geométricas, raramente estespixmaps têm uma proporção de 1 para 1.Figura 8.1: Mapeamento de TexturasA aplicação de imagens à geometria é referida como texture ou texture mapping. A utilização de texturaspode aumentar dramaticamente o realismo e a qualidade dos nossos cenários.8.1 Carregamento de TexturasO primeiro passo na aplicação de texturas à nossa geometria, consiste no carregamento da imagem correspondentepara a memória. Esta imagem passa a ser considerada o “estado actual” da textura. O carregamento de imagenssob a forma de texturas pode ser feito utilizando uma das três versões da função glTextImage:glTexImage1D (int target , int level , int internalFormat ,int width , int border ,int format , int type ,Buffer pixels);glTexImage2D (int target , int level , int internalformat ,int width , int height , int border ,int format , int type ,Buffer pixels);glTexImage3D (78

int target , int level , int internalformat ,int width , int height , int depth , int border ,int format , int type ,Buffer pixels);Estas três funções permitem-nos dizer ao OpenGL tudo aquilo que ele precisa de saber relativamente à imagemcontida no array pixels. A função glTextImage carrega para a memória, a imagem fornecida e torna-a atextura actual a ser aplicada na geometria. Este carregamento para a memória pode ser dispendioso (alternativasdiscutidas mais à frente na Secção 8.6).O valor do target para cada uma das funções é respectivamente : GL TEXTURE 1D, GL TEXTURE 2D eGL TEXTURE 3D ou GL PROXY TEXTURE 1D, GL PROXY TEXTURE 2D ou GL PROXY TEXTURE 3D. Ao utilizar proxies,o OpenGL faz uma verificação prévia do que o sistema suporta em termos de compatibilidade, no caso de nãohaver suporte, o estado da imagem é tornado inválido sem que qualquer tipo de erro seja reportado 1 .O argumento level define o nível de mipmapping (discutido na Secção 8.5.3), de momento utilizaremostexturas sem mipmapping, especificando o valor 0.O argumento internalFormat, especifica quantos componentes de cor são armazenados por texel, o espaçonecessário ao armazenamento dos componentes e/ou se a textura é comprimida. A Tabela 8.1 lista os valoresmais comuns para este parâmetro.ConstanteGL ALPHAGL LUMINANCEGL LUMINANCE ALPHAGL RGBGL RGBAArmazenar os texels como:Valores de alphaValores de luminânciaValores de luminância e alphaComponentes de red, green e blueComponentes de red, green, blue e alphaTabela 8.1: Factores de Blending do OpenGLOs valores de width, height e depth (apropriadamente) especificam as dimensões da textura que estamosa carregar para a memória. Estas dimensões devem ser inteiros com base 2 (2 x = 1, 2, 4, 8, . . . ), isto nãoimplica que o mapeamento da textura seja quadrado, mas um valor não 2 x provovará que o mapeamento sejaimplicitamente desabilitado.O argumento border especifica a largura da borda à volta da textura. Esta borda permite acrescentartexels adicionais à textura.Os argumentos format, type, têm o mesmo objectivo que quando utilizados na função glDrawPixels. Oargumento pixels contêm a informação da imagem propriamente dita.Para aplicarmos textura à nossa geometria temos que activar o seu estado apropriado. Para tal utilizamosas funções glEnable/glDisable com as constantes GL TEXTURE 1D, GL TEXTURE 2D e GL TEXTURE 3D 2 , comoilustra o exemplo:glDisable ( GL2 . GL_TEXTURE_1D );glEnable ( GL2 . GL_TEXTURE_2D );8.1.1 Pipeline do Carregamento de ImagensO carregamento de imagens no OpenGL (por ex.: utilizando glTexImage) obedece a um pipeline de processamentoà semelhança do pipeline de transformações do OpenGL.As operações de convolução, pixel zoom, pixel packing, . . . (discutidas no capítulo anterior) são aplicadassegundo a Figura 8.2.8.1.2 Utilizando o Color BufferÉ possível carregar texturas 1D e 2D a partir do color buffer, utilizando as seguintes funções:glCopyTexImage1D (int target , int level , int internalformat ,int x, int y, int width ,int border);1 Para verificar se foi bem sucedido utiliza-se a função glGetTexParameter2 É boa ideia desactivar os estados não utilizados, uma vez que apenas um destes estados pode existir em simultâneo79

Figura 8.2: Pipeline - Carregamento de ImagensglCopyTexImage2D (int target , int level , int internalformat ,int x, int y, int width , int height ,int border);O significado dos argumentos é semelhante aos argumentos da função glTexImage, mas neste caso o x, y,width e height especificam a área no color buffer a ler. O source buffer pode ser definido utilizando a funçãoglReadBuffer.8.1.3 Actualização de TexturasO carregamento repetido de texturas pode ser dispendioso em termos de processamento. Substituir umadeterminada textura pode ser mais rápido, na maior parte das vezes do que o carregamento utilizando glTexImage.Para tal utilizamos as funções:glTexSubImage1D (int target , int level ,int xoffset ,int width ,int format , int type , Buffer data);glTexSubImage2D (int target , int level ,int xoffset , int yoffset ,int width , int height ,int format , int type , Buffer data);glTexSubImage3D (int target , int level ,int xoffset , int yoffset , int zoffset ,int width , int height , int depth ,int format , int type , Buffer data);Mais uma vez, os argumentos são semelhantes aos utilizados em glTexImage. O xoffset, yoffset e zoffsetespecificam o local na textura actual para começar a fazer a substituição. O tamanho da textura no argumentodata é especificado pelos argumentos width, height e depth.Finalmente um conjunto final de funções permite-nos substituir uma parte de uma textura utilizandoinformação extraída directamente do color buffer:glCopyTexSubImage1D (int target , int level ,int xoffset ,int x, GLint y,int width);glCopyTexSubImage2D (int target , int level ,int xoffset , int yoffset ,80

int x, GLint y,int width , int height);glCopyTexSubImage3D (int target , int level ,int xoffset , int yoffset , int zoffset ,int x, GLint y,int width);Podem ter reparado que não existe uma função glCopyTexImage3D, isto deve-se ao facto do color bufferser bi-dimensional. No entanto podemos querer copiar informação do color buffer para uma face (plano?) emespecífico da nossa textura 3D, isso pode ser conseguido utilizando glCopyTexSubImage3D.8.2 Mapeamento de Texturas à GeometriaAo activar o mapeamento de texturas, o OpenGL permite-nos mapear qualquer textura a qualquer uma dasprimitivas. No entanto, é necessário fornecer ao OpenGL informação acerca de como esse mapeamento é feito, oque é conseguido especificando uma coordenada na textura (texture coordinate) para cada vértice. Os texels 1não são especificados utilizando posições de memória, tal como nos pixmaps, mas com um sistema de coordenadasmais abstracto. As coordenadas das texturas são normalmente especificadas utilizando valores entre 0.0 e 1.0.Os nomes das coordenadas são s, t, r e q (semelhantes á coordenadas vectoriais x, y, z e w). A Figura 8.3mostra como os texels são especificados com base em coordenadas 1D, 2D e 3D.Figura 8.3: Coordenadas dos texels numa texturaO factor q representa um factor de escala da textura, à semelhança do valor w dos vértices. Ou seja, osvalores das coordenadas das texturas são realmente s/q, t/q e r/q. Por omissão q=1.0.A coordenada na textura é especificada utilizando a função glTexCoord. Esta função tem um conjunto devariações para vários objectivos, à semelhança das funções em geral do OpenGL. Algumas formas simples destasfunções são:glTexCoord1f ( float s);glTexCoord2f ( float s, float t);glTexCoord3f ( float s, float t, float r);A coordenada da textura é aplicada utilizando estas funções para cada um dos vértices. O OpenGL estica ouencolhe (alias stretching) a textura de forma a aplicá-la na geometria especificada com base nas coordenadasespecíficadas. A forma como o stretching é feito depende do filtro da textura (texture filter) actual, discutidomais à frente. A Figura 8.4(a) mostra o exemplo de ume textura bi-dimensional aplicada a um GL QUAD. Noscantos do quad temos as coordenadas correspondentes da textura. A função glTexCoord tem que ser utilizadaantes de cada chamada à função glVertex.Esta coincidência entre geometria e textura é rara. Um exemplo mais comum será o da Figura 8.4(b). Ascoordenadas da textura neste caso não coinicidem com a forma da geometria.1 Um texel é um fragmento da textura, tal como o pixel de um pixmap81

(a) Textura bi-dimensional aplicada a umquad(b) Textura bi-dimensional aplicada a umtriânguloFigura 8.4: Aplicação de textura bi-dimensionalTexture MatrixÀ semelhança da matriz MODELVIEW, PROJECTION e COLOR, é também possível operar transformações na matrizde coordenadas das texturas, podemos fazê-lo passando para a texture matrix:glMatrixMode ( GL2 . GL_TEXTURE );Depois desta chamada todas as transformações são operadas nas coordenadas da textura. No entanto,a stack de tranformações só tem dois níveis de profundidade, o que implica que só podemos utilizar doisglPushMatrix/glPopMatrix encadeados.8.3 Exemplo de Textura 2DExiste um conjunto de conceitos ainda por adquirir relacionados com as texturas, tais como coordinate wrapping,texture filters e texture environment. A fim de os abordar utilizamos como plataforma um exemplo simples 2D,com configurações comuns destes parâmetros. O código fonte do exemplo Pyramid.java pode ser consultado noApêndice C.3.Figura 8.5: Exemplo pyramidA Figura 8.5 ilustra a posição dos cantos da pirâmide. A declaração será feita no método init() do nossoGLEventListener da seguinte forma:// Cantos da PiramidecTop = new GLVector (0.0f, .80f, 0.0 f);cBackLeft = new GLVector ( -0.5f, 0.0f, -.50f);cBackRight = new GLVector (0.5f, 0.0f, -0.50 f);cFrontRight = new GLVector (0.5f, 0.0f, 0.5 f);cFrontLeft = new GLVector ( -0.5f, 0.0f, 0.5 f);Ainda no método init(), carregamos a imagem que irá servir para aplicar textura na nossa geometria, eactivamos o TEXTURE 2D:82

...try {InputStream stream = Imaging . class . getResourceAsStream (" stone . tga ");img = TGAImage . read ( stream );bb = img . getData ();stream . close ();} catch ( IOException e) {e. printStackTrace ();}gl. glTexImage2D ( GL2 . GL_TEXTURE_2D , 0, GL2 . GL_RGB ,img . getWidth () , img . getHeight () ,0, img . getGLFormat () , GL2 . GL_UNSIGNED_BYTE , bb );// Activar as texturasgl. glEnable ( GL2 . GL_TEXTURE_2D );// ...A face frontal tem que ser desenhada na ordem CCW para que a nossa textura seja aplicada correctamente.Assim a ordem de desenho correcta será - cTop-cFrontLeft-cFrontRight. As coordenadas são especificadas deforma semelhante às da Figura 8.4(b).O código em baixo calcula o verctor normal à face frontal (vNormal), especifica as coordenadas da texturapara cada vértice (glTexCoord) e desenha-o 1 :// Face da FrentevNormal = GlTools . getNormalVector (cTop , cFrontLeft , cFrontRight );gl. glNormal3fv ( vNormal . toArray () , 0);gl. glTexCoord2f (.5f, 1f);cTop . draw ();gl. glTexCoord2f (0f, 0f);cFrontLeft . draw ();gl. glTexCoord2f (1f, 0f);cFrontRight . draw ();O desenho das restantes faces do triângulo são feitas de forma semelhante. A Figura 8.6 mostra o output doficheiro Pyramid.java.Figura 8.6: Output do ficheiro Pyramid.java1 Por uma questão de conveniência a class GLVector tem um método que desenha o vector actual utilizando a função glVertex83

8.4 Texture EnvironmentNo exemplo Pyramid, a pirâmide é desenhada utilizando material de cor branca e a textura é aplicada de formaque as suas cores são “escaladas” (scaled) segundo a cor da geometria (branca) (Figura 8.7).Figura 8.7: Geometria Branca + Texture = Shaded TextureA forma como a cor dos texels é combinada com a geometria subjacente é controlada pelo texture environment.A sua configuração é feita utilizando a função glTexEnv:glTexEnvi ( int target , int pname , int param );glTexEnvf ( int target , int pname , float param );glTexEnviv ( int target , int pname , IntBuffer param );glTexEnvfv ( int target , int pname , FloatBuffer param );Esta função pode ser usada de várias formas, e permite configurar parâmetros avançados das texturas. Noexemplo Pyramid, o environment mode é confiurado com o valor GL MODULATE:gl. glTexEnvi ( GL2 . GL_TEXTURE_ENV , GL2 . GL_TEXTURE_ENV_MODE , GL2 . GL_MODULATE );Com a opção GL MODULATE, a cor do texel é multiplicada pela cor da geometria (depois do calculo das luzes).Ao especificar uma cor clara para a geometria (branca, no exemplo) a textura é afectada de forma igual àgeometria. Isto permite com a mesma textura obter várias colorizações.Utilizando GL REPLACE, podemos substituir completamente a cor da geometria pela cor do texel. Isto eliminatodos os efeitos aplicados à geometria subjacente. Se a textura tiver um alpha channel podemos utilizar estemodo para tornar zonas da geometria transparente se a imagem contiver blocos também transparentes, activandoo blending.A opção GL DECAL é semelhante à opção GL REPLACE se a imagem não tiver alpha channel. No caso de aimagem ter um alpha channel a cor da geometria transparece pela textura no valor do alpha, de forma que oobjecto parece ser blended com os fragmentos subjacentes.Podemos também fazer o blending da geometria com uma cor fixa (Figura 8.8) utilizando:gl. glTexEnvi ( GL2 . GL_TEXTURE_ENV ,GL2 . GL_TEXTURE_ENV_MODE , GL2 . GL_BLEND );gl. glTexEnvfv ( GL2 . GL_TEXTURE_ENV ,GL2 . GL_TEXTURE_ENV_COLOR , new float [] {1f, 0f, 0f, 0f}, 0);Figura 8.8: Utilizando GL BLENDFinalmente podemos fazer a adição do valor da cor dos texels aos fragmentos da geometria, utilizando GL ADDcomo argumento. Os valores que ultrapassem 1.0 são truncados, o que poderá provocar saturação das cores.84

8.5 Parametrização de TexturasO texturing no OpenGL envolve mais do que o simples mapeamento de uma textura num dos lados de umtriângulo. Um conjunto de parâmetros afectam o compotamento e a renderização das texturas aplicadas. Estesparâmetros podem ser configurados com a função glTexParameter, utilizando uma das variantes:glTexParameterf ( int target , int pname , float param );glTexParameteri ( int target , int pname , int param );glTexParameterfv ( int target , int pname , FloatBuffer params );glTexParameteriv ( int target , int pname , IntBuffer params );O argumento target, especifica o modo da textura para o parâmetro que estamos a configurar (GL TEXTURE 1D,GL TEXTURE 1D, GL TEXTURE 3D). O parâmetro a configurar é especificado em pname e o seu valor é definido noúltimo argumento da função (param/params).8.5.1 Filtering BásicoProque raramente a geometria coincide com a textura em termos de pixels (ao contrário dos pixmaps), asimagens de textura são normalmente “deformadas” para obedecer às coordenadas especificadas para a geometria.A imagem pode ser encolhida ou esticada, ou ambos na aplicação à geometria.O processo de cálculo dos fragmentos de cor, quando uma textura está a ser aplicada, é chamado defiltering. Podemos especificar os filtros utilizados na altura de encolher (minification) ou de esticar (magnification).Os parâmetros para a configuração destes valores são, respectivamente, GL TEXTURE MIN FILTER eGL TEXTURE MAG FILTER. Podemos especificar dois valores para este parâmetro:(a) Filtering com GL NEAREST(b) Filtering com GL LINEARFigura 8.9: Aplicação de textura bi-dimensional• GL NEAREST: Simples e rápido. São apuradas as coordenadas de cada fragmento para cada texel, a corcorrespondente a essa coordenada é utilizada como a cor do fragmento da textura. A técnica de nearestneighbour é caracterizada pelo aparecimento de blocos de uma só cor, quando a geometria é aumantada(Figura 8.9(a)). Pode ser configurado utilizando:gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MAG_FILTER , GL2 . GL_NEAREST );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MIN_FILTER , GL2 . GL_NEAREST );• GL LINEAR: Requer mais processamento, mas o resultado justifica. O custo de processamento do linearfiltering é, nos computadores actuais despresível. O valor da cor de cada fragmento da textura é conseguidopela interpolação linear (média ponderada) dos texels que rodeiam a sua coordenada. Pode ser configuradoutilizando:gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MAG_FILTER , GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MIN_FILTER , GL2 . GL_LINEAR );85

8.5.2 Texture WrapNormalmente especificamos as coordenadas das texturas com valores entre 0.0 e 1.0 relativamente ao texturemap. A forma como são tratados os valores que saem fora do intervalo [0.0, 1.0] é definida no parâmetro texturewrap. O valor deste parâmetro é definido individualmente para as coordenada s, t e r, utilizando a funçãoglTexParameteri com o pname - GL TEXTURE WRAP S, GL TEXTURE WRAP T, or GL TEXTURE WRAP R. Os modosdisponíveis para o wrapping são:• GL REPEAT: Neste modo a textura é repetida na direcção do valor que ultrapassou o intervalo. Isto permiteutilizar uma textura pequena para superfcícies grandes. Se a imagem for bem escolhida podemos dar asensação de uma textura muito maior à custa de uma porção mais pequena.• GL CLAMP: Os texels são obtidos a partir da cor borda da imagem. Esta cor é especificada no parâmetroGL TEXTURE BORDER COLOR (configurado com glTexParameterfv).• GL CLAMP TO EDGE: Faz com que os valores fora da borda não sejam utilizados no cálculo da interpolaçãolinear.• GL CLAMP TO BORDER: Utiliza os valores da borda quando as coordenadas da textura caem fora do intervalo[0.0, 1.0].A escolha do tipo de wrapping influencia o modo como o filtering funciona, principalmente quando estamos ausar GL LINEAR. Como o valor do fragmento é calculado com base na vizinhança, o cálculo junto das bordas datextura pode representar um problema se nos limitarmos a fazer clamping. O problema pode ser resolvido deforma simples quando utilizamos GL REPEAT. Os novos texels são obtidos a partir da linha/coluna adjacentes, queno repeat mode são tirados a partir do outro extremo da imagem (como se juntássemos as duas arestas opostasda imagem). Isto funciona especialmente bem quando usamos texturas em que um lado encaixa perfeitamenteno outro (por ex.: esferas).Uma aplicação comum para o clamping pode ser vista no mapping de texturas que não caberiam em memóriapelo seu tamanho. Em vez disso, são utilizados “mosaicos”. No entanto, a não utilização de GL CLAMP TO EDGEpode levar ao aparecimento de artefactos indesejados no texture mapping.8.5.3 MipmappingO mipmapping é uma técnica que permite melhorar a performance de renderização e a qualidade visual de umacena. O melhoramento é feito endereçando dois problemas comuns na aplicação de textura à geometria:1. Scintillation: Consiste de artefactos de aliasing que aparecem nas superfcícies quando os objectos sãomuito renderizados muito pequenos, comparados com a textura que lhes é aplicada. Este efeito é maisnotório quando existe movimento na cena, ou quando o observador se encontra em movimento.2. Performance: Uma grande quantidade de memória deve ser carregada com texturas e processada (filtering)para renderizar um conjunto limitado (ou pequeno) de fragmentos no ecrã. O que provoca um decréscimona performance à medida que a quantidade e tamanho das texturas aumenta.Uma solução para estes dois problemas poderia passar pela utilização de uma textura mais pequenta. Noentanto, quando nos aproximamos do objecto, essa textura será inevitavelmente escalada, tornando as nossasmenos nítidas ou cheias de artefactos.A solução deveras eficaz passa pela utilização de mipmapping 1 . O mipmapping consiste na utilização devárias imagens com diferentes tamanhos e resoluções para a mesma textura. O OpenGL utiliza então tiras dasimagens para aplicar à geometria de forma apropriada e com base num novo conjunto de filtros. Isto poderá serfeito à custa de um pouco mais de memória e/ou processamento.Uma textura mipmapped consiste de um conjunto de imagens, onde cada uma é metade da anterior até queatingem o tamanho 1x1 (Figura 8.10).As imagens não precisam de ser necessariamente quadradas, neste caso quando uma coordenada chega a 1 aoutra é dividida repetidamente até que chega a 1x1.A utilização de mipmapping poderá ocupar até 3× mais memória de textura que a não utilização.Os níveis de mipmap para cada imagem são especificados no segundo argumento (level) da função glTexImageaquando do seu carregamento. O primeiro nível será 0, depois 1, 2, 4 e por aí fora numa base 2 x em que x é aiteração da imagem. Quando o mipmapping não está a ser utilizado, a imagem especificada no valor 0 é tomadopor omissão.1 Palavra proveniente de multum in parvo - muitas coisas num local pequeno86

Figura 8.10: Conjunto de imagens MipmappedPor omissão, para utilizar o mipmapping, temos que especificar uma imagem para cada nível de mip.Podemos, no entanto, definir qual o valor base e máximos utilizando os parâmetros GL TEXTURE BASE LEVEL eGL TEXTURE MAX LEVEL, como mostra o exemplo:gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_BASE_LEVEL , 0);gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_MAX_LEVEL , 4);Desta forma, serão apenas utilizados os níveis 0, 1, 2 e 4 de mipmapping para aplicar à nossa geometria.Podemos ainda especificar os valores mínimos e máximos de detalhe a ser utilizados alterandos os valores deGL TEXTURE MIN LOD e GL TEXTURE MAX LOD.8.5.4 Mipmap FilteringCom o mipmapping ganhamos um novo conjunto de modos de filtering de texturas. Estes novos modos estãodescritos na Tabela 8.2.ConstanteGL NEARESTGL LINEARGL NEAREST MIPMAP NEARESTGL NEAREST MIPMAP LINEARGL LINEAR MIPMAP NEARESTGL LINEAR MIPMAP LINEARDescriçãoCalcular com base no “vizinho mais próximo” no nívelde mip actualCalcular com base na interpolação linear da vizinhançano nível de mip actualSeleccionar o nível de mip mais próximo e operar filtronearestInterpolação linear entre níveis de mip e operar filtronearestSeleccionar o nível de mip mais próximo e operar filtragemlinearInterpolação linear entre níveis de mip e operar filtragemlinear (alias trilinear mipmapping)Tabela 8.2: Mipmap FilteringO simples facto de especificarmos o nível de mip na função glTexImage não activa o mipmapping. Se o filtroda textura estiver configurado para GL LINEAR ou GL NEAREST, os níveis de mip ≠ 0 são ignorados. Um dosfiltros de mipmapping deve ser especificado para que o mipmapping seja usado.As constantes tomam a forma GL MIPMAP , onde o FILTRO especifica o tipo de filtragemoperado no nível de mip seleccionado. O SELECTOR, como o nível de mip é seleccionado. Se seleccionarmosum modo de filtering que activa o mipmapping sem carregar os níveis de mip correspondente, desactivamos omapping de texturas.A escolha do filtro depende um pouco da aplicação e dos requisitos de performance. Utilizando o filtroGL NEAREST MIPMAP NEAREST, conseguimos um desempenho melhor e um valor de scintillation reduzido, noentanto o aspecto visual final não é o mais agradável. O GL LINEAR MIPMAP NEAREST é utilizado normalmentepara acelerar jogos, mantendo um aspecto visual melhorado, ainda que a seleccção do nível de mip seja feita porproximidade.A utilização de nearest para a seleccção do nível de mip, poderá também conduzir ao aparecimento deartefactos indesejados. Quando vista de uma forma obliqua, é perceptível a transição de um nível para o outrode mip. A utilização de uma selecção LINEAR (GL * MIPMAP LINEAR) permite uma interpolação adicional entreníveis para eliminar esta zona de transição, ainda que à custa de processamento adicional.8.5.5 Geração de níveis de MipmappingPoderiamos chamar de forma reptida a função glTexImage para conseguirmos popular todos os níveis de mip.No entanto, isto pode ser uma tarefa ardua, sendo que nem sempre o developer tem acesso a todos tamanhos da87

imagem da textura. A biblioteca GLU fornece um conjunto de funções que permitem convenientemente gerar osvários níveis para cada imagem. Estas funções carregam ainda a imagem automaticamente utilizando a funçãoglTexImage. As variantes da função são:gluBuild1DMipmaps (int target , int internalFormat ,int width ,int format , int type ,Buffer data);gluBuild2DMipmaps (int target , int internalFormat ,int width , int height ,int format , int type ,Buffer data);gluBuild3DMipmaps (int target , int internalFormat ,int width , int height , int depth ,int format , int type ,Buffer data);A utilização destas funções é semelhante à utilização da função glTexImage, no entanto, não especificamos oargumento level uma vez que os níveis de mip são gerados de forma automática. A imagem é redimensionadautilizando um box filter, que poderá não ter o mesmo efeito que utilizando um programa de desenho (como oPhotoshop).Para o caso de querermos especificar o nível de mip a que uma imagem se refere 1 aquando da geração dosníveis podemos ainda utilizar:gluBuild1DMipmapLevels (int target , int internalFormat ,int width ,int format , int type , int level ,int base , int max , Buffer data);gluBuild2DMipmapLevels (int target , int internalFormat ,int width , int height ,int format , int type , int level ,int base , int max , Buffer data);gluBuild3DMipmapLevels (int target , int internalFormat ,int width , int height , int depth ,int format , int type , int level ,int base , int max , Buffer data);Aqui o level especifica o nível de mip a que a imagem (data) se refere e o base e max, definem o nívelmínimo e máximo de mip. Estas funções são utilizadas para gerar os níveis dentre base e max.8.5.6 Geração de Mipmaps por HardwareSe soubermos que queremos utilizar todos os níveis de mipmapping, podemos utilizar a aceleração de hardwaredo OpenGL para os gerar de forma rápida. Isto é conseguido fazendo:gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_GENERATE_MIPMAP , GL2 . GL_TRUE );Quando o valor de GL GENERATE MIPMAP é GL TRUE, as chamadas subsequentes a glTexImage e glTexSubImageque actualizam o nível 0, actualizam de forma automática todos os outros níveis 2 . A utilização desta funcionalidadepermite um ganho em desempenho relativamente à utilização de gluBuildMipmaps.1 Por exemplo: temos a imagem para o nível 4 de mip e estamos a gerar do 0 ao 82 Esta funcionalidade está disponível apenas para versões do OpenGL ≥ 1.488

8.5.7 Level Of Detail (LOD) BiasO OpenGL calcula o nível de mip a utilizar com base no número de níveis disponíveis no tamanho da geometriaa renderizar. Podemos, no entanto, dizer ao OpenGL para “polarizar” o valor do seu critério (valores de mipmais baixos) ou diminuir essa polarização (valores mais altos de mip). O ajuste deste valor poderá aumentar aperformance (utilizando os níveis mais baixos de mip) ou aumentar a fidelidade das nossas texturas (utilizandoníveis mais altos de mip). O valor desta polarização pode ser configurado utilizando, por exemplo:gl. glTexEnvf ( GL2 . GL_TEXTURE_FILTER_CONTROL , GL2 . GL_TEXTURE_LOD_BIAS , -1.5);No exemplo em cima, o detalhe das texturas é aumentado ligeiramente (nível de mip mais baixo), resultandonum cenário com aspecto melhorado, ainda que à custa de processamento adicional.8.6 Texture ObjectsO carregamento e gestão das texturas representam uma porção importante no desenvolvimento de qualqueraplicação 3D, tal como os jogos, em particular.As funções glTexImage, glTexSubImage e gluBuildMipmaps, movem grandes quantidades de memória, peloque a troca entre texturas seria uma operação dispoendiosa, em termos de processamento.Os texture objects permitem-nos carregar mais do que um estado de textura de cada vez e trocar entre elasde forma rápida. O estado das texturas é armazenado e rotulado com um identificador inteiro. A alocação detexturas com identificadores é feita utilizando:glGenTextures ( int n, IntBuffer textures );O argumento n especifica o número de texturas que queremos armazenar e o argumento textures é umarray de inteiros (IntBuffer) que irá conter os identificadores gerados. Para fazer o bind de uma textura a umdestes estados fazemos:glBindTexture ( int target , int texture );Mais uma vez o target pode tomar o valor GL TEXTURE 1D, GL TEXTURE 2D ou GL TEXTURE 3D. O argumentotexture é o identificador ao qual vamos fazer o bind. O carregamentos de texturas e parametrizações subsequentesafectaram apenas o estado da textura representado pelo identificador texture.Para apagar um determinado estado utilizamos a função:glDeleteTextures ( int n, IntBuffer textures );O significado dos argumentos é o mesmo da função glBindTexture.Podemos verificar se um determinado identificador contém um estado válido utilizando a função:boolean glIsTexture ( int texture );O valor de retorno da função será GL TRUE no caso de ter sido alocado um estado a este identificador.89

Capítulo 9Mapeamento de Texturas: ConceitosAvançados9.1 Cor SecundáriaAntes de aplicar as texturas à geometria, o OpenGL calcula os valores individuais de cada fragmento, incluindo acomponente de LIGHTING. O valor de cada fragmento é mais tarde combinado com os texels (depois do processode filtering) dando origem à textura.Este processo diminui drásticamente a visibilidade da componente especular.A solução para este problema passa pela aplicação da componente especular da luz apenas após ter sidoaplicada a textura. Esta técnica é designada de secondary specular color. Apesar de poder ser aplicada de formamanual, o OpenGL contém já um mecanismo que faz esse trabalho de forma automática. Para tal basta-nosalterar o nosso light model, da seguinte forma:glLightModeli ( GL2 . GL_LIGHT_MODEL_COLOR_CONTROL , GL2 . GL_SEPARATE_SPECULAR_COLOR );As Figuras 9.1(a) e 9.1(b) mostram as diferenças sem e com a separação da componente especular.(a) Sem GL SEPARATE SPECULAR COLOR(b) Com GL SEPARATE SPECULAR COLORFigura 9.1: Utilização de Secondary ColorPara retomar o light model anterior podemos utilizar:glLightModeli ( GL2 . GL_LIGHT_MODEL_COLOR_CONTROL , GL2 . GL_COLOR_SINGLE );9.2 Anisotropic FilteringApesar de não fazer parte da espeficicação do OpenGL, a técnica de Anisotropic Filtering é suportada pela maiorparte dos fabricantes. A sua utilização permite um melhoramento das operações de filtering das texturas.90

No processo de filtering, o OpenGL utiliza os texels na vizinhança de uma determinada posição para fazero sampling da textura 1 . Com este processo obtemos resultados perfeitos quando a textura é vista de frente(perpendicularmente à geometria), no entanto, quando a geometria é vista de forma oblíqua podemos observar aperda de informação da imagem (como que uma desfocagem).Para evitar este efeito a área da vizinhança utilizada no filtering tem agora uma forma adequada à posição doobservador (Figura 9.2). Isto implica que vários samples da imagem sejam feitos, relativamente ao observador,resultado numa imagem anisotrópica.Figura 9.2: Textura normal vs Anisotropic FilteringPodemos aplicar o anisotropic filtering a texturas básicas e mipmapped. Para tal são efectuados 3 passos:1. Verificamos se a extensão para anisotropic filtering está disponível:GL2 gl = ...;gl. isExtensionAvailable (" GL_EXT_texture_filter_anisotropic ");2. Obtemos valor máximo de anisotpropia suportado:// Array temporario de saida para a funcao glGetFloatv (...)FloatBuffer out = FloatBuffer . allocate (1);gl. glGetFloatv ( GL2 . GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT , out );// Valor maximo de anisotropia esta na posicao 0 de outfloat largest = out . get (0);3. Finalmente definimos a quantidade de anisotropia utilizando:gl. glTexParameterf (GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MAX_ANISOTROPY_EXT ,largest);Quando maior o valor de anisotropia definido, maior será a quantidade de texels que são utilizados noprocesso de filtering.Pegando no exemplo Tunnel.java dos capítulos anteriores, as texturas serão carregadas da seguinte formano método init():// ...// Se afLargest se mantiver a 0 nao suporta anisotropic filteringfloat afLargest = 0f;// Se o anisotropic filtering for suportado obtemos o valor maximo// e armazenamos em afLargestif(gl. isExtensionAvailable (" GL_EXT_texture_filter_anisotropic ")) {FloatBuffer out = FloatBuffer . allocate (1);gl. glGetFloatv ( GL2 . GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT , out );afLargest = out . get (0);}for ( int i = 0; i < textureNames . size (); i ++) {1 Utilizando por exemplo GL NEAREST e GL LINEAR91

Fazer o bind do estado da textura ao identificadorgl. glBindTexture ( GL2 . GL_TEXTURE_2D , textures . get (i ));// Carregar e Ler a imagem para a nossa texturaTGAImage img = loadTexture ( textureNames . get (i ));ByteBuffer bb = img . getData ();glu . gluBuild2DMipmaps ( GL2 . GL_TEXTURE_2D , GL2 . GL_RGBA ,img . getWidth () , img . getHeight () , img . getGLFormat () ,GL2 . GL_UNSIGNED_BYTE , bb );// Parametros da textura ( ignorar para ja)gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_MAG_FILTER ,GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_MIN_FILTER ,GL2 . GL_LINEAR_MIPMAP_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_WRAP_S ,GL2 . GL_CLAMP_TO_EDGE );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_WRAP_T ,GL2 . GL_CLAMP_TO_EDGE );// Se afLargest for > 1f o anisotropic filtering e suportadoif( afLargest > 1f)gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MAX_ANISOTROPY_EXT ,afLargest );}As Figuras 9.3(a) e 9.3(b) ilustram a diferença entre o filtering e sem e com utilização de anisotropic filtering.(a) Sem Anisotropic Filtering(b) Com Anisotropic FilteringFigura 9.3: Utilização de Anisotropic Filteing9.3 Compressão de TexturasA indiscutível melhoria introduzida pelas texturas é normalmente acompanhada por uma quantidade importantede memória ocupada e algum overhead de processamento. No entanto, o mais preocupante é realmente o espaçoocupado (normalmente na memória gráfica).O OpenGL permite ao utilizador fazer o carregamento de texturas comprimidas 1 . Os dados da texturamantém-se comprimidos na memória gráfica, o que pode representar um ganho no desempenho aquando doswapping de texturas, bem como uma menor quantidade de memória ocupada.1 Na maior parte das implementações92

As texturas carregadas não precisam de estar inicialmente comprimidas. Na altura do carregamento destaspodemos solicitar a compressão ao OpenGL, alterando o internalFormat para um dos valores na Tabela 9.1.Formato ComprimidoGL COMPRESSED ALPHAGL COMPRESSED LUMINANCEGL COMPRESSED LUMINANCE ALPHAGL COMPRESSED INTENSITYGL COMPRESSED RGBGL COMPRESSED RGBAFormato BaseGL ALPHAGL LUMINANCEGL LUMINANCE ALPHAGL INTENSITYGL RGBGL RGBATabela 9.1: Formatos de Texturas ComprimidasAo utilizar os formatos de texturas comprimidos, é adicionado um ligeiro overhead no carregamento inicialdas texturas. No entanto, este overhead é despresível face as melhorias na utilização da memória.Se por algum motivo a textura não for carregada com o formato comprimido solicitado, o OpenGL alternapara o formato base correspondente (Tabela 9.1).Quando utilizamos estes formatos para a compressão de texturas, o OpenGL tenta determinar a melhor formade comprimir a textura. Podemos dizer ao OpenGL para escolher um algortimo mais rápido ou com melhorqualidade utilizando a função glHint:• Método mais rápido:gl. glHint ( GL2 . GL_TEXTURE_COMPRESSION_HINT , GL2 . GL_FASTEST );• Método com melhor qualidade:gl. glHint ( GL2 . GL_TEXTURE_COMPRESSION_HINT , GL2 . GL_NICEST );• Deixar o OpenGL decidir:gl. glHint ( GL2 . GL_TEXTURE_COMPRESSION_HINT , GL2 . GL_DONT_CARE );9.4 Geração de Coordenadas de TexturasComo vimos no capítulo anterior, a atribuição das coordenadas das texturas a geometria é uma tarefa simplesquando estamos a lidar com superfícies simples (triângulos, quadrados, etc. . . ). No entanto, para superfíciescomplexas, o cálculo das coordenadas correctas pode ser uma tarefa complexa.Até certo ponto, o OpenGL consegue gerar automáticamente estas coordenadas das texturas para cada vértice.Para activar/desactivar a geração das coordenadas (s, r, t e q), utilizamos as funções glEnable()/glDisable()com as flags - GL TEXTURE GEN S, GL TEXTURE GEN R, GL TEXTURE GEN T e GL TEXTURE GEN Q.Quando a geração de coordenadas está activa, quaisquer chamadas subsequentes às funções glTextCoord sãoignoradas.A função utilizada pelo o OpenGL para o cálculo destas coordenadas é definida utilizando uma das funções:glTexGenf ( int coord , int pname , float param );glTexGenfv ( int coord , int pname , FloatBuffer param );O argumento coord pode tomar um dos valores - GL S, GL T, GL R ou GL Q. O argumento pname deverá serum de - GL TEXTURE GEN MODE, GL OBJECT PLANE ou GL EYE PLANE. O argumento param define os valores paraa função utilizada no argumento pname.Para exemplificar a utilização das funções de cálculo das coordenadas foi criado o programa TexGen.java(ver Apêndice C.4). O programa permite ao utilizador alterar a função de cálculo em runtime, utilizando asteclas 1 = Object Linear, 2 = Eye Linear e 3 = Sphere Map.9.4.1 Oject Linear MappingQuando a função para a geração das texturas é GL OBJECT LINEAR, as coordenadas das texturas são geradascom base na seguinte função:Coord OLM = P 1 × x + P 2 × y + P 3 × z + P 4 × w93

Onde x, y, z e w são as coordenadas dos vértices do objecto onde está a ser aplicada a textura e os valoresP i (i = [1; 4]) são os coeficientes de uma equação do plano.Nesta caso, as coordenadas da textura são projectadas sobre a geometria, sob o ponto de vista do planodescrito pela equação. O excerto de código em baixo do programa TexGen.java, projecta as coordenadas s e t,a partir do plano z = 0:FloatBuffer zPlane = FloatBuffer . wrap ( new float [] {0f, 0f, 1f, 0f });gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_OBJECT_LINEAR );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_OBJECT_LINEAR );gl. glTexGenfv ( GL2 .GL_S , GL2 . GL_OBJECT_PLANE , zPlane );gl. glTexGenfv ( GL2 .GL_T , GL2 . GL_OBJECT_PLANE , zPlane );De notar que é ainda possível definir funções diferentes para cada coordenada (neste caso s e t). Esta técnicamapeia as coordenadas da texturas em coordenadas no objecto, independentemente das tranformações em curso.O resultado final pode ser observado na Figura 9.4. Na Figura é possível observar o objecto com a texturaaplicada e a textura propriamente dita.Figura 9.4: Função Object Plange9.4.2 Eye Linear MappingQuando a função de geração das coordenadas é GL EYE LINEAR, as coordenadas são geradas de forma semelhantea GL OBJECT LINEAR, mas neste caso os valores de x, y, z e w referem-se agora à localização do observador. Aequação do plano têm também os seus coeficientes invertidos.Coord ELM = −P 1 × x eye − P 2 × y eye − P 3 × z eye − P 4 × w eyeA textura parece deslizar sobre a geometria à medida que é afectada pelas transformações geométricas. Oexcerto do programa TexGen.java abaixo mostra como podemos utilizar o eye linear mapping para o mesmoplano z = 0:FloatBuffer zPlane = FloatBuffer . wrap ( new float [] {0f, 0f, 1f, 0f });gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_EYE_LINEAR );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_EYE_LINEAR );gl. glTexGenfv ( GL2 .GL_S , GL2 . GL_EYE_PLANE , zPlane );gl. glTexGenfv ( GL2 .GL_T , GL2 . GL_EYE_PLANE , zPlane );O resultado pode ser observado nas Figuras 9.5(a) e 9.5(b).94

(a) GL EYE LINEAR(b) GL EYE LINEAR após ligeira rotaçãoFigura 9.5: Função GL EYE LINEAR9.4.3 Sphere MappingAo utilizar o GL SPHERE MAP o OpenGL calcula as coordenadas das texturas de tal forma que ficamos coma impressão de que o objecto actual está a reflectir a textura que lhe aplicámos. O excerto do programaTexGen.java em baixo exemplifica a utilização da função sphere mapping:gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_SPHERE_MAP );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_SPHERE_MAP );Para obter uma sensação de reflexão convincente, uma textura é normalmente adquirida utilizando uma lentefish-eye.Apesar de o sphere mapping ter sido substituído pelo cube mapping (Secção 9.5), ainda se encontram algunscasos de uso, na medida em que apenas uma textura é necessária, ao contrário do cube mapping onde sãonecessárias 6 !. Se apenas queremos dar a sensação de reflexão e não realismo, o sphere mapping é uma boaescolha.Um exemplo em que o sphere mapping faz um match perfeito, é o caso das superfícies que não reflectem oambiente de forma não espelhada, como por exemplo uma peça de metal não uniforme.No programa TexGen.java foi utilizada a imagem de fundo (constante em todos os exemplos) para aplicarna textura com a função sphere map. Quando aplicamos transformações, o torus parece reflectir o ambiente(Figura 9.6).9.5 Cube MappingOs últimos dois modos de geração de coordenadas são o GL REFLECTCION MAP e o GL NORMAL MAP, ambos requerema utilização de um tipo especial de textura de ambiente (environment texture) - o cube map.A Figura 9.7 mostra a disposição das seis texturas nas faces do cube map utilizado no programa CubeMap.java(ver Apêndice C.5).Este mapa será uma aproximação das vistas (frente, trás, esquerda, direita, “tecto” e chão) de um cenárioreal. Utilizando o modo GL REFLECTION MAP, é possível criar uma reflexão bastante precisa.9.5.1 Carregamento do Cube MapO cube mapping adiciona 6 novos valores para o primeiro argumento da função glTexImage2D:• GL TEXTURE CUBE MAP POSITIVE X• GL TEXTURE CUBE MAP NEGATIVE X• GL TEXTURE CUBE MAP POSITIVE Y• GL TEXTURE CUBE MAP NEGATIVE Y95

Figura 9.6: Sphere MapFigura 9.7: Cube Map do programa CubeMap.java96

• GL TEXTURE CUBE MAP POSITIVE Z• GL TEXTURE CUBE MAP NEGATIVE ZAs constantes representam a direcção no ambiente real para a textura que estamos a carregar. Por exemplopara definirmos a textura para a direcção x positiva, poderiamos utilizar a função glTexImage2D da seguinteforma:TGAImage img = loadImage (" facex . tga ");glTexImage2D ( GL2 . GL_TEXTURE_CUBE_MAP_POSITIVE_X , 0,img . getGLFormat () , img . getWidth () , img . getHeight () , 0,GL_RGBA , GL_UNSIGNED_BYTE , img . getData ());O excerto de código em baixo pertence ao programa CubeMap.java, e ilustra a forma como as texturaspoderiam carregadas para o cube map:// Obter os identificadoresIntBuffer textures = IntBuffer . allocate ( NumTextures );gl. glGenTextures ( NumTextures , textures );// ...// Direccoes para as texuras do cuboList < String > textureNames = new ArrayList < String >();private static final int [] CubeDirection = {GL2 . GL_TEXTURE_CUBE_MAP_POSITIVE_X ,GL2 . GL_TEXTURE_CUBE_MAP_NEGATIVE_X ,GL2 . GL_TEXTURE_CUBE_MAP_POSITIVE_Y ,GL2 . GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ,GL2 . GL_TEXTURE_CUBE_MAP_POSITIVE_Z ,GL2 . GL_TEXTURE_CUBE_MAP_NEGATIVE_Z};// ...// Texturas do Cube MaptextureNames . add (" cubemap / right . tga ");textureNames . add (" cubemap / left . tga ");textureNames . add (" cubemap /up.tga ");textureNames . add (" cubemap / down . tga ");textureNames . add (" cubemap / backward . tga ");textureNames . add (" cubemap / forward . tga ");// ...// Carregar as texturas do Cubogl. glBindTexture ( GL2 . GL_TEXTURE_CUBE_MAP , textures . get ( CubeStartIndex ));// Parametros das texturas do cube mapgl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_MAG_FILTER ,GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_MIN_FILTER ,GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_WRAP_S , GL2 . GL_REPEAT );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_WRAP_T , GL2 . GL_REPEAT );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_WRAP_R , GL2 . GL_REPEAT );// Restantes texturas preenchem o cubofor ( int i = CubeStartIndex ; i < textureNames . size (); i ++) {// Carregar e Ler a imagem para a nossa texturaTGAImage img = loadTexture ( textureNames . get (i ));ByteBuffer bb = img . getData ();}gl. glTexImage2D ( CubeDirection [i - CubeStartIndex ], 0, GL2 . GL_RGBA ,img . getWidth () , img . getHeight () , 0, img . getGLFormat () ,GL2 . GL_UNSIGNED_BYTE , bb );97

O valor utilizado no primeiro argumento das funções relacionadas com as texturas passa agora a serGL TEXTURE CUBE MAP. O mesmo valor é utilizado para activar o cube mapping:gl. glEnable ( GL2 . GL_TEXTURE_CUBE_MAP );No caso de GL TEXTURE CUBE MAP e GL TEXTURE 2D estarem activos simultâneamente, o cube map prevalece.De notar que a utilização do glTexParameter no cube map afecta as 6 texturas de uma só vez. Para todos osefeitos, os cube maps são tratados como texturas 3D, com coordenadas s, t e r.9.5.2 Utilização dos Cube MapsA utilização mais comum para o cube map é a reflexão do ambiente. No exemplo CubeMap.java, a cena écapturada mudando o ponto de vista 6 vezes utilizando um field of view de 90 o .Para conseguir o efeito de reflexão com a composição das seis imagens, utilizamos:gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_REFLECTION_MAP );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_REFLECTION_MAP );gl. glTexGeni ( GL2 .GL_R , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_REFLECTION_MAP );Ao desenhar a nossa geometria (no exemplo um torus e uma sphere), desactivamos temporáriamenteo GL TEXTURE 2D e activamos o GL TEXTURE CUBE MAP, activamos a geração das coordenadas das texturas edesenhamos a geometria normalmente. Seguidamente restauramos o estado anterior reactivando o GL TEXTURE 2D:// Desactivar temporariamente TEXTURE_2Dgl. glDisable ( GL2 . GL_TEXTURE_2D );// Activar o Cube Mapgl. glEnable ( GL2 . GL_TEXTURE_CUBE_MAP );gl. glBindTexture ( GL2 . GL_TEXTURE_CUBE_MAP , textures . get ( CubeStartIndex ));gl. glEnable ( GL2 . GL_TEXTURE_GEN_S );gl. glEnable ( GL2 . GL_TEXTURE_GEN_T );gl. glEnable ( GL2 . GL_TEXTURE_GEN_R );// Desenhar a Geometria que reflecte o cube mapgl. glTranslatef (0 , .5f, -.3f);glut . glutSolidSphere (.15 , 61 , 37);gl. glRotatef (( float ) Math . toDegrees ( torusRot ), 0, 1f, 0);glut . glutSolidTorus (.1f, .3f, 61 , 37);// Colocar tudo como estavagl. glDisable ( GL2 . GL_TEXTURE_GEN_S );gl. glDisable ( GL2 . GL_TEXTURE_GEN_T );gl. glDisable ( GL2 . GL_TEXTURE_GEN_R );gl. glDisable ( GL2 . GL_TEXTURE_CUBE_MAP );gl. glEnable ( GL2 . GL_TEXTURE_2D );O output do programa CubeMap.java pode ser analisado na Figura 9.8.98

Figura 9.8: CubeMap.java99

Capítulo 10Curvas e Superfícies10.1 Superfícies Incorporadas no OpenGLDisponíveis na biblioteca GLU 1 , estão disponíveis um conjunto de funções que renderizam superfícies quádricas 2 .São suportados três tipos de superfícies quádricas - esferas, cilindros e discos. Para desenhar um cone, porexemplo, podemos utilizar um cilindro, tendo um dos lados raio=0. Os discos permitem especificar um buracono centro.A Figura 10.1 mostra algumas formas conseguidas com recurso a estas superfícies.Figura 10.1: Formas QuádricasPara conseguir formas mais complexas, podemos utilizar composições contendo as várias superfícies quádricasdo OpenGL. Como por exemeplo, os eixos unitários 3D (Figura 10.2), que são construídos com a ajuda de 1 esfera,3 cilindros e 3 cones.Figura 10.2: Eixos unitários (x, y, z) desenhados com quádricas1 OpenGL Utility Library2 Conjunto dos pontos do espaço tridimensional cujas coordenadas formam um polinómio de segundo grau, com um máximo trêsvariáveis → equação cartesiana da superfície100

Os eixos 3D servem de auxílio ao posicionamento e à visualização no sistema de coordenadas de um modogeral. Para desenhar os eixos pode ser utilizada a função GlUtil.drawUnitAxes() fornecida na biblioteca deapoio à cadeira de Computação gráfica.10.1.1 Configuração de Superfícies QuádricasO desenho de superfícies quádricas fornece alguma flexibilidade no que respeita a normais, coordenadas detexturas e outros parâmetros. No entanto, a colocação de todos estes parâmetros numa única função tornariaa sua utilização pouco prática. Em vez disso, é utilizada uma abordagem orientada a objectos. Um objectoquádrico é criado e os parâmetros de renderização são definidos com um conjunto de funções, como mostra oexemplo:GLU glu = new GLU ();// Criar o objecto para a superficie quadricaGLUquadric quad = glu . gluNewQuadric ();// Configurar parametros// Desenhar as superficies// Apagar o objectoglu . gluDeleteQuadric ( quad );A função GLU.gluNewQuadric() retorna um objecto do tipo GLUquadric sobre o qual vamos alterar aspreferências. Depois de o objecto ser desenhado, podemos libertar o objecto anteriormente criado utilizando afunção GLU.gluDeleteQuadric().Existem quatro funções para alterar a forma com os quadrics são desenhados. A primeira função é:GLU . gluQuadricDrawStyle ( GLUquadric quad , int drawStyle );O primeiro parâmetro da função é o objecto criado previamente. O segundo parâmetro toma o valor de umadas constantes descritas na Tabela 10.1.ConstanteGLU.GLU FILLGLU.GLU LINEGLU.GLU POINTGLU.GLU SILHOUETTEDescriçãoQuadrics desenhados como objectos sólidosQuadrics desenhados como wireframesQuadrics desenhados como pontosParecido com o wireframe, mas faces adjacentesdos polígonos não são desenhadasTabela 10.1: Estilos de Desenho dos QuadricsA função seguinte permite definir a forma como as normais são criadas para a geometria:GLU . gluQuadricNormals ( GLUquadric quad , int normals );Os valores possíveis para o parâmetro normals são:• GLU NONE - superfície desenhadas sem normais• GLU SMOOTH - as normais são calculadas para cada vértice, dando uma aparência suave à superfície• GLU FLAT - as normais são calculadas com base no conjunto dos vértices de cada polígono (triângulo)A orientação das normais pode ser especificada com:GLU . gluQuadricOrientation ( GLUquadric quad , int orientation );Neste caso, o parâmetro orientation, pode tomar um dos valores GLU OUTSIDE ou GLU INSIDE. Por omissão,os quadrics são desenhados com a face para fora (CCW).Esta função é útil para o caso de querermos alterar a face sobre a qual a luz incide, por exemplo, no interiorde uma esfera especificaríamos GLU INSIDE.A última função permite activar a geração de coordenadas para a superfície:GLU . gluQuadricTexture ( GLUquadric quad , boolean texture );Neste caso quanto texture é true, é activada a geração, caso contrário é desactivada. As esferas e cilindrossão “embrulhados” na textura, como se a textura os envolvesse. No caso dos discos, o centro da textura coinciecomo centro do disco e as bordas da textura coincidem com as bordas do disco.101

10.1.2 Desenho de Superfícies QuádricasDepois de um objecto ter sido configurado de forma satisfatória, pode ser desenhado com uma única função. Nocaso da esfera, utilizamos:GLU . gluSphere ( GLUQuadric quad , double radius , int slices , int stacks );O argumento quad representa o nosso objecto GLUquadric previamente criado. O argumento radius defineo raio da esfera. A esfera é desenhada utilizando um conjunto de triângulos 1 dispostos numa stack (pilha) desdeo fundo até ao topo. O número de elementos da pilha é definido no parâmetro stacks. O parâmetro slices,define o número de triângulos (ou quads) utilizados para desenhar à volta da esfera (Figura 10.3).Os valores são semelhantes, conceptualmente, à latitude e longitude do globo terrestre.Figura 10.3: Stacks e SlicesA esfera é desenhada com o centro na origem das coordenadas e com o eixo-z positivo a “sair” do topo daesfera.Figura 10.4: Esfera desenhada com quadricsO resultado da Figura 10.4 pode ser obtido com o código:GlUtil . drawUnitAxes ();GLUquadric quad = glu . gluNewQuadric ();glu . gluQuadricDrawStyle (quad , GLU . GLU_LINE );glu . gluSphere (quad , .75 , 16 , 16);glu . gluDeleteQuadric ( quad );O cilindro é desenhado de forma semelhante à esfera. Um conjunto de stacks são desenhadas ao longo doeixo-z positivo. A função para desenhar o cilindro é:1 Ou quads dependendo da implementação da biblioteca GLU102

GLU . gluCylinder (GLUquadric quad , double base ,double top , double height ,int slices , int stacks);Com esta função especificamos o raio da base e topo (base e top), sendo a base localizada na origem. Oparâmetro height define o coprimento do cilindro (Figura 10.5).Figura 10.5: Cilindro desenhado com quadricsPara desenhar um cone basta colocar o raio do topo (top) a 0 (Figura 10.6).Figura 10.6: Cone desenhado com quadricsA última superfície é o disco. Os discos são desenhados com recurso a loops de trinângulos (ou quads)dispostos por vários slices. A função utilizada para desenhar um disco é:gluDisk (GLUquadric quad , double inner ,double outer ,int slices , int loops);Para desenhar o disco especificamos um raio interno (inner) e um raio exterior (outer) (Figura 10.7). Paraconseguir um disco sólido, especificamos inner=0. Com um valor de inner diferente de 0 obtemos um disco comum orificio no meio.103

(a) inner=0(b) inner=0.25Figura 10.7: Disco desenhado com quadricsO disco é desenhado no plano xy.A composição de diferentes quadrics permite a criação de objectos, tal como o exemplo Snowman.java daFigura 10.8 (ver Apêndice C.6).Figura 10.8: Snowman.java10.2 Curvas de Bézier e SuperfíciesOs quadrics fornecem um meio de desenhar superfícies facilmente modeladas com equações algébricas. Noentanto, para desenhar superfícies mais complexas, tais como curvas ou superfícies não lineares, onde não existeuma especificação matemática inicial, a tarefa não é trivial.Pierre Bézies, um designer da industria automóvel, reconheceu esta dificuldade e criou uma forma de desenharcurvas com recurso a um conjunto de pontos de controlo (control points). Para além da facilidade narepresentação das curvas, os pontos de controlo representam uma forma interactiva de mudar a forma da curvaou superfície.104

10.2.1 Representação ParamétricaAntes de passar ao desenho de curvas, convém estabelecer algum vocabulário e relembrar alguns conceitosmatemáticos.Se estivermos a pensar em linha recta, a representação no plano-xy pode ser feita com recurso à equação:y = m · x + bO valor m representa a inclinação da recta, enquanto que o valor b define a coordenada y onde a recta secruza com o eixo-y.Outra forma de representar uma curva (ou recta), consiste na parametrização das suas coordenadas emfunção de uma outra variável que não tem necessáriamente a ver com o sistema de coordenadas. Por exemplo,podemos especificar a forma como as coordenadas variam, ao longo do tempo (t). Assim para cada coordenadateremos uma função que varia com o tempo:x = f(t)y = g(t)z = h(t)No OpenGL, as curvas são definidas utilizando uma equação paramétrica. A curva é definida por um parâmetrou e pelo conjunto dos seus valores no domínio da curva. Para a definição de superfícies utilizamos um valoradicional v (Figura 10.9).É importante reter que os valores u e v não representam coordenadas reais da curva, são antes valores deparametrização da mesma. Desta forma, uma curva será definida com base nos seus domínios u e v 1 .Figura 10.9: Representação Paramétrica de Curvas e Superfícies10.2.2 Pontos de Control (control points)Uma curva pode ser representada por um conjunto de pontos de controlo que determinam o comportamento dacurva. O primeiro e último pontos da curva pertencem às coordenadas da curva, no entanto, os restantes pontosestão fora da curva e representam uma espécie de “pontos magnéticos” que atraém a curva no seu percurso(Figura 10.10).Figura 10.10: Pontos de Controlo1 Sendo um domínio, o conjunto dos valores possíveis para um parâmetro na curva em questão105

A curva da Figura 10.10b é uma curva quadrática (2 pontos de controlo) e a curva da Figura 10.10c é umacurva cúbica (3 pontos de controlo). Estas últimas são as mais utilizadas.10.2.3 ContinuidadeQuando duas curvas lado-a-lado partilham um ponto (breakpoint), formam uma secção curva (Figura 10.11). Aforma como as curvas se encontram define a continuidade da secção. As categorias de continuidade são:• none - Quando as curvas não se encontram de todo• positional (C0) - As curvas encontram-se num ponto• tangetial (C1) - As curvas partilham a mesma tangente no breakpoint• curvature (C2) - Para além de partilharem a mesma tangente, a aproximação à tangente é semelhante nasduas curvasFigura 10.11: Continuidade de CurvasOs tipos de continuidade mais utilizados, quando estamos a juntar um grande conjunto de curvas, são os tipotangential e curvature.10.2.4 EvaluatorsO OpenGL fornece uma forma simples de desenhar curvas e superfícies de Bézier. Para tal, especificamos ospontos de controlo e o domínio dos valores paramétrics u e v. Finalmente ao invocar o evaluator apropriado, oOpenGL gera os pontos que definem a curva ou superfície.Uma curva 2DO programa Bezier2D.java (ver Apêndice C.7), mostra como pode ser desenhada uma curva de Bézier 2D.A melhor forma de explicar o programa passa pela explicação de cada bloco de código.Começamos por definir uma perspectiva ortogonal entre +10 e -10, a fim de facilitar a visualização:gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();glu . gluOrtho2D ( -10f, 10f, -10f, 10f);Criamos os pontos de controlo com recurso à classe GLVectorList:// Definir Pontos de ControloctrlPoints = new GLVectorList ();ctrlPoints . add ( -4f, 0f, 0f); // StartctrlPoints . add ( -6f, 4f, 0f); // Control106

ctrlPoints . add (6f, -4f, 0f); // ControlctrlPoints . add (4f, 0f, 0f); // EndDepois de limpar o color buffer, criamos o mapping para a curva utilizando a função glMap1f:gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT );float umin = 0f; // Valor minimo do ufloat umax = 100 f; // Valor maximo do ugl. glMap1f (GL2 . GL_MAP1_VERTEX_3 , // Tipo de dados geradosumin , // Valor minimo do uumax , // Valor maximo do u3, // Distancia entre pontosctrlPoints . size () , // Numero de pontos de controloctrlPoints . toFloatBuffer () // FloatBuffer contendo pontos de controlo);O primeiro argumento da função glMap1f define o tipo de evaluator a utilizar para gerar os vértices da linha.O segundo e terceiros argumentos definem o valor de u para o ponto inicial da curve e o valor de u para o pontofinal da curva. Os pontos intermédios representam uma posição na curva 1 .O terceiro argumento representa o número de elementos em cada posição do array contendo os pontos decontrolo (neste caso um FloatBuffer). Para o programa Bezier2D.java, estamos a utilizar as coordenadas x,y e z, daí o valor ser 3. O quarto argumento define o número de pontos de controlo que pretendemos utilizar efinalmente o último argumento é o buffer (ou array) contendo os pontos de controlo.Por uma questão de conveniência, foi criado o método toFloatBuffer() na classe GLVectorList que devolveum FloatBuffer contendo as posições x, y e z dos vectores adicionados (via add(x, y, z)).No passo seguinte activamos o evaluator que utilizámos na função glMap1f e desenhamos os vértices geradoscom a ajuda da função glEvalCoord:// Activar o Evaluatorgl. glEnable ( GL2 . GL_MAP1_VERTEX_3 );// Desenhar os vertices da curvagl. glColor3f (0f, 0f, 0f);gl. glBegin ( GL2 . GL_LINE_STRIP );for ( float i= umin ; i< umax ; i ++)gl. glEvalCoord1f (i);gl. glEnd ();A fim de facilitar a compreensão dos pontos de controlo, desenhamo-los também:// Desenhar Pontos de Contrologl. glPointSize (5.0 f);gl. glColor3f (1f, 0f, 0f);gl. glBegin ( GL2 . GL_POINTS );for ( GLVector point : ctrlPoints )point . draw ();gl. glEnd ();O resultado final do nosso programa Bezier2D pode ser visualizado na Figura 10.12.Por uma questão de eficiência e a fim de tornar o código mais compacto, o OpenGL permite-nos desenhar acurva utilizando apenas as 2 funções glMapGrid e glEvalMesh, de forma que o código:gl. glBegin ( GL2 . GL_LINE_STRIP );for ( float i= umin ; i< umax ; i ++)gl. glEvalCoord1f (i);gl. glEnd ();Seria re-escrito da seguinte forma:// Mapear uma grelha de 100 pontos com u min=0 e u max =100gl. glMapGrid1d (100 , umin , umax );// Fazer o evaluate da grelha anterior utilizando linhas ( GL_LINE )gl. glEvalMesh1 ( GL2 . GL_LINE , ( int )umin , ( int ) umax );1 Neste caso, o valor 50 representa o ponto no meio da curva, o 25 a um quarto da curva, etc. . .107

Figura 10.12: Curva de Bézier 2D10.2.5 Superfícies 3DA forma de criar uma superfície de Bézier é muito semelhante à criação das curvas. Adicionamos apenas oparâmetro v que corresponde a um segundo domínio. O código completo do exemplo seguinte pode ser consultadono Apêndice C.8 referente ao programa Bezier3D.java.A diferença, à partida, em relação ao exemplo Bezier2D, é que neste utilizamos 3 conjuntos de 3 pontos decontrolo cada.Começamos então por definir os pontos de controlo, 3 na direcção de u por 3 na direcção de v:// Definir Pontos de ControloctrlPoints = new GLVectorList ();// v0ctrlPoints . add ( -4f, 0f, 4f); // Start (u0)ctrlPoints . add ( -2f, 4f, 4f); // Control (u0)ctrlPoints . add (4f, 0f, 4f); // End (u0)// v1ctrlPoints . add ( -4f, 0f, 0f); // Start (u1)ctrlPoints . add ( -2f, 4f, 0f); // Control (u1)ctrlPoints . add (4f, 0f, 0f); // End (u1)// v2ctrlPoints . add ( -4f, 0f, -4f); // Start (u2)ctrlPoints . add ( -2f, 4f, -4f); // Control (u2)ctrlPoints . add (4f, 0f, -4f); // End (u2)Seguidamente geramos o mapa bidmimensional de pontos para a superfície, utilizando a função glMap2f como primeiro argumento tendo o valor GL2.GL MAP2 VERTEX 3, em vez da função glMap1f, da seguinte forma:float umin = 0f; // Valor minimo do ufloat umax = 10f; // Valor maximo do ufloat vmin = 0f; // Valor minimo do vfloat vmax = 10f; // Valor maximo do vgl. glMap2f (GL2 . GL_MAP2_VERTEX_3 , // Tipo de dados geradosumin , // Valor minimo do uumax , // Valor maximo do u108

);3, // Distancia entre pontos ( dominio u)3, // Numero de pontos de controlo ( dominio u)vmin , // Valor minimo do vvmax , // Valor maximo do v9, // Distancia entre pontos ( dominio v)3, // Numero de pontos de controlo ( dominio v)ctrlPoints . toFloatBuffer () // FloatBuffer contendo pontos de controloO segundo e terceiro argumentos definem os valores mínimo e máximo no domínio u. O quarto e quintoargumentos definem, respectivamente, o intervalo entre os pontos do domínio u no buffer de dados e o númerode pontos de controlo. O intervalo de dados para u é de 3 pela mesma razão do exemplo anterior. O número depontos de controlo ao longo de u é de 3.O sexto e sétimo argumentos representam o valor mínimo e máximo do domínio v. O oitávo e nono argumentosrepresentam, respectivamente, o intervalo entre os pontos no domínio v e o número de pontos de controlo. Ointervalo no caso do domínio v é de 9, uma vez que para cada iteração de v existem 3 pontos em u (3 × 3 = 9).O número de pontos de controlo ao longo de v é igualmente de 3.O último argumento é o FloatBuffer contendo os pontos de controlo.Finalmente podemos desenhar a nossa superfície de forma semelhante à utilizada para o exemplo anterior:// Desenhar os vertices da superficiegl. glColor3f (0f, 0f, 0f);// Mapear uma grelha de 10 × 10 pontos com u entre u min e u max e v entre v min e v maxgl. glMapGrid2d (10 , umin , umax , 10 , vmin , vmax );// Fazer o evaluate da grelha anterior utilizando linhasgl. glEvalMesh2 ( GL2 . GL_LINE , ( int )umin , ( int )umax , ( int )vmin , ( int ) vmax );O resultado final do programa Bezier3D pode ser analisado na Figura 10.13.Figura 10.13: Superfície 3D de Bézier10.2.6 Luzes e Vectores NormaisA fim de utilizar luzes com as nossas superfícies basta-nos substituir o código:gl. glEvalMesh2 ( GL2 . GL_LINE , ( int )umin , ( int )umax , ( int )vmin , ( int ) vmax );Pelo código:gl. glEvalMesh2 ( GL2 . GL_FILL , ( int )umin , ( int )umax , ( int )vmin , ( int ) vmax );gl. glEnable ( GL2 . GL_AUTO_NORMAL );O que produz o resultado da Figura 10.14, que pode ser conseguido correndo o programa BezierLighting.java(ver Apêndice C.9).109

Figura 10.14: Superfície de Bézier com Lighting110

Capítulo 11Conceitos Avançados11.1 Display ListsOs comandos (funções) especificados no código do nosso programa em OpenGL, não são inconsequentes, sãonormalmente compilados para um conjunto de instruções que são colocadas num buffer. Quando apropriado, obuffer de comandos é enviado para o hardware.Para cenários geometricamente complexos, este processo pode ser reptido milhares de vezes, antes que umasimples imagem seja desenhada no ecrã. Em várias situações, a geometria repete-se de frame para frame, o querepresenta um overhead desnecessário de processamento.O OpenGL oferece a possibilidade de agregar um conjunto de comandos numa lista pré-processada. Esta listade comandos pode, mais tarde ser copiada para o command buffer, poupando o tempo da chamada e compilaçãodos comandos.Esta lista de comandos pré-processados é chamada de display list. O código necessário à criação de displaylists poderá ser:int name = ...; // Identificador da listagl. glNewList (name , GL2 . GL_COMPILE );// Comandos OpenGLgl. glEndList ();A função glNewList cria a display list identificada pelo valor de name, armazenando os comandos até que éencontrada a função glEndList. O parâmetro GL2.GL COMPILE, diz ao OpenGL para compilar esta lista. Esteprocesso é normalmente levado a cabo na inicialização do nosso programa (função init()) e mais tarde a lista éinvocada durante o processo de renderização.O parâmetro name poderá tomar qualquer valor inteiro (unsigned int). No caso de ser especificado duasvezes o mesmo valor ao invocar glNewList, a lista actualmente associada ao identificador, é substituída pelanova especificação.A fim de evitar a substituição acidental de uma lista previamente criada, podemos pedir ao OpenGL que gereum conjunto de identificadores (um para cada lista).int NumLists = 3;// ...int first = gl. glGenLists ( NumLists );O código em cima gera os identificadors para 3 display lists consecutivas, onde first será o valor do primeiroidentificador. Para especificarmos a lista de comandos para as listas recém-criadas, podemos escrever:int first = gl. glGenLists ( NumLists );int second = first + 1;int third = first + 2;gl. glNewList ( first , GL2 . GL_COMPILE );// Desenhar Geometria (1)gl. glEndList ();gl. glNewList ( second , GL2 . GL_COMPILE );// Desenhar Geometria (2)gl. glEndList ();gl. glNewList ( third , GL2 . GL_COMPILE );111

Desenhar Geometria (3)gl. glEndList ();Os comandos da lista, ou listas criadas durante o processo de inicialização podem ser executados durante oprocesso de rendering (função display()), utilizando a função:glCallLists ( int listId );Sendo o argumento listId o valor do identificador da lista.Quando as display lists não estiverem a ser usadas, podemos libertar os recursos reservados para elas utilizandoa função glDeleteLists:gl. glDeleteLists ( first , NumLists );Onde o primeiro argumento é o primeiro identificador da lista e o segundo argumento é o número de listas aapagar. Este procedimento é normalmente levado a cabo no encerramento do programa (ex.: método dispose()).11.1.1 Prós e ContrasA utilização de display lists representam, em hardwre da maior parte dos fabricantes, um aumento significativono desempenho. O seu uso é ideal para acelerar mudanças de estado (p.ex.: activar/desactivar lighting, etc. . . ).O carregamento de texturas e a leitura do color buffer (ex.: glReadPixel e glTexImage2D) não fazem muitosentido dentro de uma lista. Faz antes sentido a criação de texture objects e a sua invocação (com glBindTexture)dentro da lista.Dentro de uma display list podemos ainda invocar a execução de uma outra, não sendo possível, no entanto,chamadas a (glNewList/glEndList) dentro de uma display list.112

Apêndice AExemplosA.1 Exemplo Simplespublic class OpenGL0 extends GLFrame {public OpenGL0 () {setSize (300 , 300) ;}@Overridepublic void display ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GLCanvas canvas = getCanvas ();GLCapabilities cap = canvas . getChosenGLCapabilities ();cap . setDoubleBuffered ( false );}GL2 gl = drawable . getGL (). getGL2 ();gl. glClearColor (0.0f, 0.0f, 1.0f, 1.0 f);gl. glClear (GL. GL_COLOR_BUFFER_BIT );gl. glFlush ();public static void main ( String [] args ) {new OpenGL0 (). setVisible ( true );}}113

Apêndice BTabelasB.1 Formato de Imagem (pixmap)TipoGL RGBGL RGBAGL BGR / GL BGR EXTGL BGRA / GL BGRA EXTGL REDGL GREENGL BLUEGL ALPHAGL LUMINANCEGL LUMINANCE ALPHAGL STENCIL INDEXGL DEPTH COMPONENTDescriçãoCores representadas por red, green e blueCores representadas por red, green, blue e alphaCores representadas por blue, green e redCores representadas por blue, green, red e alphaCada pixel contém um único componente de redCada pixel contém um único componente de greenCada pixel contém um único componente de blueCada pixel contém um único componente de alphaCada pixel contém um único componente de intensidade(luminance)Cada pixel contém um componente de intensidade seguidopor um componente de alphaCada pixel contém um único valor de stencilCada pixel contém um único valor de profundidade(depth)Tabela B.1: Formato de Imagem (pixmap)114

B.2 Tipo de Dados (pixmap)TipoGL UNSIGNED BYTEGL BYTEGL BITMAPGL UNSIGNED SHORTGL SHORTGL UNSIGNED INTGL INTGL FLOATGL UNSIGNED BYTE 3 2 2GL UNSIGNED BYTE 2 3 3 REVGL UNSIGNED SHORT 5 6 5GL UNSIGNED SHORT 5 6 5 REVGL UNSIGNED SHORT 4 4 4 4GL UNSIGNED SHORT 4 4 4 4 REVGL UNSIGNED SHORT 5 5 5 1GL UNSIGNED SHORT 1 5 5 5 REVGL UNSIGNED INT 8 8 8 8GL UNSIGNED INT 8 8 8 8 REVGL UNSIGNED INT 10 10 10 2GL UNSIGNED INT 2 10 10 10 REVDescriçãoCada componente é um unsigned integer de 8-bitinteger de 8-bitApenas bits, sem informação de cor (equivaliente aoglBitmap)unsigned integer de 16-bitsigned integer de 16-bitunsigned integer de 32-bitsigned integer de 32-bitsingle precision floatPacked RGB valuesPacked RGB valuesPacked RGB valuesPacked RGB valuesPacked RGBA valuesPacked RGBA valuesPacked RGBA valuesPacked RGBA valuesPacked RGBA valuesPacked RGBA valuesPacked RGBA valuesPacked RGBA valuesTabela B.2: Tipo de Dados (pixmap)115

Apêndice CCódigo FonteC.1 Example0.javapackage pt.ipb . esact .cg. examples ;import java . awt . BorderLayout ;import java . util . ArrayList ;import java . util . List ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;import pt.ipb . esact .cg.gl. CGEngine ;import pt.ipb . esact .cg.gl. GLVector ;import pt.ipb . esact .cg.gl. tools . GlUtil ;import com . jogamp . opengl . util . FPSAnimator ;import com . jogamp . opengl . util . gl2 . GLUT ;@SuppressWarnings (" serial ")public class Example0 extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLUT glut = new GLUT ();private GLCanvas canvas ;private GLVector fLightPos = new GLVector ( -100f, 100f, 50f, 1f);private float fNoLight [] = { 0.0f, 0.0f, 0.0f, 0.0 f };private float fLowLight [] = { 0.25f, 0.25f, 0.25f, 1.0 f };private float fBrightLight [] = { 1.0f, 1.0f, 1.0f, 1.0 f };private static final float FloorSize = 20f;private static final int NumSpheres = 30;private List < GLVector > spherePositions = new ArrayList < GLVector >();public static void main ( String [] args ) {new Example0 ();}116

public Example0 () {super (" Modelo OpenGL ");setUndecorated ( true );setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);canvas = new GLCanvas ();add ( canvas , BorderLayout . CENTER );canvas . addGLEventListener ( this );GLVector location = new GLVector (0f, .5f, .5f);new CGEngine ( canvas , location );setVisible ( true );canvas . requestFocus ();}FPSAnimator animator = new FPSAnimator ( canvas , 25);animator . start ();public void dispose ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();}// Grayish backgroundgl. glClearColor ( fLowLight [0] , fLowLight [1] , fLowLight [2] , fLowLight [3]);// Cull backs of polygonsgl. glCullFace ( GL2 . GL_BACK );gl. glFrontFace ( GL2 . GL_CCW );gl. glEnable ( GL2 . GL_CULL_FACE );gl. glEnable ( GL2 . GL_DEPTH_TEST );spherePositions = GlUtil . generateRandomPositions ( FloorSize , NumSpheres );setupLight (gl );private void setupLight ( GL2 gl) {// Setup light parametersgl. glLightModelfv ( GL2 . GL_LIGHT_MODEL_AMBIENT , fNoLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_AMBIENT , fLowLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_DIFFUSE , fBrightLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_SPECULAR , fBrightLight , 0);gl. glEnable ( GL2 . GL_LIGHTING );gl. glEnable ( GL2 . GL_LIGHT0 );}// Mostly use material trackinggl. glEnable ( GL2 . GL_COLOR_MATERIAL );gl. glColorMaterial ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE );gl. glMateriali ( GL2 . GL_FRONT , GL2 . GL_SHININESS , 128);@Overridepublic void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );gl. glMaterialfv ( GL2 . GL_FRONT , GL2 . GL_SPECULAR , fBrightLight , 0);117

gl. glPushMatrix ();gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , fLightPos . toArray () , 0);// Desenhar um Torus Verdegl. glColor3f (0 , 1f, 0);drawWorld (gl );}gl. glColor4f (0.60f, .40f, .10f, .5f);GlUtil . drawGround ( FloorSize , 1f);gl. glPopMatrix ();private void drawWorld ( GL2 gl) {// Desenhar o Torusgl. glPushMatrix ();gl. glTranslatef (0 , .5f, 0);glut . glutSolidTorus (.1f, .2f, 61 , 37);gl. glPopMatrix ();}// Desenhar esferas aleatoriamentefor ( GLVector s : spherePositions ) {gl. glPushMatrix ();gl. glTranslatef (s.x() , s.y() , s.z ());glut . glutSolidSphere (s.w() , 20 , 10);gl. glPopMatrix ();}@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();if ( height == 0) height = 1;gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();float volume = 100 f;float fAspect = ( float ) width / ( float ) height ;glu . gluPerspective (100f, fAspect , .001f, volume * 5f);}}C.2 Imaging.javapackage pt.ipb . esact .cg. examples ;import java . awt . BorderLayout ;import java . awt . event . KeyAdapter ;import java . awt . event . KeyEvent ;import java .io. IOException ;import java .io. InputStream ;import java . nio . ByteBuffer ;import java . nio . FloatBuffer ;import java . nio . IntBuffer ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;118

import com . jogamp . opengl . util . FPSAnimator ;import com . jogamp . opengl . util . texture . spi . TGAImage ;@SuppressWarnings (" serial ")public class Imaging extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLCanvas canvas ;private ByteBuffer bb;private TGAImage img ;private RenderMode renderMode = RenderMode . Normal ;static enum RenderMode {GaussianBlur , Sharpen , Emboss , Invert , Brighten , Normal}public static void main ( String [] args ) {new Imaging ();}public Imaging () {super (" Modelo OpenGL ");setUndecorated ( true );setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (512 , 512);canvas = new GLCanvas ();add ( canvas , BorderLayout . CENTER );canvas . addGLEventListener ( this );canvas . addKeyListener ( new KeyAdapter () {@Overridepublic void keyReleased ( KeyEvent e) {switch (e. getKeyCode ()) {case KeyEvent . VK_1 : renderMode = RenderMode . Normal ; break ;case KeyEvent . VK_2 : renderMode = RenderMode . Brighten ; break ;case KeyEvent . VK_3 : renderMode = RenderMode . Invert ; break ;case KeyEvent . VK_4 : renderMode = RenderMode . Emboss ; break ;case KeyEvent . VK_5 : renderMode = RenderMode . Sharpen ; break ;case KeyEvent . VK_6 : renderMode = RenderMode . GaussianBlur ; break ;case KeyEvent . VK_Q : // SairsetVisible ( false );dispose ();System . exit (0);break ;default :break ;}}});setVisible ( true );canvas . requestFocus ();}FPSAnimator animator = new FPSAnimator ( canvas , 25);animator . start ();public void dispose ( GLAutoDrawable drawable ) {}@Override119

public void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Grayish backgroundgl. glClearColor (0f, 0f, 0f, 0f);}try {InputStream stream = Imaging . class . getResourceAsStream (" horse . tga ");img = TGAImage . read ( stream );bb = img . getData ();stream . close ();} catch ( IOException e) {e. printStackTrace ();}@Overridepublic void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Clear the window with current clearing colorgl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );// Armazena a informacao do viewPort lida com glGet// Contem : (x, y, width , height )IntBuffer iViewport = IntBuffer . allocate (4);// Tabela de cores invertida (3 cores * 256 niveis )ByteBuffer invertTable = ByteBuffer . allocate (256 * 3);// Matriz ( convolution kernel ) para efectuar o sharpenFloatBuffer mSharpen = FloatBuffer . wrap ( new float [] {0.0f, -1.0f, 0.0f,-1.0f, 5.0f, -1.0f,0.0f, -1.0f, 0.0 f});// Matriz ( convolution kernel ) para efectuar o embossFloatBuffer mEmboss = FloatBuffer . wrap ( new float [] {2.0f, 0.0f, 0.0f,0.0f, -1.0f, 0.0f,0.0f, 0.0f, -1.0f});// Matriz ( convolution kernel ) para efectuar gaussian blur/*| 1 2 1 || 2 4 2 || 1 2 1 |*/float norm = 16f; // somatorio dos valores da matrizFloatBuffer mGaussian = FloatBuffer . wrap ( new float [] {1f/norm , 2f/norm , 1f/norm ,2f/norm , 4f/norm , 2f/norm ,1f/norm , 2f/norm , 1f/ norm});// Posicao do raster comeca no canto inferior esquerdo por omissaogl. glRasterPos2i (0 , 0);// Ler o estado actual do viewportgl. glGetIntegerv ( GL2 . GL_VIEWPORT , iViewport );// Esticar a imagem para ficar do tamanho do viewport120

gl. glPixelZoom (( float ) iViewport . get (2) / ( float ) img . getWidth () ,( float ) iViewport . get (3) / ( float ) img . getHeight ());//switch ( renderMode ) {case Sharpen : // Sharpengl. glConvolutionFilter2D (GL2 . GL_CONVOLUTION_2D , GL2 . GL_RGB , 3, 3,GL2 . GL_LUMINANCE , GL2 . GL_FLOAT , mSharpen);gl. glEnable ( GL2 . GL_CONVOLUTION_2D );break ;case Emboss : // Embossgl. glConvolutionFilter2D (GL2 . GL_CONVOLUTION_2D , GL2 . GL_RGB , 3, 3,GL2 . GL_LUMINANCE , GL2 . GL_FLOAT , mEmboss );gl. glEnable ( GL2 . GL_CONVOLUTION_2D );break ;case Invert : // Invertfor ( int i = 0; i < 255; i ++) {invertTable . put (i * 3 + 0, ( byte ) (255 - i ));invertTable . put (i * 3 + 1, ( byte ) (255 - i ));invertTable . put (i * 3 + 2, ( byte ) (255 - i ));}gl. glColorTable (GL2 . GL_COLOR_TABLE , GL2 . GL_RGB , 256 , GL2 . GL_RGB ,GL2 . GL_UNSIGNED_BYTE , invertTable);gl. glEnable ( GL2 . GL_COLOR_TABLE );break ;case Brighten : // Brighten// Mudar para o matrix mode Colorgl. glMatrixMode ( GL2 . GL_COLOR );// Aumentar todas as cores em 50%gl. glScalef (2f, 2f, 2f);// Voltar ao ModelViewgl. glMatrixMode ( GL2 . GL_MODELVIEW );break ;case GaussianBlur : // Gaussian Blurgl. glConvolutionFilter2D (GL2 . GL_CONVOLUTION_2D , GL2 . GL_RGB , 3, 3,GL2 . GL_LUMINANCE , GL2 . GL_FLOAT , mGaussian );gl. glEnable ( GL2 . GL_CONVOLUTION_2D );break ;}case Normal : // Normaldefault :break ;// Desenhar a Imagem com as alteracoes efectuadas (ou nao )gl. glDrawPixels (img . getWidth () , img . getHeight () ,img . getGLFormat () ,GL2 . GL_UNSIGNED_BYTE , bb );121

Reverter as ( possiveis ) transformacoes efectuadas// na matriz Colorgl. glMatrixMode ( GL2 . GL_COLOR );gl. glLoadIdentity ();// Voltar ao ModelViewgl. glMatrixMode ( GL2 . GL_MODELVIEW );// Desactivar as alteracoesgl. glDisable ( GL2 . GL_CONVOLUTION_2D );gl. glDisable ( GL2 . GL_COLOR_TABLE );}@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();gl. glViewport (0 , 0, width , height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();glu . gluOrtho2D (0 , width , 0, height );}gl. glMatrixMode ( GL2 . GL_MODELVIEW );gl. glLoadIdentity ();}C.3 Pyramid.javapackage pt.ipb . esact .cg. examples ;import java . awt . BorderLayout ;import java . awt . Container ;import java .io. IOException ;import java .io. InputStream ;import java . nio . ByteBuffer ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;import pt.ipb . esact .cg.gl. CGEngine ;import pt.ipb . esact .cg.gl. GLVector ;import pt.ipb . esact .cg.gl. tools . GlTools ;import pt.ipb . esact .cg.gl. tools . GlUtil ;import com . jogamp . opengl . util . FPSAnimator ;import com . jogamp . opengl . util . texture . spi . TGAImage ;@SuppressWarnings (" serial ")public class Pyramid extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLCanvas canvas ;FPSAnimator animator ;122

private GLVector lightPos = new GLVector ( -10f, 5f, 5f, 1f);private float whiteLight [] = { 0.05f, 0.05f, 0.05f, 1.0 f };private float sourceLight [] = { 0.25f, 0.25f, 0.25f, 1.0 f };private CGEngine e;private TGAImage img ;private ByteBuffer bb;private GLVector cTop ;private GLVector cBackLeft ;private GLVector cBackRight ;private GLVector cFrontRight ;private GLVector cFrontLeft ;public static void main ( String [] args ) {new Pyramid ();}public Pyramid () {super (" Modelo OpenGL ");setUndecorated ( true );setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);Container p = getContentPane ();BorderLayout l = new BorderLayout (5 , 5);p. setLayout (l);canvas = new GLCanvas ();p. add ( canvas , BorderLayout . CENTER );canvas . addGLEventListener ( this );GLVector location = new GLVector (1f, 1f, 1f);e = new CGEngine ( canvas , location );e. camera (). lookAt (0f, 1f, 0f);setVisible ( true );canvas . requestFocus ();}animator = new FPSAnimator ( canvas , 25);animator . start ();@Overridepublic void dispose ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Fundo Pretogl. glClearColor (0f, 0f, 0f, 1f);gl. glEnable ( GL2 . GL_CULL_FACE ); // Nao calcular dentro dos objectosgl. glFrontFace ( GL2 . GL_CCW ); // Poligonos CCW tem a face para foragl. glEnable ( GL2 . GL_DEPTH_TEST ); // Remocao de Superficies Escondidas123

Activar as Luzesgl. glEnable ( GL2 . GL_LIGHTING );// Configurar e Activar a luzgl. glLightModelfv ( GL2 . GL_LIGHT_MODEL_AMBIENT , whiteLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_AMBIENT , sourceLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_DIFFUSE , sourceLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , lightPos . toArray () , 0);gl. glEnable ( GL2 . GL_LIGHT0 );// Activar o Color Trackinggl. glEnable ( GL2 . GL_COLOR_MATERIAL );// Propriedades dos materiais obedecem ’a luzgl. glColorMaterial ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE );// Carregar e Ler a imagem para a nossa texturatry {InputStream stream = Pyramid . class . getResourceAsStream (" stone . tga ");img = TGAImage . read ( stream );bb = img . getData ();stream . close ();} catch ( IOException e) {e. printStackTrace ();}gl. glTexImage2D ( GL2 . GL_TEXTURE_2D , 0, GL2 . GL_RGBA ,img . getWidth () , img . getHeight () ,0, img . getGLFormat () , GL2 . GL_UNSIGNED_BYTE , bb );// Parametros da textura ( ignorar para ja)gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MIN_FILTER , GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MAG_FILTER , GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_WRAP_S , GL2 . GL_CLAMP_TO_EDGE );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_WRAP_T , GL2 . GL_CLAMP_TO_EDGE );// Configuracao do Texture Environmentgl. glTexEnvi ( GL2 . GL_TEXTURE_ENV ,GL2 . GL_TEXTURE_ENV_MODE , GL2 . GL_MODULATE );// Activar as texturasgl. glEnable ( GL2 . GL_TEXTURE_2D );// Cantos da PiramidecTop = new GLVector (0.0f, .80f, 0.0 f);cBackLeft = new GLVector ( -0.5f, 0.0f, -.50f);cBackRight = new GLVector (0.5f, 0.0f, -0.50 f);cFrontRight = new GLVector (0.5f, 0.0f, 0.5 f);cFrontLeft = new GLVector ( -0.5f, 0.0f, 0.5 f);}private float yRot = 0f;@Overridepublic void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();yRot += .1f;if( yRot >= GlTools . GL_PI * 2f)yRot = 0;124

GLVector vNormal ;// Limpar a cor de Fundogl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );gl. glColor3f (.2f, .2f, .2f);gl. glDisable ( GL2 . GL_TEXTURE_2D );GlUtil . drawGround (20f, 1f);gl. glEnable ( GL2 . GL_TEXTURE_2D );gl. glPushMatrix ();// Levantar um pouco do chaogl. glTranslatef (0f, .5f, 0f);gl. glRotatef (( float ) Math . toDegrees ( yRot ), 0, 1f, 0);// Desenhar a Piramidegl. glColor3f (1f, 1f, 1f);gl. glBegin ( GL2 . GL_TRIANGLES );// Seccao do Fundo (2 triangulos )gl. glNormal3f (0f, -1f, 0f); // Virada para baixo// Bottom 0gl. glTexCoord2f (1f, 1f);cBackRight . draw ();gl. glTexCoord2f (0f, 0f);cFrontLeft . draw ();gl. glTexCoord2f (0f, 1f);cBackLeft . draw ();// Bottom 1gl. glTexCoord2f (1f, 1f);cBackRight . draw ();gl. glTexCoord2f (1f, 0f);cFrontRight . draw ();gl. glTexCoord2f (0f, 0f);cFrontLeft . draw ();// Face da FrentevNormal = GlTools . getNormalVector (cTop , cFrontLeft , cFrontRight );gl. glNormal3fv ( vNormal . toArray () , 0);gl. glTexCoord2f (.5f, 1f);cTop . draw ();gl. glTexCoord2f (0f, 0f);cFrontLeft . draw ();gl. glTexCoord2f (1f, 0f);cFrontRight . draw ();// Face da EsquerdavNormal = GlTools . getNormalVector (cTop , cBackLeft , cFrontLeft );gl. glNormal3fv ( vNormal . toArray () , 0);gl. glTexCoord2f (.5f, 1f);cTop . draw ();gl. glTexCoord2f (0f, 0f);cBackLeft . draw ();gl. glTexCoord2f (1f, 0f);cFrontLeft . draw ();// Face de TrasvNormal = GlTools . getNormalVector (cTop , cBackRight , cBackLeft );gl. glNormal3fv ( vNormal . toArray () , 0);gl. glTexCoord2f (.5f, 1f);cTop . draw ();125

gl. glTexCoord2f (0f, 0f);cBackRight . draw ();gl. glTexCoord2f (1f, 0f);cBackLeft . draw ();// Face da DireitavNormal = GlTools . getNormalVector (cTop , cFrontRight , cBackRight );gl. glNormal3fv ( vNormal . toArray () , 0);gl. glTexCoord2f (.5f, 1f);cTop . draw ();gl. glTexCoord2f (0f, 0f);cFrontRight . draw ();gl. glTexCoord2f (1f, 0f);cBackRight . draw ();gl. glEnd ();gl. glPopMatrix ();}@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();}if ( height == 0)height = 1; // prevnir divisao por 0// O meu viewport tera o tamanho da janela ( width x height )gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );// Mudar para a matiz de PROJECTIONgl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();float volume = 100 f;float fAspect = ( float ) width / ( float ) height ;// Projeccao em Perspectivaglu . gluPerspective (100f, fAspect , .001f, volume * 5f);}C.4 TexGen.javapackage pt.ipb . esact .cg. examples ;import java . awt . BorderLayout ;import java . awt . Container ;import java . awt . event . KeyEvent ;import java .io. IOException ;import java .io. InputStream ;import java . nio . FloatBuffer ;import java . nio . IntBuffer ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;126

import pt.ipb . esact .cg.gl. CGEngine ;import pt.ipb . esact .cg.gl. GLKeyboardAdapter ;import pt.ipb . esact .cg.gl. GLVector ;import pt.ipb . esact .cg.gl. tools . GlTools ;import com . jogamp . opengl . util . FPSAnimator ;import com . jogamp . opengl . util . gl2 . GLUT ;import com . jogamp . opengl . util . texture . spi . TGAImage ;@SuppressWarnings (" serial ")public class TexGen extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLUT glut = new GLUT ();private GLCanvas canvas ;FPSAnimator animator ;private float bgColor [] = { 0f, 0f, 0f, 0f };private GLVector location = new GLVector (0f, 0f, 5f);private GLVector lookAt = new GLVector (0f, 0f, 0f);private IntBuffer textures = IntBuffer . allocate (2);private CGEngine e;// Identificadores das Texturaspublic static final int Stripes = 0, Environment = 1;public static final int ObjectLinear = 0, EyeLinear = 1, SphereMap = 2;private int renderMode = SphereMap ;private TGAImage environment ;public static void main ( String [] args ) {new TexGen ();}public TexGen () {super (" TexGen ");setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);Container p = getContentPane ();BorderLayout l = new BorderLayout (5 , 5);p. setLayout (l);canvas = new GLCanvas ();canvas . addGLEventListener ( this );p. add ( canvas , BorderLayout . CENTER );e = new CGEngine ( canvas , location );e. camera (). lookAt ( lookAt );setVisible ( true );canvas . requestFocus ();}animator = new FPSAnimator ( canvas , 25);animator . start ();127

@Overridepublic void dispose ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();gl. glClearColor ( bgColor [0] , bgColor [1] , bgColor [2] , bgColor [3]);// Cull backs of polygonsgl. glFrontFace ( GL2 . GL_CCW );gl. glEnable ( GL2 . GL_CULL_FACE );gl. glEnable ( GL2 . GL_DEPTH_TEST );gl. glEnable ( GL2 . GL_BACK );// As texturas substitem o material da geometriagl. glTexEnvi ( GL2 . GL_TEXTURE_ENV , GL2 . GL_TEXTURE_ENV_MODE , GL2 . GL_DECAL );// 2 Texturasgl. glGenTextures (2 , textures );/*** Carregamento da textura stripes*/environment = loadTexture (" environment . tga ");gl. glBindTexture ( GL2 . GL_TEXTURE_2D , textures . get ( Environment ));gl. glTexImage2D ( GL2 . GL_TEXTURE_2D , 0, GL2 . GL_RGBA ,environment . getWidth () , environment . getHeight () ,0, environment . getGLFormat () , GL2 . GL_UNSIGNED_BYTE ,environment . getData ());gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MIN_FILTER , GL2 . GL_LINEAR );gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MAG_FILTER , GL2 . GL_LINEAR );gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_WRAP_S , GL2 . GL_REPEAT );gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_WRAP_T , GL2 . GL_REPEAT );/*** Carregamento da textura de ambiente*/TGAImage sriptes = loadTexture (" stripes . tga ");gl. glBindTexture ( GL2 . GL_TEXTURE_2D , textures . get ( Stripes ));gl. glTexImage2D ( GL2 . GL_TEXTURE_2D , 0, GL2 . GL_RGBA ,sriptes . getWidth () , sriptes . getHeight () ,0, sriptes . getGLFormat () , GL2 . GL_UNSIGNED_BYTE ,sriptes . getData ());gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MIN_FILTER , GL2 . GL_LINEAR );gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_MAG_FILTER , GL2 . GL_LINEAR );gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_WRAP_S , GL2 . GL_REPEAT );gl. glTexParameterf ( GL2 . GL_TEXTURE_2D ,GL2 . GL_TEXTURE_WRAP_T , GL2 . GL_REPEAT );// Activar o Texture Mapping128

gl. glEnable ( GL2 . GL_TEXTURE_2D );// Activar a Geracao de Coordenadasgl. glEnable ( GL2 . GL_TEXTURE_GEN_S );gl. glEnable ( GL2 . GL_TEXTURE_GEN_T );// Por omissao utilizamos SphereMapgl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_SPHERE_MAP );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_SPHERE_MAP );canvas . addKeyListener ( new GLKeyboardAdapter ( canvas ) {@Overridepublic void handleKey ( GLAutoDrawable drawable , KeyEvent e) {GL2 gl = drawable . getGL (). getGL2 ();if(e. getKeyCode () == KeyEvent . VK_1 )setObjectLinear (gl );if(e. getKeyCode () == KeyEvent . VK_2 )setEyeLinear (gl );if(e. getKeyCode () == KeyEvent . VK_3 )setSphereMap (gl );}});}// Mudar para Object Linear Functionprotected void setObjectLinear ( GL2 gl) {FloatBuffer zPlane = FloatBuffer . wrap ( new float [] { 1f, 0f, 0f, 0f });gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_OBJECT_LINEAR );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_OBJECT_LINEAR );gl. glTexGenfv ( GL2 .GL_S , GL2 . GL_OBJECT_PLANE , zPlane );gl. glTexGenfv ( GL2 .GL_T , GL2 . GL_OBJECT_PLANE , zPlane );renderMode = ObjectLinear ;}// Mudar para Eye Linear Functionprotected void setEyeLinear ( GL2 gl) {FloatBuffer zPlane = FloatBuffer . wrap ( new float [] {0f, 0f, 1f, 0f });gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_EYE_LINEAR );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE ,GL2 . GL_EYE_LINEAR );gl. glTexGenfv ( GL2 .GL_S , GL2 . GL_EYE_PLANE , zPlane );gl. glTexGenfv ( GL2 .GL_T , GL2 . GL_EYE_PLANE , zPlane );renderMode = EyeLinear ;}protected void setSphereMap ( GL2 gl) {gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_SPHERE_MAP );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_SPHERE_MAP );renderMode = SphereMap ;}private TGAImage loadTexture ( String name ) {TGAImage img = null ;try {InputStream stream = Tunnel . class . getResourceAsStream ( name );img = TGAImage . read ( stream );stream . close ();} catch ( IOException e) {e. printStackTrace ();System . exit (0);129

}}return img ;@Overridepublic void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Clear the window with current clearing colorgl. glClear ( GL2 . GL_COLOR_BUFFER_BIT );// Desnhar a imagem de fundo ( desactivando as texturas )gl. glDisable ( GL2 . GL_TEXTURE_2D );gl. glPixelZoom (( float ) drawable . getWidth () / ( float ) environment . getWidth () ,( float ) drawable . getHeight () / ( float ) environment . getHeight ());gl. glDrawPixels ( environment . getWidth () , environment . getHeight () ,environment . getGLFormat () , GL2 . GL_UNSIGNED_BYTE ,environment . getData ());gl. glEnable ( GL2 . GL_TEXTURE_2D );gl. glClear ( GL2 . GL_DEPTH_BUFFER_BIT );// May need to switch to stripe textureif( renderMode == SphereMap )gl. glBindTexture ( GL2 . GL_TEXTURE_2D , textures . get ( Environment ));elsegl. glBindTexture ( GL2 . GL_TEXTURE_2D , textures . get ( Stripes ));// Turn texgen and depth writing back ongl. glEnable ( GL2 . GL_TEXTURE_GEN_S );gl. glEnable ( GL2 . GL_TEXTURE_GEN_T );// Save the matrix state and do the rotationsgl. glPushMatrix ();gl. glRotatef (45f, 0f, 1f, 0f);gl. glTranslatef ( -1.5f, 0f, 0f);// Draw the toursGlTools . gltDrawTorus (1f, 0.4f, 61 , 37);// Restore the matrix stategl. glPopMatrix ();// Desenhar uma amostra da textura actualgl. glPushMatrix ();gl. glDisable ( GL2 . GL_TEXTURE_GEN_S );gl. glDisable ( GL2 . GL_TEXTURE_GEN_T );gl. glRotatef ( -45f, 0f, 1f, 0f);gl. glTranslatef (1.5f, 0f, 0f);float quadSize = 1.2 f;gl. glBegin ( GL2 . GL_QUADS );gl. glTexCoord2f (0f, 0f);gl. glVertex2f (- quadSize , - quadSize );gl. glTexCoord2f (1f, 0f);gl. glVertex2f ( quadSize , - quadSize );gl. glTexCoord2f (1f, 1f);gl. glVertex2f ( quadSize , quadSize );130

}gl. glTexCoord2f (0f, 1f);gl. glVertex2f (- quadSize , quadSize );gl. glEnd ();gl. glPopMatrix ();@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();if ( height == 0)height = 1; // prevnir divisao por 0gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();float volume = 100 f;float fAspect = ( float ) width / ( float ) height ;glu . gluPerspective (100f, fAspect , .001f, volume * 5f);}}C.5 CubeMap.javapackage pt.ipb . esact .cg. examples ;import java . awt . BorderLayout ;import java . awt . Container ;import java .io. IOException ;import java .io. InputStream ;import java . nio . ByteBuffer ;import java . nio . IntBuffer ;import java . util . ArrayList ;import java . util . List ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;import pt.ipb . esact .cg.gl. CGEngine ;import pt.ipb . esact .cg.gl. GLVector ;import pt.ipb . esact .cg.gl. tools . GlTools ;import pt.ipb . esact .cg.gl. tools . GlUtil ;import com . jogamp . opengl . util . FPSAnimator ;import com . jogamp . opengl . util . gl2 . GLUT ;import com . jogamp . opengl . util . texture . spi . TGAImage ;@SuppressWarnings (" serial ")public class CubeMap extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLUT glut = new GLUT ();private GLCanvas canvas ;FPSAnimator animator ;private GLVector fLightPos = new GLVector ( -100f, 100f, 50f, 1f);private float fNoLight [] = { 0.0f, 0.0f, 0.0f, 0.0 f };131

private float fLowLight [] = { 0.25f, 0.25f, 0.25f, 1.0 f };private float fBrightLight [] = { 1.0f, 1.0f, 1.0f, 1.0 f };private static final float FloorSize = 20f;private static final int NumSpheres = 30;private List < GLVector > spherePositions = new ArrayList < GLVector >();private List < String > textureNames = new ArrayList < String >();private IntBuffer textures ;// Identificadores das texturas da Geometriaprivate static final int Earth = 0, Grass = 1;// Numero total de texturasprivate static final int NumTextures = 3;// Identificadores das texturas do Cuboprivate static final int CubeStartIndex = 2;// Direccoes para as texuras do cuboprivate static final int [] CubeDirection = {GL2 . GL_TEXTURE_CUBE_MAP_POSITIVE_X ,GL2 . GL_TEXTURE_CUBE_MAP_NEGATIVE_X ,GL2 . GL_TEXTURE_CUBE_MAP_POSITIVE_Y ,GL2 . GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ,GL2 . GL_TEXTURE_CUBE_MAP_POSITIVE_Z ,GL2 . GL_TEXTURE_CUBE_MAP_NEGATIVE_Z};public static void main ( String [] args ) {new CubeMap ();}public CubeMap () {super (" Modelo OpenGL ");setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);Container p = getContentPane ();BorderLayout l = new BorderLayout (5 , 5);p. setLayout (l);canvas = new GLCanvas ();p. add ( canvas , BorderLayout . CENTER );canvas . addGLEventListener ( this );GLVector location = new GLVector (0f, .5f, .5f);new CGEngine ( canvas , location );setVisible ( true );canvas . requestFocus ();}animator = new FPSAnimator ( canvas , 25);animator . start ();@Overridepublic void dispose ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();gl. glDeleteTextures ( NumTextures , textures );}132

@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();}// Grayish backgroundgl. glClearColor ( fLowLight [0] , fLowLight [1] , fLowLight [2] , fLowLight [3]);// Cull backs of polygonsgl. glCullFace ( GL2 . GL_BACK );gl. glFrontFace ( GL2 . GL_CCW );gl. glEnable ( GL2 . GL_CULL_FACE );gl. glEnable ( GL2 . GL_DEPTH_TEST );setupLight (gl );spherePositions = GlUtil . generateRandomPositions ( FloorSize , NumSpheres );setupTextures (gl );setupCubeMap (gl );private TGAImage loadTexture ( String name ) {TGAImage img = null ;try {InputStream stream = Anisotropic . class . getResourceAsStream ( name );img = TGAImage . read ( stream );stream . close ();} catch ( IOException e) {e. printStackTrace ();System . exit (0);}return img ;}private void setupTextures ( GL2 gl) {// Activar as texturasgl. glEnable ( GL2 . GL_TEXTURE_2D );// Obter os identificadorestextures = IntBuffer . allocate ( NumTextures ); // 2 texturas + 1 cubogl. glGenTextures ( NumTextures , textures );// Configuracao do Texture Environmentgl. glTexEnvi ( GL2 . GL_TEXTURE_ENV , GL2 . GL_TEXTURE_ENV_MODE , GL2 . GL_MODULATE );// Texturas da GeometriatextureNames . add (" earth . tga "); // Para os circulostextureNames . add (" grass . tga ");// Texturas do Cube MaptextureNames . add (" cubemap / right . tga ");textureNames . add (" cubemap / left . tga ");textureNames . add (" cubemap /up.tga ");textureNames . add (" cubemap / down . tga ");textureNames . add (" cubemap / backward . tga ");textureNames . add (" cubemap / forward . tga ");// Carregar as texturas da Geometriafor ( int i = 0; i < CubeStartIndex ; i ++) {// Fazer o bind do estado da textura ao identificadorgl. glBindTexture ( GL2 . GL_TEXTURE_2D , textures . get (i ));133

Carregar e Ler a imagem para a nossa texturaTGAImage img = loadTexture ( textureNames . get (i ));ByteBuffer bb = img . getData ();// Carregar a textura ( comprimida RGB )gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_GENERATE_MIPMAP , GL2 . GL_TRUE );gl. glTexImage2D ( GL2 . GL_TEXTURE_2D , 0, GL2 . GL_COMPRESSED_RGB ,img . getWidth () , img . getHeight () , 0, img . getGLFormat () ,GL2 . GL_UNSIGNED_BYTE , bb );// Parametros da texturagl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_MAG_FILTER ,GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_MIN_FILTER ,GL2 . GL_LINEAR_MIPMAP_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_WRAP_S ,GL2 . GL_CLAMP_TO_EDGE );gl. glTexParameteri ( GL2 . GL_TEXTURE_2D , GL2 . GL_TEXTURE_WRAP_T ,GL2 . GL_CLAMP_TO_EDGE );}}private void setupCubeMap ( GL2 gl) {// Carregar as texturas do Cubogl. glBindTexture ( GL2 . GL_TEXTURE_CUBE_MAP , textures . get ( CubeStartIndex ));gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_MAG_FILTER ,GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_MIN_FILTER ,GL2 . GL_LINEAR );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_WRAP_S ,GL2 . GL_REPEAT );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_WRAP_T ,GL2 . GL_REPEAT );gl. glTexParameteri ( GL2 . GL_TEXTURE_CUBE_MAP , GL2 . GL_TEXTURE_WRAP_R ,GL2 . GL_REPEAT );// Restantes texturas preenchem o cubofor ( int i = CubeStartIndex ; i < textureNames . size (); i ++) {// Carregar e Ler a imagem para a nossa texturaTGAImage img = loadTexture ( textureNames . get (i ));ByteBuffer bb = img . getData ();}gl. glTexImage2D ( CubeDirection [i - CubeStartIndex ], 0, GL2 . GL_RGBA ,img . getWidth () , img . getHeight () , 0, img . getGLFormat () ,GL2 . GL_UNSIGNED_BYTE , bb );}gl. glTexGeni ( GL2 .GL_S , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_REFLECTION_MAP );gl. glTexGeni ( GL2 .GL_T , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_REFLECTION_MAP );gl. glTexGeni ( GL2 .GL_R , GL2 . GL_TEXTURE_GEN_MODE , GL2 . GL_REFLECTION_MAP );private void setupLight ( GL2 gl) {// Setup light parametersgl. glLightModelfv ( GL2 . GL_LIGHT_MODEL_AMBIENT , fNoLight , 0);gl. glLightModeli ( GL2 . GL_LIGHT_MODEL_COLOR_CONTROL ,GL2 . GL_SEPARATE_SPECULAR_COLOR );gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_AMBIENT , fLowLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_DIFFUSE , fBrightLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_SPECULAR , fBrightLight , 0);gl. glEnable ( GL2 . GL_LIGHTING );134

gl. glEnable ( GL2 . GL_LIGHT0 );}// Utilizar color trackinggl. glEnable ( GL2 . GL_COLOR_MATERIAL );gl. glColorMaterial ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE );gl. glMateriali ( GL2 . GL_FRONT , GL2 . GL_SHININESS , 128);private float torusRot = 0, earthRot = 0;@Overridepublic void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();torusRot += .1f;if( torusRot > 2f * GlTools . GL_PI )torusRot = 0f;earthRot += .05 f;if( earthRot > 2f * GlTools . GL_PI )earthRot = 0f;// Clear the window with current clearing colorgl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );// Componente Especulargl. glMaterialfv ( GL2 . GL_FRONT , GL2 . GL_SPECULAR , fBrightLight , 0);// Cor do Material Brancagl. glColor3f (1f, 1f, 1f);gl. glPushMatrix ();// Colocar a Luzgl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , fLightPos . toArray () , 0);// Desenhar o ChaoGlUtil . drawTexturedGround ( textures . get ( Grass ),FloorSize , 1f);// Desenhar o nosso mundo de novodrawWorld (gl );gl. glPopMatrix ();}private void drawWorld ( GL2 gl) {// Desenhar esferas aleatoriamentegl. glBindTexture ( GL2 . GL_TEXTURE_2D , textures . get ( Earth ));for ( GLVector s : spherePositions ) {gl. glPushMatrix ();gl. glTranslatef (s.x() , s.y() , s.z ());gl. glRotatef (( float ) Math . toDegrees ( earthRot ), 0f, 1f, 0f);GlTools . gltDrawSphere (.2f, 20 , 10);gl. glPopMatrix ();}// Desenhar o Torusgl. glPushMatrix ();// Desactivar temporariamente TEXTURE_2Dgl. glDisable ( GL2 . GL_TEXTURE_2D );// Activar o Cube Mapgl. glEnable ( GL2 . GL_TEXTURE_CUBE_MAP );135

gl. glBindTexture ( GL2 . GL_TEXTURE_CUBE_MAP , textures . get ( CubeStartIndex ));gl. glEnable ( GL2 . GL_TEXTURE_GEN_S );gl. glEnable ( GL2 . GL_TEXTURE_GEN_T );gl. glEnable ( GL2 . GL_TEXTURE_GEN_R );// Desenhar a Geometria que reflecte o cube mapgl. glTranslatef (0 , .5f, -.3f);glut . glutSolidSphere (.15 , 61 , 37);gl. glRotatef (( float ) Math . toDegrees ( torusRot ), 0, 1f, 0);glut . glutSolidTorus (.1f, .3f, 61 , 37);// Colocar tudo como estavagl. glDisable ( GL2 . GL_TEXTURE_GEN_S );gl. glDisable ( GL2 . GL_TEXTURE_GEN_T );gl. glDisable ( GL2 . GL_TEXTURE_GEN_R );gl. glDisable ( GL2 . GL_TEXTURE_CUBE_MAP );gl. glEnable ( GL2 . GL_TEXTURE_2D );gl. glPopMatrix ();}@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();if ( height == 0)height = 1; // prevenir divisao por 0gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();float volume = 100 f;float fAspect = ( float ) width / ( float ) height ;glu . gluPerspective (100f, fAspect , .001f, volume * 5f);}}C.6 SnowMan.javapackagept.ipb . esact .cg. examples .c9;import java . awt . BorderLayout ;import java . awt . Container ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . media . opengl . glu . GLUquadric ;import javax . swing . JFrame ;import pt.ipb . esact .cg.gl. CGEngine ;import pt.ipb . esact .cg.gl. GLVector ;import com . jogamp . opengl . util . FPSAnimator ;@SuppressWarnings (" serial ")public class SnowMan extends JFrame implements GLEventListener {136

private GLU glu = new GLU ();private GLCanvas canvas ;FPSAnimator animator ;private GLVector fLightPos = new GLVector ( -100f, 100f, 50f, 1f);private float fNoLight [] = { 0.5f, 0.5f, 0.5f, 1.0 f };private float fLowLight [] = { 0.25f, 0.25f, 0.25f, 1.0 f };private float fBrightLight [] = { 1.0f, 1.0f, 1.0f, 1.0 f };private GLVector lookAt = new GLVector (0f, 0f, 0f);private CGEngine e;public static void main ( String [] args ) {new SnowMan ();}public SnowMan () {super (" Modelo OpenGL ");setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);Container p = getContentPane ();BorderLayout l = new BorderLayout (5 , 5);p. setLayout (l);canvas = new GLCanvas ();p. add ( canvas , BorderLayout . CENTER );GLVector location = new GLVector (1f, .5f, 1f);e = new CGEngine ( canvas , location );e. camera (). lookAt ( lookAt );canvas . addGLEventListener ( this );setVisible ( true );canvas . requestFocus ();}animator = new FPSAnimator ( canvas , 25);animator . start ();@Overridepublic void dispose ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Grayish backgroundgl. glClearColor ( fLowLight [0] , fLowLight [1] , fLowLight [2] , fLowLight [3]);// Cull backs of polygonsgl. glCullFace ( GL2 . GL_BACK );gl. glFrontFace ( GL2 . GL_CCW );gl. glEnable ( GL2 . GL_CULL_FACE );gl. glEnable ( GL2 . GL_DEPTH_TEST );setupLight (gl );137

}private void setupLight ( GL2 gl) {// Setup light parametersgl. glLightModelfv ( GL2 . GL_LIGHT_MODEL_AMBIENT , fNoLight , 0);gl. glLightModeli ( GL2 . GL_LIGHT_MODEL_COLOR_CONTROL ,GL2 . GL_SEPARATE_SPECULAR_COLOR );gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_AMBIENT , fLowLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_DIFFUSE , fBrightLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_SPECULAR , fBrightLight , 0);gl. glEnable ( GL2 . GL_LIGHTING );gl. glEnable ( GL2 . GL_LIGHT0 );}// Utilizar color trackinggl. glEnable ( GL2 . GL_COLOR_MATERIAL );gl. glColorMaterial ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE );gl. glMateriali ( GL2 . GL_FRONT , GL2 . GL_SHININESS , 128);@Overridepublic void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Clear the window with current clearing colorgl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );// Componente Especulargl. glMaterialfv ( GL2 . GL_FRONT , GL2 . GL_SPECULAR , fBrightLight , 0);// Posicao da Luzgl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , fLightPos . toArray () , 0);// Cor do Material Brancagl. glColor3f (0f, 0f, 0f);GLUquadric quad = glu . gluNewQuadric (); // Criar o quadricgl. glPushMatrix ();glu . gluQuadricNormals (quad , GLU . GLU_SMOOTH );// Corpogl. glPushMatrix ();// Bola do Fundogl. glColor3f (1.0f, 1.0f, 1.0 f);glu . gluSphere (quad , .40f, 26 , 13);// Bola do Corpogl. glTranslatef (0.0f, .550f, 0.0 f);glu . gluSphere (quad , .3f, 26 , 13);// Bola da Cabecagl. glTranslatef (0.0f, 0.45f, 0.0 f);glu . gluSphere (quad , 0.24f, 26 , 13);// Olhosgl. glColor3f (0.0f, 0.0f, 0.0 f);gl. glTranslatef (0.1f, 0.1f, 0.21 f);glu . gluSphere (quad , 0.02f, 26 , 13);gl. glTranslatef ( -0.2f, 0.0f, 0.0 f);glu . gluSphere (quad , 0.02f, 26 , 13);138

Narizgl. glColor3f (1.0f, 0.3f, 0.3 f);gl. glTranslatef (0.1f, -0.12f, 0.0 f);glu . gluCylinder (quad , 0.04f, 0.0f, 0.3f, 26 , 13);gl. glPopMatrix ();// Chapeugl. glPushMatrix ();gl. glColor3f (0.0f, 0.0f, 0.0 f);gl. glTranslatef (0.0f, 1.17f, 0.0 f);gl. glRotatef ( -90.0f, 1.0f, 0.0f, 0.0 f);glu . gluCylinder (quad , 0.17f, 0.17f, 0.4f, 26 , 13);// Hat brimgl. glDisable ( GL2 . GL_CULL_FACE ); // Pintar ambos os ladosglu . gluDisk (quad , 0.17f, 0.28f, 26 , 13);gl. glEnable ( GL2 . GL_CULL_FACE );gl. glTranslatef (0.0f, 0.0f, 0.40 f);glu . gluDisk (quad , 0.0f, 0.17f, 26 , 13);gl. glPopMatrix ();}gl. glPopMatrix ();@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();if ( height == 0)height = 1; // prevenir divisao por 0gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );}gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();float volume = 100 f;float fAspect = ( float ) width / ( float ) height ;glu . gluPerspective (100f, fAspect , .001f, volume * 5f);}C.7 Bezier2D.javapackagept.ipb . esact .cg. examples .c9;import java . awt . BorderLayout ;import java . awt . Container ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;import pt.ipb . esact .cg.gl. GLVector ;import pt.ipb . esact .cg.gl. GLVectorList ;import com . jogamp . opengl . util . FPSAnimator ;@SuppressWarnings (" serial ")139

public class Bezier2D extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLCanvas canvas ;FPSAnimator animator ;private GLVectorList ctrlPoints ;public static void main ( String [] args ) {new Bezier2D ();}public Bezier2D () {super (" Modelo OpenGL ");setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);Container p = getContentPane ();BorderLayout l = new BorderLayout (5 , 5);p. setLayout (l);canvas = new GLCanvas ();p. add ( canvas , BorderLayout . CENTER );canvas . addGLEventListener ( this );setVisible ( true );canvas . requestFocus ();}animator = new FPSAnimator ( canvas , 25);animator . start ();@Overridepublic void dispose ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Grayish backgroundgl. glClearColor (.5f, .5f, .5f, .5f);}// Definir Pontos de ControloctrlPoints = new GLVectorList ();ctrlPoints . add ( -4f, 0f, 0f); // StartctrlPoints . add ( -6f, 4f, 0f); // ControlctrlPoints . add (6f, -4f, 0f); // ControlctrlPoints . add (4f, 0f, 0f); // Endpublic void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT );float umin = 0f; // Valor minimo do ufloat umax = 100 f; // Valor maximo do ugl. glMap1f (GL2 . GL_MAP1_VERTEX_3 , // Tipo de dados geradosumin , // Valor minimo do uumax , // Valor maximo do u3, // Distancia entre pontos140

ctrlPoints . size () , // Numero de pontos de controloctrlPoints . toFloatBuffer () // FloatBuffer contendo pontos de controlo);// Activar o Evaluatorgl. glEnable ( GL2 . GL_MAP1_VERTEX_3 );// Desenhar os vertices da curva/*gl. glColor3f (0f, 0f, 0f);gl. glBegin ( GL2 . GL_LINE_STRIP );for ( float i= umin ; i< umax ; i ++)gl. glEvalCoord1f (i);gl. glEnd ();*/gl. glColor3f (0f, 0f, 0f);gl. glMapGrid1d (100 , umin , umax );gl. glEvalMesh1 ( GL2 . GL_LINE , ( int )umin , ( int ) umax );// Desenhar Pontos de Contrologl. glPointSize (5.0 f);gl. glColor3f (1f, 0f, 0f);gl. glBegin ( GL2 . GL_POINTS );for ( GLVector point : ctrlPoints )point . draw ();gl. glEnd ();}@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();if ( height == 0)height = 1; // prevenir divisao por 0gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();glu . gluOrtho2D ( -10f, 10f, -10f, 10f);}gl. glMatrixMode ( GL2 . GL_MODELVIEW );gl. glLoadIdentity ();}C.8 Bezier3D.javapackagept.ipb . esact .cg. examples .c9;import java . awt . BorderLayout ;import java . awt . Container ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;import pt.ipb . esact .cg.gl. CGEngine ;import pt.ipb . esact .cg.gl. GLVector ;141

import pt.ipb . esact .cg.gl. GLVectorList ;import com . jogamp . opengl . util . FPSAnimator ;@SuppressWarnings (" serial ")public class Bezier3D extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLCanvas canvas ;FPSAnimator animator ;private GLVectorList ctrlPoints ;private GLVector lookAt = new GLVector (0f, .5f, 0f);private CGEngine e;public static void main ( String [] args ) {new Bezier3D ();}public Bezier3D () {super (" Modelo OpenGL ");setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);Container p = getContentPane ();BorderLayout l = new BorderLayout (5 , 5);p. setLayout (l);canvas = new GLCanvas ();p. add ( canvas , BorderLayout . CENTER );canvas . addGLEventListener ( this );GLVector location = new GLVector (5f, .5f, 5f);e = new CGEngine ( canvas , location );e. camera (). lookAt ( lookAt );setVisible ( true );canvas . requestFocus ();}animator = new FPSAnimator ( canvas , 25);animator . start ();@Overridepublic void dispose ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();// Grayish backgroundgl. glClearColor (.5f, .5f, .5f, .5f);// Definir Pontos de ControloctrlPoints = new GLVectorList ();// v0ctrlPoints . add ( -4f, 0f, 4f); // Start (u0)ctrlPoints . add ( -2f, 4f, 4f); // Control (u0)ctrlPoints . add (4f, 0f, 4f); // End (u0)142

v1ctrlPoints . add ( -4f, 0f, 0f); // Start (u1)ctrlPoints . add ( -2f, 4f, 0f); // Control (u1)ctrlPoints . add (4f, 0f, 0f); // End (u1)// v2ctrlPoints . add ( -4f, 0f, -4f); // Start (u2)ctrlPoints . add ( -2f, 4f, -4f); // Control (u2)ctrlPoints . add (4f, 0f, -4f); // End (u2)}public void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT );}float umin = 0f; // Valor minimo do ufloat umax = 10f; // Valor maximo do ufloat vmin = 0f; // Valor minimo do vfloat vmax = 10f; // Valor maximo do vgl. glMap2f (GL2 . GL_MAP2_VERTEX_3 , // Tipo de dados geradosumin , // Valor minimo do uumax , // Valor maximo do u3, // Distancia entre pontos ( dominio u)3, // Numero de pontos de controlo ( dominio u)vmin , // Valor minimo do vvmax , // Valor maximo do v9, // Distancia entre pontos ( dominio v)3, // Numero de pontos de controlo ( dominio v)ctrlPoints . toFloatBuffer () // FloatBuffer contendo pontos de controlo);// Activar o Evaluatorgl. glEnable ( GL2 . GL_MAP2_VERTEX_3 );// Desenhar os vertices da superficiegl. glColor3f (0f, 0f, 0f);gl. glMapGrid2d (10 , umin , umax , 10 , vmin , vmax );gl. glEvalMesh2 ( GL2 . GL_LINE , ( int )umin , ( int )umax , ( int )vmin , ( int ) vmax );// Desenhar Pontos de Contrologl. glPointSize (5.0 f);gl. glColor3f (1f, 0f, 0f);gl. glBegin ( GL2 . GL_POINTS );for ( GLVector point : ctrlPoints )point . draw ();gl. glEnd ();gl. glPopMatrix ();@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();if ( height == 0)height = 1; // prevenir divisao por 0gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();float volume = 100 f;float fAspect = ( float ) width / ( float ) height ;143

}glu . gluPerspective (100f, fAspect , .001f, volume * 5f);}C.9 BezierLighting.javapackagept.ipb . esact .cg. examples .c9;import java . awt . BorderLayout ;import java . awt . Container ;import javax . media . opengl . GL2 ;import javax . media . opengl . GLAutoDrawable ;import javax . media . opengl . GLEventListener ;import javax . media . opengl . awt . GLCanvas ;import javax . media . opengl . glu . GLU ;import javax . swing . JFrame ;import pt.ipb . esact .cg.gl. CGEngine ;import pt.ipb . esact .cg.gl. GLVector ;import pt.ipb . esact .cg.gl. GLVectorList ;import pt.ipb . esact .cg.gl. tools . GlTools ;import com . jogamp . opengl . util . FPSAnimator ;@SuppressWarnings (" serial ")public class BezierLighting extends JFrame implements GLEventListener {private GLU glu = new GLU ();private GLCanvas canvas ;FPSAnimator animator ;private GLVector fLightPos = new GLVector (100f, 100f, 50f, 1f);private float fNoLight [] = { 0.0f, 0.0f, 0.0f, 0.0 f };private float fLowLight [] = { 0.25f, 0.25f, 0.25f, 1.0 f };private float fBrightLight [] = { .5f, .5f, .5f, 1.0 f };private GLVectorList ctrlPoints ;private GLVector lookAt = new GLVector (0f, .5f, 0f);private CGEngine e;public static void main ( String [] args ) {new BezierLighting ();}public BezierLighting () {super (" Modelo OpenGL ");setDefaultCloseOperation ( JFrame . EXIT_ON_CLOSE );setSize (600 , 600);Container p = getContentPane ();BorderLayout l = new BorderLayout (5 , 5);p. setLayout (l);canvas = new GLCanvas ();p. add ( canvas , BorderLayout . CENTER );canvas . addGLEventListener ( this );144

GLVector location = new GLVector (5f, .5f, 5f);e = new CGEngine ( canvas , location );e. camera (). lookAt ( lookAt );setVisible ( true );canvas . requestFocus ();}animator = new FPSAnimator ( canvas , 25);animator . start ();@Overridepublic void dispose ( GLAutoDrawable drawable ) {}@Overridepublic void init ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();}// Grayish backgroundgl. glClearColor (0f, 0f, 0f, 0f);// Cull backs of polygonsgl. glCullFace ( GL2 . GL_BACK );gl. glFrontFace ( GL2 . GL_CCW );gl. glEnable ( GL2 . GL_DEPTH_TEST );setupLight (gl );// Definir Pontos de ControloctrlPoints = new GLVectorList ();updateControlPoints ();// Activar a geracao automatica de normaisgl. glEnable ( GL2 . GL_AUTO_NORMAL );private float a0 = 0, a1 = GlTools . GL_PI / 4, a2 = GlTools . GL_PI / 2;private void updateControlPoints () {ctrlPoints . clear ();a0 += .1f;if(a0 >= GlTools . GL_PI )a0 = 0;a1 += .1f;if(a1 >= GlTools . GL_PI )a1 = 0;a2 += .1f;if(a2 >= GlTools . GL_PI )a2 = 0;// v0ctrlPoints . add ( -4f, 0f, 4f); // Start (u0)ctrlPoints . add ( -2f, ( float ) ( Math . sin (a0) * 8f - 4f), 4f); // Control (u0)ctrlPoints . add (4f, 0f, 4f); // End (u0)// v1ctrlPoints . add ( -4f, 0f, 0f); // Start (u1)ctrlPoints . add ( -2f, ( float ) ( Math . sin (a1) * 8f - 4f), 0f); // Control (u1)145

ctrlPoints . add (4f, 0f, 0f); // End (u1)}// v2ctrlPoints . add ( -4f, 0f, -4f); // Start (u2)ctrlPoints . add ( -2f, ( float ) ( Math . sin (a2) * 8f - 4f), -4f); // Control (u2)ctrlPoints . add (4f, 0f, -4f); // End (u2)private void setupLight ( GL2 gl) {// Setup light parametersgl. glLightModelfv ( GL2 . GL_LIGHT_MODEL_AMBIENT , fNoLight , 0);gl. glLightModeli ( GL2 . GL_LIGHT_MODEL_COLOR_CONTROL ,GL2 . GL_SEPARATE_SPECULAR_COLOR );gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_AMBIENT , fLowLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_DIFFUSE , fBrightLight , 0);gl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_SPECULAR , fBrightLight , 0);gl. glEnable ( GL2 . GL_LIGHTING );gl. glEnable ( GL2 . GL_LIGHT0 );}// Utilizar color trackinggl. glEnable ( GL2 . GL_COLOR_MATERIAL );gl. glColorMaterial ( GL2 . GL_FRONT , GL2 . GL_AMBIENT_AND_DIFFUSE );gl. glMateriali ( GL2 . GL_FRONT , GL2 . GL_SHININESS , 128);public void display ( GLAutoDrawable drawable ) {GL2 gl = drawable . getGL (). getGL2 ();gl. glClear ( GL2 . GL_COLOR_BUFFER_BIT | GL2 . GL_DEPTH_BUFFER_BIT );updateControlPoints ();// Componente Especulargl. glMaterialfv ( GL2 . GL_FRONT , GL2 . GL_SPECULAR , fBrightLight , 0);// Posicao da Luzgl. glLightfv ( GL2 . GL_LIGHT0 , GL2 . GL_POSITION , fLightPos . toArray () , 0);float umin = 0f; // Valor minimo do ufloat umax = 10f; // Valor maximo do ufloat vmin = 0f; // Valor minimo do vfloat vmax = 10f; // Valor maximo do vgl. glMap2f (GL2 . GL_MAP2_VERTEX_3 , // Tipo de dados geradosumin , // Valor minimo do uumax , // Valor maximo do u3, // Distancia entre pontos ( dominio u)3, // Numero de pontos de controlo ( dominio u)vmin , // Valor minimo do vvmax , // Valor maximo do v9, // Distancia entre pontos ( dominio v)3, // Numero de pontos de controlo ( dominio v)ctrlPoints . toFloatBuffer () // FloatBuffer contendo pontos de controlo);// Activar o Evaluatorgl. glEnable ( GL2 . GL_MAP2_VERTEX_3 );// Desenhar os vertices da superficiegl. glColor3f (0f, 0f, 1f);gl. glMapGrid2d (10 , umin , umax , 10 , vmin , vmax );gl. glEvalMesh2 ( GL2 . GL_FILL , ( int )umin , ( int )umax , ( int )vmin , ( int ) vmax );// Desenhar Pontos de Controlo146

gl. glPointSize (5.0 f);gl. glColor3f (1f, 0f, 0f);gl. glBegin ( GL2 . GL_POINTS );for ( GLVector point : ctrlPoints )point . draw ();gl. glEnd ();gl. glPopMatrix ();}@Overridepublic void reshape ( GLAutoDrawable drawable , int x, int y, int width , int height ) {GL2 gl = drawable . getGL (). getGL2 ();if ( height == 0)height = 1; // prevenir divisao por 0gl. glViewport (0 , 0, canvas . getSize (). width , canvas . getSize (). height );gl. glMatrixMode ( GL2 . GL_PROJECTION );gl. glLoadIdentity ();float volume = 100 f;float fAspect = ( float ) width / ( float ) height ;glu . gluPerspective (100f, fAspect , .001f, volume * 5f);}}147