# 3d balken der sich dreht



## Kassel (8. Jan 2011)

hi community,

ich muss einen 3d balken erstellen , der eine bestimmte grösse ( länge ) hat und in der mitte steht jetzt soll er sich um diesen nennen wirr ihn (0,0)- der in der mitte liegt drehen , dafür benötige ich ja nur 2 werte also nur x und y. wie kann ich dies realisieren ?

arbeite zum ersten mal mit 3d - hatte schon probleme es überhaupt auf meinem eclipse zum laufen zu bringen


----------



## Runtime (9. Jan 2011)

Was hast du für eine 3D-Engine? Wie sieht dein Ansatz aus?


----------



## CroniD (9. Jan 2011)

Für sowas muss man auf 3D setzen? Ist das nicht einfach ein Balken in dem ein Farbverlauf von oben nach unten läuft in einer Dauerschleife, oder habe ich da was nicht richtig verstanden? ^^


----------



## Runtime (9. Jan 2011)

So ist das gemeint :idea:.  Ist ja nicht so schwierig, zeig mal deinen Ansatz.


----------



## CroniD (9. Jan 2011)

Weißt du wie spät es schon ist? ^^

Aber damit dieser Post nicht nur Kategorie Spam ist:

```
public class BewegterBalken extends JPanel {
	
	public static int size = 50;
	
	private int pos = 15;
	
	public BewegterBalken() {
		super();
		setPreferredSize(new Dimension(200, size));
	}
	
	public int getPos() {
		return this.pos;
	}
	
	public void setPos(int pos) {
		this.pos = pos;
		repaint();
	}

	@Override public void paint(Graphics g) {
		super.paint(g);
		Graphics2D g2 = (Graphics2D) g;
		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		g2.setColor(Color.BLACK);
		GradientPaint gra = new GradientPaint(0, pos-size/2, Color.blue, 0, pos, Color.red, true);
		g2.setPaint(gra);
		g2.fillRect(0, 0, 200, size);
	}
	
	public static void main(String[] args) {
		JFrame f = new JFrame();
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
		final BewegterBalken bb = new BewegterBalken();
		f.getContentPane().add(bb);
		f.pack();
		f.setVisible(true);
		new Thread(new Runnable() {
			@Override public void run() {
				while (true) {
					EventQueue.invokeLater(new Runnable() {
						@Override public void run() {
							// bb.getHeight()-1, weil sonst das letzte painting wie das erste
							// aussieht und es wirkt wie ein Bildlag
							bb.setPos(bb.getPos() == bb.getHeight()-1 ? 0 : bb.getPos()+1);
						}
					});
					try { Thread.sleep(50); } catch (Exception e) {}
				}
			}
		}).start();
	}
}
```
Na ja, aber ich bin mir mittlerweile nicht mehr sicher, ob das mit "Balken" so gemeint war. Ah, ich sollte so spät nichts mehr lesen, ich verzettel mich immer. ^^

Wenn es wirklich 3D sein soll, dann bist du im falschen Bereich des Forums glaube ich. Schau mal hier vorbei: Spiele- und Multimedia-Programmierung - java-forum.org


----------



## Kassel (9. Jan 2011)

hi community,

ich muss mich entschuldigen wenn ich es ein wenig schwammig erklärt habe - es geht um java3d.
Hier ist ein Beispiel programm dass ich modifiziert habe:


