import javax.media.j3d.View; //导入依赖的package包/类
public Java3dRenderingViewer( Java3dSceneGraph scene, CapturingCanvas3D canvas )
    {
        super();

//        GraphicsConfiguration gc = SimpleUniverse .getPreferredConfiguration();
        mCanvas = canvas; // new CapturingCanvas3D( gc );

        mScene = scene;

        viewTransform = new TransformGroup();
        view = new View();
        mScene .addView( initView( view, viewTransform, mCanvas ) );
            
        mLights = mScene .getLightsGroup();
        mFog = mScene .getFog();
        
        mPickCanvas = new PickCanvas( mCanvas,  mScene .getRoot() );
        mPickCanvas .setMode( PickTool.GEOMETRY );
        mPickCanvas .setTolerance( 0.1f );
    }
 

import javax.media.j3d.View; //导入依赖的package包/类
private static BranchGroup initView( View view, TransformGroup trans, Canvas3D canvas )
{
    ViewPlatform vp = new ViewPlatform();
    trans .setCapability( TransformGroup .ALLOW_TRANSFORM_WRITE );
    BranchGroup bg = new BranchGroup();
    bg .addChild( trans );
    trans .addChild( vp );
    view .addCanvas3D( canvas );
    view .setPhysicalBody( new PhysicalBody() );
    view .setPhysicalEnvironment( new PhysicalEnvironment() );
    view .attachViewPlatform( vp );
    view .setFrontClipPolicy( View.VIRTUAL_EYE );
    view .setBackClipPolicy( View.VIRTUAL_EYE );
    view .setScreenScalePolicy( View .SCALE_EXPLICIT );
    return bg;
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * Create a new canvas given the graphics configuration
 * No timing information will be displayed
 *
 * @param gc The graphics configuration to use for the canvas
 */
public ElumensCanvas3D(GraphicsConfiguration gc, View view, EventModelEvaluator eme, boolean sEvent, int numChannels) {
    super(gc,false, view);

    eventModel = eme;
    runEventModel = false;
    this.sEvent = sEvent;
    this.view = view;
    spi = new SPI();
    this.numChannels = numChannels;
    listeners = new ArrayList();
    coordinateSources = new ArrayList();

    near = 0.1f;
    far = 5000f;
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * Returns a new 3D universe that displays <code>home</code> objects.
 */
private SimpleUniverse createUniverse(boolean displayShadowOnFloor, boolean listenToHomeUpdates,
		boolean waitForLoading)
{
	// Create a universe bound to no canvas 3D
	ViewingPlatform viewingPlatform = new ViewingPlatform();
	// Add an interpolator to view transform to get smooth transition 
	TransformGroup viewPlatformTransform = viewingPlatform.getViewPlatformTransform();
	CameraInterpolator cameraInterpolator = new CameraInterpolator(viewPlatformTransform);
	cameraInterpolator.setSchedulingBounds(new BoundingSphere(new Point3d(), 1E7));
	viewPlatformTransform.addChild(cameraInterpolator);
	viewPlatformTransform.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
	
	Viewer viewer = new Viewer(new Canvas3D[0]);
	SimpleUniverse universe = new SimpleUniverse(viewingPlatform, viewer);
	
	View view = viewer.getView();
	view.setTransparencySortingPolicy(View.TRANSPARENCY_SORT_GEOMETRY);
	
	// Update field of view from current camera
	updateView(view, this.home.getCamera(), this.home.getTopCamera() == this.home.getCamera());
	
	// Update point of view from current camera
	updateViewPlatformTransform(viewPlatformTransform, this.home.getCamera(), false);
	
	// Add camera listeners to update later point of view from camera
	if (listenToHomeUpdates)
	{
		addCameraListeners(view, viewPlatformTransform);
	}
	
	// Link scene matching home to universe
	universe.addBranchGraph(createSceneTree(displayShadowOnFloor, listenToHomeUpdates, waitForLoading));
	
	return universe;
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * Returns an image of the home viewed by this component at the given size.
 */
public BufferedImage getOffScreenImage(int width, int height)
{
	List<Selectable> selectedItems = this.home.getSelectedItems();
	SimpleUniverse offScreenImageUniverse = null;
	try
	{
		View view;
		if (this.offscreenUniverse == null)
		{
			offScreenImageUniverse = createUniverse(this.displayShadowOnFloor, false, true);
			view = offScreenImageUniverse.getViewer().getView();
			// Replace textures by clones because Java 3D doesn't accept all the time 
			// to share textures between offscreen and onscreen environments 
			Map<Texture, Texture> replacedTextures = new HashMap<Texture, Texture>();
			for (Enumeration it = offScreenImageUniverse.getLocale().getAllBranchGraphs(); it.hasMoreElements();)
			{
				cloneTexture((Node) it.nextElement(), replacedTextures);
			}
		}
		else
		{
			view = this.offscreenUniverse.getViewer().getView();
		}
		
		// Empty temporarily selection to create the off screen image
		List<Selectable> emptySelection = Collections.emptyList();
		this.home.setSelectedItems(emptySelection);
		return Component3DManager.getInstance().getOffScreenImage(view, width, height);
	}
	finally
	{
		// Restore selection
		this.home.setSelectedItems(selectedItems);
		if (offScreenImageUniverse != null)
		{
			offScreenImageUniverse.cleanup();
		}
	}
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * Adds listeners to home to update point of view from current camera.
 */
private void addCameraListeners(final View view, final TransformGroup viewPlatformTransform)
{
	this.cameraChangeListener = new PropertyChangeListener()
	{
		public void propertyChange(PropertyChangeEvent ev)
		{
			// Update view transform later to avoid flickering in case of multiple camera changes 
			EventQueue.invokeLater(new Runnable()
			{
				public void run()
				{
					updateView(view, home.getCamera(), home.getTopCamera() == home.getCamera());
					updateViewPlatformTransform(viewPlatformTransform, home.getCamera(), true);
				}
			});
		}
	};
	this.home.getCamera().addPropertyChangeListener(this.cameraChangeListener);
	this.homeCameraListener = new PropertyChangeListener()
	{
		public void propertyChange(PropertyChangeEvent ev)
		{
			updateView(view, home.getCamera(), home.getTopCamera() == home.getCamera());
			updateViewPlatformTransform(viewPlatformTransform, home.getCamera(), false);
			// Add camera change listener to new active camera
			((Camera) ev.getOldValue()).removePropertyChangeListener(cameraChangeListener);
			home.getCamera().addPropertyChangeListener(cameraChangeListener);
		}
	};
	this.home.addPropertyChangeListener(Home.Property.CAMERA, this.homeCameraListener);
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * Sets whether the component 3D should use parallel or perspective projection.
 */
protected void setParallelProjection(boolean parallelProjection)
{
	this.parallelProjection = parallelProjection;
	if (this.universe != null)
	{
		this.universe.getViewer().getView()
				.setProjectionPolicy(parallelProjection ? View.PARALLEL_PROJECTION : View.PERSPECTIVE_PROJECTION);
	}
}
 

import javax.media.j3d.View; //导入依赖的package包/类
void createViewPlatform() {
	// viewplatform
	viewPlatform = new ViewPlatform();
	viewPlatform.setActivationRadius(100f);
	viewPlatform.setViewAttachPolicy(View.NOMINAL_HEAD);
	// view
	view = new View();

	view.setProjectionPolicy(View.PERSPECTIVE_PROJECTION);
	view.setViewPolicy(View.SCREEN_VIEW);
	view.attachViewPlatform(viewPlatform);
	// physical body
	PhysicalBody phyBody = new PhysicalBody();
	view.setPhysicalBody(phyBody);
	// physical environment
	PhysicalEnvironment phyEnv = new PhysicalEnvironment();
	view.setPhysicalEnvironment(phyEnv);
	// ???? pas compris , pour l'antiliasing
	GraphicsConfigTemplate3D template = new GraphicsConfigTemplate3D();
	template.setSceneAntialiasing(GraphicsConfigTemplate.PREFERRED);
	GraphicsConfiguration config = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getBestConfiguration(template);
	// antialiasing
	view.setSceneAntialiasingEnable(true);
	/*
	 * to add a onscreen canvas canvas3d = new Canvas3D(config);
	 * view.addCanvas3D(canvas3d);
	 */
	// attach offscreen canvas to the view
	offscreenCanvas3D = new OffScreenCanvas3D(config);
	offscreenCanvas3D.getScreen3D().setSize(imageWidth, imageWidth);
	offscreenCanvas3D.getScreen3D().setPhysicalScreenHeight(0.5);
	offscreenCanvas3D.getScreen3D().setPhysicalScreenWidth(0.5);
	view.addCanvas3D(offscreenCanvas3D);
	addChild(viewPlatform);
	// turn canvas in front of X axis
	rotateY(-Math.PI / 2);
}
 

import javax.media.j3d.View; //导入依赖的package包/类
public Renderer(View vw, Context ctx, Volume vol)
{
	view = vw;
	context = ctx;
	volume = vol;
	// debug = Boolean.getBoolean("debug");
	// timing = Boolean.getBoolean("timing");
}
 

import javax.media.j3d.View; //导入依赖的package包/类
public SlicePlane3DRenderer(View view, Context context, Volume vol)
{
	super(view, context, vol);
	texVol = new Texture3DVolume(context, vol);

	TransparencyAttributes transAttr = new TransparencyAttributes();
	transAttr.setTransparencyMode(TransparencyAttributes.BLENDED);
	texAttr = new TextureAttributes();
	texAttr.setTextureMode(TextureAttributes.MODULATE);
	texAttr.setCapability(TextureAttributes.ALLOW_COLOR_TABLE_WRITE);
	Material m = new Material();
	m.setLightingEnable(false);
	PolygonAttributes p = new PolygonAttributes();
	p.setCullFace(PolygonAttributes.CULL_NONE);
	p.setPolygonOffset(1.0f);
	p.setPolygonOffsetFactor(1.0f);
	appearance = new Appearance();
	appearance.setMaterial(m);
	appearance.setTextureAttributes(texAttr);
	appearance.setTransparencyAttributes(transAttr);
	appearance.setPolygonAttributes(p);
	appearance.setCapability(Appearance.ALLOW_TEXTURE_WRITE);
	appearance.setCapability(Appearance.ALLOW_TEXGEN_WRITE);

	shape = new Shape3D(null, appearance);
	shape.setCapability(Shape3D.ALLOW_GEOMETRY_READ);
	shape.setCapability(Shape3D.ALLOW_GEOMETRY_WRITE);

	root.addChild(shape);
}
 

import javax.media.j3d.View; //导入依赖的package包/类
public SlicePlaneRenderer(View view, Context context, Volume vol)
{
	super(view, context, vol);
	volRefPtAttr = (CoordAttr) context.getAttr("Vol Ref Pt");

	root = new BranchGroup();

	// subclasses add the slice geometry to root

	borderSwitch = new Switch(Switch.CHILD_ALL);
	borderSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);

	RenderingAttributes ra = new RenderingAttributes();
	ra.setDepthBufferEnable(true);
	ColoringAttributes bclr = new ColoringAttributes(0.4f, 0.4f, 0.4f,
			ColoringAttributes.SHADE_FLAT);
	Appearance ba = new Appearance();
	ba.setColoringAttributes(bclr);
	ba.setRenderingAttributes(ra);

	borderShape = new Shape3D(null, ba);
	borderShape.setCapability(Shape3D.ALLOW_GEOMETRY_WRITE);

	borderSwitch.addChild(borderShape);

	root.addChild(borderSwitch);

	root.setCapability(BranchGroup.ALLOW_DETACH);
	root.setCapability(Node.ALLOW_LOCAL_TO_VWORLD_READ);
}
 

import javax.media.j3d.View; //导入依赖的package包/类
public SlicePlane2DRenderer(View view, Context context, Volume vol)
{
	super(view, context, vol);
	texVol = new Texture2DVolume(context, vol);

	for (int i = 0; i < 4; i++)
	{
		shapeColrs[i] = new Color4f();
	}

	texAttr.setTextureMode(TextureAttributes.MODULATE);
	texAttr.setCapability(TextureAttributes.ALLOW_COLOR_TABLE_WRITE);
	trans.setTransparencyMode(TransparencyAttributes.BLENDED);
	trans.setSrcBlendFunction(TransparencyAttributes.BLEND_ONE);
	trans.setDstBlendFunction(TransparencyAttributes.BLEND_ONE);
	m.setLightingEnable(false);
	p.setCullFace(PolygonAttributes.CULL_NONE);
	r.setDepthBufferWriteEnable(false);

	// these are the default for no texture
	trans.setTransparency(0.0f);
	clr.setColor(0.0f, 0.0f, 0.0f);

	// set up an initial, empty slice
	sliceGroup.setCapability(Group.ALLOW_CHILDREN_READ);
	sliceGroup.setCapability(Group.ALLOW_CHILDREN_WRITE);
	sliceGroup.addChild(null);
	root.addChild(sliceGroup);
	numSlicePts = 0;
	setSliceGeo();
}
 

import javax.media.j3d.View; //导入依赖的package包/类
@Override
    public void setPerspective( double fov, double aspectRatio, double near, double far )
    {
        view .setProjectionPolicy( View.PERSPECTIVE_PROJECTION );
        view .setScreenScale( 1d );
        view .setFieldOfView( fov );
//        mLeftEyeView .setProjectionPolicy( View.PERSPECTIVE_PROJECTION );
//        mLeftEyeView .setScreenScale( 1d );
//        mLeftEyeView .setFieldOfView( fov );
        setDistances( near, far );
    }
 

import javax.media.j3d.View; //导入依赖的package包/类
@Override
    public void setOrthographic( double halfEdge, double near, double far )
    {
        view .setProjectionPolicy( View.PARALLEL_PROJECTION );
        view .setScreenScale( 1 / ( 6 * halfEdge ) );  // WHY 6???
//        mLeftEyeView .setProjectionPolicy( View.PARALLEL_PROJECTION );
//        mLeftEyeView .setScreenScale( 1 / ( 6 * halfEdge ) );  // WHY 6???
        setDistances( near, far );
    }
 

import javax.media.j3d.View; //导入依赖的package包/类
void createViewPlatform() {
  // viewplatform
  viewPlatform = new ViewPlatform();
  viewPlatform.setActivationRadius(100f);
  viewPlatform.setViewAttachPolicy(View.NOMINAL_HEAD);
  // view
  view = new View();

  view.setProjectionPolicy(View.PERSPECTIVE_PROJECTION);
  view.setViewPolicy(View.SCREEN_VIEW);
  view.attachViewPlatform(viewPlatform);
  // physical body
  PhysicalBody phyBody = new PhysicalBody();
  view.setPhysicalBody(phyBody);
  // physical environment
  PhysicalEnvironment phyEnv = new PhysicalEnvironment();
  view.setPhysicalEnvironment(phyEnv);
  // ???? pas compris , pour l'antiliasing
  GraphicsConfigTemplate3D template = new GraphicsConfigTemplate3D();
  template.setSceneAntialiasing(GraphicsConfigTemplate.PREFERRED);
  GraphicsConfiguration config = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getBestConfiguration(template);
  // antialiasing
  view.setSceneAntialiasingEnable(true);
  /*
   * to add a onscreen canvas canvas3d = new Canvas3D(config);
   * view.addCanvas3D(canvas3d);
   */
  // attach offscreen canvas to the view
  offscreenCanvas3D = new OffScreenCanvas3D(config);
  offscreenCanvas3D.getScreen3D().setSize(imageWidth, imageWidth);
  offscreenCanvas3D.getScreen3D().setPhysicalScreenHeight(0.5);
  offscreenCanvas3D.getScreen3D().setPhysicalScreenWidth(0.5);
  view.addCanvas3D(offscreenCanvas3D);
  addChild(viewPlatform);
  // turn canvas in front of X axis
  rotateY(-Math.PI / 2);
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * @param scale
 */
public void scaleParameters( double scale )
{
	View v = universe.getViewer( ).getView( );
	v.setBackClipDistance( v.getBackClipDistance( ) * scale );
	v.setFrontClipDistance( v.getFrontClipDistance( ) * scale );
	
	orbiter.setTransFactors( orbiter.getTransXFactor( ) * scale , orbiter.getTransYFactor( ) * scale );
	orbiter.setZoomFactor( orbiter.getZoomFactor( ) * scale );
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * @return la vue de l'interface
 */
public View getView() {
  return this.view;
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * Creates the universe to attach the scenegraph. Used only in the creation
 * phase.
 * 
 * @param ed
 *            the environment description.
 */
private void createUniverse(EnvironmentDescription ed) {
	System.out.println("create Universe");
	// show infos
	Map map = VirtualUniverse.getProperties();
	System.out.println("----------------------------------------");
	System.out.println("j3d.version = " + map.get("j3d.version"));
	System.out.println("j3d.vendor = " + map.get("j3d.vendor"));
	System.out.println("j3d.specification.version = " + map.get("j3d.specification.version"));
	System.out.println("j3d.specification.vendor = " + map.get("j3d.specification.vendor"));
	System.out.println("j3d.renderer = " + map.get("j3d.renderer"));
	System.out.println("J3DThreadPriority = " + VirtualUniverse.getJ3DThreadPriority());
	System.out.println("----------------------------------------");

	createCanvas3D();
	createSceneBranch(ed);

	universe = new VirtualUniverse();

	Locale locale = new Locale(universe);

	// Create and add VIEW branch
	// locale->viewBranch->viewTransformGroup->viewPlatform
	viewBranch = new BranchGroup();
	viewTransformGroup = new TransformGroup();
	viewTransformGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
	viewTransformGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
	Transform3D t3d = new Transform3D();
	t3d.setIdentity();
	viewTransformGroup.setTransform(t3d);
	viewBranch.addChild(viewTransformGroup);

	// Creates View and viewplatform
	viewPlatform = new ViewPlatform();
	viewPlatform.setViewAttachPolicy(View.NOMINAL_HEAD);
	viewPlatform.setActivationRadius(100);
	view = new View();
	view.setProjectionPolicy(View.PERSPECTIVE_PROJECTION);

	view.setViewPolicy(View.SCREEN_VIEW);
	view.setVisibilityPolicy(View.VISIBILITY_DRAW_ALL);

	view.setFrontClipDistance(0.02);

	GraphicsConfigTemplate3D template = new GraphicsConfigTemplate3D();
	template.setSceneAntialiasing(GraphicsConfigTemplate.REQUIRED);
	template.setDoubleBuffer(GraphicsConfigTemplate.PREFERRED);
	/*
	 * GraphicsConfiguration config = GraphicsEnvironment
	 * .getLocalGraphicsEnvironment().getDefaultScreenDevice()
	 * .getBestConfiguration(template);
	 */
	// request antialiasing
	view.setSceneAntialiasingEnable(true);

	view.addCanvas3D(canvas3d);
	PhysicalBody phyBody = new PhysicalBody();
	PhysicalEnvironment phyEnv = new PhysicalEnvironment();
	view.setPhysicalBody(phyBody);
	view.setPhysicalEnvironment(phyEnv);
	view.attachViewPlatform(viewPlatform);
	viewTransformGroup.addChild(viewPlatform);

	// Add both branch to the unique locale
	locale.addBranchGraph(viewBranch);
	locale.addBranchGraph(sceneBranch);

	// Add mouse control in the canvas3d
	mouseOrbiter = new MouseOrbiter(canvas3d, viewTransformGroup);

	// sets initial viewpoint
	changeViewPoint(ed.worldViewPoint, null);
}
 

import javax.media.j3d.View; //导入依赖的package包/类
public Axis2DRenderer(View view, Context context, Volume vol)
{
	super(view, context, vol);
	texVol = new Texture2DVolume(context, vol);
}
 

import javax.media.j3d.View; //导入依赖的package包/类
/**
 * Transform the point from local coords to window coords
 */
public void transformPt(Point3d localPt, Point2d windowPt)
{
	// TODO: throw some kind of error if node and canvas haven't been
	// set

	// System.out.println("vWorld Pt = " + localPt);

	localToImagePlate.transform(localPt, imagePlatePt);
	// System.out.println("imagePlatePt = " + imagePlatePt);

	double zScale = 1.0; // default, used for PARALELL_PROJECTION
	if (projType == View.PERSPECTIVE_PROJECTION)
	{
		// get the vector from eyePos to imagePlatePt
		projVec.sub(imagePlatePt, eyePos);

		// Scale this vector to make it end at the projection plane.
		// Scale is ratio :
		// eye->imagePlate Plane dist / eye->imagePlatePt dist
		// eye dist to plane is eyePos.z (eye is in +z space)
		// image->eye dist is -projVec.z (image->eye is in -z dir)
		// System.out.println("eye dist = " + (eyePos.z));
		// System.out.println("image dist = " + (-projVec.z));
		zScale = eyePos.z / (-projVec.z);

		screenPt.x = eyePos.x + projVec.x * zScale;
		screenPt.y = eyePos.y + projVec.y * zScale;
	} else
	{
		screenPt.x = imagePlatePt.x;
		screenPt.y = imagePlatePt.y;
	}
	// System.out.println("screenPt = " + screenPt);
	// Note: screenPt is in image plate coords, at z=0

	// Transform from image plate coords to screen coords
	windowPt.x = (screenPt.x / metersPerPixelX) - canvasScr.x;
	windowPt.y = screenSize.height - 1 - (screenPt.y / metersPerPixelY)
			- canvasScr.y;
	// System.out.println("windowPt = " + windowPt);

}