/* -------------------------------------------------------------------
    * Java source file for the class BasicRenderer
    * 
    * Copyright (c), 2003, Masahiro Takatsuka.
    * All Rights Researved.
    * 
    * Original Author: Masahiro Takatsuka (masa@jbeans.net)
    * $Author: takatsukam $
    * 
   * $Date: 2004/03/03 11:53:06 $
   * 
   * $Id: BasicRenderer.java,v 1.3 2004/03/03 11:53:06 takatsukam Exp $
   * 
   * Reference:		Document no:
   * ___				___
   * 
   * To Do:
   * ___
   * 
  ------------------------------------------------------------------- */
  
  /* --------------------------- Package ---------------------------- */
  package net.jbeans.j3d.renderer;
  
  /* ------------------ Import classes (packages) ------------------- *//package-summary/html">class="comment"> ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment">/* ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment"> ------------------ Import classes (packages) ------------------- */
  import java.awt.*;
  import java.io.*;
  import javax.media.j3d.*;
  import javax.swing.*;
  import javax.vecmath.*;
  import com.sun.j3d.loaders.*;
  import com.sun.j3d.utils.picking.*;
  import com.sun.j3d.utils.universe.*;
  
  import net.jbeans.ui.*;
  import net.jbeans.j3d.transform.*;
  import net.jbeans.j3d.universe.*;
  
  import net.jbeans.util.debug.*;
  
  /*====================================================================
                  Implementation of class BasicRenderer                 
  ====================================================================*/
  /***
   * A BasicRenderer is a frame containing objects (2D and 3D canvas,
   * button, dials, etc.) used to manipulate rendered object.
   * 
   * @version $Revision: 1.3 $
   * @author Masahiro Takatsuka (masa@jbeans.net)
   * @see JPanel
   * @see Externalizable
   */
  
  public abstract class BasicRenderer extends JPanel implements Externalizable {
  	private static final boolean DEBUG = Debug.getDebugFlag(BasicRenderer.class);
  
  	public static final BoundingSphere DEFAULT_BOUNDS = new BoundingSphere(new Point3d(0.0, 0.0, 0.0), 2000000.0);
  	
  	protected static final int MRG = 10;
  	protected static final int YGAP = 5;
  	protected static final int DEFAULT_CANVAS3D_WIDTH  = 400;
  	protected static final int DEFAULT_CANVAS3D_HEIGHT = 400;
  	protected static final int DEFAULT_CANVAS3D_TOP = 0 ;
  	
  	/* -------------------------- serialized -------------------------- */
  	protected Color backColor;
  	private boolean stereoEnable = false;
  	private double eyeSeparation = 0.0066;
  	private int windowEyepointPolicy = View.RELATIVE_TO_FIELD_OF_VIEW;
  	
  	/* ------------------------ not serialized ------------------------ */
  	/***
  	* A Universe.
  	*/
  	transient protected Universe universe = null;
  
  	/***
  	* A canvas to render 3D objects.
  	*/
  	transient protected Canvas3D canvas3D;
  
  	/***
  	 * background leaf.
  	 */
  	transient Background background;
  
  	transient JPanel initRendererPanel;
  	
  	/***
  	 * Constructs a new BasicRenderer object.
  	 *                                         Masahiro Takatsuka/1999-Jun-11
  	 */
  	BasicRenderer() {
  		this("Basic Renderer");
  	}
  
  	/***
  	* Constructs a new Renderer object.
  	*                                         Masahiro Takatsuka/1999-Jun-11
 	*/
 	BasicRenderer(String title) {
 		super();
 		this.backColor = Color.black;
 		initialize(title);
 	}
 
 	private void initialize(String title) {
 		init3D();				// initialize 3D.
 		initUI(title);			// initialize UI.
 		setVisible(true);
 		setBackgroundColor(this.backColor);
 		setEyeSeparation();		// set the default eye separation 0.0066.
 	}
 
 	public boolean getStereoEnable() {
 		return this.stereoEnable;
 	}
 		
 	public void setStereoEnable(boolean b) {
 		this.stereoEnable = b;
 		setEyeSeparation();
 		this.canvas3D.setStereoEnable(b);
 	}
 
 	private void setEyeSeparation() {
 		PhysicalBody myBody = this.canvas3D.getView().getPhysicalBody();
 		myBody.setRightEyePosition(new Point3d(this.eyeSeparation/2.0, 0.0, 0.0));
 		myBody.setLeftEyePosition(new Point3d( - this.eyeSeparation/2.0, 0.0, 0.0));
 	}
 
 	public void setEyeSeparation(double eyeseparation) {
 		this.eyeSeparation = eyeseparation;
 		setEyeSeparation();
 	}
 
 	public double getEyeSeparation() {
 		return this.eyeSeparation;
 	}
 	
 	public void setWindowEyepointPolicy(int policy) {
 		switch(policy) {
 		case View.RELATIVE_TO_SCREEN:
 			break;
 		case View.RELATIVE_TO_WINDOW:
 			break;
 		case View.RELATIVE_TO_COEXISTENCE:
 			break;
 		case View.RELATIVE_TO_FIELD_OF_VIEW:
 		default:
 			policy = View.RELATIVE_TO_FIELD_OF_VIEW;
 			break;
 		}
 		this.windowEyepointPolicy = policy;
 		this.canvas3D.getView().setWindowEyepointPolicy(this.windowEyepointPolicy);		
 	}
 
 	public int getWindowEyepointPolicy() {
 		return this.windowEyepointPolicy;
 	}
 	
 	public void setBackgroundColor(Color color) {
 		this.backColor = color;
 		float[] col4f = new float[4];
 		this.backColor.getComponents(col4f);
 		this.background.setColor(col4f[0],
 								 col4f[1],
 								 col4f[2]);
 	}
 
 	public Color getBackgroundColor() {
 		return this.backColor;
 	}
 
     /***
      * Serialization methods
      */
     public void readExternal(ObjectInput in) throws ClassNotFoundException, IOException {
 		String title = (String) in.readObject();
 		this.backColor = (Color) in.readObject();
 		initialize(title);
     }
 
     /***
      * Serialization methods
      */
     public void writeExternal(ObjectOutput out) throws IOException {
 		out.writeObject(getName());
 		out.writeObject(this.backColor);
     }
 
 	/***
 	 * Initializing GUI
 	 *                                         Masahiro Takatsuka/1999-Jun-11
 	 */
 	private void initUI(String title) {
   		setName(title);
 
 		// set a Borderlayout as a layout manager.
 		setLayout(new BorderLayout());
 
 		// Create the "base" color for the AWT components.
 		setBackground(new Color(100, 100, 100));
 		this.initRendererPanel = initRendererPanel();
 		add(this.initRendererPanel, BorderLayout.CENTER);
 	}
 
 	protected JPanel initRendererPanel() {
 		// Create the canvas container.
 		JPanel renderPanel = new JPanel();
 		renderPanel.setSize(DEFAULT_CANVAS3D_WIDTH+MRG*2, DEFAULT_CANVAS3D_HEIGHT+MRG*2);
 		renderPanel.setLayout(new BorderLayout());
 		renderPanel.setBackground( Color.darkGray );
 		// Add the 3D canvas to the container.
 		renderPanel.add(this.canvas3D, BorderLayout.CENTER);
 
 		return renderPanel;
 	}
 
 	/***
 	* Initializes 3D related stuff.
 	* <PRE>
 	* </PRE>
 	*
 	* @return void
 	*/
 	private void init3D() {
 		GraphicsConfiguration gc = Universe.getPreferredConfiguration();
 		this.canvas3D = new Canvas3D(gc);	// Create a 3D graphics canvas.
 		this.canvas3D.setSize(DEFAULT_CANVAS3D_WIDTH, DEFAULT_CANVAS3D_HEIGHT);
 		this.universe = createUniverse(this.canvas3D); // create universe.
 		
 		// Set background color
   		Color3f bgColor = new Color3f(0.17f, 0.65f, 0.92f);
 		this.background = new Background(bgColor);
 		this.background.setCapability(Background.ALLOW_COLOR_READ);
 		this.background.setCapability(Background.ALLOW_COLOR_WRITE);
 		this.background.setApplicationBounds(DEFAULT_BOUNDS);
 		BranchGroup bg = new BranchGroup();
 		bg.addChild(this.background);
 		this.universe.addBranchGraph(bg);
 
 		// This will move the ViewPlatform back a bit so the
 		// objects in the scene can be viewed.
   		this.universe.getViewingPlatform().setNominalViewingTransform();
 
 		// Change transparency settings to get proper ordering of transparent objects
 		this.universe.getViewer().getView().setTransparencySortingPolicy(View.TRANSPARENCY_SORT_GEOMETRY);
 		this.universe.getViewer().getView().setDepthBufferFreezeTransparent(false);
 	}
 
 	protected abstract Universe createUniverse(Canvas3D canvas3d);
 //    	protected Universe createUniverse(Canvas3D canvas3d) {
 //    		return new Universe(canvas3d);
 //    	}
 
 	/***
 	* sets projection type.
 	*
 	* @param projection Either View.PERSPECTIVE_PROJECTION or
 	* View.PARALLEL_PROJECTION.  If other values are set,
 	* View.PERSPECTIVE_PROJECTION will be used.
 	*/
 	public void setProjection(int projection) {
 		projection = (projection == View.PARALLEL_PROJECTION) ?
 			View.PARALLEL_PROJECTION : View.PERSPECTIVE_PROJECTION;
         this.canvas3D.getView().setProjectionPolicy(projection);
 	}
 
 	public int getProjection() {
         return this.canvas3D.getView().getProjectionPolicy();
 	}
 	
 	/***
 	 * Sets the projection to PERSPECTIVE.
 	 */
 	public void setPerspectiveProjection() {
 		setProjection(View.PERSPECTIVE_PROJECTION);
 	}
 
 	/***
 	 * Sets the projection to PARALLEL_PROJECTION.
 	 */
 	public void setParallelProjection() {
 		setProjection(View.PARALLEL_PROJECTION);
 	}
 
 	/***
 	 * Returns an universe.
 	* <PRE>
 	* </PRE>
 	*
 	* @return VirtualUniverse
 	*/
 	public VirtualUniverse getUniverse() {
 		return this.universe;
 	}
 
 	/***
 	 * Returns a canvas3D object.
 	 * <PRE>
 	 * </PRE>
 	 *
 	 * @return Canvas3D
 	 */
 	public Canvas3D getCanvas3D() {
 		return this.canvas3D;
 	}
 
 	/***
 	 * Adds a new branch graphoup to the scene.
 	 * <PRE>
 	 * </PRE>
 	 *
 	 * @param branch BranchGroup object to be added.
 	 * @return void
 	 */
 	public void addBranchGraph(BranchGroup branch) {
 		try {
 			Node parent = branch.getParent();
 			if (parent != null) {
 				// it is already a part of a scene graph!
 				// don't do anything, just return
 				if (DEBUG) {
 					System.out.println("BasicRenderer.addBranchGraph() : it already has a parent");
 				}
 				return;
 			}
 			// else
 			if (DEBUG) {
 				System.out.println("BasicRenderer.addBranchGraph() : adding " + branch);
 			}
 			/*
 			* Nothing can be added to the live emtpy BranchGroup.
 			* I think this is a Java3D's bug.
 			* The following is the work around.
 			* I'm adding a default BoundingSphere for an empty BranghGroup.
 			* Masahiro Takatsuka/2001-Jul-14
 			*/
 			branch.setCapability(Node.ALLOW_BOUNDS_READ);
 			branch.setCapability(Node.ALLOW_BOUNDS_WRITE);
 			if (branch.getBounds().isEmpty()) {		
 				branch.setBounds(new BoundingSphere());
 			}
 
 			branch.setCapability(Group.ENABLE_PICK_REPORTING);
 			this.universe.addBranchGraph(branch);
 		} catch (Exception e) {// javax.media.j3d.RestrictedAccessException
 			// it is already a part of a scene graph!
 			// don't do anything, just return
 			if (DEBUG) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	/***
 	 * Adds a new branch graphoup to the scene.
 	 * <PRE>
 	 * </PRE>
 	 *
 	 * @param branch BranchGroup object to be added.
 	 * @return void
 	 */
 	public void addBranchGraph(Object branch) {
 		if (branch instanceof BranchGroup) {
 			addBranchGraph((BranchGroup) branch);
 		}
 	}
 	
 	public void detachBranchGraph(BranchGroup branch) {
 		if (DEBUG) {
 			System.out.println("removing : " + branch);
 		}
 		this.universe.removeBranchGraph(branch);
 	}
 
 	public void detachAllBranchGraph() {
 		this.universe.removeAllBranchGraph();
 	}
 	
 	/***
 	 * Adds a specified scene to the current universe.
 	 * <P>
 	 * this is no longer used.
 	 *
 	 * @param scene Scene object to be added.
 	 * @return void
 	 */
 	private void addScene(Scene scene) {
 		BranchGroup sceneGroup = scene.getSceneGroup();
 		BranchGroup g = new BranchGroup();
 		g.setCapability(Group.ENABLE_PICK_REPORTING);
 
 		Behavior[] behaviors = scene.getBehaviorNodes();
 		ResettableTransformGroup ptg = new ResettableTransformGroup();
 
 		ptg.setBounds(DEFAULT_BOUNDS);
 		ptg.enableMouseBehaviors();
 		ptg.addChild(sceneGroup);
 		if (behaviors != null) {	// there are behaviors!
 			for (int i = 0; i < behaviors.length; i++) {
 				ptg.addChild(behaviors[i]);
 			}
 		}
 		g.addChild(ptg);
 		this.universe.addBranchGraph(g);
 	}
 }