swingtest.java

《Java 3D编程》的源代码

/**********************************************************
  Copyright (C) 2001 	Daniel Selman

  First distributed with the book "Java 3D Programming"
  by Daniel Selman and published by Manning Publications.
  http://manning.com/selman

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation, version 2.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  The license can be found on the WWW at:
  http://www.fsf.org/copyleft/gpl.html

  Or by writing to:
  Free Software Foundation, Inc.,
  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  Authors can be contacted at:
   Daniel Selman: [e-mail]

  If you make changes you think others would like, please 
  contact one of the authors or someone at the 
  www.j3d.org web site.
**************************************************************/

package org.selman.java3d.book.swingtest;

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.io.*;

import javax.media.j3d.*;
import javax.vecmath.*;
import javax.swing.*;

import com.sun.image.codec.jpeg.*;

/**
*	This example displays a Swing based application
*	with a JMenuBar that allows you to switch between
*	displaying a Cube and a Sphere. You can also
*	perform a simple screen capture and start/stop
*	rotation using menu commands.
*/
public class SwingTest extends JPanel implements ActionListener
{
	/**
	*	the is root of the scenegraph which contains 
	*	the cube and sphere objects
	*/
	private BranchGroup 			sceneBranchGroup = null;

	/**
	*	a rotation interpolator that automatically
	*	rotates the cube and sphere
	*/
	private RotationInterpolator 	rotator = null;

	/**
	*	an offscreen Canvas3D that is used to 
	*	perform screen captures
	*/
	private Canvas3D 				offScreenCanvas3D = null;

	/**
	*	the image that is attached to the offscreen
	*	Canvas3D and contains the results of screen captures
	*/
	private ImageComponent2D 		imageComponent = null;

	/**
	*	the width of the offscreen Canvas3D
	*/
	private static final int		offScreenWidth = 400;

	/**
	*	the height of the offscreen Canvas3D
	*/
	private static final int		offScreenHeight = 400;


	/**
	*	Constructor. 
	*	Set the layout algorithm for the panel and initialize the 
	*	Java 3D rendering system and view side scenegraph.
	*/
	public SwingTest( )
	{
		setLayout( new BorderLayout( ) );		
		init( );		
	}

	/**
	*	Initialize the Java 3D rendering system and view side scenegraph.
	*/
	protected void init( )
	{
		VirtualUniverse universe = createVirtualUniverse( );

		Locale locale = createLocale( universe );

		BranchGroup sceneBranchGroup = createSceneBranchGroup( );

		Background background = createBackground( );

		if( background != null )
			sceneBranchGroup.addChild( background );

		ViewPlatform vp = createViewPlatform( );
		BranchGroup viewBranchGroup = createViewBranchGroup( getViewTransformGroupArray( ), vp );

		locale.addBranchGraph( sceneBranchGroup );
		addViewBranchGroup( locale, viewBranchGroup );

		createView( vp );
	}

	/**
	*	Callback to allow the Canvas3D to be added to a Panel.
	*/
	protected void addCanvas3D( Canvas3D c3d )
	{
		add( c3d, BorderLayout.CENTER );
	}

	/**
	*	Create a Java 3D View and attach it to a ViewPlatform
	*/
	protected View createView( ViewPlatform vp )
	{
		View view = new View( );

		PhysicalBody pb = createPhysicalBody( );
		PhysicalEnvironment pe = createPhysicalEnvironment( );

		view.setPhysicalEnvironment( pe );
		view.setPhysicalBody( pb );

		if( vp != null )
			view.attachViewPlatform( vp );

		view.setBackClipDistance( getBackClipDistance( ) );
		view.setFrontClipDistance( getFrontClipDistance( ) );

		// create the visible canvas		
		Canvas3D c3d = createCanvas3D( false );
		view.addCanvas3D( c3d );

		// create the off screen canvas
		view.addCanvas3D( createOffscreenCanvas3D( ) );

		// add the visible canvas to a component
		addCanvas3D( c3d );

		return view;
	}

	/**
	*	Create a Background for the Canvas3D.
	*/
	protected Background createBackground( )
	{
		Background back = new Background( new Color3f( 0.9f, 0.9f, 0.9f ) );
		back.setApplicationBounds( createApplicationBounds( ) );
		return back;
	}

	/**
	*	Create a Bounds object for the scene.
	*/
	protected Bounds createApplicationBounds( )
	{
		return new BoundingSphere( new Point3d( 0.0,0.0,0.0 ), 100.0 );
	}

	/**
	*	Create a Canvas3D.
	*	@param offscreen true to specify an offscreen canvas
	*/
	protected Canvas3D createCanvas3D( boolean offscreen )
	{
		GraphicsConfigTemplate3D gc3D = new GraphicsConfigTemplate3D( );
		gc3D.setSceneAntialiasing( GraphicsConfigTemplate.PREFERRED );
		GraphicsDevice gd[] = GraphicsEnvironment.getLocalGraphicsEnvironment( ).getScreenDevices( );

		Canvas3D c3d = new Canvas3D( gd[0].getBestConfiguration( gc3D ), offscreen );
		c3d.setSize( 500, 500 );

		return c3d;
	}

