Beispiel #1
0
  public BranchGroup createSceneGraph() {
    // Create the root of the branch graph
    BranchGroup objRoot = new BranchGroup();

    // Create the TransformGroup node and initialize it to the
    // identity. Enable the TRANSFORM_WRITE capability so that
    // our behavior code can modify it at run time. Add it to
    // the root of the subgraph.
    TransformGroup objTrans = new TransformGroup();
    objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    objRoot.addChild(objTrans);

    // Create a simple Shape3D node; add it to the scene graph.
    objTrans.addChild(new ColorCube(0.4));

    // Create a new Behavior object that will perform the
    // desired operation on the specified transform and add
    // it into the scene graph.
    Transform3D yAxis = new Transform3D();
    Alpha rotationAlpha = new Alpha(-1, 4000);

    RotationInterpolator rotator =
        new RotationInterpolator(rotationAlpha, objTrans, yAxis, 0.0f, (float) Math.PI * 1.0f);
    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0), 100.0);
    rotator.setSchedulingBounds(bounds);
    objRoot.addChild(rotator);

    // Have Java 3D perform optimizations on this scene graph.
    objRoot.compile();

    return objRoot;
  }
  // In this method, the objects for the scene are generated and added to
  // the SimpleUniverse.
  public void createSceneGraph(SimpleUniverse su) {

    // *** The root of the graph containing the scene (with a cube and a sphere). ***
    BranchGroup theScene = new BranchGroup();

    // Generate an Appearance.
    Color3f ambientColourShaded = new Color3f(0.0f, 0.4f, 0.4f);
    Color3f emissiveColourShaded = new Color3f(0.0f, 0.0f, 0.0f);
    Color3f diffuseColourShaded = new Color3f(0.0f, 0.7f, 0.7f);
    Color3f specularColourShaded = new Color3f(0.0f, 0.5f, 0.5f);

    float shininessShaded = 20.0f;

    Appearance shadedApp = new Appearance();
    shadedApp.setMaterial(
        new Material(
            ambientColourShaded,
            emissiveColourShaded,
            diffuseColourShaded,
            specularColourShaded,
            shininessShaded));

    float r = 0.3f; // The radius of the sphere.
    float boxHL = 0.7f * r; // Half the vertex length of the cube.
    float shift = 3.0f * r; // Distance between cube and sphere.

    // *** The sphere and its transformation group ***
    Sphere s = new Sphere(r, Sphere.GENERATE_NORMALS, 100, shadedApp);
    Transform3D tfSphere = new Transform3D();
    tfSphere.setTranslation(new Vector3f(-0.95f + r, 0.0f, 0.0f));
    TransformGroup tgSphere = new TransformGroup(tfSphere);
    tgSphere.addChild(s);
    theScene.addChild(tgSphere);

    // *** The cube and its transformation group ***
    Box b2 = new Box(boxHL, boxHL, boxHL, shadedApp);
    Transform3D tfBox2 = new Transform3D();
    tfBox2.setTranslation(new Vector3f(-0.95f + r + shift, 0.0f, 0.0f));
    Transform3D rotation = new Transform3D();
    rotation.rotY(Math.PI / 4);
    Transform3D rotationX = new Transform3D();
    rotationX.rotX(Math.PI / 6);
    rotation.mul(rotationX);
    tfBox2.mul(rotation);
    TransformGroup tgBox2 = new TransformGroup(tfBox2);
    tgBox2.addChild(b2);
    theScene.addChild(tgBox2);

    // Generate a white background.
    Background bg = new Background(new Color3f(1.0f, 1.0f, 1.0f));
    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0), Double.MAX_VALUE);
    bg.setApplicationBounds(bounds);
    theScene.addChild(bg);

    theScene.compile();

    // Add the scene to the universe.
    su.addBranchGraph(theScene);
  }
  private TransformGroup makeText(Vector3d vertex, String text)
        // Create a Text2D object at the specified vertex
      {
    Text2D message = new Text2D(text, white, "SansSerif", 36, Font.BOLD);
    // 36 point bold Sans Serif

    TransformGroup tg = new TransformGroup();
    Transform3D t3d = new Transform3D();
    t3d.setTranslation(vertex);
    tg.setTransform(t3d);
    tg.addChild(message);
    return tg;
  } // end of getTG()
