JOGL - Guia Rápido
Este capítulo apresenta o OpenGL, suas funções, os vínculos OpenGL em java (GL4java, LWJGL, JOGL) e as vantagens do JOGL sobre outros vínculos OpenGL.
Java binding para OcanetaGL(JOGL) é a ligação recente para API gráfica OpenGL em Java. É uma biblioteca de wrapper, que pode acessar a API OpenGL, e foi projetada para criar aplicativos gráficos 2D e 3D codificados em Java. JOGL é uma biblioteca de código aberto desenvolvida inicialmente pelos ex-alunos de pós-graduação do MIT Ken Russell e Chris Kline. Mais tarde, foi adotado pelo grupo de jogos da Sun Microsystems e agora é mantido por Java on Graphics Audio and Processing (JOGAMP). JOGL funciona em vários sistemas operacionais, como Windows, Solaris, Mac OS X e Linux (em x86).
O que é OpenGL?
OpenGL significa Open Graphics Library, que é uma coleção de comandos para criar gráficos 2D e 3D. Com OpenGL, você pode criar formas 3D complicadas usando primitivos muito básicos, como pontos, linhas, polígonos, bitmaps e imagens.
Aqui estão alguns recursos do OpenGL -
Ele pode funcionar em várias plataformas.
Possui ligações em várias linguagens como C ++, Python, etc
Ele pode renderizar gráficos vetoriais 2D e 3D.
Ele interage com a unidade de processamento gráfico (GPU) para obter uma renderização rápida e de alta qualidade. Renderização é o processo de criação de uma imagem a partir de um modelo 2D ou 3D.
É uma API padrão da indústria para escrever aplicativos gráficos 3D. Por exemplo, jogos, protetores de tela, etc.
Ele contém cerca de 150 comandos, que os programadores podem usar para especificar objetos e operações para desenvolver aplicativos.
Ele contém OpenGL Utility Library (GLU) que fornece vários recursos de modelagem, como superfícies quádricas e curvas NURBS. GLU é um componente padrão do OpenGL.
O design do OpenGL é focado na eficiência, eficácia e sua implementação em várias plataformas usando vários idiomas. Para manter a simplicidade de uma API OpenGL, as tarefas de janelas não estão incluídas.
Portanto, OpenGL depende de outras linguagens de programação para tarefas de janela.
Java Binding para API OpenGL
É uma especificação da API Java Specification Request (JSR), que permite usar OpenGL na plataforma Java.
Especificações | Detalhes |
---|---|
JSR 231 | Este pacote de vinculação Java oferece suporte à plataforma Java SE. |
JSR 239 | Este pacote de vinculação Java oferece suporte à plataforma Java ME. |
Existem várias ligações OpenGL em Java. Eles são discutidos abaixo
GL4java
É conhecido como OpenGL para tecnologia Java. Ele contém links para OpenGL 1.3 e para quase todas as extensões de fornecedores. Além disso, ele pode ser usado com o Abstract Window Toolkit (AWT) e Swings. É uma ligação OpenGL focada em jogos, que é uma janela única que exibe aplicativos em tela inteira.
LWJGL
Biblioteca de jogos Java leve (LWJGL), usa OpenGL 1.5 e funciona com a versão mais recente do java.
Ele pode usar recursos de tela inteira do JSE 1.4. Tem suporte limitado para AWT / Swings.
É adequado para dispositivos leves, como telefones celulares, dispositivos incorporados, etc.
JOGL
JOGL se concentra apenas em renderização 2D e 3D. As interfaces que lidam com som e entrada-saída não estão incluídas no JOGL.
Inclui a Biblioteca de Utilitários Gráficos (GLU), o kit de ferramentas de Utilitários GL (GLUT) e sua própria API - Native Windowing Toolkit (NEWT).
Por que JOGL?
Ele fornece acesso total às APIs OpenGL (versão 1.0, 4.3, ES 1, ES 2 e ES 3), bem como a quase todas as extensões do fornecedor. Portanto, todos os recursos do OpenGL estão incluídos no JOGL.
O JOGL se integra ao AWT, Swing e Standard Widget Toolkit (SWT). Ele também inclui seu próprio Native Windowing Toolkit (NEWT). Portanto, ele fornece suporte completo para janelamento.
História da JOGL
1992 - Silicon Graphics Inc. lançou a primeira especificação OpenGL.
2003 - O site Java.net foi lançado com novos recursos e o JOGL foi publicado pela primeira vez no mesmo site.
2010 - Desde o ano de 2010, é um projeto independente de código aberto sob a licença BSD, que é uma licença liberal para software de computador.
Este capítulo cobre a configuração do ambiente para usar JOGL em seu sistema usando diferentes ambientes de desenvolvimento integrado (IDEs).
Instalando JOGL
Para a instalação do JOGL, você precisa ter os seguintes requisitos de sistema -
Requisitos de sistema
O primeiro requisito é ter o Java Development Kit (JDK) instalado em sua máquina.
Requerimento | Descrição |
---|---|
Versão JDK | 1,4 ou superior |
Memória | nenhum requisito mínimo |
Espaço em disco | nenhum requisito mínimo |
Sistema operacional | nenhum requisito mínimo |
Você precisa seguir as etapas fornecidas para configurar seu ambiente para iniciar o desenvolvimento de aplicativos JOGL -
Etapa 1 - Verificando a instalação do Java em sua máquina
Abra o console do seu sistema e execute o seguinte comando java -
Plataforma | TAREFA | COMANDO |
---|---|---|
janelas | Abrir console de comando | C: \> versão java |
Linux | Terminal de comando aberto | $ java -version |
MAC | Terminal aberto | Máquina: ~ joseph $ java -version |
Verifique a saída no respectivo sistema operacional.
Plataforma | Resultado |
---|---|
janelas | Java “1.6.0.21” Java (TM) SE Runtime Environment (build 1..6.0_21-b07) Java HotSpot (TM) Client VM (build 17.0-b7, modo misto, compartilhamento) |
Linux | Java “1.6.0.21” Java (TM) SE Runtime Environment (build 1..6.0_21-b07) Java HotSpot (TM) Client VM (build 17.0-b7, modo misto, compartilhamento) |
MAC | Java “1.6.0.21” Java (TM) SE Runtime Environment (build 1..6.0_21-b07) Java HotSpot (TM) Client VM (build 17.0-b7, modo misto, compartilhamento) |
Etapa 2 - Configurando o Java Development Kit (JDK)
Se o Java não estiver instalado em sua máquina, você precisará instalar o Java SDK do site da Oracle: Oracle . Você pode encontrar instruções para instalar o JDK nos arquivos baixados. Você precisa seguir as instruções fornecidas para instalar e configurar a configuração. Finalmente, defina as variáveis de ambiente PATH e JAVA_HOME para se referir ao diretório que contém os arquivos java.exe e javac.exe, normalmente java_install_dir / bin e java_install_dir respectivamente.
Conjunto Java-home variável de ambiente para apontar para o local do diretório base no mesmo caminho, onde o Java está instalado em sua máquina.
Plataforma | Comando |
---|---|
janelas | Defina a variável de ambiente JAVA_HOME para C: \ ProgramFiles \ Java \ Jdk1.6.0_21 |
Linux | Exportar JAVA_HOME = / usr / local / java-current |
MAC | Exportar JAVA_HOME = / Library / Java / Home |
Anexe a localização do compilador Java ao caminho do sistema da seguinte maneira -
Plataforma | Comando |
---|---|
janelas | Anexe a string;% JAVA_HOME% bin no final da variável do sistema e caminho |
Linux | Exportar PATH = $ PATH: $ JAVA_HOME / bin / |
MAC | Não requerido |
Etapa 3 - Baixando JOGL
Você pode baixar a versão mais recente do JOGL no site www.jogamp.org
Vá para a página inicial de www.jogamp.org
Clique em Builds / Downloads> Current (zip).
Isso leva você para a lista de arquivos .jar para todas as APIs mantidas pelo site.
Baixe o arquivo .jar da biblioteca jogamp-all-platforms.7z, documentações java para biblioteca nativa OpenGL glugen-javadoc.7ze JOGL jogl-javadocs.7z.
Extraia os arquivos .jar baixados usando qualquer software de extração zip.
Ao abrir a pasta extraída, você encontrará a pasta jar, códigos-fonte e outros arquivos.
Obtenha os códigos-fonte gluegen-java-src.zip e jogl-java-src.zippara suportar IDE. Isso é opcional.
Dentro da pasta jar, existem vários arquivos .jar. Esta coleção de arquivos pertence a Glugen e JOGL.
JOAMP fornece bibliotecas nativas que suportam vários sistemas operacionais, como Windows, Solaris, Linux e Android. Portanto, você precisa obter os arquivos jar apropriados que podem ser executados na plataforma desejada. Por exemplo, se você estiver usando o sistema operacional Windows de 64 bits, obtenha os seguintes arquivos .jar da pasta jar -
- gluegenrt.jar
- jogl-all.jar
- gluegen-rt-natives-windows-amd64.jar
- jogl-all-natives-windowsamd64.jar
Configurando JOGL para Eclipse 4.4
Siga o procedimento fornecido para configurar o JOGL -
Adicionando Bibliotecas
Step 1 - Abra o Eclipse.
Step 2 - Crie um novo projeto.
Step 3- Crie uma nova pasta chamada lib na pasta do projeto.
Step 4- Copie os arquivos gluegen-rt-natives-windows-amd64.jar, gluegenrt.jar, jogl-all-natives-windowsamd64.jar ejogl-all.jarna pasta lib .
Step 5- Agora selecione esses arquivos e clique com o botão direito do mouse. Um menu de atalho é exibido, que contémBuild Path > Add to Build Path.
Step 6- Para disponibilizar todos os arquivos .jar para outros projetos, acesse o menu principal. Selecione Janela> Preferências. A janela Preferências é exibida.
Na janela de preferências, no menu suspenso à esquerda, siga a hierarquia - Java → Build Path → User Libraries.
Clique no botão “Novo…”.
Ele abre uma caixa de diálogo. Insira o nome da biblioteca como jogl2.1.
Adicionar arquivos jar glugen-rt.jar e jogl-all.jar usando o botão “Adicionar JARs externos ...”.
Ele cria uma nova biblioteca de usuário chamada jogl2.1.
Da mesma forma, podemos adicionar documentação java e código-fonte para os arquivos.jar adicionados.
Adicionar Bibliotecas Nativas
Step 1 - Expanda o nó jogl-all.jar, selecione o local Javadoc (nenhum).
Step 2- Clique no botão “Novo…”. Digite o nome do documento JOGL Java.
Step 3 - Clique no botão “Adicionar JARs externos…”.
Step 4 - Abre uma caixa de diálogo onde você precisa selecionar o local da documentação do JOGL Java, que já baixamos anteriormente.
Adicionando código fonte
Step 1 - Selecione o local da biblioteca nativa do nó: (Nenhum).
Step 2 - Clique no botão “Novo…”.
Step 3 - Digite o nome das bibliotecas nativas e clique no botão “OK”.
Step 4 - Clique no botão “Adicionar JARs externos…”.
Step 5- Agora selecione o caminho onde os arquivos da biblioteca nativa ('gluegen-rt-natives-windows-amd64.jar e joglall-natives-windows-amd64.jar') estão localizados.
Step 6 - Repita o mesmo procedimento para o código-fonte.
Step 7 - Podemos definir os locais para Javadoc, código-fonte e arquivos jar da mesma forma dada acima para ambos os arquivos de biblioteca nativa glegen-rt.jar e glugen-natives-windows-amd64.jar.
Configurando JOGL para NetBeans 4.4
Vamos seguir as etapas para configurar o JOGL para NetBeans 4.4 -
Adicionando Bibliotecas
Step 1 - No menu principal, selecione Tools > Libraries.
Step 2 - Isso te leva a Ant Library Manager.
Step 3 - Sob o Classpath guia, clique New Librarybotão localizado no canto inferior esquerdo. Ele abre uma pequena caixa de diálogo.
Step 4 - Insira o nome da biblioteca como JoGl2.0.
Step 5 - Clique no botão “OK”.
Step 6 - Clique no botão “Adicionar JAR / Pasta…”.
Step 7 - Selecione o caminho onde os arquivos .jar jogl.all.jar e gluegen-rt.jar estão localizados.
Para incluir a biblioteca JOGL em cada projeto, siga as etapas abaixo -
Step 1 - Clique com o botão direito no project name. Mostra um menu de atalho.
Step 2 - Selecione Properties. Ele abre uma janela chamada Project properties.
Step 3 - Selecione Libraries das categorias no lado esquerdo.
Step 4 - Selecione Compile tabe clique no botão “Adicionar biblioteca ...”. A caixa de diálogo Adicionar biblioteca é exibida.
Step 5 - Agora adicione a biblioteca JOGL2.0, que você criou anteriormente.
Incluindo Biblioteca Nativa em Cada Projeto
Siga as etapas fornecidas para incluir a biblioteca nativa em cada projeto -
Step 1 - Clique com o botão direito no projeto.
Step 2 - Selecione Set Configuration > Customize…
Isso leva você ao Project Properties janela.
Step 3 - Do lado direito, em VM options, clique no botão “Personalizar”.
Step 4 - Procure o caminho que contém as bibliotecas nativas JOGL gluegen-rtnatives-windows-amd64.jar'' e 'jogl-all-natives-windowsamd64.jar.
Adicionando documentação Java de bibliotecas nativas
Você precisa abrir o gerenciador de biblioteca Ant novamente para disponibilizar os códigos-fonte e Javadoc para cada projeto. Siga o procedimento fornecido -
Step 1 - Aberto main menu.
Step 2 - Selecione Tools > Libraries. Isso leva você aLibrary manager.
Step 3 - Sob o JavaDoc guia, clique no botão “Nova Biblioteca…”.
Step 4 - Entre JOGLJavadocnome. (Você pode inserir qualquer nome desejado.)
Step 5 - Clique no botão “Adicionar jarras / bibliotecas…”.
Step 6 - Selecione o caminho onde foi descompactado JOGL documentation o código está localizado.
Adicionando código-fonte de bibliotecas nativas
Step 1 - Sob Sourcesguia, clique no botão “Nova Biblioteca…”. EntrarJOGLsources nome.
Step 2- Clique no botão “Adicionar jarras / bibliotecas…”. Selecione o caminho onde o código-fonte descompactado está localizado.
Personalizando o Editor JDK
Step 1 - Definir Classpath para arquivos jogl.all.jar e gluegen-rt.jar.
Step 2- Defina o caminho para as bibliotecas nativas gluegen-rt-natives-windows-amd64.jar e joglall-natives-windowsamd64.jar ou copie todos os arquivos jar da pasta onde você os baixou e cole-os nojse lib pasta.
Usando a programação JOGL, é possível desenhar várias formas gráficas, como linhas retas, triângulos, formas 3D, incluindo efeitos especiais como rotação, iluminação, cores, etc. Para desenhar objetos em JOGL, em primeiro lugar, temos que construir um quadro JOGL básico . Abaixo são fornecidas as classes necessárias para construir um quadro básico.
Interface GLEventListener
Para tornar seu programa capaz de usar a API gráfica JOGL, você precisa implementar GLEventListenerinterface. Você pode encontrar oGLEventListener interface no javax.media.opengl pacote.
A tabela a seguir fornece os detalhes de vários métodos e descrições de GLEventListener interface -
Sr. Não. | Métodos e Descrições |
---|---|
1 | Void display(GLAutoDrawable drawable) É chamado pelo objeto da interface GLAutoDrawable para iniciar a renderização OpenGL pelo cliente. ou seja, este método contém a lógica usada para desenhar elementos gráficos usando a API OpenGL. |
2 | Void dispose(GLAutoDrawable drawable) Este método sinaliza ao ouvinte para realizar a liberação de todos os recursos OpenGL por cada GLContext, como buffers de memória e programas GLSL. |
3 | Void init(GLAutoDrawble drawable) É chamado pelo objeto da interface GLAutoDrawable imediatamente após o contexto OpenGL ser inicializado. |
4 | Void reshape(GLAutoDrawble drawble, int x, int y, int width, int height) É chamado pelo objeto da interface GLAutoDrawable durante a primeira repintura após o redimensionamento do componente. Também é chamado sempre que a posição do componente na janela é alterada. |
Todos os métodos de GLEventListener requer objeto de GLAutoDrawable interface como um parâmetro.
Interface GLAutoDrawable
Esta interface fornece um mecanismo baseado em eventos (GLEventListener) para executar renderização OpenGL. GLAutoDrawable cria automaticamente um contexto de renderização primária que está associado com GLAutoDrawable durante a vida útil do objeto.
A tabela a seguir fornece os detalhes de vários métodos e descrições de GLAutoDrawable interface -
Sr. Não | Métodos e Descrições |
---|---|
1 | GL getGL() Retorna o objeto de pipeline GL que é usado pelo objeto atual da interface GLAutoDrawable. |
2 | void addGLEventListener(GLEventListener Listener) Adiciona o ouvinte fornecido ao final da fila drawable atual. |
3 | void addGLEventListener(int index, GLEventListener listener) Adiciona o ouvinte fornecido no índice fornecido desta fila drawable. |
4 | void destroy() Destroys todos os recursos associados a este objeto da interface GLAutoDrawable, incluindo o GLContext. |
Note- Existem outros métodos neste pacote. Apenas alguns métodos importantes relativos ao modelo são discutidos nesta interface.
Classe GLCanvas
GLCanvas e GLJpanel são as duas classes principais de JOGL GUI que implementam GLAutoDrawable interface, que pode ser utilizada como superfície de desenho para comandos OpenGL.
GLCanvas é um componente AWT pesado que fornece suporte de renderização OpenGL. Esta é a implementação primária de umAWTAutoGLDrawableinterface. Também herdajava.awt.Canvasclasse. Por ser um componente pesado, em certos casos,GLJCanvaspode não se integrar ao componente de giro corretamente. Portanto, deve-se ter cuidado ao usá-lo com o Swing. Sempre que você enfrenta problemas comGLJCanvas, então você deve usar GLJPanel classe.
O diagrama hierárquico da classe GLCanvas pode ser como mostrado abaixo -
GLEventistener interface funciona junto com GLCanvasclasse. Ele responde às mudanças emGLCanvas aula e aos pedidos de desenho feitos por eles.
Sempre que GLCanvas classe é instanciada, o init() método de GLEventListeneré invocado. Você pode substituir esse método para inicializar o estado OpenGL.
Sempre que GLCanvas é desenhado inicialmente (instanciado) ou redimensionado, o reshape() método de GLEventListenerÉ executado. É usado para inicializar a janela de exibição OpenGL e a matriz de projeção. Ele também é chamado sempre que a localização do componente é alterada.
O método display () de GLEventListenercontém o código para renderizar cena 3D. É invocado sempre que o método display () deGLCanvas é invocado.
Abaixo são fornecidos os construtores necessários para instanciar a classe GLCanvas.
Sr. Não | Construtor e Descrição |
---|---|
1 | GLCanvas() Ele cria um novo componente GLCanvas com um conjunto padrão de recursos OpenGL, usando o mecanismo de seleção de recursos OpenGL padrão, no dispositivo de tela padrão. |
2 | GLCanvas(GLCapabilitiesImmutable) Ele cria um novo componente GLCanvas com o conjunto solicitado de recursos OpenGL usando o mecanismo de seleção de recursos OpenGL padrão no dispositivo de tela padrão. |
Abaixo são fornecidos os métodos usados para tratamento de eventos da classe GLCanvas.
Sr. Não. | Métodos e Descrição |
---|---|
1 | void addGLEventListener(GLEventListener listener) Adiciona o ouvinte fornecido ao final desta fila drawable. |
2 | void addGLEventListener(int indexGLEventListener listener) Adiciona o ouvinte fornecido no índice fornecido desta fila drawable. |
Para instanciar GLCanvas classe, você precisa do objeto de GLCapabilitiesImmutable interface, que especifica um conjunto imutável de recursos OpenGL.
Uma das maneiras de obter um objeto de CapabilitiesImmutable interface é instanciar GLCapabilitiesclasse, que implementa a interface. Uma instância deGLCapabilities classe pode ser usada para servir ao propósito.
Classe GLCapabilities
Esta classe especifica um conjunto de recursos OpenGL. Leva o objeto GLCapabilities como parâmetro. oGLCapabilities classe descreve os recursos desejados que um contexto de renderização deve oferecer suporte, como o perfil OpenGL.
Abaixo é fornecido um construtor para instanciar a classe GLCapabilities
Sr. Não. | Métodos e Descrição |
---|---|
1 | GLCapabilities(GLProfile glprofile) Ele cria um objeto GLCapabilities. |
Para instanciar GLCanvas classe, você precisa de um objeto de interface GLCapabilitiesImmutable, que especifica um conjunto imutável de recursos OpenGL.
Uma das maneiras de obter um objeto de CapabilitiesImmutable interface é instanciar GLCapabilitiesclasse, que implementa a interface. A instância deGLCapabilities classe pode ser usada para servir ao propósito.
o GLCapabilities aula, por sua vez, requer um GLProfile objeto.
Classe GLProfile
Uma vez que várias versões da API OpenGL foram lançadas; você precisa especificar a versão exata da API OpenGL sendo usada em seu programa para sua Java Virtual Machine (JVM). Isso é feito usando oGLProfile classe.
o get() método desta classe aceita diferentes predefinidos Stringobjetos como parâmetros. Cada objeto String é o nome de uma interface e cada interface oferece suporte a certas versões do OpenGL. Se você inicializar esta classe como estática e singleton, ela lhe dará um singletonGLProfile objetos para cada perfil JOGL disponível.
Abaixo, está o protótipo do método get da classe GLProfile.
Sr. Não. | Método e Descrição |
---|---|
1 | Static GLProfile get(String profile) Usa o dispositivo padrão. |
Como este é um método estático, você precisa invocá-lo usando o nome da classe e requer uma variável de string estática predefinida como parâmetro. Existem 12 dessas variáveis nesta classe, cada uma representa uma implementação individual da interface GL.
GLProfile.get(GLProfile.GL2);
Parâmetros do método get ()
Sr. Não | Valor de string predefinido (nome da interface) e descrição |
---|---|
1 | GL2 Esta interface contém todos os métodos OpenGL [1.0… 3.0], bem como a maioria de suas extensões definidas no momento desta especificação. |
2 | GLES1 Esta interface contém todos os métodos OpenGL ES [1.0 ... 1.1], bem como a maioria de suas extensões definidas no momento desta especificação. |
3 | GLES2 Essa interface contém todos os métodos OpenGL ES 2.0, bem como a maioria de suas extensões definidas no momento desta especificação. |
4 | GLES3 Esta interface contém todos os métodos OpenGL ES 3.0, bem como a maioria de suas extensões definidas no momento desta especificação. |
5 | GL2ES1 Esta interface contém o subconjunto comum de GL2 e GLES1. |
6 | GL2ES2 Esta interface contém o subconjunto comum de GL3, GL2 e GLES2. |
7 | GL2GL3 Esta interface contém o subconjunto comum do núcleo GL3 (OpenGL 3.1+) e GL2. |
8 | GL3 Esta interface contém todos os métodos principais do OpenGL [3.1 ... 3.3] , bem como a maioria de suas extensões definidas no momento desta especificação. |
9 | GL3bc Esta interface contém todos os métodos de compatibilidade OpenGL [3.1 ... 3.3] , bem como a maioria de suas extensões definidas no momento desta especificação. |
10 | GL3ES3 Esta interface contém o subconjunto comum do núcleo GL3 (OpenGL 3.1+) e GLES3 (OpenGL ES 3.0). |
11 | GL4 Esta interface contém todos os métodos centrais do OpenGL [4.0 ... 4.3] , assim como a maioria de suas extensões definidas no momento desta especificação. |
12 | GL4bc Esta interface contém todos os perfis de compatibilidade OpenGL [4.0 ... 4.3] , assim como a maioria de suas extensões definidas no momento desta especificação. |
13 | GL4ES3 Interface contendo o subconjunto comum do núcleo GL4 (OpenGL 4.0+) e GLES3 (OpenGL ES 3.0). |
Classe GLJPanel
É um componente Swing leve que fornece suporte de renderização OpenGL. É fornecido para compatibilidade com Swing.
Hierarquia de classe GLJPanel
A seguir, o diagrama que representa a hierarquia de classes da classe GLJPanel.
Abaixo são fornecidos vários construtores da classe GLJPanel.
Sr. Não. | Construtores e descrição |
---|---|
1 | GJPanel() Ele cria um novo componente GLJPanel com um conjunto padrão de recursos OpenGL. |
2 | (GLCapabilitiesImmutable) Ele cria um novo componente GLJPanel com o conjunto solicitado de recursos OpenGL. |
3 | GLJPanel(GLCapabilitiesImmutable userCapsRequest, GLCapabilitiesChooser chooser) Ele cria um novo componente GLJPanel. |
Abaixo são fornecidos os métodos da classe GLJPanel.
Sr. Não. | Métodos e Descrição |
---|---|
1 | void addGLEventListener(GLEventListener listener) Este método adiciona o ouvinte fornecido ao final desta fila drawable. |
2 | void addGLEventListener(int indexGLEventListener listener) Este método adiciona o ouvinte fornecido no índice fornecido desta fila drawable. |
Este capítulo explica como desenhar um quadro básico JOGL usando Canvas com quadro AWT. Aqui, construiremos um quadro AWT e adicionaremos o objeto de tela ao quadro AWT usando oadd() método da classe frame.
Abaixo, são fornecidas as etapas para escrever um programa que cria um quadro básico JOGL com a combinação da classe Canvas do JOGL e a classe Frame do AWT.
Etapa 1: Criação da classe
Crie inicialmente uma classe que implemente GlEventListenerinterface e importe o pacote javax.media.opengl. Implementar todos os quatro métodosdisplay(), dispose(), reshape(), init().Como este é o quadro básico, tarefas primitivas, como a criação de uma classe de tela e sua adição ao quadro, foram discutidas. TodosGLEVentListener os métodos de interface não foram implementados.
Etapa 2: Preparando a tela
(a) Construindo o GLCanvas objeto de classe
final GLCanvas glcanvas = new GLCanvas( xxxxxxx );
//here capabilities obj should be passed as parameter
(b) Instanciando o GLCapabilities classe
GLCapabilities capabilities = new GLCapabilities( xxxxx );
//here profile obj should be passed as parameter
(c) Gerando GLProfile objeto
Por ser um método estático, é invocado usando o nome da classe. Como este tutorial é sobre JOGL2, vamos gerar o objeto de interface GL2.
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
// both, variable and method are static hence both are called using class name.
Vamos ver o trecho de código da tela.
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
(d) Agora adicione GLEventListener para a tela usando o método addGLEventListener(). Este método precisa de objeto deGLEventListenerinterface como parâmetro. Portanto, passe o objeto de uma classe que implementaGLEventListener.
BasicFrame basicframe = newBasic Frame( );// class which implements
GLEventListener interface
glcanvas.addGLEventListener( basicframe );
(e) Defina o tamanho do quadro usando o método setSize () herdado por GLCanvas de javax.media.opengl.awt.AWTGLAutoDrawable.
glcanvas.setSize( 400, 400 );
Agora você está pronto com GLCanvas.
Passo 3: Criando o Quadro
Crie o quadro instanciando o Frame classe Objeto do componente de quadro JSE AWT.
Adicione uma tela a ele e torne a moldura visível.
//creating frame
final Frame frame = new frame( " Basic Frame" );
//adding canvas to frame
frame.add( glcanvas );
frame.setVisible( true );
Etapa 4: Visualização do quadro em tela inteira
Para visualizar o quadro em tela inteira, obtenha o tamanho de tela padrão usando java.awt.Toolkitclasse. Agora, usando essas dimensões de tamanho de tela padrão, defina o tamanho do quadro usandosetSize() método.
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
frame.setSize(screenSize.width, screenSize.height);
Vamos percorrer o programa para gerar o quadro básico usando AWT -
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class BasicFrame implements GLEventListener {
@Override
public void display(GLAutoDrawable arg0) {
// method body
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
// method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
BasicFrame b = new BasicFrame();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final Frame frame = new Frame (" Basic Frame");
//adding canvas to frame
frame.add(glcanvas);
frame.setSize( 640, 480 );
frame.setVisible(true);
}
}
Se você compilar e executar o programa acima, a seguinte saída será gerada. Ele mostra um quadro básico formado quando usamosGLCanvas classe com AWT -
Este capítulo explica como desenhar um quadro básico JOGL usando Canvas, e JFrameclasse do pacote javax.swing. Aqui, iremos instanciar um JFrame e adicionar o objeto de tela à instância do JFrame usando oadd() método.
Usar o Canvas com AWT oferece um quadro gráfico com recursos pesados. Para ter um quadro gráfico leve, você precisa usarGLCanvascom Swing. Enquanto estiver usandoGLCanvas com Swing, você pode colocar GLCanvas no JFrame janela diretamente, ou você pode adicioná-la a JPanel.
Abaixo fornecido é o programa que cria um quadro básico JOGL com a combinação de JOGL's GLCanvas classe e JFrameclasse do pacote javax.swing .
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class BasicFrame implements GLEventListener {
@Override
public void display(GLAutoDrawable arg0) {
// method body
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
// method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
BasicFrame b = new BasicFrame();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" Basic Frame");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport
Se você compilar e executar o programa acima, a seguinte saída será gerada. Ele mostra um quadro básico formado quando usamosGLCanvas com janela Swing.
Este capítulo explica como desenhar um quadro básico JOGL usando a classe GLJpanel. É um componente Swing leve que fornece suporte de renderização OpenGL. É fornecido para compatibilidade com Swing. Aqui, iremos instanciar um JFrame e adicionar o objeto GLJpanel à instância do JFrame usando oadd() método.
O programa a seguir gera um quadro básico usando GLJPanel com janela Swing -
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class BasicFrame implements GLEventListener {
@Override
public void display(GLAutoDrawable arg0) {
// method body
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
// method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The GLJpanel class
GLJPanel gljpanel = new GLJPanel( glcapabilities );
BasicFrame b = new BasicFrame();
gljpanel.addGLEventListener(b);
gljpanel.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" Basic Frame");
//adding canvas to it
frame.getContentPane().add( gljpanel);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport
Se você compilar e executar o programa acima, a seguinte saída será gerada. Ele mostra um quadro básico formado quando usamosGLJPanel com janela giratória -
A API OpenGL forneceu métodos primitivos para desenhar elementos gráficos básicos como ponto, vértice, linha etc. Usando esses métodos, você pode desenvolver formas como triângulo, polígono e círculo. Em ambas as dimensões, 2D e 3D. Este capítulo ensina como desenhar uma linha básica usando JOGL em um programa Java.
Objetos de Desenho
Para acessar programas que são específicos para plataformas de hardware e sistema operacional e onde as bibliotecas são escritas em outras linguagens como C e C ++ (aplicativos nativos), Java usa uma estrutura de programação chamada Java Native Interface (JNI). O JOGL usa essa interface internamente para acessar as funções do OpenGL, conforme mostrado no diagrama a seguir.
Todos os quatro métodos de GLEventListenerinterface tem o código (métodos java JOGL) para chamar funções OpenGL internamente. A nomenclatura desses métodos JOGL também é semelhante às convenções de nomenclatura do OpenGL. Se o nome da função em OpenGL forglBegin(), é usado como gl.glBegin().
Sempre que gl.glBegin() método de java JOGL é chamado, ele invoca internamente o glBegin()método do OpenGL. Esta é a razão para instalar os arquivos da biblioteca nativa no sistema do usuário no momento da instalação do JOGL.
O Método Display ()
Este é um método importante que contém o código para desenvolver gráficos. Requer oGLAutoDrawable objeto de interface como seu parâmetro.
o display()O método inicialmente obtém o contexto OpenGL usando o objeto da interface GL (o GL herda a interface GLBase que contém métodos para gerar todos os objetos de contexto OpenGL). Como este tutorial é sobre JOGL2, vamos gerar um objeto GL2.
O seguinte trecho de código mostra como gerar um objeto GL2 -
//Generating GL object
GL gl = drawable.getGL();
GL gl = drawable.getGL();
//Using this Getting the Gl2 Object
//this can be written in a single line like
final GL2 gl = drawable.getGL().getGL2();
Utilizando o objeto da interface GL2, é possível acessar os membros desta interface, que por sua vez fornecem acesso às funções do OpenGL [1.0 ... 3.0].
Desenhando uma Linha
A interface GL2 contém uma lista enorme de métodos, mas aqui três métodos principais importantes são discutidos, a saber glBegin(), glVertex(), e glEnd().
Sr. Não. | Métodos e Descrição |
---|---|
1 | glBegin() Este método inicia o processo de desenho de uma linha. Leva o número inteiro de string predefinido “GL_LINES” como parâmetro, que é herdado da interface GL. |
2 | glVertex3f()/glVertex2f() Este método cria o vértice e temos que passar as coordenadas como parâmetros 3f e 2f, que denotam coordenadas de ponto flutuante tridimensional e coordenadas de ponto flutuante bidimensional, respectivamente. |
3 | glEnd() termina a linha |
Abaixo é fornecido o programa para desenhar uma linha básica usando JOGL -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Line implements GLEventListener{
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINES);//static field
gl.glVertex3f(0.50f,-0.50f,0);
gl.glVertex3f(-0.50f,0.50f,0);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Line l = new Line();
glcanvas.addGLEventListener(l);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame ("straight Line");
//adding canvas to frame
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;
No capítulo anterior, aprendemos como desenhar uma linha básica usando JOGL. Desenhamos linhas passando um campo predefinido,Gl_linespara o método glBegin () .
Este capítulo fornece exemplos para desenhar formas como triângulo, losango e uma casa, usando o método glBegin () e GL_Lines.
Vamos passar por um programa para desenhar um triângulo usando GL_LINES -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Triangle implements GLEventListener{
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINES);
//drawing the base
gl.glBegin (GL2.GL_LINES);
gl.glVertex3f(-0.50f, -0.50f, 0);
gl.glVertex3f(0.50f, -0.50f, 0);
gl.glEnd();
//drawing the right edge
gl.glBegin (GL2.GL_LINES);
gl.glVertex3f(0f, 0.50f, 0);
gl.glVertex3f(-0.50f, -0.50f, 0);
gl.glEnd();
//drawing the lft edge
gl.glBegin (GL2.GL_LINES);
gl.glVertex3f(0f, 0.50f, 0);
gl.glVertex3f(0.50f, -0.50f, 0);
gl.glEnd();
gl.glFlush();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
// method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Triangle l = new Triangle();
glcanvas.addGLEventListener(l);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame ("Triangle");
//adding canvas to frame
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;
Se você compilar e executar o programa acima, a seguinte saída será gerada. Ele mostra um triângulo desenhado usando GL_LINES deglBegin() método.
Vamos examinar um programa para desenhar um losango usando GL_LINES -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Rhombus implements GLEventListener{
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
//edge1
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0.0f,0.75f,0 );
gl.glVertex3f( -0.75f,0f,0 );
gl.glEnd();
//edge2
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.75f,0f,0 );
gl.glVertex3f( 0f,-0.75f, 0 );
gl.glEnd();
//edge3
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0f,-0.75f, 0 );
gl.glVertex3f( 0.75f,0f, 0 );
gl.glEnd();
//edge4
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0.75f,0f, 0 );
gl.glVertex3f( 0.0f,0.75f,0 );
gl.glEnd();
gl.glFlush();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init(GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
// method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Rhombus rhombus = new Rhombus();
glcanvas.addGLEventListener( rhombus );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame ( "Rhombus" );
//adding canvas to frame
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
}
}
Se você compilar e executar o programa acima, obterá a seguinte saída. Ele mostra um losango gerado usando GL_LINES deglBegin() método.
Vamos passar por um programa para desenhar uma casa usando GL_LINES -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class House implements GLEventListener{
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
//drawing top
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( -0.3f, 0.3f, 0 );
gl.glVertex3f( 0.3f,0.3f, 0 );
gl.glEnd();
//drawing bottom
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.3f,-0.3f, 0 );
gl.glVertex3f( 0.3f,-0.3f, 0 );
gl.glEnd();
//drawing the right edge
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.3f,0.3f, 0 );
gl.glVertex3f( -0.3f,-0.3f, 0 );
gl.glEnd();
//drawing the left edge
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0.3f,0.3f,0 );
gl.glVertex3f( 0.3f,-0.3f,0 );
gl.glEnd();
//building roof
//building lft dia
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0f,0.6f, 0 );
gl.glVertex3f( -0.3f,0.3f, 0 );
gl.glEnd();
//building rt dia
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0f,0.6f, 0 );
gl.glVertex3f( 0.3f,0.3f, 0 );
gl.glEnd();
//building door
//drawing top
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( -0.05f, 0.05f, 0 );
gl.glVertex3f( 0.05f, 0.05f, 0 );
gl.glEnd();
//drawing the left edge
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( -0.05f, 0.05f, 0 );
gl.glVertex3f( -0.05f, -0.3f, 0 );
gl.glEnd();
//drawing the right edge
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( 0.05f, 0.05f, 0 );
gl.glVertex3f( 0.05f, -0.3f, 0 );
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
// method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
House house = new House();
glcanvas.addGLEventListener( house );
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame( "House" );
//adding canvas to frame
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
}//end of main
}//end of class
Se você compilar e executar o programa acima, obterá a seguinte saída. Ele mostra um diagrama de casa gerado usando o método GL_LINES ().
Nos capítulos anteriores, aprendemos como desenhar formas como linha, triângulo e losango usando JOGL. Desenhamos linhas passando um campo predefinido,Gl_linespara o método glBegin () .
Outro que não seja GL_LINES, a glBegin()método aceita mais oito parâmetros. Você pode usá-los para desenhar formas diferentes. Eles são usados da mesma maneira que GL_LINES.
A tabela a seguir mostra o glBegin() parâmetros do método junto com sua descrição -
Sr. Não | Parâmetros e Descrição |
---|---|
1 | GL_LINES Cria cada par de vértices como um segmento de linha independente. |
2 | GL_LINE_STRIP Desenha um grupo conectado de segmentos de linha do primeiro vértice ao último. |
3 | GL_LINE_LOOP Desenha um grupo conectado de segmentos de linha do primeiro vértice ao último, novamente de volta ao primeiro. |
4 | GL_TRIANGLES Trata cada trinca de vértices como um triângulo independente. |
5 | GL_TRIANGLE_STRIP Desenha um grupo conectado de triângulos. Um triângulo é definido para cada vértice apresentado após os dois primeiros vértices. |
6 | GL_TRIANGLE_FAN Desenha um grupo conectado de triângulos. Um triângulo é definido para cada vértice apresentado após os dois primeiros vértices. |
7 | GL_QUADS Trata cada grupo de quatro vértices como um quadrilátero independente. |
8 | GL_QUAD_STRIP Desenha um grupo conectado de quadriláteros. Um quadrilátero é definido para cada par de vértices apresentado após o primeiro par. |
9 | GL_POLYGON Desenha um único polígono convexo. Os vértices 1,…, n definem este polígono. |
Vamos ver alguns exemplos usando glBegin() parâmetros.
Programa para desenhar uma faixa de linha
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class LineStrip implements GLEventListener{
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINE_STRIP);
gl.glVertex3f(-0.50f,-0.75f, 0);
gl.glVertex3f(0.7f,0.5f, 0);
gl.glVertex3f(0.70f,-0.70f, 0);
gl.glVertex3f(0f,0.5f, 0);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
// method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
LineStrip r = new LineStrip();
glcanvas.addGLEventListener(r);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame ("LineStrip");
//adding canvas to frame
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;
Se você compilar e executar o código acima, a seguinte saída é gerada -
Trecho de código para o método display () para desenhar um loop de linha
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINE_LOOP);
gl.glVertex3f( -0.50f, -0.75f, 0);
gl.glVertex3f(0.7f, .5f, 0);
gl.glVertex3f(0.70f, -0.70f, 0);
gl.glVertex3f(0f, 0.5f, 0);
gl.glEnd();
}
Se você substituir o display() método de qualquer um dos programas de modelo básico com o código acima, compilar e executá-lo, a seguinte saída é gerada -
Snippet de código para o método display () para desenhar um triângulo usando GL_TRIANGLES
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin(GL2.GL_TRIANGLES); // Drawing Using Triangles
gl.glVertex3f(0.5f,0.7f,0.0f); // Top
gl.glVertex3f(-0.2f,-0.50f,0.0f); // Bottom Left
gl.glVertex3f(0.5f,-0.5f,0.0f); // Bottom Right
gl.glEnd();
}
Se você substituir o display() método de qualquer um dos programas de modelo básico com o código acima, compilar e executá-lo, a seguinte saída é gerada -
Snippet de código para o método display () para desenhar uma faixa de triângulo
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_TRIANGLE_STRIP);
gl.glVertex3f(0f,0.5f,0);
gl.glVertex3f(-0.50f,-0.75f,0);
gl.glVertex3f(0.28f,0.06f,0);
gl.glVertex3f(0.7f,0.5f,0);
gl.glVertex3f(0.7f,-0.7f,0);
gl.glEnd();
}
Se você substituir o display() método de qualquer um dos programas de modelo básico com o código acima, compile e execute-o, a seguinte saída é gerada -
Snippet de código para o método display () para desenhar um quadrilátero
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin(GL2.GL_QUADS);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(0f,-0.75f,0);
gl.glVertex3f(0.75f,0f,0);
gl.glEnd();
}
Se você substituir o display() método de qualquer um dos programas de modelo básico com o código acima, compilar e executá-lo, a seguinte saída é gerada -
Snippet de código para o método display () para desenhar um polígono
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin(GL2.GL_POLYGON);
gl.glVertex3f(0f,0.5f,0f);
gl.glVertex3f(-0.5f,0.2f,0f);
gl.glVertex3f(-0.5f,-0.2f,0f);
gl.glVertex3f(0f,-0.5f,0f);
gl.glVertex3f(0f,0.5f,0f);
gl.glVertex3f(0.5f,0.2f,0f);
gl.glVertex3f(0.5f,-0.2f,0f);
gl.glVertex3f(0f,-0.5f,0f);
gl.glEnd();
}
Se você substituir display() método de qualquer um dos programas de modelo básico com o código acima, compilar e executá-lo, a seguinte saída é gerada -
OpenGL fornece mais recursos, como aplicação de cores a um objeto, dimensionamento, iluminação, rotação de um objeto, etc. Este capítulo descreve algumas das transformações em objetos usando JOGL.
Movendo um objeto na janela
Nos capítulos anteriores, discutimos os programas para desenhar uma linha e desenhar várias formas usando linhas simples. As formas criadas desta forma podem ser exibidas em qualquer local da janela. É feito usando o métodoglTranslatef (float x, float y, float z).
Este método pertence ao GLMatrixFunc interface, que está no javax.media.opengl.fixedfunc pacote.
Interface GLMatrixFunc
interface - GLMatrixFunc
package - javax.media.opengl.fixedfunc
A tabela a seguir lista alguns métodos importantes dessa interface -
Sr. Não. | Métodos e Descrição |
---|---|
1 | void glRotatef(float angle, float x, float y, float z) Gira a matriz atual. |
2 | void glScalef(float x, float y, float z) Usado para dimensionar a matriz atual. |
3 | void glTranslatef(float x, float y,float z) Usado para traduzir a matriz atual. |
4 | void glLoadIdentity() Carrega a matriz atual com a matriz de identidade. |
o glTranslate() método move a origem do sistema de coordenadas para o ponto especificado pelos parâmetros (x, y, z), passados para o glTranslate() método como
argumento. Para salvar e restaurar o sistema de coordenadas não traduzido,glPushMatrix() e glPopMatrix() métodos são usados.
gl.glTranslatef(0f, 0f, -2.5f);
Sempre que glTranslate()for usado, ele altera a posição do componente na tela. Portanto, oreshape() método de GLEventListener a interface deve ser substituída e a janela de visualização OpenGL e a matriz de projeção devem ser inicializadas.
O código a seguir mostra o modelo para inicializar uma porta de visualização e matriz de projeção -
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
// TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
// get the OpenGL 2 graphics object
if(height <=0) height = 1;
//preventing devided by 0 exception height = 1;
final float h = (float) width / (float) height;
// display area to cover the entire window
gl.glViewport(0, 0, width, height);
//transforming projection matrix
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
//transforming model view gl.glLoadIdentity();
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
Este capítulo ensina como aplicar cores aos objetos usando JOGL. Para aplicar cor a um objeto, use o métodoglColor() do GL2. A seguir é fornecida a sintaxe para usar o método glColor.
Sintaxe
gl.glColorXY(1f,0f,0f);
Onde,
X denota o número de cores usadas, 3 (vermelho, verde, azul) ou 4 (vermelho, verde, azul, alfa). Para obter várias combinações de cores, os valores dessas cores são passados como parâmetros. A seqüência dos parâmetros de cores deve ser mantida nessa ordem.
Example
Se você passar os valores de cor como (1, 0, 0), você obterá a cor vermelha. Da mesma forma, (1, 1, 0) fornece a cor amarela.
Y denota o tipo de dados que aceita parâmetros como byte (b), double (d), float (f), int (i), short (s), ubyte (ub), uint (ui) e ushort (us) .
gl.glColor3f(1f,0f,0f); //gives us red
gl.glColor3f(0f,1f,0f); //gives us green
gl.glColor3f(0f,0f,1f); //gives us blue
No caso do triângulo, você pode aplicar cores diferentes para cada vértice.
Vamos seguir o programa para aplicar cores a um triângulo -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class TriangleColor implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin( GL2.GL_TRIANGLES );
// Drawing Using Triangles
gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
gl.glVertex3f( 0.5f,0.7f,0.0f ); // Top
gl.glColor3f( 0.0f,1.0f,0.0f ); // green
gl.glVertex3f( -0.2f,-0.50f,0.0f ); // Bottom Left
gl.glColor3f( 0.0f,0.0f,1.0f ); // blue
gl.glVertex3f( 0.5f,-0.5f,0.0f ); // Bottom Right
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
// method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
TriangleColor triangle = new TriangleColor();
glcanvas.addGLEventListener( triangle );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" Colored Triangle");
//adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize());
frame.setVisible( true );
} //end of main
} //end of class
Quando você compila e executa o programa acima, obtém o seguinte triângulo colorido -
Aplicação de cor a um polígono
Vamos seguir o programa para aplicar cores a um polígono -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class PolygonColor implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glColor3f( 1f,0f,0f ); //applying red
gl.glBegin( GL2.GL_POLYGON );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( -0.5f,0.2f,0f );
gl.glVertex3f( -0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( 0.5f,0.2f,0f );
gl.glVertex3f( 0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
// method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
PolygonColor polygon = new PolygonColor();
glcanvas.addGLEventListener( polygon );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame ( "Colored Polygon" );
//adding canvas to frame
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
} //end of main
} //end of class
Quando você compila e executa o programa acima, obtém o seguinte polígono colorido -
Este capítulo ensina como dimensionar um objeto, ou seja, aumentar ou diminuir o tamanho de um objeto usando JOGL.
O dimensionamento de um objeto é feito usando o glScalef(float x, float y, float z) método de GLMatrixFuncinterface. Este método aceita três parâmetros de ponto flutuante, usando os quais especificamos os fatores de escala ao longo dos eixos x, y e z, respectivamente.
Por exemplo, no programa a seguir, um triângulo é reduzido para 50%. Aqui, o valor 50 é passado como parâmetro ao longo de todos os eixos.
Vamos seguir o programa para dimensionar um triângulo -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Scaling implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glScalef( 0.50f,0.25f,0.50f );
gl.glBegin( GL2.GL_TRIANGLES );
// Drawing Using Triangles
gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
gl.glVertex3f( 0.5f,0.7f,0.0f ); // Top
gl.glColor3f( 0.0f,1.0f,0.0f ); // blue
gl.glVertex3f( -0.2f,-0.50f,0.0f ); // Bottom Left
gl.glColor3f( 0.0f,0.0f,1.0f ); // green
gl.glVertex3f( 0.5f,-0.5f,0.0f ); // Bottom Right
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
// method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Scaling scaling = new Scaling();
glcanvas.addGLEventListener( scaling );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" Dimnished Triangle (Scaling )");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
} //end of main
} //end of classimport javax.media.opengl.GL2;
Ao compilar e executar o programa acima, obtemos a seguinte saída. Aqui, você pode observar um triângulo diminuto em comparação com o triângulo original produzido por TriangleColor.java -
Neste capítulo, explicamos como girar um objeto usando JOGL. A rotação de objetos pode ser feita ao longo de qualquer um dos três eixos, usando oglRotatef(float angle, float x, float y, float z) método de GLMatrixFuncinterface. Você precisa passar um ângulo de rotação ex os eixos x, y, z como parâmetros para este método.
As etapas a seguir o guiam para girar um objeto com sucesso -
Limpe o buffer de cor e o buffer de profundidade inicialmente usando gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT)método. Este método apaga o estado anterior do objeto e torna a visão clara.
Reinicie a matriz de projeção usando o glLoadIdentity() método.
Instancie a classe do animador e inicie o animador usando o start() método.
Classe FPSAnimator
Abaixo estão os vários construtores da classe FPSAnimator.
Sr. Não. | Métodos e Descrições |
---|---|
1 | FPSAnimator(GLAutoDrawable drawable, int fps) Ele cria um FPSAnimator com um determinado valor de quadros por segundo de destino e um drawable inicial para animar. |
2 | FPSAnimator(GLAutoDrawable drawable, int fps, boolean cheduleAtFixedRate) Ele cria um FPSAnimator com um determinado valor de quadros por segundo de destino, um drawable inicial para animar e um sinalizador indicando se deve ser usado o agendamento de taxa fixa. |
3 | FPSAnimator(int fps) Ele cria um FPSAnimator com um determinado valor de quadros por segundo de destino. |
4 | Ele cria um FPSAnimator com um determinado valor de quadros por segundo de destino e um sinalizador indicando se deve ser usado o agendamento de taxa fixa. |
Ele cria um FPSAnimator com um determinado valor de quadros por segundo de destino e um sinalizador indicando se deve ser usado o agendamento de taxa fixa.
start() e stop()são os dois métodos importantes nesta classe. O programa a seguir mostra como girar um triângulo usando a classe FPSAnimator -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class TriangleRotation implements GLEventListener {
private float rtri; //for angle of rotation
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glClear (GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT );
// Clear The Screen And The Depth Buffer
gl.glLoadIdentity(); // Reset The View
//triangle rotation
gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );
// Drawing Using Triangles
gl.glBegin( GL2.GL_TRIANGLES );
gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
gl.glVertex3f( 0.5f,0.7f,0.0f ); // Top
gl.glColor3f( 0.0f,1.0f,0.0f ); // blue
gl.glVertex3f( -0.2f,-0.50f,0.0f ); // Bottom Left
gl.glColor3f( 0.0f,0.0f,1.0f ); // green
gl.glVertex3f( 0.5f,-0.5f,0.0f ); // Bottom Right
gl.glEnd();
gl.glFlush();
rtri +=0.2f; //assigning the angle
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities);
TriangleRotation triangle = new TriangleRotation();
glcanvas.addGLEventListener( triangle );
glcanvas.setSize( 400, 400 );
// creating frame
final JFrame frame = new JFrame ("Rotating Triangle");
// adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane() .getPreferredSize());
frame.setVisible( true );
//Instantiating and Initiating Animator
final FPSAnimator animator = new FPSAnimator(glcanvas, 300,true);
animator.start();
}
} //end of main
} //end of class
Se você compilar e executar o programa acima, ele gerará a seguinte saída. Aqui, você pode observar vários instantâneos de um triângulo colorido girando em torno do eixo x.
Este capítulo explica como aplicar o efeito de iluminação a um objeto usando JOGL.
Para definir a iluminação, inicialmente habilite a iluminação usando o glEnable()método. Em seguida, aplique iluminação para os objetos, usando oglLightfv(int light, int pname, float[] params, int params_offset) método de GLLightingFuncinterface. Este método leva quatro parâmetros.
A tabela a seguir descreve os parâmetros de gllightfv() método.
Sr. Não. | Nome e descrição do parâmetro |
---|---|
1 | Light Especifica uma luz. O número de luzes depende da implementação, mas pelo menos oito luzes são suportadas. Ele aceita dez valores, esses parâmetros são discutidos em uma tabela separada chamada Parâmetros da fonte de luz fornecida a seguir. |
2 | Pname Especifica um parâmetro de fonte de luz de valor único. Para fonte de luz, existem dez parâmetros, conforme discutido abaixo. |
3 | Params Especifica um ponteiro para o valor ou valores definidos para o parâmetro pname da luz da fonte de luz . |
4 | Light source parameter Você pode usar qualquer um dos parâmetros da fonte de luz fornecidos abaixo. |
Parâmetros da fonte de luz
Sr. Não. | Parâmetro e Descrição |
---|---|
1 | GL_AMBIENT Ele contém os parâmetros que especificam a intensidade ambiente da luz. |
2 | GL_DIFFUSE Ele contém os parâmetros que especificam a intensidade difusa da luz. |
3 | GL_SPECULAR Ele contém os parâmetros que especificam a intensidade especular da luz. |
4 | GL_POSITION Ele contém quatro valores inteiros ou de ponto flutuante que especificam a posição da luz em coordenadas homogêneas do objeto. |
5 | GL_SPOT_DIRECTION Ele contém parâmetros que especificam a direção da luz em coordenadas homogêneas de objetos. |
6 | GL_SPOT_EXPONENT Seus parâmetros especificam a distribuição da intensidade da luz. |
7 | GL_SPOT_CUTOFF O único parâmetro especifica o ângulo máximo de propagação da luz. |
8 | GL_CONSTANT_ATTENUATION or GL_LINEAR_ATTENUATION or GL_QUADRATIC_ATTENUATION Você pode usar qualquer um desses fatores de atenuação, que é representado por um único valor. |
A iluminação é ativada ou desativada usando glEnable() e glDisable () métodos com o argumento GL_LIGHTING.
O seguinte modelo é fornecido para iluminação -
gl.glEnable(GL2.GL_LIGHTING);
gl.glEnable(GL2.GL_LIGHT0);
gl.glEnable(GL2.GL_NORMALIZE);
float[] ambientLight = { 0.1f, 0.f, 0.f,0f }; // weak RED ambient
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambientLight, 0);
float[] diffuseLight = { 1f,2f,1f,0f }; // multicolor diffuse
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuseLight, 0);
Aplicação de luz a um polígono giratório
Siga as etapas fornecidas para aplicar luz a um polígono em rotação.
Gire o polígono usando o método glRotate ()
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
// Clear The Screen And The Depth Buffer
gl.glLoadIdentity();
// Reset The View
gl.glRotatef(rpoly, 0.0f, 1.0f, 0.0f);
Vamos prosseguir com o programa para aplicar luz a um polígono em rotação -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class PolygonLighting implements GLEventListener {
private float rpoly;
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glColor3f(1f,0f,0f); //applying red
// Clear The Screen And The Depth Buffer
gl.glClear( GL2.GL_COLOR_BUFFER_BIT |
GL2.GL_DEPTH_BUFFER_BIT );
gl.glLoadIdentity(); // Reset The View
gl.glRotatef( rpoly, 0.0f, 1.0f, 0.0f );
gl.glBegin( GL2.GL_POLYGON );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( -0.5f,0.2f,0f );
gl.glVertex3f( -0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( 0.5f,0.2f,0f );
gl.glVertex3f( 0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glEnd();
gl.glFlush();
rpoly += 0.2f; //assigning the angle
gl.glEnable( GL2.GL_LIGHTING );
gl.glEnable( GL2.GL_LIGHT0 );
gl.glEnable( GL2.GL_NORMALIZE );
// weak RED ambient
float[] ambientLight = { 0.1f, 0.f, 0.f,0f };
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient-Light, 0);
// multicolor diffuse
float[] diffuseLight = { 1f,2f,1f,0f };
gl.glLightfv( GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse-Light, 0 );
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
// method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
PolygonLighting polygonlighting = new PolygonLighting();
glcanvas.addGLEventListener( polygonlighting );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" Polygon lighting ");
//adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize());
frame.setVisible( true );
//Instantiating and Initiating Animator
final FPSAnimator animator = new FPSAnimator(glcanvas, 300,true );
animator.start();
} //end of main
} //end of class
Se você compilar e executar o programa acima, ele gerará a seguinte saída. Aqui, você pode observar vários instantâneos de um polígono giratório com iluminação.
Nos capítulos anteriores, vimos como criar objetos 2D, aplicar efeitos a eles e transformar o objeto. Este capítulo ensina como desenhar uma linha com a 3ª dimensão e algumas formas.
Vamos desenhar uma linha simples com o eixo z e ver a diferença entre as linhas 2D e 3D. Desenhe uma linha simples primeiro, depois desenhe a segunda linha com 3 unidades na janela.
Vamos seguir o programa para desenhar uma linha 3D -
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
public class Line3d implements GLEventListener {
private GLU glu = new GLU();
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glTranslatef( 0f, 0f, -2.5f );
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.75f,0f,0 );
gl.glVertex3f( 0f,-0.75f, 0 );
gl.glEnd();
//3d line
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.75f,0f,3f );// 3 units into the window
gl.glVertex3f( 0f,-0.75f,3f );
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
// method body
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
GL2 gl = drawable.getGL().getGL2();
if( height <= 0 )
height = 1;
final float h = ( float ) width / ( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Line3d line3d = new Line3d();
glcanvas.addGLEventListener( line3d );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" 3d line");
//adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
}//end of main
}//end of class
Quando você compila e executa o programa acima, a seguinte saída é gerada -
Formas 3D podem ser desenhadas dando valores diferentes de zero ao quadrante z do glVertex3f()método, que gera a visualização acima. Agora, juntar as linhas restantes levará a uma borda 3D.
Agora, da mesma forma, vamos desenvolver uma vantagem com a 3ª dimensão.
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
public class Edge1 implements GLEventListener {
private GLU glu = new GLU();
@Override
public void display(GLAutoDrawable drawable) {
// TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
gl.glTranslatef(0f, 0f, -2.5f);
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(0f,-0.75f, 0);
gl.glEnd();
//3d line
gl.glBegin(GL2.GL_LINES);
//3 units in to the window
gl.glVertex3f(-0.75f,0f,3f);
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
//top
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
//bottom
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
// TODO Auto-generated method stubfinal
GL2 gl = drawable.getGL().getGL2();
if(height <= 0)
height = 1;
final float h = (float) width / (float) height;
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Edge1 b = new Edge1();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" 3d edge");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of class
Quando você compila e executa o programa acima, a seguinte saída é gerada -
Da mesma forma, desenvolvendo arestas 3D para lados correspondentes de qualquer quadrilátero 2D e juntando os vértices adjacentes, você pode obter um quadrilátero 3D.
Abaixo é fornecido um programa para desenhar um losango usando JOGL.
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
public class Rhombus implements GLEventListener {
private GLU glu = new GLU();
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glTranslatef(0f, 0f, -2.5f);
//drawing edge1.....
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(0f,-0.75f, 0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,3f); // 3 units into the window
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
//top
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
// bottom
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
// edge 2....
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0.75f,0f, 0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 3f);
gl.glVertex3f(0.75f,0f, 3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0f,-0.75f, 3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f, 0);
gl.glVertex3f(0.75f,0f, 3f);
gl.glEnd();
//Edge 3.............
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f(-0.75f,0f,0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
//final edge
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f, 0);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f,3f);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f, 0);
gl.glVertex3f(0.75f,0f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
// method body
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
// TODO Auto-generated method stub final
GL2 gl = drawable.getGL().getGL2();
if(height lt;= 0)
height = 1;
final float h = (float) width / (float) height;
gl.glViewport(3, 6, width, height);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Rhombus b = new Rhombus();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" Rhombus 3d");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;
Quando você compila e executa o programa acima, a seguinte saída é gerada. Mostra um losango desenhado com linhas 3D.
Os parâmetros predefinidos de glBegin() método pode ser usado para desenhar formas 3D.
No capítulo anterior, vimos como desenhar formas 3D, este capítulo ensina como desenhar triângulos 3D e girá-los.
Abaixo, está o programa para desenhar um triângulo 3D e girá-lo.
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class Triangle3d implements GLEventListener {
private GLU glu = new GLU();
private float rtri = 0.0f;
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
// Clear The Screen And The Depth Buffer
gl.glClear( GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT );
gl.glLoadIdentity(); // Reset The View
gl.glTranslatef( -0.5f, 0.0f, -6.0f ); // Move the triangle
gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );
gl.glBegin( GL2.GL_TRIANGLES );
//drawing triangle in all dimensions
// Front
gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top Of Triangle (Front)
gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Left Of Triangle (Front)
gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Right Of Triangle (Front)
// Right
gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top Of Triangle (Right)
gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Left Of Triangle (Right)
gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Right Of Triangle (Right)
// Left
gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top Of Triangle (Back)
gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Left Of Triangle (Back)
gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Right Of Triangle (Back)
//left
gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top Of Triangle (Left)
gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Left Of Triangle (Left)
gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Right Of Triangle (Left)
gl.glEnd(); // Done Drawing 3d triangle (Pyramid)
gl.glFlush();
rtri += 0.2f;
}
@Override
public void dispose( GLAutoDrawable drawable ) {
//method body
}
@Override
public void init( GLAutoDrawable drawable ) {
//method body
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
// TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if(height lt;=;)
height = 1;
final float h = ( float ) width / ( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
// TODO Auto-generated method stub
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Triangle3d triangle = new Triangle3d();
glcanvas.addGLEventListener( triangle );
glcanvas.setSize( 400, 400 );
final JFrame frame = new JFrame ( "3d Triangle (shallow)" );
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
final FPSAnimator animator = new FPSAnimator(glcanvas,300,true);
animator.start();
}
}
Quando você compila e executa o programa acima, a seguinte saída é gerada. Aqui, você tem os instantâneos do triângulo 3D giratório. Como este programa não inclui teste de profundidade, o triângulo é gerado oco.
Para tornar o triângulo sólido, você precisa habilitar o teste de profundidade usando glEnable(GL_DEPTH_TEST). A ativação do buffer de profundidade fornece uma tela em branco. Isso pode ser limpo limpando a cor usandoglClear(GL_COLOR_BUFFERBIT | GL_DEPTH_BUFFER_BIT)método. Para habilitar o teste de profundidade no método init () ou noglDisplay() método, escreva o seguinte código -
public void init(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel(GL2.GL_SMOOTH);
gl.glClearColor(0f, 0f, 0f, 0f);
gl.glClearDepth(1.0f);
gl.glEnable(GL2.GL_DEPTH_TEST);
gl.glDepthFunc(GL2.GL_LEQUAL);
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
}
Abaixo é fornecido o programa para desenhar um triângulo 3D com teste de profundidade.
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class Triangledepthtest implements GLEventListener {
private GLU glu = new GLU();
private float rtri = 0.0f;
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel( GL2.GL_SMOOTH );
gl.glClearColor( 0f, 0f, 0f, 0f );
gl.glClearDepth( 1.0f );
gl.glEnable( GL2.GL_DEPTH_TEST );
gl.glDepthFunc( GL2.GL_LEQUAL );
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
// Clear The Screen And The Depth Buffer
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity(); // Reset The View
gl.glTranslatef( -0.5f,0.0f,-6.0f ); // Move the triangle
gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );
gl.glBegin( GL2.GL_TRIANGLES );
//drawing triangle in all dimensions
//front
gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Left
gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Right)
//right
gl.glColor3f( 1.0f, 0.0f, 0.0f );
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
gl.glColor3f( 0.0f, 0.0f, 1.0f );
gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Left
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Right
//left
gl.glColor3f( 1.0f, 0.0f, 0.0f );
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Left
gl.glColor3f( 0.0f, 0.0f, 1.0f );
gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Right
//top
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
gl.glColor3f( 0.0f, 0.0f, 1.0f );
gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Left
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Right
gl.glEnd(); // Done Drawing 3d triangle (Pyramid)
gl.glFlush();
rtri += 0.2f;
}
@Override
public void dispose( GLAutoDrawable drawable ) {
}
@Override
public void init( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel( GL2.GL_SMOOTH );
gl.glClearColor( 0f, 0f, 0f, 0f );
gl.glClearDepth( 1.0f );
gl.glEnable( GL2.GL_DEPTH_TEST );
gl.glDepthFunc( GL2.GL_LEQUAL );
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST );
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height ) {
// TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if( height <= 0 )
height = 1;
final float h = ( float ) width / ( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
// TODO Auto-generated method stub
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Triangledepthtest triangledepthtest = new Triangledepthtest();
glcanvas.addGLEventListener( triangledepthtest );
glcanvas.setSize( 400, 400 );
final JFrame frame = new JFrame ( "3d Triangle (solid)" );
frame.getContentPane().add(glcanvas);
frame.setSize( frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
final FPSAnimator animator = new FPSAnimator( glcanvas, 300,true);
animator.start();
}
}
Quando você compila e executa o programa acima, a seguinte saída é gerada.
Aqui, você pode ver os instantâneos de um triângulo 3D giratório. Visto que este programa inclui código para teste de profundidade, o triângulo é gerado sólido.
Nos capítulos anteriores, vimos como desenhar um triângulo 3d e girá-lo. Agora neste capítulo você pode aprender como fazer um cubo 3d, como girá-lo, como anexar uma imagem a ele. Da mesma forma, este capítulo fornece exemplos para desenhar um cubo 3D e aplicar cores a ele e anexar imagens a ele.
Abaixo, está o programa para desenhar um cubo 3D e aplicar cores a ele.
import java.awt.DisplayMode;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class Cube implements GLEventListener {
public static DisplayMode dm, dm_old;
private GLU glu = new GLU();
private float rquad = 0.0f;
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT );
gl.glLoadIdentity();
gl.glTranslatef( 0f, 0f, -5.0f );
// Rotate The Cube On X, Y & Z
gl.glRotatef(rquad, 1.0f, 1.0f, 1.0f);
//giving different colors to different sides
gl.glBegin(GL2.GL_QUADS); // Start Drawing The Cube
gl.glColor3f(1f,0f,0f); //red color
gl.glVertex3f(1.0f, 1.0f, -1.0f); // Top Right Of The Quad (Top)
gl.glVertex3f( -1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Top)
gl.glVertex3f( -1.0f, 1.0f, 1.0f ); // Bottom Left Of The Quad (Top)
gl.glVertex3f( 1.0f, 1.0f, 1.0f ); // Bottom Right Of The Quad (Top)
gl.glColor3f( 0f,1f,0f ); //green color
gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Top Right Of The Quad
gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Top Left Of The Quad
gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Bottom Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Bottom Right Of The Quad
gl.glColor3f( 0f,0f,1f ); //blue color
gl.glVertex3f( 1.0f, 1.0f, 1.0f ); // Top Right Of The Quad (Front)
gl.glVertex3f( -1.0f, 1.0f, 1.0f ); // Top Left Of The Quad (Front)
gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Bottom Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Bottom Right Of The Quad
gl.glColor3f( 1f,1f,0f ); //yellow (red + green)
gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Bottom Left Of The Quad
gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Bottom Right Of The Quad
gl.glVertex3f( -1.0f, 1.0f, -1.0f ); // Top Right Of The Quad (Back)
gl.glVertex3f( 1.0f, 1.0f, -1.0f ); // Top Left Of The Quad (Back)
gl.glColor3f( 1f,0f,1f ); //purple (red + green)
gl.glVertex3f( -1.0f, 1.0f, 1.0f ); // Top Right Of The Quad (Left)
gl.glVertex3f( -1.0f, 1.0f, -1.0f ); // Top Left Of The Quad (Left)
gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Bottom Left Of The Quad
gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Bottom Right Of The Quad
gl.glColor3f( 0f,1f, 1f ); //sky blue (blue +green)
gl.glVertex3f( 1.0f, 1.0f, -1.0f ); // Top Right Of The Quad (Right)
gl.glVertex3f( 1.0f, 1.0f, 1.0f ); // Top Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Bottom Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Bottom Right Of The Quad
gl.glEnd(); // Done Drawing The Quad
gl.glFlush();
rquad -= 0.15f;
}
@Override
public void dispose( GLAutoDrawable drawable ) {
// TODO Auto-generated method stub
}
@Override
public void init( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel( GL2.GL_SMOOTH );
gl.glClearColor( 0f, 0f, 0f, 0f );
gl.glClearDepth( 1.0f );
gl.glEnable( GL2.GL_DEPTH_TEST );
gl.glDepthFunc( GL2.GL_LEQUAL );
gl.glHint( GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST );
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
// TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if( height lt;= 0 )
height = 1;
final float h = ( float ) width / ( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
// The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Cube cube = new Cube();
glcanvas.addGLEventListener( cube );
glcanvas.setSize( 400, 400 );
final JFrame frame = new JFrame ( " Multicolored cube" );
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
final FPSAnimator animator = new FPSAnimator(glcanvas, 300,true);
animator.start();
}
}
Quando você compila e executa o programa acima, a seguinte saída é gerada. Mostra um cubo 3D colorido.
Aplicando textura ao cubo
As etapas a seguir são fornecidas para aplicar textura a um cubo -
Você pode vincular a textura necessária ao cubo usando o gl.glBindTexture(GL2.GL_TEXTURE_2D.texture) método da interface Drawable.
Este método requer argumento de textura (int) junto com GL2.GL_TEXTURE_2D(int).
Antes de executar Display(), você precisa criar uma variável de textura
No init() método ou nas linhas iniciais de glDisplay() método, habilite a textura using gl.glEnable(GL2.GL_TEXTURE_2D) método.
Crie o objeto de textura, que precisa de um objeto de arquivo como parâmetro, que por sua vez precisa do caminho da imagem usada como textura para o objeto.
File file = new File(“c:\\pictures\\boy.jpg”);
Texture t = textureIO.newTexture(file, true);
texture = t.getTextureObject(gl);
- Lidar com a exceção 'arquivo não encontrado'
Abaixo fornecido é o programa para anexar imagem em um cubo.
import java.awt.DisplayMode;
import java.io.File;
import java.io.IOException;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
import com.jogamp.opengl.util.texture.Texture;
import com.jogamp.opengl.util.texture.TextureIO;
public class CubeTexture implements GLEventListener {
public static DisplayMode dm, dm_old;
private GLU glu = new GLU();
private float xrot,yrot,zrot;
private int texture;
@Override
public void display(GLAutoDrawable drawable) {
// TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity(); // Reset The View
gl.glTranslatef(0f, 0f, -5.0f);
gl.glRotatef(xrot, 1.0f, 1.0f, 1.0f);
gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);
gl.glRotatef(zrot, 0.0f, 0.0f, 1.0f);
gl.glBindTexture(GL2.GL_TEXTURE_2D, texture);
gl.glBegin(GL2.GL_QUADS);
// Front Face
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, -1.0f);
// Bottom Face
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f);
// Left Face
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, -1.0f);
gl.glEnd();
gl.glFlush();
//change the speeds here
xrot += .1f;
yrot += .1f;
zrot += .1f;
}
@Override
public void dispose(GLAutoDrawable drawable) {
// method body
}
@Override
public void init(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel(GL2.GL_SMOOTH);
gl.glClearColor(0f, 0f, 0f, 0f);
gl.glClearDepth(1.0f);
gl.glEnable(GL2.GL_DEPTH_TEST);
gl.glDepthFunc(GL2.GL_LEQUAL);
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
//
gl.glEnable(GL2.GL_TEXTURE_2D);
try{
File im = new File("E:\\office\\boy.jpg ");
Texture t = TextureIO.newTexture(im, true);
texture= t.getTextureObject(gl);
}catch(IOException e){
e.printStackTrace();
}
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
// TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if(height lt;= 0)
height = 1;
final float h = (float) width / (float) height;
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
// The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
CubeTexture r = new CubeTexture();
glcanvas.addGLEventListener(r);
glcanvas.setSize(400, 400);
final JFrame frame = new JFrame (" Textured Cube");
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
final FPSAnimator animator = new FPSAnimator(glcanvas, 300, true);
animator.start();
}
}
Quando você compila e executa o programa acima, a seguinte saída é gerada. Você pode ver um cubo 3D com a textura desejada aplicada nele.
GPU - Unidade de processamento gráfico, é um dispositivo eletrônico especial que acelera a renderização de imagens.
JNI- Interface nativa Java. Usando o qual, java acessa métodos nativos.
Model - Eles são os objetos construídos a partir de primitivos gráficos básicos, como pontos, linhas e polígonos.
Pixel - Menor unidade de exibição vista na tela.
Projection - O método de mapear as coordenadas de um objeto em um plano bidimensional é chamado de projeção.
Projection matrix - É uma transformação linear de um objeto na superfície 2D.
Rendering - Um processo pelo qual o computador cria imagens de modelos.
Viewport - Uma janela de visualização é uma região de visualização na tela em computação gráfica.