	/**
	*	Initialize an offscreen Canvas3D.
	*/
	protected Canvas3D createOffscreenCanvas3D( )
	{
		offScreenCanvas3D = createCanvas3D( true );
		offScreenCanvas3D.getScreen3D( ).setSize( offScreenWidth, offScreenHeight );
		offScreenCanvas3D.getScreen3D( ).setPhysicalScreenHeight( 0.0254/90 * offScreenHeight );
		offScreenCanvas3D.getScreen3D( ).setPhysicalScreenWidth( 0.0254/90 * offScreenWidth );

		RenderedImage renderedImage = new BufferedImage( offScreenWidth, offScreenHeight, BufferedImage.TYPE_3BYTE_BGR );
		imageComponent = new ImageComponent2D( ImageComponent.FORMAT_RGB8, renderedImage );
		imageComponent.setCapability( ImageComponent2D.ALLOW_IMAGE_READ );
		offScreenCanvas3D.setOffScreenBuffer( imageComponent );

		return offScreenCanvas3D;
	}

	/**
	*	Callback to get the scale factor for the View side of the scenegraph
	*/
	protected double getScale( )
	{
		return 3;
	}

	/**
	*	Get the TransformGroup for the View side of the scenegraph
	*/
	public TransformGroup[] getViewTransformGroupArray( )
	{
		TransformGroup[] tgArray = new TransformGroup[1];
		tgArray[0] = new TransformGroup( );

		// move the camera BACK a little...
		// note that we have to invert the matrix as 
		// we are moving the viewer
		Transform3D t3d = new Transform3D( );
		t3d.setScale( getScale( ) );
		t3d.setTranslation( new Vector3d( 0.0, 0.0, -20.0 ) );
		t3d.invert( );
		tgArray[0].setTransform( t3d );

		return tgArray;
	}

	/**
	*	Adds the View side of the scenegraph to the Locale
	*/
	protected void addViewBranchGroup( Locale locale, BranchGroup bg )
	{
		locale.addBranchGraph( bg );
	}

	/**
	*	Create a Locale for the VirtualUniverse
	*/
	protected Locale createLocale( VirtualUniverse u )
	{
		return new Locale( u );
	}

	/**
	*	Create the scene side of the scenegraph
	*/
	protected BranchGroup createSceneBranchGroup( )
	{
		// create the root of the scene side scenegraph
		BranchGroup objRoot = new BranchGroup( );

		// create a TransformGroup to rotate the objects in the scene
		// set the capability bits on the TransformGroup so that it
		// can be modified at runtime
		TransformGroup objTrans = new TransformGroup( );
		objTrans.setCapability( TransformGroup.ALLOW_TRANSFORM_WRITE );
		objTrans.setCapability( TransformGroup.ALLOW_TRANSFORM_READ );

		// create a spherical bounding volume
		BoundingSphere bounds =	new BoundingSphere( new Point3d( 0.0,0.0,0.0 ), 100.0 );

		// create a 4x4 transformation matrix
		Transform3D yAxis = new Transform3D( );

		// create an Alpha interpolator to automatically generate
		// modifications to the rotation component of the transformation matrix
		Alpha rotationAlpha = new Alpha( -1, Alpha.INCREASING_ENABLE,
			0, 0,
			4000, 0, 0,
			0, 0, 0 );

		// create a RotationInterpolator behavior to effect the TransformGroup
		rotator = new RotationInterpolator( rotationAlpha, objTrans, yAxis, 0.0f, (float) Math.PI*2.0f );

		// set the scheduling bounds on the behavior
		rotator.setSchedulingBounds( bounds );

		// add the behavior to the scenegraph
		objTrans.addChild( rotator );

		// create the BranchGroup which contains the objects
		// we add/remove to and from the scenegraph
		sceneBranchGroup = new BranchGroup( );

		// allow the BranchGroup to have children added at runtime 
		sceneBranchGroup.setCapability( Group.ALLOW_CHILDREN_EXTEND );
		sceneBranchGroup.setCapability( Group.ALLOW_CHILDREN_READ );
		sceneBranchGroup.setCapability( Group.ALLOW_CHILDREN_WRITE );

		// add both the cube and the sphere to the scenegraph
		sceneBranchGroup.addChild( createCube( ) );
		sceneBranchGroup.addChild( createSphere( ) );

		// create the colors for the lights
		Color3f lColor1 = new Color3f( 0.7f,0.7f,0.7f );
		Vector3f lDir1  = new Vector3f( -1.0f,-1.0f,-1.0f );
		Color3f alColor = new Color3f( 0.2f,0.2f,0.2f );

		// create the ambient light
		AmbientLight aLgt = new AmbientLight( alColor );
		aLgt.setInfluencingBounds( bounds );

		// create the directional light
		DirectionalLight lgt1 = new DirectionalLight( lColor1, lDir1 );
		lgt1.setInfluencingBounds( bounds );

		// add the lights to the scenegraph