Beispiel #4
0
  public void addLinesAroundRegion(TransformGroup tg) {
    Color3f x = new Color3f(Color.green.brighter().brighter());
    Color3f y = new Color3f(Color.yellow.brighter().brighter());
    Color3f z = new Color3f(Color.red.brighter().brighter());

    LineArray wireframe = new LineArray(12 * 2, GeometryArray.COORDINATES | GeometryArray.COLOR_3);

    wireframe.setCapability(LineArray.ALLOW_COLOR_WRITE);
    wireframe.setCapability(LineArray.ALLOW_COORDINATE_READ);
    wireframe.setCapability(LineArray.ALLOW_COUNT_READ);
    ArrayList<Point3f> vx = getVertices();

    // Add lines parallel to x
    wireframe.setCoordinate(0, vx.get(0));
    wireframe.setCoordinate(1, vx.get(2));
    wireframe.setCoordinate(2, vx.get(1));
    wireframe.setCoordinate(3, vx.get(3));

    wireframe.setCoordinate(4, vx.get(4));
    wireframe.setCoordinate(5, vx.get(6));
    wireframe.setCoordinate(6, vx.get(5));
    wireframe.setCoordinate(7, vx.get(7));

    for (int i = 0; i < 8; i++) wireframe.setColor(i, x);

    // Add lines parallel to y
    wireframe.setCoordinate(8, vx.get(0));
    wireframe.setCoordinate(9, vx.get(4));
    wireframe.setCoordinate(10, vx.get(1));
    wireframe.setCoordinate(11, vx.get(5));

    wireframe.setCoordinate(12, vx.get(2));
    wireframe.setCoordinate(13, vx.get(6));
    wireframe.setCoordinate(14, vx.get(3));
    wireframe.setCoordinate(15, vx.get(7));

    for (int i = 8; i < 16; i++) wireframe.setColor(i, y);

    // Add lines parallel to z
    wireframe.setCoordinate(16, vx.get(0));
    wireframe.setCoordinate(17, vx.get(1));
    wireframe.setCoordinate(18, vx.get(2));
    wireframe.setCoordinate(19, vx.get(3));
    wireframe.setCoordinate(20, vx.get(4));
    wireframe.setCoordinate(21, vx.get(5));
    wireframe.setCoordinate(22, vx.get(6));
    wireframe.setCoordinate(23, vx.get(7));

    for (int i = 16; i < 24; i++) wireframe.setColor(i, z);

    Shape3D shape = new Shape3D(wireframe);
    tg.addChild(shape);
  }
  // Directional light rotating around the scene and some ambient light.
  public void addLight(SimpleUniverse su) {

    BranchGroup bgLight = new BranchGroup();

    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0), Double.MAX_VALUE);

    // Directional light (to be rotated).
    Color3f lightColour = new Color3f(1.0f, 1.0f, 1.0f);
    Vector3f lightDir = new Vector3f(0.0f, 0.0f, -1.0f);
    DirectionalLight light = new DirectionalLight(lightColour, lightDir);
    light.setInfluencingBounds(bounds);

    // The transformation group for the directional light and its rotation.
    TransformGroup tfmLight = new TransformGroup();
    tfmLight.addChild(light);

    // The Alpha for the rotation.
    Alpha alphaLight = new Alpha(-1, 4000);
    // The rotation
    RotationInterpolator rot =
        new RotationInterpolator(
            alphaLight, tfmLight, new Transform3D(), 0.0f, (float) Math.PI * 2);
    rot.setSchedulingBounds(bounds);

    tfmLight.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    tfmLight.addChild(rot);

    bgLight.addChild(tfmLight);

    // Ambient light.
    Color3f ambientLightColour = new Color3f(0.5f, 0.5f, 0.5f);
    AmbientLight ambLight = new AmbientLight(ambientLightColour);
    ambLight.setInfluencingBounds(bounds);
    bgLight.addChild(ambLight);

    su.addBranchGraph(bgLight);
  }
Beispiel #6
0
  public ObjectViewer(URL url) {
    setLayout(new BorderLayout());
    Canvas3D canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
    add("Center", canvas3D);

    BoundingSphere bounds = new BoundingSphere(new Point3d(), 1000);
    BranchGroup root = new BranchGroup();
    BranchGroup scene = createSceneGraph(url);
    scene.setBoundsAutoCompute(true);
    System.out.println(scene.getBounds());
    BoundingSphere sceneBounds = new BoundingSphere(scene.getBounds());

    SimpleUniverse univ = new SimpleUniverse(canvas3D);
    ViewingPlatform view = univ.getViewingPlatform();
    view.setNominalViewingTransform();

    Transform3D t = new Transform3D();
    TransformGroup viewTransform = view.getViewPlatformTransform();

    t.set(new Vector3d(0, 0, 3 * sceneBounds.getRadius()));
    viewTransform.setTransform(t);

    BranchGroup lights = new BranchGroup();
    Light light = new AmbientLight();
    light.setInfluencingBounds(bounds);
    lights.addChild(light);
    light = new DirectionalLight();
    light.setInfluencingBounds(bounds);
    lights.addChild(light);
    root.addChild(lights);

    TransformGroup tg = new TransformGroup();
    tg.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
    tg.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    tg.addChild(scene);

    root.addChild(tg);

    MouseRotate mouse = new MouseRotate();
    mouse.setTransformGroup(tg);
    mouse.setSchedulingBounds(bounds);
    root.addChild(mouse);

    MouseZoom mousezoom = new MouseZoom();
    mousezoom.setTransformGroup(tg);
    mousezoom.setSchedulingBounds(bounds);
    root.addChild(mousezoom);

    Background background = new Background(1, 1, 1);
    background.setApplicationBounds(bounds);
    root.addChild(background);

    root.compile();

    univ.addBranchGraph(root);
  }
Beispiel #7
0
  public void processStimulus(Enumeration criteria) {
    posVector.set(
        (float) targetHistogram.neutronNumber - ((float) targetMaxNeutron / 2.0f),
        (float) targetHistogram.abundance[step] - targetHistogram.normalizationFactor,
        (float) -targetHistogram.protonNumber + ((float) targetMaxProton / 2.0f));
    ca = targetHistogram.fillingAppearance.getColoringAttributes();
    targetColorRamp.getColor(
        targetHistogram.abundance[step] - targetHistogram.normalizationFactor, histColor);
    ca.setColor(histColor);

    step++;
    if (step >= targetHistogram.abundance.length) {
      step = 0;
    }

    targetT3D.set(posVector);
    targetTG.setTransform(targetT3D);
    this.wakeupOn(new WakeupOnAWTEvent(MouseEvent.MOUSE_CLICKED));
  }