J2ME/Lições/M3G/No GameCanvas

Preparando um gráfico no GameCanvas

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

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

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();
            }
        }
    }
}