# Sonnensystem - Eigenrotation der Planeten funktioniert nicht



## MarcusS (18. Mai 2005)

Hallo, 
habe in j3d ein Sonnensystem programmiert. Eine Klasse "Sonnensystem" in der die einzelnen Planeten erzeugt werden. Die Planeten drehen sich richtig um die Sonne, nur die Eigenrotation der Planeten funktioniert nicht. Wenn jemand mal Lust hat einen Blick darauf zu werfen wäre ich SEHR dankbar...

Hier meine Klasse Planet:


```
import java.awt.Component;
import javax.media.j3d.*;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3d;
import com.sun.j3d.utils.geometry.Primitive;
import com.sun.j3d.utils.geometry.Sphere;
import com.sun.j3d.utils.image.TextureLoader;

public class Planet {

	//Instanzvariablen eines Planeten
	private TransformGroup planetWurzel; //wird wieder an Klasse Sonnensystem zurückgegeben
	private TransformGroup tg;
	//private TransformGroup eigenRotTG;
	private Transform3D transformPlanet;
	private int umlaufzeit;			//Umlaufzeit um Sonne
	private float abstandSonne;		//Abstand zur Sonne
	private String texturPfad;		//Pfad für Textur
	private int eigenrotation;		//Eigenrotationszeit um sich selbst
	private float planetGroesse;	//Groesse des Planeten
	private float neigung;			//Neigung des Planeten um eigene Achse
	private static final int KREISKOORDINATEN = 128; // Anzahl Kreiskoordinaten
	private Shape3D orbit;			//Orbit um einen Planeten (Kreisbahn)
	private final BoundingSphere bs = new BoundingSphere(new Point3d(0,0,0),100);

	
	//Konstruktor
	public Planet(TransformGroup tg, int umlaufzeit, float abstandSonne,
			String texturPfad, int eigenrotation, float planetGroesse, float neigung) {
		super();
		this.tg = tg;
		this.umlaufzeit = umlaufzeit;
		this.abstandSonne = abstandSonne;
		this.texturPfad = texturPfad;
		this.eigenrotation = eigenrotation;
		this.planetGroesse = planetGroesse;
		this.neigung = neigung;
		
	}
	
	//Erzeugen des Planeten
	public TransformGroup erzeugePlanet(Component observer){
		transformPlanet = new Transform3D();
		//Festlegen der Neigung der Planetachse
		transformPlanet.rotZ(this.neigung);
		planetWurzel = new TransformGroup(transformPlanet);
		planetWurzel.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		planetWurzel.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
		
		//Festelegen der Appearance für jeden Planeten
		Appearance planetAppear = new Appearance();
		TextureLoader texturLoaderPlanet = 
                                    new TextureLoader(texturPfad,TextureLoader.GENERATE_MIPMAP,observer);
		TextureAttributes texAttrPlanet = new TextureAttributes();
	 	texAttrPlanet.setTextureMode(TextureAttributes.MODULATE);
	 	planetAppear.setTextureAttributes(texAttrPlanet);
		
	 	//Festlegen des Material für den Planeten
		Material planetMat = new Material(new Color3f(1.0f, 1.0f, 1.0f),
                                    new Color3f(0.0f, 0.0f, 0.0f),new Color3f(1.0f, 1.0f, 1.0f), new Color3f(0.0f, 0.0f, 0.0f), 1.0f);
		planetMat.setLightingEnable(true);
		planetAppear.setMaterial(planetMat);	
		planetAppear.setTexture(texturLoaderPlanet.getTexture());
		
		//Festlegen des Abstandes von Sonne zu Planet
		transformPlanet.setTranslation(new Vector3d(abstandSonne,0.0d,0.0d));
		planetWurzel.setTransform(transformPlanet);
		
		//Erzeugen des Planeten
		planetWurzel.addChild(new Sphere
                                        (planetGroesse,Primitive.GENERATE_TEXTURE_COORDS|
                                        Primitive.GENERATE_NORMALS,50,planetAppear));
		
	   	//Erzeugen der Umlaufbahn: nur zeichnen der Umlaufbahn
		orbit = new Shape3D(erzeugeKreisGeometrie(abstandSonne, KREISKOORDINATEN));
		tg.addChild(orbit);
		
		//versetze Planet in Bewegung um die Sonne
		erzeugeUmlaufBahnUmSonne();
		
		//versetze Planeten in Eigenrotation um eigene Achse
		//erzeugeEigenrotation();
		
		return planetWurzel;
	}

	//erzeugt die Geometrie eines Kreises mit Radius r und N Punkten
	//wird in der Methode erzeugePlanet aufgerufen
	private Geometry erzeugeKreisGeometrie(float r, int N) {
        int[] stripCounts = {N}; 
        LineStripArray lsa =
            new LineStripArray(N, LineStripArray.COORDINATES, stripCounts);
        lsa.setCoordinates(0, erzeugeKreisKoordinaten(r, N));
        return lsa;
	}
	
	 //liefert die Koordinaten eines Kreises mit dem Radius r und N Paaren
	//wird in der Methode erzeugeKreisGeometrie aufgerufen
    private Point3f[] erzeugeKreisKoordinaten(float r, int N) {
        Point3f[] koordinaten = new Point3f[N];
        int       n;
        double    a;
        float     x, z;

        for (a = 0, n = 0; n < N; a = 2.0 * Math.PI / (N-1) * ++n) {
            x = (float) (r * Math.sin(a));
            z = (float) (r * Math.cos(a));         
            koordinaten[n] = new Point3f(x, 0f, z);
        }
        return koordinaten;
    }
	
	
	
	//simuliert einen Planeten-Tag (zum Beispiel: Roation der Erde um sich selbst)
    private void erzeugeEigenrotation(){
    	Vector3d erdePos =  new Vector3d(abstandSonne, 0.0, 0);
    	Transform3D drehungPlanet = new Transform3D();
    	drehungPlanet.set(erdePos);
		TransformGroup planetRotUmSichSelbstTG = new TransformGroup(drehungPlanet);
        planetRotUmSichSelbstTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        planetRotUmSichSelbstTG.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
	           
        Alpha rotationAlpha = new Alpha(-1, (int) eigenrotation);
        
        RotationInterpolator planetUmdrehung = new RotationInterpolator(rotationAlpha, planetRotUmSichSelbstTG, 
                transformPlanet, 0.0f, (float) Math.PI*2.0f);      
        planetUmdrehung.setSchedulingBounds(bs);
		
        planetRotUmSichSelbstTG.addChild(planetUmdrehung);
		planetWurzel.addChild(planetRotUmSichSelbstTG);
    }
    
    //simuliert ein Planeten-Jahr (zum Beispiel: Bewegung der Erde um die Sonne)
    private void erzeugeUmlaufBahnUmSonne() {
    	
    	Transform3D yAxis = new Transform3D();
    	TransformGroup planetRot = new TransformGroup(yAxis);
    	Alpha rotor1Alpha = new Alpha(-1, Alpha.INCREASING_ENABLE, 0, 0,(int) umlaufzeit, 0, 0, 0, 0, 0);
    	
    	RotationInterpolator planetenUmlaufbahn = new RotationInterpolator(rotor1Alpha,tg,yAxis,0.0f,
                    (float) Math.PI*2.0f);
    	planetenUmlaufbahn.setSchedulingBounds(bs);
    	
    	planetRot.addChild(planetenUmlaufbahn);
    	planetWurzel.addChild(planetRot); 
    }
    
}
```


