gameframe.java

Java 3D Game SDK.老外做的.

/*
 * GameFrame.java
 */

package org.java3dgamesdk.core;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;

/**
 * This class is the main game frame for the windowed or full screen application.
 *
 * @author  Norbert Nopper
 */
public class GameFrame extends JFrame implements Runnable, WindowListener, MouseInputListener, MouseWheelListener, KeyListener {
    
    final private static int                MOUSEBUTTONS = 3;
    final private static int                KEYS = 256;
    
    /**
     * Thread for updating the scene.
     */
    private Thread                          runThread;
    
    /**
     * Flag, if the application is running in window or full screen mode.
     */
    private boolean                         windowed;
    
    /**
     * Original display mode. Needed for setting back after leaving the application.
     */
    private DisplayMode                     originalDisplayMode;
    
    /**
     * Graphics device for the full screen mode.
     */
    private GraphicsDevice                  graphicsDevice;
    
    /**
     * The canvas for rendering 3D scenes.
     */
    protected Canvas3D                      canvas3d;
    
    /**
     * Graphics context for rendering 3D scenes.
     */
    protected GraphicsContext3D             gc3D;
    
    /**
     * Empty universe for immediate mode rendering.
     */
    private SimpleUniverse                  simpleUniverse;
    
    /**
     * Flag, if the game mouse is enabled.
     */
    protected boolean                       gameMouse;
    
    /**
     * The x position of the mouse. If game mouse is enabled, it is the relative position.
     */
    protected int                           mouseX;

    /**
     * The y position of the mouse. If game mouse is enabled, it is the relative position.
     */
    protected int                           mouseY;
    
    /**
     * Flag, if the mouse was moved or not.
     */
    private boolean                         mouseMoved;
    
    /**
     * Delta movement on the x axis.
     */
    protected int                           deltaX;

    /**
     * Delta movement on the y axis.
     */
    protected int                           deltaY;
    
    /**
     * Array for the three mouse buttons.
     */
    protected boolean[]                     mouseButton = new boolean[MOUSEBUTTONS];

    /**
     * Integer value of the mouse wheel position.
     */    
    protected int                           mouseWheel;

    /**
     * Flag, if the mouse wheel was moved or not.
     */
    private boolean                         mouseWheelMoved;
        
    /**
     * AWT Toolkit to control the mouse cursor.
     */    
    private Robot                           mouseRobot;

    /**
     * Array for the game keys.
     */
    protected boolean[]                     gameKeys = new boolean[KEYS];
        
    /**
     * Initialize the game frame without deciding to start in full or window mode.
     */
    public GameFrame() {
        // pass the graphic configuration to the super class
        super(SimpleUniverse.getPreferredConfiguration());
        
        // at this point of time the application is in window mode
        windowed = true;
        
        // save the original display mode
        this.originalDisplayMode = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDisplayMode() ;
        
        // get the graphics device
        this.graphicsDevice = SimpleUniverse.getPreferredConfiguration().getDevice();
        
        // prepare the layout for one container
        getContentPane().setLayout(new BorderLayout());
        
        // create the canvas3d to render on
        canvas3d = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
        
        // get the graphics context 3D
        gc3D = canvas3d.getGraphicsContext3D();
        
        // stop the renderer for immediate mode
        canvas3d.stopRenderer();
        
        // add the cancas3d to the frame
        getContentPane().add("Center", canvas3d);
        
        // create the simple universe
        simpleUniverse = new SimpleUniverse(canvas3d);
        
        // listen to window events
        addWindowListener(this);
        
        // listen to the mouse events on the canvas 3d
        canvas3d.addMouseListener(this);
        canvas3d.addMouseMotionListener(this);
        canvas3d.addMouseWheelListener(this);
        
        // game mouse to off
        gameMouse = false;
        
        // create a robot to control the mouse cursor
        try {
            mouseRobot = new Robot(graphicsDevice);
        } catch(AWTException awte) {
            System.err.println(awte);
            System.exit(1);
        }
        
        // listen to the key events
        canvas3d.addKeyListener(this);
    }
    
    /**
     * Method for creating the window screen.
     *
     * @param width the width of the screen
     * @param height the width of the screen
     *
     * @return true, if the creation was successful
     */
    final public boolean makeWindowScreen(int width, int height) {
        windowed = true;
        
        // resize the frame
        setSize(width, height);
        
        // validate the frame
        validate();
        
        // make the frame visible
        setVisible(true);
        
        return true;
    }
    
