# Java3D: automatisches Bewegen der Kamera



## veritas696 (30. Mrz 2009)

Hallo,

Ich möchte eine Kamera haben die sich innerhalb meines Sonnensystems mit einem Planeten mitbewegt. Das heißt sie soll "hinter" dem Planeten installiert sein und in richtig Sonne schauen.

Verwende ich den folgenden Quellcode so ist die Kamera beim Start des Programms korrekt hinter dem Planeten, doch bewegt sich nicht mit dem Planeten mit, kann mir einer erklären warum?


[highlight=Java]public class Planet
{
    ////////////////////////////////////////////////////////////////////////////////////
    // MEMBERS
    // Planeten eigenschaften
    private float size = 0; // Größe des Planeten
    private float ownRotDuration = 0; // EigenRotationsdauer
    private float distanceToCenter = 0; // Entfernung zum Zentralgestirn
    protected float centerRotDuration = 0; // Rotationsdauer um Zentralgestirn
    private float ownNeigung = 0;
    // Planet selbst
    private Sphere sphere = null; // Die Kugel selbst

    // Oberflächeneigenschaften
    private String texString = "";

    private boolean texActivated = true;

    // Eigenlicht
    //private AmbientLight ownALight = new AmbientLight(new Color3f(1f, 1f, 1f));

    //private DirectionalLight DLgt = new DirectionalLight( new Color3f(1f, 1f, 1f),
    // new Vector3f(-0.5f,-0.5f,-1f));

    // BranchGroup (Planetensystem)
    public BranchGroup RootBG = new BranchGroup(); // Root Objekt

    // Transformationsgruppe (eigene Rotation, Neigung)
    private TransformGroup SphereTG = new TransformGroup(); // Transformationen für die Kugel
    private Transform3D SphereT3D = new Transform3D(); // Transformierungen für die Kugel
    //Rotationswerkzeuge für den Planeten (Eigenrotation)
    private TransformGroup ownRotTG = new TransformGroup(); // Transformationen für die Rotation
    private RotationInterpolator ownRotator;
    private Alpha ownRotationAlpha;

    // Transformationsgruppe (Rotation ums Zentralgestirn)
    protected TransformGroup CenterTG = new TransformGroup();
    private Transform3D CenterT3D = new Transform3D(); // Transformierungen für die Kugel
    //Rotationswerkzeuge für den Planeten (Rotation um Zentralgestirn)
    private TransformGroup centerRotTG = new TransformGroup(); // Transformationen für die Rotation
    private RotationInterpolator centerRotator;
    private Alpha centerRotationAlpha;

    // Umlaufbahn der PlanetenKamera
    private TransformGroup CamTG = new TransformGroup(); // Transformationen für die Kamera
    private Transform3D CamT3D = new Transform3D(); // Transformierungen für die Kamera

    static int i = 0;

    ////////////////////////////////////////////////////////////////////////////////////
    // Konstruktoren
    public Planet(float size, float ownRotDuration, float distanceToCenter,
            float centerRotDuration, float ownNeig, String tex)
    {
        this.size = size;
        this.ownRotDuration = ownRotDuration;
        this.distanceToCenter = distanceToCenter;
        this.centerRotDuration = centerRotDuration;
        this.ownNeigung = ownNeig;
        this.texString = tex;

        this.initObject(); // Erscheinungsbild festlegen 
    }

    ////////////////////////////////////////////////////////////////////////////////////
    // Functions
    /////////////////////////////////////////////////////////////////////////////////////
    private void initObject()
    {
        this.initRotations();

        // Objekt anlegen
        sphere = new Sphere(size, Sphere.GENERATE_NORMALS
                | Sphere.GENERATE_TEXTURE_COORDS, 64,
                new PlanetAppearance(texString));

        // festgelegte Rotation(zb. Erdachsenneigung)
        if (ownNeigung != 0.0) {
            SphereT3D.setRotation(new AxisAngle4f(1f, 0f, 0f, (float) Math
                    .toRadians(-ownNeigung)));
        }

        // Position festlegen
        SphereT3D.setTranslation(new Vector3f(0.0f, 0f, -distanceToCenter));

        SphereTG.setTransform(SphereT3D);

        // Position der Kamera festlegen
        CamT3D.setTranslation(new Vector3f(0.0f, 0f, -distanceToCenter - 20));
        CamTG.setTransform(CamT3D);
        //CamTG.addChild(centerRotator);

        // TODO: wieder entfernen wenn Planeten Kamera funktioniert
        CamTG.addChild(new Sphere(0.2f, Sphere.GENERATE_NORMALS
                | Sphere.GENERATE_TEXTURE_COORDS, 64, new Appearance()));
        CamTG.setCapability(TransformGroup.ALLOW_CHILDREN_EXTEND);
        CamTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        CamTG.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
        CamTG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);

        // eigene Rotation festlegen
        SphereTG.addChild(ownRotTG);
        SphereTG.setCapability(TransformGroup.ALLOW_CHILDREN_EXTEND);
        ownRotTG.addChild(sphere);
        ownRotTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        ownRotTG.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
        ownRotTG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);
        //ownRotTG.setCapability(TransformGroup.);

        SphereTG.addChild(ownRotator);

        // Rotation ums Zentralgestirn
        CenterTG.addChild(centerRotTG);

        centerRotTG.addChild(SphereTG);
        centerRotTG.addChild(CamTG); // Kamera um ZG rotieren

        centerRotTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

        CenterTG.addChild(centerRotator);
        CenterTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        CenterTG.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
        CenterTG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);

        // Oribts entfernen/ hinzufügen
        CenterTG.setCapability(TransformGroup.ALLOW_CHILDREN_EXTEND);

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////
    private void initRotations()
    {
        // Eigenrotation
        ownRotationAlpha = new Alpha(-1, // loopCount -1 = endlos
                /*Alpha.DECREASING_ENABLE|*/Alpha.INCREASING_ENABLE, // mode, welche Parts sollen durchlaufen werden
                0, // triggerTime, wann soll Rotation beginnen 0=sofort
                0, // phaseDelayDuration, wann soll Rotation beginnen 0=sofort

                //increasing Part 
                (int) ownRotDuration, // increasingAlphaDuration in msec (Rotationsgeschwindigkeit)
                0, // increasingAlphaRampDuration Beschleunigung (brauch ich net)
                0, // alphaAtOneDuration

                // decreasing Part / wird nicht betrachtet wenn nur INCREASING_ENABLE gesetzt
                9000, // decreasingAlphaDuration
                3000, // decreasingAlphaRampDuration
                500); // alphaAtZeroDuration
        ownRotator = new RotationInterpolator(ownRotationAlpha, ownRotTG);
        ownRotator.setMinimumAngle(0f);
        ownRotator.setMaximumAngle((float) Math.toRadians(360));
        ownRotator.setSchedulingBounds(Universe.BigBounds);

        // Rotation ums Zentralgestirn
        centerRotationAlpha = new Alpha(-1, // loopCount -1 = endlos
                //Alpha.DECREASING_ENABLE|
                Alpha.INCREASING_ENABLE, // mode, welche Parts sollen durchlaufen werden
                0, // triggerTime, wann soll Rotation beginnen 0=sofort
                0, // phaseDelayDuration, wann soll Rotation beginnen 0=sofort

                //increasing Part 
                (int) centerRotDuration, // increasingAlphaDuration in msec (Rotationsgeschwindigkeit)
                0, // increasingAlphaRampDuration Beschleunigung (brauch ich net)
                0, // alphaAtOneDuration

                // decreasing Part / wird nicht betrachtet wenn nur INCREASING_ENABLE gesetzt
                9000, // decreasingAlphaDuration
                3000, // decreasingAlphaRampDuration
                500); // alphaAtZeroDuration
        centerRotator = new RotationInterpolator(centerRotationAlpha, centerRotTG);
        centerRotator.setMinimumAngle(0f);
        centerRotator.setMaximumAngle((float) Math.toRadians(360));

        //TODO: ist hier bigbounds nötig?, wofür steht schedulingBounds?
        centerRotator.setSchedulingBounds(Universe.BigBounds);

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////
    public void addChild(Planet planet)
    {
        SphereTG.addChild(planet.createSceneGraph());
    }

    //////////////////////////////////////////////////////////////////////////////////////////////// 
    // Erstellung des Planeten
    public BranchGroup createSceneGraph()
    {
        System.out.println("createPlanet: " + (i++));

        RootBG.addChild(CenterTG);

        RootBG.compile();
        return RootBG;
    }

    /////////////////////////////////////////////////////////////////////////////

    /////////////////////////////////////////////////////////////////////////////
    public TransformGroup getCamTG()
    {
        return CamTG;
    }
}
[/highlight]