```
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GraphicsConfigTemplate;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.FileOutputStream;

import javax.media.j3d.Alpha;
import javax.media.j3d.AmbientLight;
import javax.media.j3d.Appearance;
import javax.media.j3d.Background;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.Bounds;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.GraphicsConfigTemplate3D;
import javax.media.j3d.Group;
import javax.media.j3d.ImageComponent;
import javax.media.j3d.ImageComponent2D;
import javax.media.j3d.Locale;
import javax.media.j3d.Material;
import javax.media.j3d.PhysicalBody;
import javax.media.j3d.PhysicalEnvironment;
import javax.media.j3d.RotationInterpolator;
import javax.media.j3d.SceneGraphObject;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.View;
import javax.media.j3d.ViewPlatform;
import javax.media.j3d.VirtualUniverse;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.ToolTipManager;
import javax.swing.WindowConstants;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

/**
 * 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 = 300;

  /**
   * 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());
  

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

    // 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
    objRoot.addChild(aLgt);
    objRoot.addChild(lgt1);

    // wire the scenegraph together
    objTrans.addChild(sceneBranchGroup);
    objRoot.addChild(objTrans);

    // return the root of the scene side of the scenegraph
    return objRoot;
  }

  /**
   * Create a BranchGroup that contains a Cube. The user data for the
   * BranchGroup is set so the BranchGroup can be identified.
   */
  protected BranchGroup createCube() {
    BranchGroup bg = new BranchGroup();
    bg.setCapability(BranchGroup.ALLOW_DETACH);
    bg.addChild(new com.sun.j3d.utils.geometry.Box());
    bg.setUserData("Cube");
    return bg;
  }

  /**
   * Create a BranchGroup that contains a Sphere. The user data for the
   * BranchGroup is set so the BranchGroup can be identified.
   */


  /**
   * Removes a BranchGroup from the scene based on user data
   * 
   * @param name
   *            the user data to look for
   */
  protected void removeShape(String name) {
    try {
      java.util.Enumeration e = sceneBranchGroup.getAllChildren();
      int index = 0;

      while (e.hasMoreElements() != false) {
        SceneGraphObject sgObject = (SceneGraphObject) e
            .nextElement();
        Object userData = sgObject.getUserData();

        if (userData instanceof String
            && ((String) userData).compareTo(name) == 0) {
          System.out.println("Removing: " + sgObject.getUserData());
          sceneBranchGroup.removeChild(index);
        }

        index++;
      }
    } catch (Exception e) {
      // the scenegraph may not have yet been synchronized...
    }
  }

  /**
   * Creates the PhysicalBody for the View
   */
  protected PhysicalBody createPhysicalBody() {
    return new PhysicalBody();
  }

  /**
   * Creates the PhysicalEnvironment for the View
   */
  protected PhysicalEnvironment createPhysicalEnvironment() {
    return new PhysicalEnvironment();
  }

  /**
   * Returns the View Platform Activation Radius
   */
  protected float getViewPlatformActivationRadius() {
    return 100;
  }

  /**
   * Creates the View Platform for the View
   */
  protected ViewPlatform createViewPlatform() {
    ViewPlatform vp = new ViewPlatform();
    vp.setViewAttachPolicy(View.RELATIVE_TO_FIELD_OF_VIEW);
    vp.setActivationRadius(getViewPlatformActivationRadius());

    return vp;
  }

  /**
   * Returns the distance to the rear clipping plane.
   */
  protected double getBackClipDistance() {
    return 100.0;
  }

  /**
   * Returns the distance to the near clipping plane.
   */
  protected double getFrontClipDistance() {
    return 3.0;
  }

  /**
   * Creates the View side BranchGroup. The ViewPlatform is wired in beneath
   * the TransformGroups.
   */
  protected BranchGroup createViewBranchGroup(TransformGroup[] tgArray,
      ViewPlatform vp) {
    BranchGroup vpBranchGroup = new BranchGroup();

    if (tgArray != null && tgArray.length > 0) {
      Group parentGroup = vpBranchGroup;
      TransformGroup curTg = null;

      for (int n = 0; n < tgArray.length; n++) {
        curTg = tgArray[n];
        parentGroup.addChild(curTg);
        parentGroup = curTg;
      }

      tgArray[tgArray.length - 1].addChild(vp);
    } else
      vpBranchGroup.addChild(vp);

    return vpBranchGroup;
  }

  /**
   * Creates the VirtualUniverse for the application.
   */
  protected VirtualUniverse createVirtualUniverse() {
    return new VirtualUniverse();
  }

  /**
   * Called to render the scene into the offscreen Canvas3D and save the image
   * (as a JPEG) to disk.
   */
  

  /**
   * main entry point for the application. Creates the parent JFrame, the
   * JMenuBar and creates the JPanel which is the application itself.
   */
  public static void main(String[] args) {
    JPopupMenu.setDefaultLightWeightPopupEnabled(false);

    ToolTipManager ttm = ToolTipManager.sharedInstance();
    ttm.setLightWeightPopupEnabled(false);
    JFrame frame = new JFrame();
    SwingTest swingTest = new SwingTest();
    frame.getContentPane().add(swingTest);
    frame.setSize(500, 300);
  
    frame.setVisible(true);
  }

@Override
public void actionPerformed(ActionEvent arg0) {
	// TODO Auto-generated method stub
	
}
}
```

Ich brauche statt einem Würfel einen Balken ( also nur den würfel in die breite ziehen ) 
ich denke ich muss diesen Quellcode modifizieren :

```
protected BranchGroup createCube() {
    BranchGroup bg = new BranchGroup();
    bg.setCapability(BranchGroup.ALLOW_DETACH);
    bg.addChild(new com.sun.j3d.utils.geometry.Box());
    bg.setUserData("Cube");
    return bg;
  }
```

also new com.sun.j3d.utils.geometry.Box() ich muss bei Box wahrscheinlich bestimmte parameter eingeben damit er zu einem balken wird

und dass zweite ist ich will zwei methoden haben:
z.B: dreheUmXachse(int radius)  und dreheUmYachse (int radius)  - 
und wenn ich z.B 30 eingebe soll er sich um 30 grad drehen ... also nicht automatisch wie im beispiel 

ich weiss nicht was ich moifizieren muss im quellcode

plz help


----------

