joglview.java

基于java的3d开发库。对坐java3d的朋友有很大的帮助。

//===========================================================================

// Java basic classes
import java.util.ArrayList;

// AWT/Swing classes
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Rectangle;
import java.awt.geom.Rectangle2D;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;

// JOGL classes
import javax.media.opengl.GL;

// VSDK classes
import vsdk.toolkit.common.VSDK;
import vsdk.toolkit.common.ColorRgb;
import vsdk.toolkit.common.Vector3D;
import vsdk.toolkit.common.Matrix4x4;
import vsdk.toolkit.common.RendererConfiguration;
import vsdk.toolkit.environment.Camera;
import vsdk.toolkit.environment.geometry.Geometry;
import vsdk.toolkit.environment.geometry.Arrow;
import vsdk.toolkit.environment.scene.SimpleBody;
import vsdk.toolkit.media.RGBAImage;
import vsdk.toolkit.media.RGBAPixel;
import vsdk.toolkit.render.jogl.JoglImageRenderer;
import vsdk.toolkit.render.jogl.JoglMatrixRenderer;
import vsdk.toolkit.render.awt.AwtRGBAImageRenderer;
import vsdk.toolkit.gui.TranslateGizmo;

/**
A `JoglView` represents an specific Jogl viewport inside a canvas. One Jogl
canvas may contain one ore more `JoglView`s, arrange geometrically in 2D,
ussually forming a partition (or at least a set of non overlaping 2D
rectangles).

The JoglView covers an area defined in terms of percentages.  For example,
a Jogl canvas with a single JoglView covering all of its area, will have
a view located at start percent (0%, 0%) with size (100%, 100%). When
the containing canvas resizes, the internal `JoglView`s will resize
accordingly and will keep its ocupation percentages (see 
`viewportStartXPercent`, `viewportStartYPercent`, `viewportSizeXPercent` and
`viewportSizeYPercent` attributes.
).
*/
public class JoglView implements KeyListener
{
    // JoglView occupancy specification with respect to containing canvas
    private double viewportStartXPercent;
    private double viewportStartYPercent;
    private double viewportSizeXPercent;
    private double viewportSizeYPercent;

    // Current configuration, available only after a call to activateViewportGL
    private int viewportStartX;
    private int viewportStartY;
    private int viewportSizeX;
    private int viewportSizeY;
    private int viewportBorder; // In pixels

    // A JoglView can request an specific size in pixels. If this size gets
    // smaller than percent-based area, the viewport is assigned to match the
    // requested size. If a requested size dimension in pixels is greater
    // than the percent-based area, the requested size is ignored and the
    // viewport will get the percent-based size. The smaller requested size
    // viewport will always be centered inside the given percent-based area.
    // A requested size of 0 means the requested size match the percent-based
    // size.
    private int viewportRequestedSizeXInPixels;
    private int viewportRequestedSizeYInPixels;

    // Every JoglView has an internal camera and renderer configuration
    private Camera camera;
    private Camera cameraPerspective;
    private Camera cameraTop;
    private Camera cameraBottom;
    private Camera cameraLeft;
    private Camera cameraFront;
    private RendererConfiguration quality;

    //
    private boolean selected;
    private boolean active;
    private String title;
    private RGBAImage titleImage;
    private RGBAImage xLabelImage;
    private RGBAImage yLabelImage;
    private RGBAImage zLabelImage;
    private RGBAImage xLabelImageSelected;
    private RGBAImage yLabelImageSelected;
    private RGBAImage zLabelImageSelected;
    private Font font;

    // Each JoglView can call a different visualization algorithm
    public static final int RENDER_MODE_ZBUFFER = 1;
    public static final int RENDER_MODE_RAYTRACING = 2;
    private int renderMode;

    public boolean showGrid;