Die folgendene Klasse stellt meine Kamera da. im Konstruktor wird die ViewPlatformTransform übergeben 
---->_u_.getViewingPlatform().getViewPlatformTransform()

[highlight=Java] 
public class Camera extends BranchGroup
{
    private TransformGroup transformGroup;
    private Transform3D ViewT3D = new Transform3D();

    /////////////////////////////////////////////////////////////////////////////////
    public Camera(TransformGroup tg)
    {
        transformGroup = tg;

        enablePlanetCamera(ObjectManager.planetErde);

    }

    /////////////////////////////////////////////////////////////////////////////////
    public void enablePlanetCamera(Planet currentPlanet)
    {

        // aktuelle Transformation des Planeten holen
        TransformGroup ViewTG = currentPlanet.getCamTG();
        ViewTG.getTransform(ViewT3D);

        // Rotation der Kamera um 180 grad auf die Sonne
        ViewT3D.setRotation(new AxisAngle4f(0, -1, 0, (float) Math.toRadians(180)));

        transformGroup.setTransform(ViewT3D);

    }
}
[/highlight]


hoffe das erschlägt euch nicht und es ist einigermaßen verständlich :bahnhof:


----------



## Ebenius (30. Mrz 2009)

Allgemeiner Hinweis: Weniger Slash's und mehr Einrückung würden die Lesbarkeit enorm erhöhen!

