import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Returns a new background node.  
 */
private Node createBackgroundNode(boolean listenToHomeUpdates, final boolean waitForLoading)
{
	final Appearance backgroundAppearance = new Appearance();
	ColoringAttributes backgroundColoringAttributes = new ColoringAttributes();
	backgroundAppearance.setColoringAttributes(backgroundColoringAttributes);
	// Allow background color and texture to change
	backgroundAppearance.setCapability(Appearance.ALLOW_TEXTURE_WRITE);
	backgroundAppearance.setCapability(Appearance.ALLOW_COLORING_ATTRIBUTES_READ);
	backgroundColoringAttributes.setCapability(ColoringAttributes.ALLOW_COLOR_WRITE);
	
	Geometry halfSphereGeometry = createHalfSphereGeometry(true);
	final Shape3D halfSphere = new Shape3D(halfSphereGeometry, backgroundAppearance);
	BranchGroup backgroundBranch = new BranchGroup();
	backgroundBranch.addChild(halfSphere);
	backgroundBranch.addChild(new Shape3D(createHalfSphereGeometry(false)));
	
	final Background background = new Background(backgroundBranch);
	updateBackgroundColorAndTexture(backgroundAppearance, this.home, waitForLoading);
	background.setImageScaleMode(Background.SCALE_FIT_ALL);
	background.setApplicationBounds(new BoundingBox(new Point3d(-1E7, -1E7, -1E7), new Point3d(1E7, 1E7, 1E7)));
	
	if (listenToHomeUpdates)
	{
		// Add a listener on sky color and texture properties change 
		this.skyColorListener = new PropertyChangeListener()
		{
			public void propertyChange(PropertyChangeEvent ev)
			{
				updateBackgroundColorAndTexture(backgroundAppearance, home, waitForLoading);
			}
		};
		this.home.getEnvironment().addPropertyChangeListener(HomeEnvironment.Property.SKY_COLOR,
				this.skyColorListener);
		this.home.getEnvironment().addPropertyChangeListener(HomeEnvironment.Property.SKY_TEXTURE,
				this.skyColorListener);
	}
	return background;
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Returns the background node.  
 */
private Node createBackgroundNode()
{
	Background background = new Background(new Color3f(0.9f, 0.9f, 0.9f));
	background.setCapability(Background.ALLOW_COLOR_WRITE);
	background.setApplicationBounds(new BoundingSphere(new Point3d(0, 0, 0), 100));
	return background;
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
private void addBackground()
// A blue sky
{
	Background back = new Background();
	back.setApplicationBounds(bounds);
	// back.setColor(0.17f, 0.65f, 0.92f); // sky colour
	back.setColor(0.0f, 0.0f, 0.0f); // sky colour
	sceneBG.addChild(back);
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
private void addBackground(BranchGroup objRoot) {
    Background bg = new Background();
    bg.setApplicationBounds(bounds);
    //bg.setColor(ColorUtil.skyBlue1); // blue sky
    bg.setColor(Utils3D.black);    // black sky
    // bg.setColor(1.0f, 1.0f, 1.0f);    // white
    objRoot.addChild(bg);
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
private void addBackground()
// A blue sky
{
  Background back = new Background();
  back.setApplicationBounds(bounds);
  // back.setColor(0.17f, 0.65f, 0.92f); // sky colour
  back.setColor(0.0f, 0.0f, 0.0f); // sky colour
  sceneBG.addChild(back);
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * ���sceneBG�ɒlj�
 */
private void addBackground() {
    Background back = new Background();
    back.setApplicationBounds(bounds);
    back.setColor(0.17f, 0.65f, 0.92f); // �‚���
    sceneBG.addChild(back);
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * ���sceneBG�ɒlj�
 */
private void addBackground() {
    Background back = new Background();
    back.setApplicationBounds(bounds);
    back.setColor(0.0f, 0.0f, 0.5f); // �‚���
    sceneBG.addChild(back);
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Paste the default background image
 * @param root root of the 3d scene
 * @param schedulingBounds bounds
 */
private void applyBackgroundImage(BranchGroup root, BoundingSphere schedulingBounds) {
    ClassLoader cl = this.getClass().getClassLoader();
    java.net.URL u = cl.getResource("org/objectweb/proactive/examples/nbody/common/fondnbody3d.jpg");
    final Image backGround = getToolkit().getImage(u);
    TextureLoader starsTexture = new TextureLoader(backGround, this);

    Dimension tailleEcran = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
    double hauteur = tailleEcran.getHeight();
    double largeur = tailleEcran.getWidth();
    Background stars = new Background(starsTexture.getScaledImage((int) largeur, (int) hauteur));
    //Background stars = new Background (starsTexture.getScaledImage(10000,10000));
    stars.setApplicationBounds(schedulingBounds);
    root.addChild(stars);
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
BranchGroup createSceneGraph() {
  // Create the root of the branch graph
  BranchGroup objRoot = new BranchGroup();

  // Create a TransformGroup to scale the scene down by 3.5x
  // TODO: move view platform instead of scene using orbit behavior
  TransformGroup objScale = new TransformGroup();
  Transform3D scaleTrans = new Transform3D();
  //scaleTrans.set(1 / 3.5f); // scale down by 3.5x
  objScale.setTransform(scaleTrans);
  objRoot.addChild(objScale);

  // Create a TransformGroup and initialize it to the
  // identity. Enable the TRANSFORM_WRITE capability so that
  // the mouse behaviors code can modify it at runtime. Add it to the
  // root of the subgraph.
  TransformGroup objTrans = new TransformGroup();
  objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
  objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
  objScale.addChild(objTrans);

  // Add the primitives to the scene
  objTrans.addChild(createLineTypes());

  BoundingSphere bounds = new BoundingSphere(new Point3d(), 100.0);    
  Background bg = new Background(new Color3f(1.0f, 1.0f, 1.0f));
  bg.setApplicationBounds(bounds);
  objTrans.addChild(bg);

  // set up the mouse rotation behavior
  MouseRotate mr = new MouseRotate();
  mr.setTransformGroup(objTrans);
  mr.setSchedulingBounds(bounds);
  mr.setFactor(0.007);
  objTrans.addChild(mr);

  // Set up the ambient light
  Color3f ambientColor = new Color3f(0.1f, 0.1f, 0.1f);
  AmbientLight ambientLightNode = new AmbientLight(ambientColor);
  ambientLightNode.setInfluencingBounds(bounds);
  objRoot.addChild(ambientLightNode);

  // Set up the directional lights
  Color3f light1Color = new Color3f(1.0f, 1.0f, 1.0f);
  Vector3f light1Direction = new Vector3f(0.0f, -0.2f, -1.0f);

  DirectionalLight light1 = new DirectionalLight(light1Color,
      light1Direction);
  light1.setInfluencingBounds(bounds);
  objRoot.addChild(light1);

  return objRoot;
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Renvoie les paramètres de fond de carte
 */
public Background getBackground3D() {
  return this.background3D;
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Sets the background color.
 */
public void setBackground(Color backgroundColor)
{
	super.setBackground(backgroundColor);
	((Background) this.sceneTree.getChild(1)).setColor(new Color3f(backgroundColor));
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Returns an icon created and scaled from piece model content.
 */
private Icon createIcon(BranchGroup modelNode, float pieceWidth, float pieceDepth, float pieceHeight)
{
	// Add piece model scene to a normalized transform group
	Transform3D scaleTransform = new Transform3D();
	scaleTransform.setScale(new Vector3d(2 / pieceWidth, 2 / pieceHeight, 2 / pieceDepth));
	TransformGroup modelTransformGroup = new TransformGroup();
	modelTransformGroup.setTransform(scaleTransform);
	modelTransformGroup.addChild(modelNode);
	// Replace model textures by clones because Java 3D doesn't accept all the time 
	// to share textures between offscreen and onscreen environments 
	cloneTexture(modelNode, new IdentityHashMap<Texture, Texture>());
	
	BranchGroup model = new BranchGroup();
	model.setCapability(BranchGroup.ALLOW_DETACH);
	model.addChild(modelTransformGroup);
	sceneRoot.addChild(model);
	
	// Render scene with a white background
	Background background = (Background) sceneRoot.getChild(0);
	background.setColor(1, 1, 1);
	canvas3D.renderOffScreenBuffer();
	canvas3D.waitForOffScreenRendering();
	BufferedImage imageWithWhiteBackgound = canvas3D.getOffScreenBuffer().getImage();
	int[] imageWithWhiteBackgoundPixels = getImagePixels(imageWithWhiteBackgound);
	
	// Render scene with a black background
	background.setColor(0, 0, 0);
	canvas3D.renderOffScreenBuffer();
	canvas3D.waitForOffScreenRendering();
	BufferedImage imageWithBlackBackgound = canvas3D.getOffScreenBuffer().getImage();
	int[] imageWithBlackBackgoundPixels = getImagePixels(imageWithBlackBackgound);
	
	// Create an image with transparent pixels where model isn't drawn
	for (int i = 0; i < imageWithBlackBackgoundPixels.length; i++)
	{
		if (imageWithBlackBackgoundPixels[i] != imageWithWhiteBackgoundPixels[i]
				&& imageWithBlackBackgoundPixels[i] == 0xFF000000
				&& imageWithWhiteBackgoundPixels[i] == 0xFFFFFFFF)
		{
			imageWithWhiteBackgoundPixels[i] = 0;
		}
	}
	
	sceneRoot.removeChild(model);
	return new ImageIcon(Toolkit.getDefaultToolkit()
			.createImage(new MemoryImageSource(imageWithWhiteBackgound.getWidth(),
					imageWithWhiteBackgound.getHeight(), imageWithWhiteBackgoundPixels, 0,
					imageWithWhiteBackgound.getWidth())));
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Creates the branch for the visible content of the scenegraph. Used only
 * in the creation phase.
 */
private void createSceneBranch(EnvironmentDescription wd) {

	sceneBranch = new BranchGroup();
	sceneRot = new TransformGroup();
	sceneRot.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
	sceneRot.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
	sceneRot.setCapability(Group.ALLOW_CHILDREN_EXTEND);
	// add transform
	sceneTrans = new TransformGroup();
	// allow transform access
	sceneTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
	sceneTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
	sceneTrans.setCapability(Group.ALLOW_CHILDREN_EXTEND);
	sceneBranch.addChild(sceneRot);
	sceneRot.addChild(sceneTrans);

	// bounds (lights,background, behaviors)
	BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0), worldSize * 3);

	// background
	Color3f bgColor = wd.backgroundColor;
	Background bgNode = new Background(bgColor);
	bgNode.setApplicationBounds(bounds);
	sceneTrans.addChild(bgNode);

	// ambient light
	TransformGroup tga = new TransformGroup();
	AmbientLight ambientLight = new AmbientLight(wd.ambientLightColor);
	ambientLight.setInfluencingBounds(bounds);
	tga.addChild(ambientLight);
	sceneBranch.addChild(tga);

	// directional lights
	light1 = addLight(wd.light1Position, wd.light1Color);
	light2 = addLight(wd.light2Position, wd.light2Color);
	light1.setEnable(wd.light1IsOn);
	light2.setEnable(wd.light2IsOn);

	createFloor(wd);
	if (wd.hasAxis)
		createAxis();

	pickableSceneBranch = new BranchGroup();
	sceneTrans.addChild(pickableSceneBranch);
	pickableSceneBranch.setCapability(Group.ALLOW_CHILDREN_EXTEND);
	pickableSceneBranch.setCapability(BranchGroup.ALLOW_DETACH);
	pickableSceneBranch.setCapability(Group.ALLOW_CHILDREN_WRITE);

}
 

import javax.media.j3d.Background; //导入依赖的package包/类
private void addBackground(BranchGroup objRoot) {
    Background background = new Background(backgroundColor);
    background.setApplicationBounds(boundingSphere);
    objRoot.addChild(background);
}
 

import javax.media.j3d.Background; //导入依赖的package包/类
public BranchGroup createSceneGraph(boolean wireFrame) {

        int VOV_L = 42; // dimensions of volume of voxels 50
        int VOV_W = 42;
        int VOV_H = 42;

        BranchGroup contentRoot = new BranchGroup();
        ColorUtil.addCoordinateSphereAxesToSceneGraph(contentRoot, 0.01f);

        VolumeOfVoxels vv = new VolumeOfVoxels(VOV_L, VOV_W, VOV_H);
        vv.fillVolumeOfSphere(true);

        /* Simple visualization by triangles */

        Vector<Triangle> triangleVector = new Vector<Triangle>();
        Util.triangulation(vv.getVoxelsValueAsFloatArray(), VOV_L, VOV_W, VOV_H, triangleVector);
        Triangle3dCreator triangleCreator = new Triangle3dCreator(ColorUtil.grey);

        for (Triangle t : triangleVector) {
            triangleCreator.addTriangleToContainer(
                    t.getP1AsScaledPoint3f(1.0f / VOV_L, 1.0f / VOV_W, 1.0f / VOV_H),
                    t.getP2AsScaledPoint3f(1.0f / VOV_L, 1.0f / VOV_W, 1.0f / VOV_H),
                    t.getP3AsScaledPoint3f(1.0f / VOV_L, 1.0f / VOV_W, 1.0f / VOV_H));
            //t.printData();
        }
        contentRoot.addChild(triangleCreator.getTriangleContainer());


        /* Simple visualization by boxes */
        Material mat = new Material();
        mat.setEmissiveColor(ColorUtil.red);
        Cube3dCreator cubeCreator = new Cube3dCreator(0.05f, 0.05f, 0.05f, mat, 0.0f);
        // vv.addAllTagedVoxelsToContainer(cubeCreator);
        contentRoot.addChild(cubeCreator.getCubeContainer());

        /* For cube testing */
        contentRoot.addChild(cubeCreator.getCubeAsShapeOfQuadArrays(0.1f, 0.1f, 0.1f));
        contentRoot.addChild(cubeCreator.getCubeAsBox(0.15f, 0.15f, 0.15f));

        Background background = new Background(new ImageComponent2D(ImageComponent2D.FORMAT_RGB,
                ColorUtil.createColoredGradientImage(FrameWidth, FrameHeight)));
        background.setApplicationBounds(new BoundingSphere(new Point3d(0.0, 0.0, 0.0), 100.0));
        contentRoot.addChild(background);

        contentRoot.compile();
        return contentRoot;
    }
 

import javax.media.j3d.Background; //导入依赖的package包/类
/**
 * Creates the branch for the visible content of the scenegraph. Used only in
 * the creation phase.
 */
private void createSceneBranch(EnvironmentDescription wd) {

  sceneBranch = new BranchGroup();
  sceneRot = new TransformGroup();
  sceneRot.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
  sceneRot.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
  sceneRot.setCapability(Group.ALLOW_CHILDREN_EXTEND);
  // add transform
  sceneTrans = new TransformGroup();
  // allow transform access
  sceneTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
  sceneTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
  sceneTrans.setCapability(Group.ALLOW_CHILDREN_EXTEND);
  sceneBranch.addChild(sceneRot);
  sceneRot.addChild(sceneTrans);

  // bounds (lights,background, behaviors)
  BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0), worldSize * 3);

  // background
  Color3f bgColor = wd.backgroundColor;
  Background bgNode = new Background(bgColor);
  bgNode.setApplicationBounds(bounds);
  sceneTrans.addChild(bgNode);

  // ambient light
  TransformGroup tga = new TransformGroup();
  AmbientLight ambientLight = new AmbientLight(wd.ambientLightColor);
  ambientLight.setInfluencingBounds(bounds);
  tga.addChild(ambientLight);
  sceneBranch.addChild(tga);

  // directional lights
  light1 = addLight(wd.light1Position, wd.light1Color);
  light2 = addLight(wd.light2Position, wd.light2Color);
  light1.setEnable(wd.light1IsOn);
  light2.setEnable(wd.light2IsOn);

  createFloor(wd);
  if (wd.hasAxis)
    createAxis();

  pickableSceneBranch = new BranchGroup();
  sceneTrans.addChild(pickableSceneBranch);
  pickableSceneBranch.setCapability(Group.ALLOW_CHILDREN_EXTEND);
  pickableSceneBranch.setCapability(BranchGroup.ALLOW_DETACH);
  pickableSceneBranch.setCapability(Group.ALLOW_CHILDREN_WRITE);

}