    public JoglView()
    {
        //-----------------------------------------------------------------
        viewportStartXPercent = 0.0;
        viewportStartYPercent = 0.0;
        viewportSizeXPercent = 1.0;
        viewportSizeYPercent = 1.0;
        viewportRequestedSizeXInPixels = 0;
        viewportRequestedSizeYInPixels = 0;
        viewportBorder = 2;

        //-----------------------------------------------------------------
        Matrix4x4 R = new Matrix4x4();

        cameraPerspective = new Camera();
        cameraPerspective.setPosition(new Vector3D(-5, -5, 5));
        R.eulerAnglesRotation(Math.toRadians(45), Math.toRadians(-35), 0);
        cameraPerspective.setRotation(R);
        cameraPerspective.setName("Perspective");

        cameraTop = new Camera();
        cameraTop.setProjectionMode(cameraTop.PROJECTION_MODE_ORTHOGONAL);
        cameraTop.setPosition(new Vector3D(0, 0, 5));
        R.eulerAnglesRotation(Math.toRadians(90), Math.toRadians(-90), 0);
        cameraTop.setRotation(R);
        cameraTop.setOrthogonalZoom(0.25);
        cameraTop.setName("Top");

        cameraBottom = new Camera();
        cameraBottom.setProjectionMode(cameraBottom.PROJECTION_MODE_ORTHOGONAL);
        cameraBottom.setPosition(new Vector3D(0, 0, -5));
        R.eulerAnglesRotation(Math.toRadians(90), Math.toRadians(90), 0);
        cameraBottom.setRotation(R);
        cameraBottom.setOrthogonalZoom(0.25);
        cameraBottom.setName("Bottom");

        cameraLeft = new Camera();
        cameraLeft.setProjectionMode(cameraLeft.PROJECTION_MODE_ORTHOGONAL);
        cameraLeft.setPosition(new Vector3D(-5, 0, 0));
        R.identity();
        cameraLeft.setRotation(R);
        cameraLeft.setOrthogonalZoom(0.25);
        cameraLeft.setName("Left");

        cameraFront = new Camera();
        cameraFront.setProjectionMode(cameraFront.PROJECTION_MODE_ORTHOGONAL);
        cameraFront.setPosition(new Vector3D(0, -5, 0));
        R.eulerAnglesRotation(Math.toRadians(90), 0, 0);
        cameraFront.setRotation(R);
        cameraFront.setOrthogonalZoom(0.25);
        cameraFront.setName("Front");

        camera = cameraPerspective;

        //-----------------------------------------------------------------
        quality = new RendererConfiguration();

        selected = true;
        active = true;

        setTitle(camera.getName());
        xLabelImage = calculateLabelImage("X", new ColorRgb(0.78, 0, 0));
        yLabelImage = calculateLabelImage("Y", new ColorRgb(0, 0.61, 0));
        zLabelImage = calculateLabelImage("Z", new ColorRgb(0, 0, 0.76));

        xLabelImageSelected = calculateLabelImage("X", new ColorRgb(1, 1, 0));
        yLabelImageSelected = calculateLabelImage("Y", new ColorRgb(1, 1, 0));
        zLabelImageSelected = calculateLabelImage("Z", new ColorRgb(1, 1, 0));

        font = new Font("Arial", Font.PLAIN, 14);

        this.renderMode = RENDER_MODE_ZBUFFER;

        showGrid = true;
    }

    /**
    Do NOT call your controller from the `keyTyped` method, or the controller
    will be invoked twice for each key. Call it only from the `keyPressed` and
    `keyReleased` method.
    */
    public void keyTyped(KeyEvent e) {
        ;
    }

    public void keyPressed(KeyEvent e) {
        int keycode;
        char unicode_id;
        boolean skipKey = false;

        keycode = e.getKeyCode();
        unicode_id = e.getKeyChar();

        if ( keycode == KeyEvent.VK_9 ) {
            // Alphanumeric 0
            skipKey = true;
            switch ( renderMode ) {
              case RENDER_MODE_ZBUFFER:
                renderMode = RENDER_MODE_RAYTRACING;
                break;
              default:
                renderMode = RENDER_MODE_ZBUFFER;
                break;
            }
        }

        if ( unicode_id != e.CHAR_UNDEFINED && !skipKey ) {
            switch ( unicode_id ) {
              case 'g':
                if ( showGrid == true ) {
                    showGrid = false;
                }
                else {
                    showGrid = true;
                }
                break;
              case 't':
                camera = cameraTop;
                setTitle(camera.getName());
                break;
              case 'l':
                camera = cameraLeft;
                setTitle(camera.getName());
                break;
              case 'f':
                camera = cameraFront;
                setTitle(camera.getName());
                break;
              case 'b':
                camera = cameraBottom;
                setTitle(camera.getName());
                break;
              case 'p':
                camera = cameraPerspective;
                setTitle(camera.getName());
                break;
              case '0':
                switch ( getViewportRequestedSizeXInPixels() ) {
                  case 0:
                    setViewportRequestedSizeXInPixels(320);
                    setViewportRequestedSizeYInPixels(240);
                    break;
                  case 320:
                    setViewportRequestedSizeXInPixels(640);
                    setViewportRequestedSizeYInPixels(480);
                    break;
                  case 640:
                    setViewportRequestedSizeXInPixels(800);
                    setViewportRequestedSizeYInPixels(600);
                    break;
                  case 800:
                    setViewportRequestedSizeXInPixels(0);
                    setViewportRequestedSizeYInPixels(0);
                    break;
                }
                break;
            }
        }
    }