Ebenius


----------



## veritas696 (30. Mrz 2009)

Also bei mir im Eclipse saß noch gut aus, nach Kopieren ins Notepad und dann hierrein, hat sich halt alles verschoben, sry


----------



## Developer_X (30. Mrz 2009)

veritas123...
ich hatte einst genau das selbe Problem, und ich habe es nie gelöst bis vor kurzem, nun möchte ich dir helfen, vertrau mir, du brauchst keine Zweite Klasse namens "Kamera"
Hier ist die Lösung:
[highlight=Java]

import java.awt.BorderLayout;
import java.awt.GraphicsConfiguration;

import javax.media.j3d.Alpha;
import javax.media.j3d.Appearance;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.RotationInterpolator;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.swing.JFrame;
import javax.vecmath.AxisAngle4f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3f;

import com.sun.j3d.utils.geometry.Sphere;
import com.sun.j3d.utils.universe.SimpleUniverse;

public class Planet extends JFrame
{
////////////////////////////////////////////////////////////////////////////////////
// MEMBERS
	float pos = 1;
	Vector3f vct;
    Transform3D ViewT3D;
    TransformGroup ViewTG;
// Planeten eigenschaften
private float size = 0; // Größe des Planeten
private float ownRotDuration = 0; // EigenRotationsdauer
private float distanceToCenter = 0; // Entfernung zum Zentralgestirn
protected float centerRotDuration = 0; // Rotationsdauer um Zentralgestirn
private float ownNeigung = 0; 
private SimpleUniverse u;
// Planet selbst
private Sphere sphere = null; // Die Kugel selbst


// Oberflächeneigenschaften
private String texString = "";

private boolean texActivated = true;

// Eigenlicht
//private AmbientLight ownALight = new AmbientLight(new Color3f(1f, 1f, 1f));

//private DirectionalLight DLgt = new DirectionalLight( new Color3f(1f, 1f, 1f),
// new Vector3f(-0.5f,-0.5f,-1f));

// BranchGroup (Planetensystem)
public BranchGroup RootBG = new BranchGroup(); // Root Objekt

// Transformationsgruppe (eigene Rotation, Neigung)
private TransformGroup SphereTG = new TransformGroup(); // Transformationen für die Kugel
private Transform3D SphereT3D = new Transform3D(); // Transformierungen für die Kugel
//Rotationswerkzeuge für den Planeten (Eigenrotation)
private TransformGroup ownRotTG = new TransformGroup(); // Transformationen für die Rotation
private RotationInterpolator ownRotator;
private Alpha ownRotationAlpha;

// Transformationsgruppe (Rotation ums Zentralgestirn)
protected TransformGroup CenterTG = new TransformGroup();
private Transform3D CenterT3D = new Transform3D(); // Transformierungen für die Kugel
//Rotationswerkzeuge für den Planeten (Rotation um Zentralgestirn)
private TransformGroup centerRotTG = new TransformGroup(); // Transformationen für die Rotation
private RotationInterpolator centerRotator;
private Alpha centerRotationAlpha;

// Umlaufbahn der PlanetenKamera
private TransformGroup CamTG = new TransformGroup(); // Transformationen für die Kamera
private Transform3D CamT3D = new Transform3D(); // Transformierungen für die Kamera


static int i = 0;


////////////////////////////////////////////////////////////////////////////////////
// Konstruktoren
public Planet(float size, float ownRotDuration, float distanceToCenter, float centerRotDuration, float ownNeig, String tex)
{
this.size = size;
this.ownRotDuration = ownRotDuration;
this.distanceToCenter = distanceToCenter;
this.centerRotDuration = centerRotDuration;
this.ownNeigung = ownNeig;
this.texString = tex;


this.initObject(); // Erscheinungsbild festlegen 
} 

////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
private void initObject()
{ 
this.initRotations();

// Objekt anlegen
sphere = new Sphere(size, Sphere.GENERATE_NORMALS | Sphere.GENERATE_TEXTURE_COORDS, 
64, null);

// festgelegte Rotation(zb. Erdachsenneigung)
if(ownNeigung != 0.0)
{
SphereT3D.setRotation(new AxisAngle4f(1f,0f,0f,(float)Math.toRadians(-ownNeigung)));
}

// Position festlegen
SphereT3D.setTranslation(new Vector3f(0.0f, 0f,-distanceToCenter));

SphereTG.setTransform(SphereT3D);

// Position der Kamera festlegen
CamT3D.setTranslation(new Vector3f(0.0f, 0f, -distanceToCenter - 20));
CamTG.setTransform(CamT3D);
//CamTG.addChild(centerRotator);

// TODO: wieder entfernen wenn Planeten Kamera funktioniert
CamTG.addChild(new Sphere(0.2f, Sphere.GENERATE_NORMALS | Sphere.GENERATE_TEXTURE_COORDS, 
64, new Appearance()));
CamTG.setCapability(TransformGroup.ALLOW_CHILDREN_EXTEND);
CamTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
CamTG.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
CamTG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);

// eigene Rotation festlegen
SphereTG.addChild(ownRotTG);
SphereTG.setCapability(TransformGroup.ALLOW_CHILDREN_EXTEND);
ownRotTG.addChild(sphere);
ownRotTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
ownRotTG.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
ownRotTG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);
//ownRotTG.setCapability(TransformGroup.);