----------



## MarcusS (18. Mai 2005)

der Aufruf "//erzeugeEigenrotation();"  in Zeile 85 ist natürlich nicht auskommentiert bei mir... das war nur zu Testzwecken


----------



## Oxygenic (19. Mai 2005)

Ein bissl viel Code zum mal eben debuggen, oder!? Prinzipiell: du hast eine TransfromGroup mit Rotator, die erzeugen die Umlaufbahnen, darunter eine weitere TG die für den Bahnradius zuständig ist und darunter wieder eine TG mit Rotator, die die Eigenrotation erzeugt. Erst anschließend kommt dein Planetenobjekt.

Wenn diese Reihenfolge nicht passt, klappts auch nicht mit der Umlaufbahn.


----------



## MarcusS (19. Mai 2005)

also wenn ich Dich verstanden habe meinst Du das so:


```
//versetze Planet in Bewegung um die Sonne
		Transform3D yAxis = new Transform3D();
    	planetRot = new TransformGroup(yAxis);
    	Alpha rotor1Alpha = new Alpha(-1, Alpha.INCREASING_ENABLE, 0, 0,(int) umlaufzeit, 0, 0, 0, 0, 0);
    	
    	RotationInterpolator planetenUmlaufbahn = 
                    new RotationInterpolator(rotor1Alpha,tg,yAxis,0.0f,(float) Math.PI*2.0f);
    	planetenUmlaufbahn.setSchedulingBounds(bs);
    	
    	planetRot.addChild(planetenUmlaufbahn);
		
//Versetze Planet in Eigenrotation
	Vector3d erdePos =  new Vector3d(abstandSonne, 0.0, 0.0);
    	Transform3D drehungPlanet = new Transform3D();
    	drehungPlanet.set(erdePos);

	TransformGroup planetRotUmSichSelbstTG = new TransformGroup(drehungPlanet);
	planetRotUmSichSelbstTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
	planetRotUmSichSelbstTG.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
	           
                Alpha rotationAlpha = new Alpha(-1, (int) eigenrotation);
        
                RotationInterpolator planetUmdrehung = 
                    new RotationInterpolator(rotationAlpha,planetRotUmSichSelbstTG,
                         transformPlanet, 0.0f, (float) Math.PI*2.0f);      
                planetUmdrehung.setSchedulingBounds(bs);
		
                planetRot.addChild(planetUmdrehung);
		
		
		
//Erzeugen des Planeten
                planetRot.addChild(new Sphere
               (planetGroesse,Primitive.GENERATE_TEXTURE_COORDS|
                        Primitive.GENERATE_NORMALS,50,planetAppear));
	planetWurzel.addChild(planetRot);
```


planetWurzel ist die TG die ich an meine Klasse Sonnensystem zurückgebe...


----------



## MarcusS (19. Mai 2005)

thnxs hab mein Problem gefunden... trotzdem DANKE


----------

