jogldrawingarea.java

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

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

// JDK Basic classes
import java.lang.reflect.Method;
import java.io.File;
import java.util.ArrayList;

// AWT/Swing classes
import java.awt.Cursor;
import java.awt.Dimension;
//import java.awt.Image; // Do not define! conflicts with VSDK's Image
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseWheelListener;
import java.awt.event.MouseMotionListener;
import javax.swing.JLabel;

// JOGL classes
import javax.media.opengl.GL;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLDrawableFactory;
import javax.media.opengl.GLEventListener;

// VSDK classes
import vsdk.toolkit.common.VSDK;
import vsdk.toolkit.common.ColorRgb;
import vsdk.toolkit.common.Matrix4x4;
import vsdk.toolkit.common.Ray;
import vsdk.toolkit.common.Quaternion;
import vsdk.toolkit.common.Vector3D;
import vsdk.toolkit.common.RendererConfiguration;
import vsdk.toolkit.common.Triangle;
import vsdk.toolkit.common.Vertex;
import vsdk.toolkit.media.Image;
import vsdk.toolkit.media.IndexedColorImage;
import vsdk.toolkit.media.RGBImage;
import vsdk.toolkit.media.RGBAImage;
import vsdk.toolkit.media.NormalMap;
import vsdk.toolkit.environment.Material;
import vsdk.toolkit.environment.Camera;
import vsdk.toolkit.environment.SimpleBackground;
import vsdk.toolkit.environment.CubemapBackground;
import vsdk.toolkit.environment.geometry.Arrow;
import vsdk.toolkit.environment.geometry.Cone;
import vsdk.toolkit.environment.geometry.Geometry;
import vsdk.toolkit.environment.geometry.GeometryIntersectionInformation;
import vsdk.toolkit.environment.geometry.Sphere;
import vsdk.toolkit.environment.geometry.TriangleMesh;
import vsdk.toolkit.environment.scene.SimpleBody;
import vsdk.toolkit.environment.scene.SimpleBodyGroup;
import vsdk.toolkit.environment.scene.SimpleScene;
import vsdk.toolkit.render.jogl.JoglRenderer;
import vsdk.toolkit.render.jogl.JoglMatrixRenderer;
import vsdk.toolkit.render.jogl.JoglMaterialRenderer;
import vsdk.toolkit.render.jogl.JoglImageRenderer;
import vsdk.toolkit.render.jogl.JoglGeometryRenderer;
import vsdk.toolkit.render.jogl.JoglTranslateGizmoRenderer;
import vsdk.toolkit.render.jogl.JoglRotateGizmoRenderer;
import vsdk.toolkit.render.jogl.JoglScaleGizmoRenderer;
import vsdk.toolkit.render.jogl.JoglRGBImageRenderer;
import vsdk.toolkit.render.jogl.JoglZBufferRenderer;
import vsdk.toolkit.gui.CameraController;
import vsdk.toolkit.gui.CameraControllerAquynza;
import vsdk.toolkit.gui.CameraControllerBlender;
import vsdk.toolkit.gui.RendererConfigurationController;
import vsdk.toolkit.gui.TranslateGizmo;
import vsdk.toolkit.gui.RotateGizmo;
import vsdk.toolkit.gui.ScaleGizmo;
import vsdk.toolkit.io.image.ImagePersistence;
import vsdk.toolkit.processing.ImageProcessing;
import vsdk.framework.shapeMatching.JoglProjectedViewRenderer;