SphereTG.addChild(ownRotator);


// Rotation ums Zentralgestirn
CenterTG.addChild(centerRotTG);

centerRotTG.addChild(SphereTG);
centerRotTG.addChild(CamTG); // Kamera um ZG rotieren

centerRotTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

CenterTG.addChild(centerRotator);
CenterTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
CenterTG.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
CenterTG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);

// Oribts entfernen/ hinzufügen
CenterTG.setCapability(TransformGroup.ALLOW_CHILDREN_EXTEND);


}

///////////////////////////////////////////////////////////////////////////////////////////////
private void initRotations()
{
// Eigenrotation
	BoundingSphere BigBounds = new BoundingSphere(new Point3d(),1000);
ownRotationAlpha = new Alpha( 
-1, // loopCount -1 = endlos
/*Alpha.DECREASING_ENABLE|*/Alpha.INCREASING_ENABLE, // mode, welche Parts sollen durchlaufen werden
0, // triggerTime, wann soll Rotation beginnen 0=sofort
0, // phaseDelayDuration, wann soll Rotation beginnen 0=sofort

//increasing Part 
(int)ownRotDuration, // increasingAlphaDuration in msec (Rotationsgeschwindigkeit)
0, // increasingAlphaRampDuration Beschleunigung (brauch ich net)
0, // alphaAtOneDuration

// decreasing Part / wird nicht betrachtet wenn nur INCREASING_ENABLE gesetzt
9000, // decreasingAlphaDuration
3000, // decreasingAlphaRampDuration
500); // alphaAtZeroDuration
ownRotator = new RotationInterpolator(ownRotationAlpha,ownRotTG);
ownRotator.setMinimumAngle(0f);
ownRotator.setMaximumAngle((float)Math.toRadians(360));
ownRotator.setSchedulingBounds(BigBounds);


// Rotation ums Zentralgestirn
centerRotationAlpha = new Alpha( 
-1, // loopCount -1 = endlos
//Alpha.DECREASING_ENABLE|
Alpha.INCREASING_ENABLE, // mode, welche Parts sollen durchlaufen werden
0, // triggerTime, wann soll Rotation beginnen 0=sofort
0, // phaseDelayDuration, wann soll Rotation beginnen 0=sofort

//increasing Part 
(int)centerRotDuration, // increasingAlphaDuration in msec (Rotationsgeschwindigkeit)
0, // increasingAlphaRampDuration Beschleunigung (brauch ich net)
0, // alphaAtOneDuration

// decreasing Part / wird nicht betrachtet wenn nur INCREASING_ENABLE gesetzt
9000, // decreasingAlphaDuration
3000, // decreasingAlphaRampDuration
500); // alphaAtZeroDuration
centerRotator = new RotationInterpolator(centerRotationAlpha,centerRotTG);
centerRotator.setMinimumAngle(0f);
centerRotator.setMaximumAngle((float)Math.toRadians(360));

//TODO: ist hier bigbounds nötig?, wofür steht schedulingBounds?
centerRotator.setSchedulingBounds(BigBounds);

}
///////////////////////////////////////////////////////////////////////////////////////////////
public void addChild(Planet planet)
{ 
SphereTG.addChild(planet.createSceneGraph());
}
//////////////////////////////////////////////////////////////////////////////////////////////// 
// Erstellung des Planeten
public BranchGroup createSceneGraph()
{ 
System.out.println("createPlanet: "+(i++));

RootBG.addChild(CenterTG);

//Hier View Initialisation!
//////////
         //View Initialisation
         ViewTG = new TransformGroup();
         ViewTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);    
         ViewTG=u.getViewingPlatform().getViewPlatformTransform();
         ViewT3D = new Transform3D();
         ViewTG.getTransform(ViewT3D);
         vct = new Vector3f(pos,0,0);
         ViewT3D.setTranslation(vct);
         ViewTG.setTransform(ViewT3D);

