m3gcanvas.java

手机 JAVA JSR184 M3G 游戏 DEMO

/*****************************************************************************

 Description: Renders a pyramid on the canvas.
                    The device must support JSR-184

 @file        M3GCanvas.java

 COPYRIGHT All rights reserved Sony Ericsson Mobile Communications AB 2004.
 The software is the copyrighted work of Sony Ericsson Mobile Communications AB.
 The use of the software is subject to the terms of the end-user license 
 agreement which accompanies or is included with the software. The software is 
 provided "as is" and Sony Ericsson specifically disclaim any warranty or 
 condition whatsoever regarding merchantability or fitness for a specific 
 purpose, title or non-infringement. No warranty of any kind is made in 
 relation to the condition, suitability, availability, accuracy, reliability, 
 merchantability and/or non-infringement of the software provided herein.

 *****************************************************************************/


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

import javax.microedition.m3g.*;

class M3GCanvas extends GameCanvas implements Runnable{
  
    private Graphics3D g3d; // Graphics object used to render the world.
    private World world; // This world contains the camera and the pyramidMesh.
    private Camera camera; // the camera in the scene
    private Mesh pyramidMesh; // the pyramid in the scene
    
    public M3GCanvas(){
        super(false);
        
        setFullScreenMode(true);
        
        g3d = Graphics3D.getInstance();
        world = new World();

        camera = new Camera();
        world.addChild(camera); // add the camera to the world.

        float w = getWidth();
        float h = getHeight();

        // Constructs a perspective projection matrix and sets that as the current projection matrix.
        camera.setPerspective(60.0f, w / h, 0.1f, 50f);
        
        pyramidMesh = createpyramid(); // create our pyramid.
        pyramidMesh.setTranslation(0.0f, 0.0f, -3.0f); // move the pyramid 3 units into the screen.
        world.addChild(pyramidMesh); // add the pyramid to the world

        world.setActiveCamera(camera);
        
        Thread t = new Thread(this);
        t.start();
    }

    public void draw3D(Graphics g){
        try{
            g3d.bindTarget(g); // Binds the given Graphics or mutable Image2D as the rendering target of this Graphics3D
            g3d.render(world); // Render the world
        }finally{
            g3d.releaseTarget();
        }
    }

    public void run() {
        Graphics g = getGraphics();

        while(true){
            // rotate the pyramid 1 degree around the Y-axis.
            pyramidMesh.postRotate(3.0f, 0.0f, 1.0f, 0.0f);

            draw3D(g);
            flushGraphics();
        }
    }


    // this method creates a colored pyramid.
    private Mesh createpyramid(){
        
        // The vertices used by the pyramid. x, y, z
        short []POINTS = new short[] {-1, -1, 1, // point 1
                                                            1, -1, 1, // point 2
                                                            1, -1, -1, // point 3
                                                            -1, -1, -1, // point 4
                                                            0, 1, 0}; // point 5, top
                                                            
                                                            
        // The points sequence.
        int []INDICES = new int[] {0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4, 2, 1, 0, 2, 0, 3};
        byte []COLORS = new byte[] {127, 0, 0, //R
                                                        0, 127, 0,  //G
                                                        0, 0, 127, //B
                                                        127, 0, 127, //B
                                                        0, 127, 127};//B
                                                        

        // The length of each sequence in the indices array.
        int []LENGTH = new int[] {3, 3, 3, 3, 3, 3}; // the pyramid is built by six triangles
        
        VertexArray POSITION_ARRAY, COLOR_ARRAY;
        IndexBuffer INDEX_BUFFER;
        
        // Create a VertexArray to be used by the VertexBuffer
        POSITION_ARRAY = new VertexArray(POINTS.length / 3, 3, 2);
        POSITION_ARRAY.set(0, POINTS.length / 3, POINTS);
        COLOR_ARRAY = new VertexArray(COLORS.length / 3, 3, 1);
        COLOR_ARRAY.set(0, COLORS.length / 3, COLORS);
        INDEX_BUFFER = new TriangleStripArray(INDICES, LENGTH);
        
        // VertexBuffer holds references to VertexArrays that contain the positions, colors, normals, 
        // and texture coordinates for a set of vertices
        VertexBuffer vertexBuffer = new VertexBuffer();
        vertexBuffer.setPositions(POSITION_ARRAY, 1.0f, null);
        vertexBuffer.setColors(COLOR_ARRAY);
        
        // Create the 3D object defined as a polygonal surface
        Mesh mesh = new Mesh(vertexBuffer, INDEX_BUFFER, null);
        
        Appearance appearance = new Appearance(); // A set of component objects that define the rendering attributes of a Mesh
        PolygonMode polygonMode = new PolygonMode(); // An Appearance component encapsulating polygon-level attributes
        polygonMode.setPerspectiveCorrectionEnable(true);
        polygonMode.setCulling(PolygonMode.CULL_NONE); // By using CULL_NONE all faces of the pyramid will be shown.
        polygonMode.setShading(PolygonMode.SHADE_SMOOTH); // use a smooth shading of the colors on the pyramid.
        appearance.setPolygonMode(polygonMode);
        
        mesh.setAppearance(0, appearance); // Set the appearance to the 3D object
        return mesh;
    }    

}