    /**
     * Method for creating the full screen. The method checks, if the graphic
     * card supports the given resolution.
     *
     * @param width the width of the screen
     * @param height the width of the screen
     * @param bitDepth the bit depth of the color (8, 16, or 32)
     * @param refreshRate refresh rate
     *
     * @return true, if the creation was successful
     */
    final public boolean makeFullScreen(int width, int height, int bitDepth, int refreshRate) {
        windowed = false;
        
        // check, if full screen mode is supported: return
        if( !graphicsDevice.isFullScreenSupported() )
            return false;
        
        // check, if the given mode is supported
        boolean available = false;
        int index = 0;
        
        DisplayMode allModes[] = graphicsDevice.getDisplayModes();
        
        // check, if display mode is available
        while(!available && index < allModes.length) {
            if( allModes[index].getWidth() == width &&
            allModes[index].getHeight() == height &&
            allModes[index].getBitDepth() == bitDepth &&
            allModes[index].getRefreshRate() == refreshRate ) {
                
                // display mode is available
                available = true;
            }
            
            index++;
        }
        
        // display mode is not available: return
        if(!available)
            return false;
        
        // no decorations for the frame
        setUndecorated(true);
        
        // do not allow to resize the frame
        setResizable(false);
        
        // set the full screen mode to this frame
        graphicsDevice.setFullScreenWindow(this);
        
        // create the new display mode
        DisplayMode newDisplayMode = new DisplayMode(width, height, bitDepth, refreshRate);
        
        // sets the new display mode
        graphicsDevice.setDisplayMode(newDisplayMode);
        
        // resize the frame
        setSize(new Dimension(newDisplayMode.getWidth(), newDisplayMode.getHeight()));
        
        // validate the frame
        validate();
        
        return true;
    }
    
    /**
     * Returns the current graphics device.
     *
     * @return the graphics device
     */
    final public GraphicsDevice getGraphicsDevice() {
        return graphicsDevice;
    }
    
    /**
     * Start the update and render thread.
     */
    final private void init() {
        if(runThread == null)
            runThread = new Thread(this);
        
        runThread.start();
    }
    
    /**
     * Exit the game frame and the whole application.
     */
    final protected void exit() {
        // stop the thread and theapplication exits
        runThread = null;
    }
    
    final public void windowActivated(WindowEvent windowEvent) {}
    
    final public void windowClosed(WindowEvent windowEvent) {}
    
    /**
     * The method cleans up the application and is directly called by the window listener.
     *
     * @param windowEvent the passed event
     */
    final public void windowClosing(WindowEvent windowEvent) {
        // clean up the system
        exit();
    }
    
    final public void windowDeactivated(WindowEvent windowEvent) {}
    
    final public void windowDeiconified(WindowEvent windowEvent) {}
    
    final public void windowIconified(WindowEvent windowEvent) {}
    
    /**
     * The method starts the render thread and is directly called by the window listener.
     *
     * @param windowEvent the passed event
     */
    final public void windowOpened(WindowEvent windowEvent) {
        // start the render thread
        init();
    }
    
    /**
     * The thread for updating the scene.
     */
    final public void run() {

        // center the mouse
        mouseRobot.mouseMove(canvas3d.getWidth()/2, canvas3d.getHeight()/2);            

        // mouse was not moved
        mouseMoved = false;
        deltaX = 0;
        deltaY = 0;
    
        // mouse wheel was not moved
        mouseWheelMoved = false;
        
        // allow the game to initalize itself
        initGame();
        
        // clean up what is possible
        System.gc();
        
        long gameTime = 0;
        long currentTime = System.currentTimeMillis();
        long lastTime = currentTime;
        while (runThread == Thread.currentThread()) {
            
            updateGame(gameTime);
            
            renderGame();
            
            // swap the scene
            canvas3d.swap();

            // allow other threads to execute
            Thread.yield();

            // reset the mouse movement values
            if(gameMouse && !mouseMoved) {
                deltaX = 0;
                deltaY = 0;
            }
            mouseMoved = false;
            
            // reset the mouse wheel movement value
            if(!mouseWheelMoved)
                mouseWheel = 0;
            mouseWheelMoved = false;
            
            // adjust the game time
            currentTime = System.currentTimeMillis();
            gameTime += currentTime - lastTime;
            lastTime = currentTime;
        }
        
        // allow the game to clean up itself ...
        exitGame();
    
        // ... and now the engine
        
        // clear the universe
        if(simpleUniverse != null)
            simpleUniverse.removeAllLocales();
        
        // reset the display to the original configuration
        if(graphicsDevice != null && windowed == false) {
            graphicsDevice.setDisplayMode(originalDisplayMode);
            graphicsDevice.setFullScreenWindow(null);
        }
        
        // finally exit
        System.exit(0);

    }
    
