Usuário: Fábio Campos
Categoria: Java
Visualizações: 1238
Primeira Janela em LWJGL
Este tutorial é o primeiro que escrevo, não sou programador, por isso meus códigos talvez tenham falhas, ou não sejam escritos da melhor forma possível, faço isso como hobby pois gosto muito de programação e computação gráfica, e é o primeiro de uma série de tutoriais que pretendo escrever sobre LWJGL e OpenGL, ele é baseado nos tutoriais do site http://nehe.gamedev.net, tentei escrevê-lo da melhor forma possível, espero que gostem.
Antes de entrar no código em si, precisamos configurar o ambiente. Para isso precisamos fazer o download da versão 2.4.2 da LWJGL, porque foi esta versão que eu usei para fazer os tutoriais. Vá até o site http://www.lwjgl.org/download.php e faça o download. Depois do download feito e API instalada, vamos criar uma variável de ambiente de usuário, com o nome de LWJGL_HOME e o valor dela será o local onde ela estiver instalada. Ex. C:\Java\lwjgl-2.4.2
Agora com o ambiente configurado, podemos dar início ao nosso tutorial.
Este tutorial é composto de 5 classes, 3 delas(GameCore, GameAction e ScreenManager) vocês vão utilizar em todos os tutoriais que eu escreverei, a classe Texture acompanhará todos os outros tutoriais, mas só será usada quando usarmos texturas nos nossos tutoriais. Neste tutorial não irei explicar todas elas em detalhes, pois seus códigos estão bem comentados(qualquer dúvida podem me mandar e-mails) mas eu explicarei o uso delas, explicarei em detalhes a classe GameCore e a classe principal que sempre terá o nome de Lesson+(número do tutorial).
Bom, vamos ao que interessa.
A classe GameCore é uma classe abstrata e ela é a base para criação da nossa primeira janela(a base de tudo que iremos fazer) e também é nela que criaremos nosso loop(laço) principal, que será usado para controlar o fluxo do nosso programa.
Os métodos, funções, variáveis, estão com os nomes em inglês, porque na minha opinião, isto facilita e integra a programação, pois todo material de pesquisa está em inglês, mas se alguém tiver dificuldade com os nomes em inglês é só me avisar.
A primeira coisa a fazer, é importar as classes e pacotes que iremos utilizar.
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.Display;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.gluPerspective;
import input.GameAction;
import org.lwjgl.Sys;
import java.io.IOException;
Depois das importações, declaramos a classe e definimos algumas variáveis que utilizaremos.
public abstract class GameCore {
// Cria um objeto do Tipo ScreenManager para gerenciar nossa janela
protected ScreenManager screen;
// Variável que controla o início e o término do programa
protected boolean isRunning;
// Variável que controla a variação de tempo que o programa irá iterar
protected float elapsedTime;
Nas duas linhas a seguir, criamos dois objetos do tipo GameAction para criarmos ações para interagir com o nosso programa, na linha seguinte declaramos uma variável para controlar a pausa no fluxo do programa.
public GameAction exit;
public GameAction fullScreen;
//Variável para controlar quando o programa irá pausar
private boolean paused;
Este é o método principal, ele é responsável pela inicialização e fluxo do programa
public void run()
{
try
{
init();
gameLoop();
}catch(IOException e)
{
e.printStackTrace();
Sys.alert("Erro", "Falhou: "+e.getMessage());
}
}
Agora criaremos um método que inicializa dois objetos GameAction criados no começo do nosso programa, os inicializamos passando como parâmetro, o nome da Ação, o tipo de acionamento de tecla(Normal ou Detectar somente o pressionamento inicial), nesse programa, definiremos para só detectar o clique inicial, e por fim definimos qual tecla será utilizada para a ação.
protected void createGameActions()
{
exit = new GameAction("Exit", GameAction.DETECT_INITIAL_PRESS_ONLY, Keyboard.KEY_ESCAPE);
fullScreen = new GameAction("FullScreen", GameAction.DETECT_INITIAL_PRESS_ONLY, Keyboard.KEY_F1);
}
Agora iremos criar a janela do nosso programa e vamos definir todos os estados iniciais da OpenGL.
protected void init() throws IOException
{
// Inicializa o objeto e define a janela com Resolução(800X600 e 32bits);
screen = new ScreenManager(800, 600, 32);
// Define a janela para não abrir em FullScreen(tela cheia) e sim no modo Window(janela)
setFullScreen(false);
screen.create(); // Cria janela
A próxima linha habilita o shade suave. Shade suave mistura as cores muito bem e suaviza a iluminação
glShadeModel(GL_SMOOTH); // Habilita Smooth Shading
As linhas a seguir definem a cor da janela quando ela sofre a operação de limpeza. Se você não sabe como as cores funcionam na OpenGL, eu explicarei rapidamente. Os valores das cores variam de 0.0f até 1.0f. 0.0f sendo o mais escuro e 1.0f o mais claro. O primeiro parâmetro depois do glClearColor é a intensidade de Vermelho, o segundo parâmetro é o Verde e o terceiro parâmetro é o Azul, assim formando o formato de cores RGB(Red-Vermelho, Green-Verde e Blue-Azul). Quanto mais próximo um número chegar de 1.0f, mais brilhante ou mais clara será aquela cor específica. O último e quarto número é um valor Alpha. Quando fazemos operação de limpeza da janela, não devemos nos preocupar com esse quarto valor. Por agora o deixe em 0.0f. Eu explicarei seu uso em outro tutorial.
Você pode criar diversas cores, apenas misturando as 3 cores primárias aditivas(Vermelho, Verde e Azul).
Então, se você tem glClearColor(0.0f,0.0f,1.0f,0.0f), você pode limpar a janela com a cor Azul. Se você tem glClearColor(0.5f,0.0f,0.0f,0.0f) você pode limpar a janela com um Vermelho médio. Nem claro(1.0f) e nem escuro(0.0f).
Para fazer um fundo de cor branca, você pode definir todas as cores para o máximo possível(1.0f). Para fazer um fundo de cor preta, você pode definir todas as cores para o mínimo possível(0.0f).
glClearColor(0.0f, 0.0f, 0.0f, 1.0f); //Limpa o fundo com a cor preta
As próximas 3 linhas são a respeito do Depth Buffer(Buffer de profundidade). Pense no Depth Buffer como camadas dentro da janela. O Depth Buffer controla o quão profundo os objetos estão na tela. Nós realmente não usaremos depth buffer neste tutorial, mas todos os programas em OpenGL, que desenham em 3D na tela usarão depth buffer. Ele classifica qual objeto será desenhado primeiro, assim um quadrado que você desenhou atrás de um círculo não aparecerá na frente dele.
O depth buffer é uma parte muito importante do OpenGL.
glClearDepth(1.0); // Define Depth Buffer
glEnable(GL_DEPTH_TEST); // Habilita teste de Profundidade
glDepthFunc(GL_LEQUAL); // Tipo de teste de profundidade que irá fazer
As linhas a seguir configuram a janela para ser visualizada em modo de perspectiva. Significa que quanto maior a distância do observador, menores os objetos ficarão. Isto cria uma cena com aspecto muito realista.
A perspectiva neste caso é calculada com um ângulo de visibilidade de 45 graus baseado na largura e altura da janela.
As distâncias 0.1f e 100.0f são respectivamente o ponto inicial e o ponto final, de quão distante podemos desenhar dentro da janela.
glMatrixMode(GL_PROJECTION)indica que as próximas 2 linhas de código afetarão a matriz de projeção.
A matriz de projeção é responsável por adicionar perspectiva para nossa cena. glLoadIdentity() é similar a um "reset", um reinício. Ele restaura a matriz selecionada, nesse caso a matriz de projeção, para o seu estado inicial. Depois de chamar glLoadIdentity(), nós configuraremos a perspectiva para nossa cena.
glMatrixMode(GL_MODELVIEW) indica que qualquer transformação(translação, rotação ou combinação dos dois) afetará a matriz ModelView.
A matriz ModelView é onde as informações referentes aos objetos são armazenadas. Finalmente nós reiniciamos nossa matriz ModelView.
glMatrixMode(GL_PROJECTION); // Selecione a Matriz de Projeção
glLoadIdentity(); // Reinicia a Matriz de Projeção
// Calcula a proporção da Janela
gluPerspective(45.0f, screen.getWidth() / screen.getHeight(), 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW); // Selecione a Matriz de ModelView
glLoadIdentity(); //Reinicia a Matriz ModelView
Na linha abaixo, nós diremos a OpenGL que nós queremos que seja feita a melhor correção de perspectiva possível. Isto causa uma pequenina queda de desempenho, mas faz com que a visão da perspectiva fique muito melhor.
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Define para ótimos cálculos de perspectiva
isRunning = true; // Define variável que dá início ao programa como verdadeiro
Aqui chamamos o método para criação das ações.
1- Quando clicarmos em F1 o programa troca o estado para FullScreen(Tela cheia) ou modo Window(Janela).
2- Quando clicarmos na tecla ESC, o programa termina.
createGameActions();
Métodos utilitários e auto-explicativos.
//Método que finaliza o programa
protected void stop()
{
isRunning = false;
Display.destroy();
System.exit(0);
}
//Método para definir FullScreen(Janela cheia) ou não.
protected void setFullScreen(boolean fullscreen)
{
screen.setFullScreen(fullscreen);
}
//Método que verifica se a Janela está em FullScreen(Tela cheia)
protected boolean isFullScreen()
{
return screen.isFullscreen();
}
//Método que verifica se o programa está no modo pause
protected boolean isPaused()
{
return paused;
}
//Método para entrar ou sair do modo pause, a função do método depende do estado do programa, pausado ou rodando
protected void setPaused()
{
paused = !paused;
}
Este é o loop(laço) principal do nosso programa, depois de iniciado só terminará ao chamar o método stop()
public void gameLoop()
{
// Variável que recebe o tempo inicial
long startTime = Sys.getTime();
// Variável que recebe o tempo corrente(inicialmente igual ao tempo inicial)
long currTime = startTime;
while (isRunning)
{
// Calcula o quanto passou desde que nós entramos neste loop
// e guarda este valor para que as rotinas de update(atualizar)
// e render(desenhar) saibam quanto tempo tem para atualização e desenho.
elapsedTime = (float)(Sys.getTime() - currTime);
elapsedTime /= 1000; // tempo em milisegundos
update(elapsedTime);
render(); //chama método desenhar
currTime = Sys.getTime(); //recebe o tempo corrente do sistema
// Finalmente dizemos para o Display fazer uma atualização.
// agora que nós desenhamos toda nossa cena, nós apenas atualizamos ela
// na janela.
screen.update();
// Se o usuário fechar a janela, apertando CTRL+F4, ou clicando no
// no botão de fechar então nós precisamos parar o looping e terminar o programa.
if (screen.isCloseRequested())
{
stop();
}
}
}
Método com implementação básica que será usado para atualizar estados de objetos. Para uma maior utilidade, deve ser sobrescrito numa classe filha concreta.
protected void update(float elapsedTime)
{
checkSystemInput();
checkGameInput();
}
Verifica se a ação de saída(a tecla correspondente a ação) foi pressionada.
protected void checkSystemInput()
{
if (exit.isPressed())
{
stop();
}
}
Verifica se as teclas utilizadas nos nossos programas foram pressionadas. Este método deve ser sobrescrito em classes filhas de acordo com a funcionalidade do programa a ser escrito.
protected void checkGameInput()
{
if (fullScreen.isPressed())
{
setFullScreen(!isFullScreen());
}
}
Finalmente chegamos ao fim da classe GameCore, o último método, é o método abstrato chamado render(). Por ele ser abstrato, obriga a classe filha a implementá-lo. Deve conter a rotina de desenho.
protected abstract void render();
}
Bom, agora que já expliquei o funcionamento do "coração" do nosso tutorial e dos que ainda estão por vir.
Vamos à classe principal, a classe que executará nosso primeiro programa e que é filha da GameCore, a Lesson01. Ela não fará nada em especial, pois esse programa é só uma introdução. A única coisa que ela fará, é abrir uma janela com fundo preto, que foi a cor que definimos na classe GameCore e que vocês poderão mudar para fazer testes.
Finalmente, uma das coisas mais importantes, é como vamos compilar e rodar nosso programa.
Compilação
Bom, para compilarmos podemos criar um arquivo batch(.bat), com a seguinte linha:
javac -cp ;%LWJGL_HOME%\jar\lwjgl.jar;%LWJGL_HOME%\jar\jinput.jar;%LWJGL_HOME%\jar\lwjgl_util.jar %1
"LWJGL_HOME" é a variável que diz qual o caminho que está instalada nossa API LWJGL e nós aprendemos a configurá-la no começo do tutorial, e o "%1" será o nome do arquivo(.java) da classe principal que iremos definir na execução do arquivo .bat.
Um exemplo seria:
C:\Licao1>compile.bat Lesson01.java
Onde:
Licao01 é o nome da pasta que se encontra as classes do seu programa.
compile.bat é o nome do arquivo que contém a linha de compilação descrita acima.
Lesson01.java é o nome do arquivo java da classe principal
Execução
Agora que compilamos nosso programa e já temos nossos arquivos .class, podemos enfim executar nosso primeiro programa. Para isso temos que fazer outro arquivo batch(.bat), alguns de vocês podem estar se perguntando, para que fazer batchs para compilar e executar os programas? Bom, isso é só para facilitar a compilação e execução deste e de todos os outros tutoriais, porque o único parâmetro que mudaremos de um tutorial para o outro, é o nome do arquivo .java e do .class que chamaremos na linha de comando.
Para executarmos, podemos criar um arquivo batch(.bat), com a seguinte linha:
java -cp ;%LWJGL_HOME%\jar\lwjgl.jar;%LWJGL_HOME%\jar\jinput.jar;%LWJGL_HOME%\jar\lwjgl_util.jar; -Djava.library.path=%LWJGL_HOME%\native\windows %1
As variáveis são as mesmas descritas acima na parte de compilação, as únicas mudanças são o nome do arquivo .bat e da classe a ser executada.
Um exemplo seria:
C:\Licao1>Exceuta.bat Lesson01
Nosso primeiro tutorial e introdução ao LWJGL chegou ao fim, espero que tenham gostado.
Neste turorial eu tentei explicar tudo em muitos detalhes, como você pode criar a sua primeira janela em OpenGL e LWJGL.
Se você tiver algum comentário, sugestão ou perguntas, se você achou algum comentário errado da minha parte, ou um código que pode ser escrito de uma forma melhor, por favor me avise.
Eu quero escrever tutoriais de LWJGL simples e de fácil entendimento por todos, e o melhor de tudo na nossa língua, coisa que
temos pouco na net.
Obrigado. Até o próximo tutorial.
Fábio Campos.(fabcampos@hotmail.com)
Download Licao01
|