public class JoglDrawingArea implements 
    GLEventListener, MouseListener, MouseMotionListener, MouseWheelListener,
    KeyListener
{
    public static final int CAMERA_INTERACTION_MODE = 1;
    public static final int SELECT_INTERACTION_MODE = 2;
    public static final int TRANSLATE_INTERACTION_MODE = 3;
    public static final int ROTATE_INTERACTION_MODE = 4;
    public static final int SCALE_INTERACTION_MODE = 5;

    public GLCanvas canvas;

    private RendererConfiguration qualitySelection;
    private RendererConfiguration qualitySelectionVisualDebug;
    private CameraController cameraController;
    private RendererConfigurationController qualityController;
    private TranslateGizmo translationGizmo;
    private RotateGizmo rotateGizmo;
    private ScaleGizmo scaleGizmo;
    private Material visualDebugMaterial;

    private Scene theScene;
    private JLabel statusMessage;

    public ArrayList<JoglView> views;

    public int interactionMode;
    public int lastInteractionMode;
    private boolean translationGizmoDrawn;

    private boolean firstTimer = true;
    public boolean wantToGetColor;
    public boolean wantToGetDepth;
    public boolean wantToGetContourns;
    public boolean wantToDebugProjectedViews;

    private JoglProjectedViewRenderer projectedViewRenderer;

    private Cursor camrotateCursor;
    private Cursor camtranslateCursor;
    private Cursor camadvanceCursor;
    private Cursor selectCursor;

    //
    private int globalViewportXSize;
    private int globalViewportYSize;
    private ViewOrganizer viewOrganizer;
    public int selectedView;
    private boolean fullViewport;
    private int viewOrderStyle;

    SceneEditorApplication parent;

    private boolean doDistanceField;
    private int distanceFieldSide;

    public JoglDrawingArea(Scene theScene, JLabel statusMessage, SceneEditorApplication parent)
    {
        this.parent = parent;
        this.theScene = theScene;
        this.statusMessage = statusMessage;
        this.globalViewportXSize = 0;
        this.globalViewportYSize = 0;

        interactionMode = CAMERA_INTERACTION_MODE;
        lastInteractionMode = CAMERA_INTERACTION_MODE;
        translationGizmoDrawn = false;
        createCursors();

        //cameraController = new CameraControllerBlender(theScene.camera);
        cameraController = new CameraControllerAquynza(theScene.camera);
        translationGizmo = new TranslateGizmo(theScene.camera);

        qualitySelection = theScene.qualityTemplate;
        qualityController = new RendererConfigurationController(qualitySelection);
        qualitySelectionVisualDebug = new RendererConfiguration();
        qualitySelectionVisualDebug.setShadingType(
            qualitySelectionVisualDebug.SHADING_TYPE_GOURAUD);
        rotateGizmo = new RotateGizmo();
        scaleGizmo = new ScaleGizmo();

        visualDebugMaterial = parent.theScene.defaultMaterial();

        canvas = new GLCanvas();

        Dimension minimumSize = new Dimension(8, 8);
        canvas.setMinimumSize(minimumSize);

        canvas.addGLEventListener(this);
        canvas.addMouseListener(this);
        canvas.addMouseMotionListener(this);
        canvas.addKeyListener(this);

        wantToGetColor = false;
        wantToGetDepth = false;
        wantToGetContourns = false;
        wantToDebugProjectedViews = false;

        //-----------------------------------------------------------------
        doDistanceField = false;
        distanceFieldSide = 320;

        if ( doDistanceField ) {
            projectedViewRenderer = new JoglProjectedViewRenderer(distanceFieldSide, distanceFieldSide, true);
        }
        else {
            projectedViewRenderer = new JoglProjectedViewRenderer(640, 640, true);
        }

        //-----------------------------------------------------------------
        JoglView view;
        int i;

        views = new ArrayList<JoglView>();
        viewOrganizer = new ViewOrganizer();
        fullViewport = false;
        viewOrderStyle = 0;
        selectedView = 2;

        for ( i = 0; i < 4; i++ ) {
            view = new JoglView();
            view.hintConfig(4, i);
            views.add(view);
        }
        selectedView = viewOrganizer.doLayout(views, fullViewport?selectedView:-1, viewOrderStyle);
    }

    private void createCursors()
    {
        Toolkit awtToolkit = Toolkit.getDefaultToolkit();
        java.awt.Image i;

        i = awtToolkit.getImage("./etc/cursors/cursor_camrotate.gif");
        camrotateCursor = awtToolkit.createCustomCursor(i, new Point(16, 16), "CameraRotation");

        i = awtToolkit.getImage("./etc/cursors/cursor_camtranslate.gif");
        camtranslateCursor = awtToolkit.createCustomCursor(i, new Point(16, 16), "CameraTranslation");

        i = awtToolkit.getImage("./etc/cursors/cursor_camadvance.gif");
        camadvanceCursor = awtToolkit.createCustomCursor(i, new Point(16, 16), "CameraAdvance");

        selectCursor = new Cursor(Cursor.DEFAULT_CURSOR);

    }

    public void rotateBackground()
    {
        theScene.selectedBackground++;
        if ( theScene.selectedBackground > 2 ) {
            theScene.selectedBackground = 0;
        }
    }

    public GLCanvas getCanvas()
    {
        return canvas;
    }

    private void drawGizmos(GL gl)
    {
        // Pending: Turn off scene light and turn on gizmo specific lighting
        translationGizmoDrawn = false;

        translationGizmo.setCamera(theScene.activeCamera);

        gl.glClear(gl.GL_DEPTH_BUFFER_BIT);

        int firstThingSelected = theScene.selectedThings.firstSelected();

        if ( interactionMode == TRANSLATE_INTERACTION_MODE ||
             (interactionMode == CAMERA_INTERACTION_MODE &&
              lastInteractionMode == TRANSLATE_INTERACTION_MODE) ) {
            if ( firstThingSelected >= 0 ) {
                Vector3D position;
                SimpleBody gi;

                gi = theScene.scene.getSimpleBodies().get(firstThingSelected);

                Matrix4x4 composed;

                position = gi.getPosition();
                //composed = new Matrix4x4(gi.getRotation());
                composed = new Matrix4x4();
                composed.M[0][3] = position.x;
                composed.M[1][3] = position.y;
                composed.M[2][3] = position.z;
                translationGizmo.setTransformationMatrix(composed);

                JoglTranslateGizmoRenderer.draw(gl, translationGizmo);
                translationGizmoDrawn = true;
            }
        }
        else if ( interactionMode == ROTATE_INTERACTION_MODE ) {
            if ( firstThingSelected >= 0 ) {
                Vector3D position;
                SimpleBody gi;

                gi = theScene.scene.getSimpleBodies().get(firstThingSelected);

                position = gi.getPosition();
                rotateGizmo.setTransformationMatrix(gi.getRotation());
                JoglRotateGizmoRenderer.draw(gl, rotateGizmo, position);
            }
        }
        else if ( interactionMode == SCALE_INTERACTION_MODE ) {
            if ( firstThingSelected >= 0 ) {
                Vector3D position;
                SimpleBody gi;

                gi = theScene.scene.getSimpleBodies().get(firstThingSelected);

                position = gi.getPosition();
                scaleGizmo.setTransformationMatrix(gi.getRotation());
                JoglScaleGizmoRenderer.draw(gl, scaleGizmo, position);
            }
        }
        gl.glEnable(gl.GL_DEPTH_TEST);
    }

    private Image createProjectedView(GL gl, SimpleBodyGroup referenceBodies, int cam)
    {
        //- Will render a normalized body inside the unit cube ------------
        double minmax[];
        SimpleBodyGroup bodySet = new SimpleBodyGroup();
        int i;

        Vector3D p;
        {
            //-----------------------------------------------------------------
            minmax = referenceBodies.getMinMax();
            Vector3D min, max, s;
            min = new Vector3D(minmax[0], minmax[1], minmax[2]);
            max = new Vector3D(minmax[3], minmax[4], minmax[5]);
            s = new Vector3D(max.x - min.x, max.y - min.y, max.z - min.z);

            double maxsize = s.x;
            if ( s.y > maxsize ) maxsize = s.y;
            if ( s.z > maxsize ) maxsize = s.z;
            // The 95% scale factor is to allow a full render of the object to
            // fit inside the rendered view
            s.x = s.y = s.z = (2/maxsize) * 0.95;

            p = max.add(min);
            p = p.multiply(-1/maxsize);

            bodySet.setPosition(p);
            bodySet.setScale(s);
            //-----------------------------------------------------------------
            SimpleBody referenceBody;
            SimpleBody framedBody;

            for ( i = 0; i < referenceBodies.getBodies().size(); i++ ) {
                referenceBody = referenceBodies.getBodies().get(i);
                framedBody = new SimpleBody();
                framedBody.setGeometry(referenceBody.getGeometry());
                framedBody.setPosition(referenceBody.getPosition());
                framedBody.setRotation(referenceBody.getRotation());
                framedBody.setRotationInverse(referenceBody.getRotationInverse());