(new Thread(){@Override public void run(){while(!isInterrupted()){       
                    pos = pos + 0.05f;
                    vct = new Vector3f(pos,0,0);
                    ViewT3D.setTranslation(vct);
                    ViewTG.setTransform(ViewT3D);

try{sleep(10);}catch(InterruptedException e){interrupt();}}}}).start();
///////////////////////////
RootBG.compile();
return RootBG;
}
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
public TransformGroup getCamTG()
{
return CamTG;
}

public Planet()
{
setSize(500,500);
setTitle("Planet");
setVisible(true);
setLayout(null);
 GraphicsConfiguration config1 = SimpleUniverse.getPreferredConfiguration();
             Canvas3D canvas1 = new Canvas3D(config1);
             canvas1.setBounds(0,0,500,500);
             u = new SimpleUniverse(canvas1);
             u.addBranchGraph(createSceneGraph());
             add(canvas1,BorderLayout.SOUTH);
}
public static void main(String[]args)
{
	new Planet();
}
}[/highlight]
Wie du sehen kannst hab ich deins so weit übernommen
PS:
Das wird bei dir aber immer noch nicht funktionieren weil du keine Lichquellen eingefügt hast,
wenn du willst kanns´t dus ja noch machen, wenn du net weißt wie, dann kann ich dir das machen
du musst es nur sagen


----------



## hdi (30. Mrz 2009)

> ich hatte einst genau das selbe Problem, und ich habe es nie gelöst bis vor kurzem, nun möchte ich dir helfen, *vertrau mir*, du brauchst keine Zweite Klasse namens "Kamera"
> Hier ist die Lösung:



Vorab: Ich hab den Code nicht gesehen, und ich will Developer nicht unterstellen, dass
der Code nicht funktioniert. Aber jeder, der diesen Code verwenden will sollte wissen:
Developer ist noch zu wacklig auf den Beinen in Sachen Java, als dass man ihm mal eben so
"vertrauen" kann.
Das meiste von seinem Code *suckt big time*!
Also etwas Vorsicht 

