J2ME/Lições/M3G/No GameCanvas

Adicionar hiperligações
Origem: Wikilivros, livros abertos por um mundo aberto.
< J2ME‎ | Lições‎ | M3G

Preparando um gráfico no GameCanvas[editar | editar código-fonte]

Inicializamos a ClasseMeuGameCanvas do mesmo jeito que fazemos com o GameCanvas normal, estendendo o GameCanvas, implementando o Runnable e colocando os objetos e métodos necessários. 

import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        boolean gameOver = false;
        while(!gameOver){
            try{
                meuThread.sleep(50);
            }catch(Exception minhaExcessao){
                minhaExcessao.printstackTrace();
            }finally{
                flushGraphics();
            }
        }
    }
}

Iniciando um gráfico 3D no GameCanvas[editar | editar código-fonte]

Vimos que a parte de inicialização do gráfico é igual a parte 2D, agora vamos criar o gráfico 3D em si, para isso vamos criar um objeto do tipo Graphics3D. 

import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        boolean gameOver = false;
        while(!gameOver){
            try{
                meuThread.sleep(50);
            }catch(Exception minhaExcessao){
                minhaExcessao.printStackTrace();
            }finally{
                flushGraphics();
            }
        }
    }
}

Agora nessa parte vamos fazer um pouco diferente do que em relação ao Canvas normal, para iniciar o gráfico 3D dentro do GameCanvas devemos obrigatoriamente criar um try-catch-finally dentro do método run(), nesse caso agora como a cada loop vamos sempre chamar o método flushGraphics() vamos coloca-lo dentro do finally. 

import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace)();
            } finally {
                flushGraphics();
            }
        }
    }
}

Agora podemos chamar os métodos padrões do Graphics3D, primeiramente dentro do try vamos chamar o gráfico3D para inicializar o gráfico através do método bindTarget() 

import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace)();
            } finally {
                flushGraphics();
            }
        }
    }
}

Agora vamos chamar o método releaseTarget() para soltar o gráfico 3D e deixar o programa correr normalmente, mas atente que faremos isso sempre dentro do finally, caso o programa não consiga inicializar o gráfico 3D. 

import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Exibindo um objeto em 3D no GameCanvas[editar | editar código-fonte]

Vamos agora ver como exibir um objeto criado externamente dentro do GameCanvas, primeiro crie normalmente um objeto .m3g em algum editor externo (não se esqueça de colocar a câmera e a luz) e salve na mesma pasta da sua classe.

Agora vamos importar primeiramente o pacote java.io para o projeto. 

import javax.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

Agora vamos criar a variável do tipo Object3D[]. 

import javax.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora dentro do método run(), mas antes do loop vamos criar um try-catch. 

import javax.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    
    public ClasseMeuGameCanvas() throws Exception {
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
        } catch(Exception minhaExcessao) {
            minhaExcecao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora vamos criar a variável do tipo Object3D[]. 

import javax.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    
    public ClasseMeuGameCanvas() throws Exception {
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
        } catch(Exception minhaExcessao) {
            minhaExcecao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Como sabemos, não se pode manipular objetos diretamente pelo Object3D[], temos que criar outro objeto do tipo World. 

import javax.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    World meuMundo;
    
    public ClasseMeuGameCanvas() throws Exception {
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
        } catch(Exception minhaExcessao) {
            minhaExcecao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora dentro do try-catch vamos converter o nosso objeto do tipo Object3D[] para o tipo World. 

import javax.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    World meuMundo;
    
    public ClasseMeuGameCanvas() throws Exception {
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
        } catch(Exception minhaExcessao) {
            minhaExcecao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrance)();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora vamos colocar o nosso World para ser renderizado no nosso gráfico 3D, vamos colocar o método render() dentro do run() logo após o bindTarget(). 

import javax.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;
import javax.microedition.game.*;

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    World meuMundo;
    
    public ClasseMeuGameCanvas() throws Exception {
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
        } catch(Exception minhaExcessao) {
            minhaExcecao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(!gameOver){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrance)();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}
Obtido em "https://pt.wikibooks.org/w/index.php?title=J2ME/Lições/M3G/No_GameCanvas&oldid=462925"