Saltar para o conteúdo

J2ME/Lições/M3G/Modificando objetos 3D

Adicionar hiperligações
Origem: Wikilivros, livros abertos por um mundo aberto.

Vamos entrar agora na parte de modificação dos objetos .m3g carregados no J2ME, vamos utilizar isso através do objeto for tipo World que criamos, na verdade esse objeto servirá como uma ponte de ligação entre o programador e os nódulos do objeto 3D em si.

Translação de um objeto

[editar | editar código-fonte]

Vamos inicialmente aprender como translatar um nódulo do objeto 3D, quando se fala em translação você deve pensar em um movimento giratório que a Terra faz no sol, no mundo 3D não é bem assim, na verdade a translação nada mais é que a posição dos eixos x, y, z dentro do espaço.

Primeiramente vamos translatar a câmera que você criou e armazenou no arquivo .m3g, para isso vamos criar um objeto do tipo Camera() e inicializa-lo. 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        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) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Criamos a variável minhaCamera, mas nenhuma câmera foi colocada lá, agora vamos fazer isso através do nosso objeto do tipo World, utilizando o método getActiveCamera(). 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora com a câmera armazanada vamos movimenta-la, para isso só precisamos pegar emprestado da classe World o método setTranslation() que irá receber 3 variáveis float, que serão respectivamente o eixo x, y e z. 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Excepetion minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                minhaCamera.setTranslation(1.0f, 3.0f, 2.0f);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Pegando a translação de um objeto

[editar | editar código-fonte]

Vamos ver agora como pegar a translação (posição dentro do mundo) de um objeto, vamos usar o mesmo exemplo anterior. 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                minhaCamera.setTranslation(1.0f, 3.0f, 2.0f);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Vamos pegar a posição X, Y e Z da câmera, para isso vamos inicialmente criar um array float de 3 posições chamado posicaoCamera[], e inicia-lo com 0. 

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    World meuMundo;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        float[] posicaoCamera = {0.0, 0.0, 0.0};
        
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                minhaCamera.setTranslation(1.0f, 3.0f, 2.0f);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora dentro do loop principal vamos usar o método getTranslation() e entrar como parâmetro a variável float que criamos que vai pegar os 3 atributos X, Y e Z nessa ordem, como saída vamos dar um System.out.println() para exibir cada posição. 

public class ClasseMeuGameCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics meuGrafico = this.getGraphics();
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    World meuMundo;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        float[] posicaoCamera = {0.0, 0.0, 0.0};
        
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                minhaCamera.setTranslation(1.0f, 3.0f, 2.0f);
                minhaCamera.getTranslation(posicaoCamera);
                System.out.println(posicaoCamera[0]);
                System.out.println(posicaoCamera[1]);
                System.out.println(posicaoCamera[2]);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Orientação de um objeto

[editar | editar código-fonte]

Vamos agora ver como orientar (rotacionar) um objeto 3D, vamos fazer como anteriormente, carregar o objeto, coloca-lo no objeto World e colocar a câmera na classe Camera. 

 //arquivo ClasseMeuCanvas.java
 import java.io.*;
 import javax.microedition.lcdui.*;
 import javax.microedition.m3g.*;
 
 public class ClasseMeuCanvas extends GameCanvas implements Runnable {
     Thread meuThread;
     Graphics3D meuGrafico3D = Graphics3D.getInstance();
     Object3D[] meuObjeto3D;
     World meuMundo;
     Camera minhaCamera = new Camera();
     
     ClasseMeuCanvas(){
         super(false)
         meuThread = new Thread(this);
         meuThread.start();
     }

     public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
     }
 }

Vamos agora utilizar o método setOrientation() e entrar como parâmetro respectivamente o angulo, o componente de roatação X, o componente de roatação Y e o componente de roatação Z. Esses componentes de rotação se colocados como 0 não irão alterar o eixo de rotação. 


 //arquivo ClasseMeuCanvas.java
 import java.io.*;
 import javax.microedition.lcdui.*;
 import javax.microedition.m3g.*;
 
 public class ClasseMeuCanvas extends GameCanvas implements Runnable {
     Thread meuThread;
     Graphics3D meuGrafico3D = Graphics3D.getInstance();
     Object3D[] meuObjeto3D;
     World meuMundo;
     Camera minhaCamera = new Camera();
     
     ClasseMeuCanvas(){
         super(false)
         meuThread = new Thread(this);
         meuThread.start();
     }

     public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                minhaCamera.setOrientation(10, 1, 2, 0);
                meuThread.sleep(50);
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
     }
 }

No exemplo a câmera irá girar 10 graus no eixo X, 20 graus no eixo Y, e 0 graus no eixo Z.

Pegando a orientação de um objeto

[editar | editar código-fonte]