    /**
     * Overwrite this method for making your own initialization method!
     */
    protected void initGame() {
    }
    
    /**
     * Overwrite this method for making your own update method!
     *
     *@param currentTime the current game time in miliseconds, starting with 0
     */
    protected void updateGame(long currentTime) {
        // exit the application by pressing the ESC key.
        if(gameKeys[27])
            exit();        
    }
  
    /**
     * Overwritete this method for making your own render method!
     */
    protected void renderGame() {
        gc3D.clear();
        
    }
    
    /**
     * Overwrite this method for making your own exit method!
     */
    protected void exitGame() {
    }
    
    /**
     * The method updates the mouse position.
     *
     * @param windowEvent the passed event
     */
    final private void updateMousePosition(MouseEvent mouseEvent) {                
        deltaX = mouseX - mouseEvent.getX();
        deltaY = mouseY - mouseEvent.getY();
            
        if(gameMouse)
            mouseRobot.mouseMove(canvas3d.getWidth()/2, canvas3d.getHeight()/2);            

        mouseX = mouseEvent.getX();
        mouseY = mouseEvent.getY();

        mouseMoved = true;
        mouseEvent.consume();
    }
    
    /**
     * The method updates the mouse buttons.
     *
     * @param windowEvent the passed event
     */
    final private void updateMouseButton(MouseEvent mouseEvent) {
        
        // pass the button to the engine
        if(mouseEvent.getButton() > 0 && mouseEvent.getButton() <= MOUSEBUTTONS) {
            if(mouseEvent.getID() == MouseEvent.MOUSE_PRESSED)
                mouseButton[mouseEvent.getButton()-1] = true;
            else
                mouseButton[mouseEvent.getButton()-1] = false;
        }
        
        mouseEvent.consume();
        
    }
    
    /**
     * The method updates the mouse position.
     *
     * @param windowEvent the passed event
     */
    final public void mouseMoved(MouseEvent mouseEvent) {
        updateMousePosition(mouseEvent);
    }
    
    /**
     * The method updates the mouse position.
     *
     * @param windowEvent the passed event
     */
    final public void mouseDragged(MouseEvent mouseEvent) {
        updateMousePosition(mouseEvent);
    }
    
    /**
     * The method updates the mouse buttons.
     *
     * @param windowEvent the passed event
     */
    final public void mousePressed(MouseEvent mouseEvent) {
        updateMouseButton(mouseEvent);
    }
    
    /**
     * The method updates the mouse buttons.
     *
     * @param windowEvent the passed event
     */
    final public void mouseReleased(MouseEvent mouseEvent) {
        updateMouseButton(mouseEvent);
    }
    
    final public void mouseClicked(MouseEvent mouseEvent) {}
    
    final public void mouseEntered(MouseEvent mouseEvent) {}
    
    final public void mouseExited(MouseEvent mouseEvent) {}
    
    /**
     * The method updates the mouse wheel.
     *
     * @param windowEvent the passed event
     */
    final public void mouseWheelMoved(MouseWheelEvent mouseWheelEvent) {
        // change the mouse wheel
        mouseWheel += mouseWheelEvent.getWheelRotation();
        
        mouseWheelMoved = true;
        mouseWheelEvent.consume();
    }
    
    final public void keyPressed(KeyEvent keyEvent) {
        updateGameKeys(keyEvent);
    }
    
    final public void keyReleased(KeyEvent keyEvent) {
        updateGameKeys(keyEvent);
    }
    
    final public void keyTyped(KeyEvent keyEvent) {}
    
    final private void updateGameKeys(KeyEvent keyEvent) {
        // System.out.println(keyEvent.getKeyCode());
        
        // pass the key status to the engine
        if(keyEvent.getKeyCode() >= 0 && keyEvent.getKeyCode() < KEYS) {
            if(keyEvent.getID() == KeyEvent.KEY_PRESSED)
                gameKeys[keyEvent.getKeyCode()] = true;
            else
                gameKeys[keyEvent.getKeyCode()] = false;
        }

        keyEvent.consume();
    }

}