edit: Nich dass manche anonymen Feiglinge schon wieder sagen, ich sei das grösste
Arschloch hier und mach alle fertig. 
Falls es jmd wieder zu krass vorkommt: So soll es nicht rüberkommen!
Ich will nur sagen man sollte etwas aufpassen, weil man einem Anfänger nun mal nicht
aus der Hand fressen sollte (gilt eig. genausogut für Profis)


----------



## Developer_X (30. Mrz 2009)

hdi
==
hilft dir immer lol
==============
Konzentrier dich auf das Thema!!!
PS:
Ich habe die Lösung erst vor kurzem gefunden, aber sie funktioniert zu deiner Info!!!


----------



## Developer_X (30. Mrz 2009)

Naja, deins funktioniert bei mir eh nicht so richtig, aber wie du das machen kannst, dass man die kamera mit hilfe eines Threads bewegen kann ist hier drin:

```
import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.Toolkit;
import javax.media.j3d.AmbientLight;
import javax.media.j3d.Appearance;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.TextureAttributes;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.swing.JFrame;
import javax.vecmath.Color3f;
import javax.vecmath.Color4f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;

import com.sun.j3d.utils.geometry.Box;
import com.sun.j3d.utils.image.TextureLoader;
import com.sun.j3d.utils.universe.SimpleUniverse;

public class Trailer_3 extends JFrame
{
    float pos = 1;
	SimpleUniverse u;
	
	Vector3f vct;
	Transform3D ViewT3D;
	TransformGroup ViewTG;
	  public Trailer_3()
	  {
		  Toolkit tk = Toolkit.getDefaultToolkit();
		    final Dimension d = tk.getScreenSize();		 	
		    
		    setSize(d);
		    setTitle("R.a.t.r.o.t.c.p.");
		 
		    setUndecorated(true);
		    
		    setVisible(true);
		    setLayout(null);
		    
		     GraphicsConfiguration config1 = SimpleUniverse.getPreferredConfiguration();
		     Canvas3D canvas1 = new Canvas3D(config1);
		  	 canvas1.setBounds(0,0,d.width,d.height);
		  	 u = new SimpleUniverse(canvas1);
		  	 u.addBranchGraph(createSceneGraph1());
		  	 add(canvas1);
	  }
	  
	  public BranchGroup createSceneGraph1()
	     {
	     BranchGroup          BG = new BranchGroup();
	     // Prepare Apperances
	     Appearance Sky = new Appearance();
	     Sky.setTexture((new TextureLoader("F:/Rayman/Films/Trailer/Sky.jpg",null)).getTexture());
	     Sky.setTextureAttributes(new TextureAttributes(TextureAttributes.MODULATE,new Transform3D(),new Color4f(),TextureAttributes.FASTEST));
	     
	     Appearance Floor = new Appearance();
	     Floor.setTexture((new TextureLoader("F:/Rayman/Films/Trailer/Floor.jpg",null)).getTexture());
	     Floor.setTextureAttributes(new TextureAttributes(TextureAttributes.MODULATE,new Transform3D(),new Color4f(),TextureAttributes.FASTEST));
	     
	    
	     ///Lights
	     //1
	     AmbientLight         L1 =new AmbientLight(new Color3f(0.8f,0.8f,0.8f));
	     Point3d p1 = new Point3d(0,0,0);	     
	     BoundingSphere       LB1 =new BoundingSphere(p1,100000);
	     L1.setInfluencingBounds(LB1); BG.addChild(L1);
	    
	    ///Real World
	     Transform3D a = new Transform3D();
	     a.setTranslation(new Vector3d(0,0,-12));
	     TransformGroup A = new TransformGroup();
	     A.setTransform(a);BG.addChild(A); A.addChild(new Box(20,4,2,Box.GENERATE_NORMALS|Box.GENERATE_TEXTURE_COORDS,Sky));
	     
	  	     ///Trees	     
	     Transform3D t = new Transform3D();
	     t.setScale(2);
	     t.setTranslation(new Vector3f(20,-1,-9.5f));
	     TransformGroup T = new TransformGroup();
	     T.setTransform(t); BG.addChild(T); T.addChild(new Model().getModel("tree.obj"));

	    	     //View Initialisation
	     ViewTG = new TransformGroup();
	     ViewTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);	
	     ViewTG=u.getViewingPlatform().getViewPlatformTransform();
	     ViewT3D = new Transform3D();
	     ViewTG.getTransform(ViewT3D);
	     vct = new Vector3f(pos,0,0);
	     ViewT3D.setTranslation(vct);
	     ViewTG.setTransform(ViewT3D);

(new Thread(){@Override public void run(){while(!isInterrupted()){       
	   				pos = pos + 0.05f;
	   				vct = new Vector3f(pos,0,0);
	   				ViewT3D.setTranslation(vct);
	   				ViewTG.setTransform(ViewT3D);
	   				
try{sleep(10);}catch(InterruptedException e){interrupt();}}}}).start();

//////////	     
	     BG.compile();
	     return BG;
	     }
	  
	  public static void main(String[]args)
	  {
		  new Trailer_3();
	  }
	public static void warte(long millis){try{Thread.sleep(millis);}catch(InterruptedException e){}}
}
```
PS:
Probier den aus!