Vamos ver agora como pegar a orientação de um objeto, vamos usar o mesmo exemplo anterior. 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                if (meuMundo != null) {
                    minhaCamera.setOrientation(10.0f, 0.0f, 1.0f, 2.0f);
                    meuGrafico3D.render(meuMundo);
                }
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Vamos pegar a rotação X, Y e Z da câmera, para isso vamos inicialmente criar um array float agora de 4 posições chamado orientacaoCamera[], e inicia-lo com 0. 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        float[] orientacaoCamera = {0.0, 0.0, 0.0, 0.0};
        
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                if (meuMundo != null) {
                    minhaCamera.setOrientation(10.0f, 0.0f, 1.0f, 2.0f);
                    meuGrafico3D.render(meuMundo);
                }
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora dentro do loop principal vamos usar o método getOrientation() e entrar como parâmetro a variável float que criamos que vai pegar os 4 atributos, como saída vamos dar um System.out.println() para exibir cada um. 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        float[] orientacaoCamera = {0.0, 0.0, 0.0, 0.0};
        
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                if (meuMundo != null) {
                    minhaCamera.setOrientation(10.0f, 0.0f, 1.0f, 2.0f);
                    minhaCamera.getOrientation(orientacaoCamera);
                    System.out.println(orientacaoCamera[0]);
                    System.out.println(orientacaoCamera[1]);
                    System.out.println(orientacaoCamera[2]);
                    System.out.println(orientacaoCamera[3]);
                    meuGrafico3D.render(meuMundo);
                }
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Pegando um objeto específico

[editar | editar código-fonte]

O World no M3G pode conter várias câmeras, meshes, luzes, etc, vamos ver aqui como pegar cada um desses objetos. Primeiramente é bom no seu editor 3D nomear cada objeto com um número, quando esse arquivo for salvo ficará mais fácil de você pegar a identificação do objeto através de um número inteiro.

Primeiramente vamos pegar os exemplos anteriores. 

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;
    Camera minhaCamera = new Camera();
    
    public ClasseMeuGameCanvas(){
        super(false);
         meuThread = new Thread(this);
         meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                if (meuMundo != null) {
                    meuGrafico3D.render(meuMundo);
                }
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora vamos criar o objeto Node, que é o objeto que pode pegar a referência de uma câmera, mesh, luz, etc... 

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;
    Camera minhaCamera = new Camera();
    Node meuNode;
    
    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                if (meuMundo != null) {
                    meuGrafico3D.render(meuMundo);
                }
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora vamos usar o método getChild() no objeto World e entrar como parâmetro a idêntificação do objeto selecionado. 

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;
    Camera minhaCamera = new Camera();
    Node meuNode;

    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        meuNode = meuMundo.getChild(1);
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                if (meuMundo != null) {
                    meuGrafico3D.render(meuMundo);
                }
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Agora usamos normalmente os métodos para modificar o Node, nesse caso vamos move-lo usando translate(). 

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;
    Camera minhaCamera = new Camera();
    Node meuNode;

    public ClasseMeuGameCanvas(){
        super(false);
        meuThread = new Thread(this);
        meuThread.start();
    }
    public void run(){
        try{
            meuObjeto3D = Loader.load("/Meu Objeto 3D.m3g");
            meuMundo = (World) meuObjeto3D[0];
            minhaCamera = meuMundo.getActiveCamera();
        } catch (Exception minhaExcessao) {
            minhaExcessao.printStackTrace();
        }
        meuNode = meuMundo.getChild(1);
        
        boolean gameOver = false;
        while(gameOver == false){
            try {
                meuGrafico3D.bindTarget(meuGrafico);
                if (meuMundo != null) {
                    meuNode.translate(0.0f, 0.0f, 0.1f);
                    meuGrafico3D.render(meuMundo);
                }
            } catch (Exception minhaExcecao) {
                minhaExcecao.printStackTrace();
            } finally {
                meuGrafico3D.releaseTarget();
                flushGraphics();
            }
        }
    }
}

Animando um objeto 3D

[editar | editar código-fonte]

Você colocou um objeto 3D para ser mostrado no seu aplicativo, mas se você criou um objeto animado deve ter notado que o objeto não expressou nenhum quadro da animação. Para fazer isso vamos usar o método animate() da classe World e receber como parâmetro, uma variavel int que irá incrementar a cada frame. 

//arquivo ClasseMeuCanvas.java
import java.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;

public class ClasseMeuCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    World meuMundo;
    
    public ClasseMeuCanvas(){
        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){
            minhaExcessao.printStackTrace();
        }
        
        int frame = 0;
        
        boolean gameOver = false;
        while(gameOver == false){
            try{
                meuGrafico3D.bindTarget(meuGrafico);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            } catch (Exception minhaExcessao) {
                minhaExcessao.printStackTrace();
            }finally{
                meuGrafico3D.releaseTarget();
                flusGraphics();
            }
        }
    }
}

Agora vamos chamar o método animate() e como parâmetro colocar uma variavel para a contagem do frame para a animação do objeto. 

//arquivo ClasseMeuCanvas.java
import java.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;

public class ClasseMeuCanvas extends GameCanvas implements Runnable {
    Thread meuThread;
    Graphics3D meuGrafico3D = Graphics3D.getInstance();
    Object3D[] meuObjeto3D;
    World meuMundo;
    
    public ClasseMeuCanvas(){
        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){
            minhaExcessao.printStackTrace();
        }

        int frame = 0;
        
        boolean gameOver = false;
        while(gameOver == false){
            try{
                meuGrafico3D.bindTarget(meuGrafico);
                meuMundo.animate(frame);
                meuGrafico3D.render(meuMundo);
                meuThread.sleep(50);
            }catch(Exception minhaExcessao){
                minhaExcessao.printStackTrace();
            }finally{
                meuGrafico3D.releaseTarget();
                frame++;
                flushGraphics()
            }
        }
    }
}
Obtido em "https://pt.wikibooks.org/w/index.php?title=J2ME/Lições/M3G/Modificando_objetos_3D&oldid=462931"