Mobile 3D Graphics API for J2ME

import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.CommandListener;

import java.util.Timer;
import java.util.TimerTask;

import javax.microedition.m3g.*;

public class Ex3D extends MIDlet implements CommandListener {
    private Display myDisplay = null;
    private JesterCanvas myCanvas = null;

    private Timer myRefreshTimer = new Timer();
    private TimerTask myRefreshTask = null;

    private Command exitCommand = new Command("Exit", Command.ITEM, 1);

    private World myWorld = null;

    /**
     * JesterTestlet - default constructor.
     */
    public Ex3D() {
        // Set up the user interface.
        myDisplay = Display.getDisplay(this);
        myCanvas = new JesterCanvas(this);
        myCanvas.setCommandListener(this);
        myCanvas.addCommand(exitCommand);
    }

    /**
     * startApp()
     */
    public void startApp()
        throws MIDletStateChangeException {

        myDisplay.setCurrent(myCanvas);

        try {
            // Load a file.
            Object3D[] roots = 
                Loader.load("/pogoroo.m3g");

            // Assume the world is the first root node loaded.
            myWorld = (World)roots[0];

            // Force a repaint so that we get the update loop started.
            myCanvas.repaint();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * pauseApp()
     */
    public void pauseApp() {
        // Release resources.
        myWorld = null;
    }

    /**
     * destroyApp()
     */
    public void destroyApp(boolean unconditional)
        throws MIDletStateChangeException {

        myRefreshTimer.cancel();
        myRefreshTimer = null;

        // Release resources.
        myWorld = null;
    }

    /**
     * MIDlet paint method.
     */
    public void paint(Graphics g) {
        // We are not fully initialised yet; just return.
        if(myCanvas == null || myWorld == null)
            return;

        // Delete any pending refresh tasks.
        if(myRefreshTask != null) {
            myRefreshTask.cancel();
            myRefreshTask = null;
        }

        // Get the current time.
        long currentTime = System.currentTimeMillis();
        // Update the world to the current time.
        int validity = myWorld.animate((int)currentTime);

        // Render to our Graphics.
        Graphics3D myGraphics3D = Graphics3D.getInstance();
        myGraphics3D.bindTarget(g);
        myGraphics3D.render(myWorld);
        myGraphics3D.releaseTarget();

        // Subtract time taken to do the update.
        validity -= System.currentTimeMillis() - currentTime;

        if(validity < 1) {
            // The validity is too small; allow a minimum of 1ms.
            validity = 1;
        }

        // If the validity is not infinite schedule a refresh task.
        if(validity < 0x7fffffff) {
            // Create a new refresh task.
            myRefreshTask = new RefreshTask();

            // Schedule an update.
            myRefreshTimer.schedule(myRefreshTask, validity);
        }
    }

    /**
     * Handle commands.
     */
    public void commandAction(Command cmd, Displayable disp) {
        if (cmd == exitCommand) {
            try {
                destroyApp(false);
                notifyDestroyed();
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Inner class for refreshing the view.
     */
    private class RefreshTask extends TimerTask {
        public void run() {
            // Get the canvas to repaint itself.
            myCanvas.repaint();
        }
    }

    /**
     * Inner class for handling the canvas.
     */
    class JesterCanvas extends Canvas {
        Ex3D myTestlet;

        /**
         * Construct a new canvas.
         */
        JesterCanvas(Ex3D Testlet) { myTestlet = Testlet; }

        /**
         * Initialize self.
         */
        void init() { }

        /**
         * Clean up and destroy.
         */
        void destroy() { }

        /**
         * Ask myTestlet to paint itself.
         */
        protected void paint(Graphics g) { myTestlet.paint(g); }
    }
}