m3gcanvas.java

第一人称视角室内漫游 其具有强烈的视觉冲击效果与身临其境的切实感受

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.m3g.Camera;
import javax.microedition.m3g.Graphics3D;
import javax.microedition.m3g.Light;
import javax.microedition.m3g.Loader;
import javax.microedition.m3g.Object3D;
import javax.microedition.m3g.Transform;
import javax.microedition.m3g.World;

public class M3GCanvas extends GameCanvas
implements Runnable {
    //线程运行标志
    boolean running = false;
    boolean done = true;
    //设置游戏结束标志 
    public static boolean gameOver = false;
    //显示场景的静态常量值
    public static final int STRONG_RENDERING_HINTS = Graphics3D.ANTIALIAS | Graphics3D.TRUE_COLOR | Graphics3D.DITHER;
    public static final int WEAK_RENDERING_HINTS = 0;
    public static int RENDERING_HINTS = STRONG_RENDERING_HINTS;
    // 判断按键的数组
    boolean[] key = new boolean[5];
    //按键常量值
    public static final int FIRE = 0;
    public static final int UP = FIRE + 1;
    public static final int DOWN = UP + 1;
    public static final int LEFT = DOWN + 1;
    public static final int RIGHT = LEFT + 1;
    // 声明坐标转换对象
    Transform identity = new Transform();
    //声明 Graphics3D对象
    Graphics3D g3d = null;
    // 声明场景世界对象
    World world = null;
    //声明摄像机对象
    Camera cam = null;
    //设置摄像机对象的参数
    float camRot = 0.0f;
    double camSine = 0.0f;
    double camCosine = 0.0f;
    float headDeg = 0.0f;
    
    /*构造函数*/
    public M3GCanvas(int fps)
    {
        //抑制按键
        super(true);
        // 设置全屏模式
        setFullScreenMode(true);
        // 调用载入场景的方法
        loadWorld();   
        // 调用载入摄像机的方法
        loadCamera();
    }
    
    public void sizeChanged(int newWidth, int newHeight)
    {
        
    }
    
    //载入摄像机的方法定义
    private void loadCamera()
    {
       
        if(world == null)
            return;
        //得到场景中当前活动的摄像机 
        cam = world.getActiveCamera();
        // 创建光线实例
        Light l = new Light();
        //采用环形光
        l.setMode(Light.AMBIENT);
        // 设置光线密度
        l.setIntensity(3.0f);
        //将光线添加到场景世界中
        world.addChild(l);
    }
    
    //定义载入场景的方法
    private void loadWorld()
    {
        try
        {
            // 载入M3G文件
            Object3D[] buffer = Loader.load("/map.m3g");
            
            //遍历场景中全部的节点并找出Wordl节点
            for(int i = 0; i < buffer.length; i++)
            {
                if(buffer[i] instanceof World)
                {
                    world = (World)buffer[i];
                    break;
                }
            }

            buffer = null;
        }
        catch(Exception e)
        {
            System.out.println("Loading error!");
            reportException(e);
        }
    }

    //屏幕绘制方法定义
    private void draw(Graphics g)
    {
        try
        {
            //调用环绕移动摄像机的方法
            moveCamera();
            // 得到Graphics3D实例
            g3d = Graphics3D.getInstance();
	        // 设置场景参数
	        g3d.bindTarget(g, true, RENDERING_HINTS);
	        //绘制场景
	        g3d.render(world);
        }
        catch(Exception e)
        {
            reportException(e);
        }
        finally
        {
            // 销毁绘制对象
            g3d.releaseTarget();
        }
    }
    
    //定义环绕移动摄像机的方法
    private void moveCamera() {
        //根据用户控制，设置旋转角度
        if(key[LEFT])
        {
            camRot += 5.0f;
        }
        else if(key[RIGHT])
        {
            camRot -= 5.0f;
        }
        
        // 设置摄像机的方位
        cam.setOrientation(camRot, 0.0f, 1.0f, 0.0f);
        
        //根据摄像机的移动，计算三角带 
        double rads = Math.toRadians(camRot);
        camSine = Math.sin(rads);
        camCosine = Math.cos(rads);
        
        if(key[UP])
        {
            // 向前移动
            cam.translate(-2.0f * (float)camSine, 0.0f, -2.0f * (float)camCosine);
            headDeg += 0.5f;
            cam.translate(0.0f, (float)Math.sin(headDeg) / 3.0f, 0.0f);
        }
        else if(key[DOWN])
        {
            // 向后移动
            cam.translate(2.0f * (float)camSine, 0.0f, 2.0f * (float)camCosine);
            headDeg -= 0.5f;
            cam.translate(0.0f, (float)Math.sin(headDeg) / 3.0f, 0.0f);
        }
        
        // 如果用户按下FIRE按键，则退出
        if(key[FIRE])
            M3GMidlet.die();
    }

    public void start() {
        Thread myThread = new Thread(this);
        
        //设置线程执行标志为true 
        running = true;
        done = false;
        
        // 启动线程
        myThread.start();
    }
    
    //多线程执行方法
    public void run() {
        while(running) {
            try {                
                //调用按键处理方法
                process();
                //绘制场景
                draw(getGraphics());
                flushGraphics();
                // 休眠一段时间
                try{ Thread.sleep(30); } catch(Exception e) {}
            }
            catch(Exception e) {
                reportException(e);
            }
        }
        // 设置执行结束标志为true
        done = true;
    }
    private void reportException(Exception e) {
        System.out.println(e.getMessage());
        System.out.println(e);
        e.printStackTrace();
    }

    //可以扩展定义游戏暂停方法
    public void pause() {}
    
    //可以扩展定义游戏结束方法
    public void stop() { running = false; }
    
    //定义处理游戏按键的方法
    protected void process()
    {
        int keys = getKeyStates();
        
        if((keys & GameCanvas.FIRE_PRESSED) != 0)
            key[FIRE] = true;
        else
            key[FIRE] = false;
        
        if((keys & GameCanvas.UP_PRESSED) != 0)
            key[UP] = true;
        else
            key[UP] = false;
        
        if((keys & GameCanvas.DOWN_PRESSED) != 0)
            key[DOWN] = true;
        else
            key[DOWN] = false;
        
        if((keys & GameCanvas.LEFT_PRESSED) != 0)
            key[LEFT] = true;
        else
            key[LEFT] = false;
        
        if((keys & GameCanvas.RIGHT_PRESSED) != 0)
            key[RIGHT] = true;
        else
            key[RIGHT] = false;
    }
    
    //检查游戏是否正在执行的方法
    public boolean isRunning() { return running; }
    
    //检查线程是否执行完成的方法
    public boolean isDone() { return done; }
}