    public void keyReleased(KeyEvent e) {
    }

    public int getRenderMode()
    {
        return renderMode;
    }

    public double getViewportStartXPercent()
    {
        return viewportStartXPercent;
    }

    public double getViewportStartYPercent()
    {
        return viewportStartYPercent;
    }

    public double getViewportSizeXPercent()
    {
        return viewportSizeXPercent;
    }

    public double getViewportSizeYPercent()
    {
        return viewportSizeYPercent;
    }

    public void setViewportStartXPercent(double viewportStartXPercent)
    {
        this.viewportStartXPercent = viewportStartXPercent;
    }

    public void setViewportStartYPercent(double viewportStartYPercent)
    {
        this.viewportStartYPercent = viewportStartYPercent;
    }

    public void setViewportSizeXPercent(double viewportSizeXPercent)
    {
        this.viewportSizeXPercent = viewportSizeXPercent;
    }

    public void setViewportSizeYPercent(double viewportSizeYPercent)
    {
        this.viewportSizeYPercent = viewportSizeYPercent;
    }

    public int getViewportRequestedSizeXInPixels()
    {
        return viewportRequestedSizeXInPixels;
    }

    public int getViewportRequestedSizeYInPixels()
    {
        return viewportRequestedSizeYInPixels;
    }

    public void setViewportRequestedSizeXInPixels(int viewportRequestedSizeXInPixels)
    {
        this.viewportRequestedSizeXInPixels = viewportRequestedSizeXInPixels;
    }

    public void setViewportRequestedSizeYInPixels(int viewportRequestedSizeYInPixels)
    {
        this.viewportRequestedSizeYInPixels = viewportRequestedSizeYInPixels;
    }

    public int getViewportStartX()
    {
        return viewportStartX;
    }

    public int getViewportStartY()
    {
        return viewportStartY;
    }

    public int getViewportSizeX()
    {
        return viewportSizeX;
    }

    public int getViewportSizeY()
    {
        return viewportSizeY;
    }

    public boolean isSelected()
    {
        return selected;
    }

    public void setSelected(boolean val)
    {
        selected = val;
    }

    public boolean getSelected()
    {
        return selected;
    }

    public boolean isActive()
    {
        return active;
    }

    public void setActive(boolean val)
    {
        active = val;
    }

    public boolean useFullContainerViewportArea()
    {
        int x, y;
        x = getViewportRequestedSizeXInPixels();
        y = getViewportRequestedSizeYInPixels();

        if ( x != 0 && y != 0 ) {
            return false;
        }
        return true;
    }    

    public Camera getCamera()
    {
        return camera;
    }

    public RendererConfiguration getRendererConfiguration()
    {
        return quality;
    }

    /**
    A given container canvas has valid pixel coordinates from (0, 0) to
    (canvasXSize-1, canvasYSize-1). Current JoglView is defined inside that
    area in terms of a start point (upper left corner) and size given in
    area percentages.
    This method calculates the (viewportStartX, viewportStartY,
    viewportSizeX, viewportSizeY) variables that defines current JoglView
    viewport in container canvas' integer pixel coordinates.
    */
    public void updateViewportConfiguration(int canvasXSize, int canvasYSize)
    {
        int w, h;
        int subCanvasXSize;
        int subCanvasYSize;

        viewportStartX = (int)(viewportStartXPercent*((double)canvasXSize))+viewportBorder+1;
        viewportStartY = (int)(viewportStartYPercent*((double)canvasYSize))+viewportBorder+1;
        subCanvasXSize = (int)(viewportSizeXPercent*((double)canvasXSize))-2*viewportBorder-2;
        subCanvasYSize = (int)(viewportSizeYPercent*((double)canvasYSize))-2*viewportBorder-2;
        if ( useFullContainerViewportArea() ) {
            viewportSizeX = subCanvasXSize;
            viewportSizeY = subCanvasYSize;
        }
        else {
            if ( viewportRequestedSizeXInPixels < subCanvasXSize ) {
                w = viewportRequestedSizeXInPixels;
            }
            else {