----------



## veritas696 (31. Mrz 2009)

@Developer: in deinem ersten Post sehe ich leider absolut nichts was mich weiterbringen würde :-( beim 2. (das mit dem Thread) is zwar ganz nett aber dabei fehlt vollig der Bezug zur Bewegung des Planeten.

P.S.: kennt jemand ein gutes Forum an daß mich mich wenden kann ?


----------



## hdi (31. Mrz 2009)

Das hier ist ein gutes Forum (@mods 50 pfennig auf mein konto bitte )

Warte doch erstmal ab, es wird bestimmt jemand hier reinschauen der sich mit Java3D
auskennt. 
Wie du schon am Wortlaut erkennen kannst, kenne _ich_ mich nicht damit aus


----------



## Illuvatar (31. Mrz 2009)

Soweit ich da gerade auf Anhieb durchblicke, ist es ja auch so, dass du die Kamera nur einmal mit dem Planeten "synchronisierst", nämlich in der enablePlanetCamera-Methode. Da wird allerdings nur die Transformation von der camTG auf die Kamera "kopiert".
Leider kenne ich keine Möglichkeit, die Kamera tatsächlich irgendwo anders in den SceneGraph einzuhängen. Die beste Lösung wäre vermutlich, einen Behavior zu schreiben, der einmal pro Frame aktiv wird (WakeupOnElapsedFrames(0)). In dessen processStimulus-Methode machst du dann genau das, was du bisher in enablePlanetCamera machst.



> @mods 50 pfennig auf mein konto bitte


Hier, bitte:


----------



## veritas696 (31. Mrz 2009)

hm, thx das werd ich mal ausprobieren wenns nicht gerade so viel Ressourcen fressen sollte. Aber wundert mich schon, daß da bisher noch keiner was zu weiß :rtfm:


----------



## Illuvatar (31. Mrz 2009)

Oh, Fehler meinerseits. Ich hab nochmal nachgeschaut - bei einer ViewingPlatform wird ALLOW_DETACH gesetzt. Das heißt, du kannst die viewingPlatform vom SimpleUniverse detachen und einfach irgendwo anders hinhängen.


----------



## veritas696 (31. Mrz 2009)

achso, das heißt ich könnte die ViewingPlatform einfach an meine Planeten hängen (quasi als Trabant) ? mal ausprobieren. Versuchs grad mit dem Behavior, aber da bewegt sich meien Kamera auch noch nicht. Sie wechselt zwar anfangs zum Planeten aber läuft dann nich mehr mit *grübbel*


----------



## veritas696 (1. Apr 2009)

so bin jetzt schonmal ein Stück weiter. Ich habe mir also ein Behavior geschrieben welches bei jedem Frame aufgerufen wird. Die Klasse sieht so aus:


[highlight=Java] 
public class PlanetLookBehavior extends Behavior
{
  WakeupOnElapsedFrames FPSwakeup = new WakeupOnElapsedFrames(0);
  private Planet currentPlanet;
  private TransformGroup targetTG;

  public PlanetLookBehavior(TransformGroup targetTG)
  {
    this.targetTG = targetTG; 
  }

  public void initialize()
  {
    this.wakeupOn(FPSwakeup);
  }

  public void processStimulus(Enumeration criteria)
  {
    if(currentPlanet != null)
    {
      TransformGroup ViewTG = currentPlanet.getCenterRotTG();
      Transform3D ViewT3D = new Transform3D();
      ViewTG.getTransform(ViewT3D);

      targetTG.setTransform(ViewT3D); 
    }
    this.wakeupOn(FPSwakeup);

  }

  public void setCurrentPlanet(Planet currentP)
  {
    currentPlanet = currentP;
  }

  public void resetCurrentPlanet()
  {
    currentPlanet = null;
  }
}
[/highlight]

Wenn ich das Programm also starte befindet sich meine Kamera (Ansicht) in der Mitte des Sonnensystems. Also an dem Punkt worum der Planet rotiert. Die Kamera verfolgt auch den Planeten in dem si mit ihm mitschwenkt(Kamera rotiert auf der Stelle). 
Jetzt möchte ich aber mit der Kamera nicht in der Mitte des Sonnensystems stehen sondern hinter dem Planeten und möchte auf den Mittelpunkt des Sonnensystems schauen und mit dem Planeten mitfliegen.
Also Kamera Planet und Sonne sollen auf einer Achse liegen wobei die Kamera Richtung Sonne schaut. Zwischen Kamera und Sonne befindet sich der Planet.
wie muss ich da transformieren (wenn das reicht) um das hinzubekommen ?


----------



## Illuvatar (1. Apr 2009)

Also, es gibt zwei Möglichkeiten.

Eine (die bessere), da musst du einfach nur die Kamera an deine "CamTG" hängen (+noch um 180° drehen wenn ich mich nicht irre) und fertig.

Nur für die andere brauchst du den Behavior. Da müsstest du jetzt in jedem Frame berechnen, wo die Kamera hinmuss, und dieses Transform3D der ViewingPlatform übergeben. Um das zu berechnen würdest du allerdings am sinvollsten das Transform3D per CamTG.getLocalToVWorld() abholen (+noch drehen).


----------



## veritas696 (1. Apr 2009)

1. Möglichkeit: wenn ich Versuche meine targetTg als Child meiner CamTg hinzuzufügen, bekomm ich den Fehler das targetTG schon ein "parent" hat, is ja logisch aber wie kann ich den targetTG aushängen aus dem alten Node. Oder muss ich meine gesamte Kamera (BranchGroup) an mein CamTG hängen?

2. Möglichkeit:
Ich habs mit diesem LocaltoVworld() probiert:

[highlight=Java] 
public void processStimulus(Enumeration criteria)
{
if(currentPlanet != null)
{
// aktuelle Transformation des Planeten holen
TransformGroup ViewTG = currentPlanet.getCamTG();
Transform3D ViewT3D = new Transform3D();

ViewTG.getLocalToVworld(ViewT3D);
//ViewTG.getTransform(ViewT3D);


targetTG.setTransform(ViewT3D);

}
this.wakeupOn(FPSwakeup);

}
[/highlight]

aber das sieht noch genauso aus wie vorher 

ach man, das kann doch nicht so schwer sein ???:L


----------



## Illuvatar (1. Apr 2009)

Was ist denn targetTg? Falls das die ViewPlatform ist, kannst du einfach
[HIGHLIGHT="Java"]targetTg.detach();
[...].addChild(targetTg);[/HIGHLIGHT]
machen.


----------



## veritas696 (1. Apr 2009)

Jo bald haben wirs geschafft :toll:

jetzt gibts noch eine Sache: Beim Start meines Programms kann ich mich erstmal frei bewegen mit der Kamera, erst wenn ich die Taste "3" drücke soll er in die "Planeteansicht"wechseln. Jetzt merke ich wenn ich mich vorher mit der freien Kamera bewege hat dies einfluß auf die spätere Position der KAmera in der Planetenansicht. Zum Beispiel: Fliege ich mit meiner freien Kamera etwas nach oben so bin ich auch in der Planetenansicht weiter oben hinter dem Planeten. Anscheinend sind die anderen Transformationen noch vorhanden, kann man die irgentwie löschen oder so. Ich meine die Kamera zurück zum Ursprung setzen - detachen - und dann an den Planeten hängen?

Edit: habs mit setNomialViewingTransform() probiert und es klappt :applaus:

Muss ich noch was beachten wenn ich zurück zur freien Kamera wechsele?
reicht da ein einfaches RootBG.addChild(viewingPlatform)?


----------



## Illuvatar (1. Apr 2009)

Ich denke, das sollte reichen.


----------



## veritas696 (1. Apr 2009)

Ja hat gereicht, ich danke dir vielmals :applaus:

werd aber bestimmt bald mit weiteren Sachen nerven ;(


----------

