JOGL - Kugel wird nicht gezeichnet

[Fesker]

Hallo liebe Leute, ich spiele immer noch mit meinen Zufallsgenerierten Sonnensystemen und LinkedLists herum, nun möchte ich die generierten Systeme in einem OpenGL-JInternalFrame anzeigen lassen.
Das Fenster funktioniert, kann drin zeichnen, nun stoße ich auf folgendes Problem.

Ich will die ganzen Methoden ja möglichst klein halten um Übersicht zu schaffen und mit dieser Methode hier die Planeten (später) an ihre jeweiligen Positionen bringen.
Um das zu schaffen, hat jedes Planetenobjekt eigene Positions- und Geschwindigkeitswerte etc, die ich hier mit einbauen muss. Aber WENN ich diese nun hier in dieser Methode die ganzen int, doubles etc. definiere/abrufe, dann wird meine Kugel nicht gezeichnet, stattdessen bleibt ein weißes Fenster übrig.
Lösche ich sie, wird die Kugel ganz normal dargestellt. warum?

private void DrawPlanet(GLAutoDrawable drawable) {	    	
	        GL2 gl = drawable.getGL().getGL2();
	        int     selectedSystem	  = MainWindow.this.sysList.getSelectedIndex();
	   	int  	selectedPlanet    = MainWindow.this.planetList.getSelectedIndex();
	   	Planet p = systems.get(selectedSystem).getPlanet(selectedPlanet);
	   	int    distance = p.getDistance();
	   	float  speed 	= p.getSpeed();
	        double xPos     = p.getXPos();
	        double yPos     = p.getYPos();
	        double zPos     = p.getZPos();
	        double xAngle   = p.getXAngle();
	        double yAngle   = p.getYAngle();
	        double zAngle   = p.getZAngle();
	        
	   		gl.glMatrixMode(gl.GL_MODELVIEW);
	        gl.glLoadIdentity();
	        
	    	 // Set material properties.
            float[] rgba = {0.3f, 0.5f, 1f};
            gl.glMaterialfv(GL.GL_FRONT, gl.GL_AMBIENT, rgba, 0);
            gl.glMaterialfv(GL.GL_FRONT, gl.GL_SPECULAR, rgba, 0);
            gl.glMaterialf(GL.GL_FRONT, gl.GL_SHININESS, 0.5f);
            gl.glColor3f(0.3f, 0.5f, 1f); 
            
            
	        // Draw sphere	        
	         /*xAngle = (xAngle + 1f) % 360;
	         zAngle = (zAngle + 1f) % 360;
	         xPos = Math.sin(Math.toRadians(xAngle))*distance;
	         zPos = Math.cos(Math.toRadians(zAngle))*distance;*/
	         
	        //gl.glTranslatef(0.0f, 10f, 0.0f); // Translate object
	        
	        GLUquadric earth = glu.gluNewQuadric();
	        glu.gluQuadricDrawStyle(earth, GLU.GLU_LINE);
	        glu.gluQuadricNormals(earth, GLU.GLU_FLAT);
	        glu.gluQuadricOrientation(earth, GLU.GLU_OUTSIDE);
	        final float radius = 6.345f;
	        final int slices = 64;
	        final int stacks = 64;
	        glu.gluSphere(earth, radius, slices, stacks);	       
	        glu.gluDeleteQuadric(earth);
	    }

Ich kann die Variablen auch nicht woanders hin verschieben, weil das GLWindow vor dem MainWindow, in dem es sich dann eigentlich befindet, geladen wird und ich dann einen Error bekomme, dass die "Syslist" ja noch gar nicht existiert...

Beste Grüße!

 

[Fesker]

Da nun doch schon einige Leute hier reingeschaut haben und nichts zu berichten wissen, hänge ich einfach mal meine Codes an, vielleicht hilft euch das weiter.. ich seh den Wald vor lauter Bäumen grad nicht mehr... :noe:

Wie gesagt, lösche ich den Teil mit

int     selectedSystem	  = MainWindow.this.sysList.getSelectedIndex();
	   		int  	selectedPlanet    = MainWindow.this.planetList.getSelectedIndex();
	   		Planet p = systems.get(selectedSystem).getPlanet(selectedPlanet);
	   		int    distance = p.getDistance();
	   		float  speed 	= p.getSpeed();
	        double xPos     = p.getXPos();
	        double yPos     = p.getYPos();
	        double zPos     = p.getZPos();
	        double xAngle   = p.getXAngle();
	        double yAngle   = p.getYAngle();
	        double zAngle   = p.getZAngle();

aus der DrawPlanet Methode, dann wird die Kugel gezeichnet... der Grund dafür ist mir nur nicht klar.
Bin auch für sonstige Vorschläge offen, wie man den Code besser gestalten könnte opcorn:

MainWindow.java:

Spoiler

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.DefaultListModel;
import javax.swing.JList;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.ListSelectionModel;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.ScrollPane;
import java.awt.SystemColor;
import javax.swing.JEditorPane;
import com.jogamp.opengl.util.FPSAnimator;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.*;

import java.awt.Font;


final public class MainWindow extends JFrame {
	
	final class GLWindow implements GLEventListener {

		
	    double cameraDistance = 100;
	    double cameraAngle = 0;
	    double cameraFocusX, cameraFocusY, cameraFocusZ;
	    double cameraX, cameraY, cameraZ;
	    
	    
	    
	    GLU glu = new GLU();
	    
	    public void GLMain() {
	    	 GLProfile glp = GLProfile.getDefault();
	         GLCapabilities caps = new GLCapabilities(glp);
	         GLCanvas canvas = new GLCanvas(caps);
	        
	        final JInternalFrame JOGLFrame = new JInternalFrame("JOGLI");
			JOGLFrame.setBounds(0, 265, 359, 266);
			JOGLFrame.add(canvas);
			JOGLFrame.setResizable(true);
			MainWindow.this.desktopPane.add(JOGLFrame);			
			JOGLFrame.setVisible(true);
				
	        canvas.addGLEventListener(new GLWindow());

	        FPSAnimator animator = new FPSAnimator(canvas,60);
	        animator.start();
	    }

	    @Override
	    public void display(GLAutoDrawable drawable) {
	        update(drawable);
	        render(drawable);
	    }

	    @Override
	    public void dispose(GLAutoDrawable drawable) {
	    }

	    @Override
	    public void init(GLAutoDrawable drawable) {
	    	GL2 gl = drawable.getGL().getGL2();
	    	
	        // Global settings.
	        gl.glShadeModel(gl.GL_SMOOTH);
	        gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST);
	        gl.glClearColor(0f, 0f, 0f, 1f);
	        
	    	    	
	    	setCamera(drawable, gl, glu, 10,0,10,0,0,0);
	    }

	    @Override
	    public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
	    }

	    private void update(GLAutoDrawable drawable) {
	    	 
	    	double theta = 0;
		    double x = 0;
		    double y = 0;
		    double z = 0;
	    	GL2 gl = drawable.getGL().getGL2();
	        theta = 1;


	         /*Kameraposition kreisen lassen
	         cameraAngle = (cameraAngle + 1f) % 360;
	         x = Math.sin(Math.toRadians(cameraAngle))*cameraDistance;
	         z = Math.cos(Math.toRadians(cameraAngle))*cameraDistance;
	         System.out.println(z);
	         y = 0;
	        	        		
	        setCamera(drawable, gl, glu, x,0, z,0,0,0); */
	    }
	    
	    private void setCamera(GLAutoDrawable drawable, GL2 gl, GLU glu, double cameraX, double cameraY, double cameraZ, double cameraFocusX, double cameraFocusY, double cameraFocusZ) {
	    	
	    	gl = drawable.getGL().getGL2();
	    	
	    	gl.glMatrixMode(gl.GL_PROJECTION);
	        gl.glLoadIdentity();
	        
	        // Perspective.
	        float widthHeightRatio = (float) getWidth() / (float) getHeight();
	        glu.gluPerspective(45, widthHeightRatio, 1, 10000);
	        glu.gluLookAt(cameraX, cameraY, cameraZ, 0, 0, 0, 0, 1, 0); // distance, x,y,z
	        
	     // Change back to model view matrix.
	        gl.glMatrixMode(gl.GL_MODELVIEW);
	        gl.glLoadIdentity();

	    }
	    
	    private void DrawPlanet(GLAutoDrawable drawable) {	    	
	        GL2 gl = drawable.getGL().getGL2();
	        int     selectedSystem	  = MainWindow.this.sysList.getSelectedIndex();
	   		int  	selectedPlanet    = MainWindow.this.planetList.getSelectedIndex();
	   		Planet p = systems.get(selectedSystem).getPlanet(selectedPlanet);
	   		int    distance = p.getDistance();
	   		float  speed 	= p.getSpeed();
	        double xPos     = p.getXPos();
	        double yPos     = p.getYPos();
	        double zPos     = p.getZPos();
	        double xAngle   = p.getXAngle();
	        double yAngle   = p.getYAngle();
	        double zAngle   = p.getZAngle();
	        
	   		gl.glMatrixMode(gl.GL_MODELVIEW);
	        gl.glLoadIdentity();
	        
	    	 // Set material properties.
            float[] rgba = {0.3f, 0.5f, 1f};
            gl.glMaterialfv(GL.GL_FRONT, gl.GL_AMBIENT, rgba, 0);
            gl.glMaterialfv(GL.GL_FRONT, gl.GL_SPECULAR, rgba, 0);
            gl.glMaterialf(GL.GL_FRONT, gl.GL_SHININESS, 0.5f);
            gl.glColor3f(0.3f, 0.5f, 1f); 
            
            
	        // Draw sphere	        
	         /*xAngle = (xAngle + 1f) % 360;
	         zAngle = (zAngle + 1f) % 360;
	         xPos = Math.sin(Math.toRadians(xAngle))*distance;
	         zPos = Math.cos(Math.toRadians(zAngle))*distance;*/
	         
	        //gl.glTranslatef(0.0f, (float)yPos, (float)zPos); // Translate our object along the y axis  
	        
	        GLUquadric earth = glu.gluNewQuadric();
	        glu.gluQuadricDrawStyle(earth, GLU.GLU_LINE);
	        glu.gluQuadricNormals(earth, GLU.GLU_FLAT);
	        glu.gluQuadricOrientation(earth, GLU.GLU_OUTSIDE);
	        final float radius = 6.345f;
	        final int slices = 64;
	        final int stacks = 64;
	        glu.gluSphere(earth, radius, slices, stacks);	       
	        glu.gluDeleteQuadric(earth);
	    }
	    
	    private void RenderSolarSystem(GLAutoDrawable drawable){
	    	 GL2 gl = drawable.getGL().getGL2();
	    	
	    	     	    
	    	 // Prepare light parameters.
	            float SHINE_ALL_DIRECTIONS = 1;
	            float[] lightPos = {-30, 0, 0, SHINE_ALL_DIRECTIONS};
	            float[] lightColorAmbient = {0.2f, 0.2f, 0.2f, 1f};
	            float[] lightColorSpecular = {0.8f, 0.8f, 0.8f, 1f};

	            // Set light parameters.
	            gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, lightPos, 0);
	            gl.glLightfv(gl.GL_LIGHT1, gl.GL_AMBIENT, lightColorAmbient, 0);
	            gl.glLightfv(gl.GL_LIGHT1, gl.GL_SPECULAR, lightColorSpecular, 0);

	            // Enable lighting in GL.
	            gl.glEnable(gl.GL_LIGHT1);
	            gl.glEnable(gl.GL_LIGHTING);

	            DrawPlanet(drawable);
		        
		        
	    }

	    private void render(GLAutoDrawable drawable) {
	        GL2 gl = drawable.getGL().getGL2();
	        gl.glClear(GL.GL_COLOR_BUFFER_BIT);
	        
	        RenderSolarSystem(drawable);
	    }
	}
	
	private JPanel contentPane;
	final List<SolarSystem> systems = new LinkedList<SolarSystem>();
	final DefaultListModel systemListModel = new DefaultListModel();
	final DefaultListModel planetListModel = new DefaultListModel();
	final JList planetList = new JList(planetListModel);
	final JList sysList    = new JList(systemListModel);
	final JEditorPane PlanetDetailTextPane = new JEditorPane();
	
	final JDesktopPane desktopPane = new JDesktopPane();
	
	
	final int getSysListSelectedIndex(){
		return sysList.getSelectedIndex();
	}
	
	// Systeme & Planeten generieren
	public void GenerateSystems(){
		
		Random iRandom = new Random();
    	for (int i=0;i<10;i++){
    	systems.add(new SolarSystem(iRandom.nextInt(10)));
    		
    			for (int z=0; z<iRandom.nextInt(15);z++)
    			{
    				systems.get(i).addPlanet(new Planet(systems.get(i)));
    				Planet p = systems.get(i).getPlanet(z);
    				System.out.println(p.getName() 
    						+ ", mass: " + p.getMass() 
    						//+ ", type: " + p.getType() 
    						+ ", distance: " + p.getDistance()
    						);
    			    //planetListModel.addElement(galaxy.get(i).getPlanet(z).getName());
    			}	
    		System.out.println(systems.get(i).getPlanetCount());
    		systemListModel.addElement(systems.get(i).getName());
    	}
	}
	
	public void UpdatePlanetFrame(){
		 int	selected    = sysList.getSelectedIndex();
		 int 	planetCount = systems.get(selected).getPlanetCount();
		 
		 planetListModel.clear();
		 
		 if (planetCount == 0) {
			 planetListModel.addElement("Leeres System");
		 }				 
		 else {	
			 	for (int i=0; i<planetCount;i++){
			 		String planetName  = systems.get(selected).getPlanet(i).getName();
			 		String planetType     = Snippets.PlanetTypeToString(systems.get(selected).getPlanet(i).getType());
			 		planetListModel.addElement(planetName +" - ["+planetType+"]");												    	
			 	}
		 }
	}
	
	public void UpdatePlanetDetailWindow(){

		 int    selectedSystem	  = sysList.getSelectedIndex();
		 int	selectedPlanet    = planetList.getSelectedIndex();		 
		 int 	planetCount 	  = systems.get(selectedSystem).getPlanetCount();
		 String fontFace1  		  = "Verdana";
		 int	fontSize 		  = 3;
		 
		 if (planetCount == 0) {
			 PlanetDetailTextPane.setText("Keine Planeten in diesem System!");
			 
		 } 
		 else {
		 Planet p                 = systems.get(selectedSystem).getPlanet(selectedPlanet);
		 PlanetDetailTextPane.setText("");
		 PlanetDetailTextPane.setText(""
		 		+ "<font face=\""+fontFace1+"\" size="+fontSize+"\">"
		 		+ p.getName() 
		 		+ "<br>"+"Typ: " + Snippets.PlanetTypeToString(p.getType())
		 		+ "<br>"+"Masse: " + p.getMass() 
		 		+ "<br>"+"Entfernung zur Sonne: " + p.getDistance() + " AU"
		 		+ "<br>Temperaturen: " + p.getMinTemp()+"°C bis "+p.getMaxTemp()+"°C "+"Ø"+p.getAvgTemp()+"°C"
		 		+ "<br>Test: get HabitableZone: "+ systems.get(selectedSystem).getHabitableZone()
		 		+ "<br>Test: get Type2: "
		 		+ ""
		 		+ "</font>");
		 }
	}
	
 	public MainWindow() {
		    	
    	sysList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
		
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 1021, 653);
		contentPane = new JPanel();
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		contentPane.setLayout(new BorderLayout(0, 0));
		setContentPane(contentPane);
				
		desktopPane.setBackground(SystemColor.menu);
		contentPane.add(desktopPane);
		
		JInternalFrame SystemFrame = new JInternalFrame("Bekannte Systeme");
		SystemFrame.setIconifiable(true);
		SystemFrame.setResizable(true);
		SystemFrame.setClosable(true);
		SystemFrame.setBounds(0, 0, 163, 254);
		desktopPane.add(SystemFrame);
		
		JInternalFrame PlanetFrame = new JInternalFrame("Enthaltene Planeten");
		PlanetFrame.setResizable(true);
		PlanetFrame.setIconifiable(true);
		PlanetFrame.setClosable(true);
		PlanetFrame.setLocation(173, 0);
		PlanetFrame.setSize(175, 254);
		desktopPane.add(PlanetFrame);
		
		JInternalFrame PlanetDetailFrame = new JInternalFrame("Details");
		PlanetDetailFrame.setClosable(true);
		PlanetDetailFrame.setResizable(true);
		PlanetDetailFrame.setIconifiable(true);
		PlanetDetailFrame.setBounds(358, 0, 235, 254);
		desktopPane.add(PlanetDetailFrame);
		
  
  		PlanetDetailTextPane.setEditable(false);
  		PlanetDetailTextPane.setFont(new Font("Tahoma", Font.PLAIN, 11));
  		PlanetDetailTextPane.setContentType("text/html");
		PlanetDetailFrame.getContentPane().add(PlanetDetailTextPane, BorderLayout.CENTER);
		PlanetDetailFrame.setVisible(true);
		
				
		sysList.addMouseListener(new MouseAdapter() { // Systemliste angeklickt
			@Override
			public void mousePressed(MouseEvent arg0) {
				UpdatePlanetFrame();
			}
		});
		
		planetList.addMouseListener(new MouseAdapter() { // PLanetList angeklickt
    		@Override
    		public void mousePressed(MouseEvent arg0) { 			
    			UpdatePlanetDetailWindow(); 
    		}
    	});
		
			
		ScrollPane planetScrollPane = new ScrollPane();
		ScrollPane systemScrollPane = new ScrollPane();
		PlanetFrame.getContentPane().add(planetScrollPane, BorderLayout.CENTER);
		planetScrollPane.add(planetList);		
		SystemFrame.getContentPane().add(systemScrollPane, BorderLayout.CENTER);
		systemScrollPane.add(sysList);
					
		SystemFrame.show();
		PlanetFrame.show();
		
		GenerateSystems();
		
		GLWindow glw = new GLWindow();
		glw.GLMain();

 	}   
	
	
 	
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					MainWindow mFrame = new MainWindow();
					mFrame.setVisible(true);
					
										
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}
}

Planet.java:

Spoiler

import java.util.*;
public class Planet {
	
	private Integer type,             // RandomNumber, converted later into "Terran", Water, Gas....
	                distance,         // DistanceToSun (radius)
	                minTemp, 
	                maxTemp, 
	                avgTemp;      // Average temperature based on Distance and PlanetType
	
	private double xPos, xAngle,
				   yPos, yAngle,
				   zPos, zAngle;
	private float  speed;          // Speed for circling around sun
	        
	private String  name;     
	
	private SolarSystem solarSystem;
	private MainWindow mw;
    private final double mass;
	     
    // construct a new planet with given attributes
    public Planet(SolarSystem solarSystem) {
    	Random random = new Random();
    	
        this.solarSystem = solarSystem; // SystemIndex where the planet is in. 
        this.name     	 = GenerateName();
        this.mass  		 = random.nextDouble();
		this.distance    = GenerateDistance();
		this.type        = GenerateType();
		this.minTemp     = GenerateMinTemp();
		this.maxTemp     = GenerateMaxTemp();
		this.avgTemp	 = (this.minTemp + this.maxTemp)/2;
	 }
    
    public double getXPos    ()  {return xPos;}    
    public double getXAngle  ()  {return xAngle;}
    public double getYPos    ()  {return yPos;}
    public double getYAngle  ()  {return yAngle;}
    public double getZPos    ()  {return zPos;}
    public double getZAngle  ()  {return zAngle;}
    public double getMass    ()  {return mass;}
    public String getName    ()  {return name;}
    public float  getSpeed   ()  {return speed;}
    public int 	  getType    ()  {return type;}   
    public int    getDistance()  {return distance;}
    public int 	  getMinTemp ()  {return minTemp;}
    public int    getMaxTemp ()  {return maxTemp;}
    public int    getAvgTemp ()  {return avgTemp;}
    
    public void setXPos(double x){this.xPos = x;}
    public void setYPos(double y){this.yPos = y;}
    public void setZPos(double z){this.zPos = z;}
    
    public int GenerateMinTemp(){ // °C
    	Random random = new Random();
    	int distance  = this.getDistance();
    	int hotZone   = this.solarSystem.getHotZone();
    	int habZone   = this.solarSystem.getHabitableZone();
    	int coldZone  = this.solarSystem.getColdZone();
    	
    	//heiß - muss planetentypennummern noch ändern, evtl enum
    	if (this.type == 0) minTemp = random.nextInt(400)+400; // Lava
    	if (this.type == 1) minTemp = random.nextInt(250)+ 50; // Extreme Wüste
    	if (this.type == 2 && distance <= hotZone) minTemp = random.nextInt(250)+ 50; // Heißer Fels
    	
    	if (this.type == 1 && (distance > hotZone) && (distance <= habZone)) minTemp = random.nextInt(70)-70; // Normale Wüste
    	if (this.type == 2 && (distance > hotZone) && (distance <= habZone)) minTemp = random.nextInt(70)-70; // Normaler Fels
    	if (this.type == 3) minTemp = random.nextInt(65)-65; // Terra
    	if (this.type == 4) minTemp = random.nextInt(20)-5; // Jungle
    	if (this.type == 5) minTemp = random.nextInt(65)-30; // Water
    	
    	if (this.type == 6) minTemp = random.nextInt(65)-240; // Gas
    	if (this.type == 7) minTemp = random.nextInt(100)-280; // Eis
    	
    	return minTemp;
    }
    
    public int GenerateMaxTemp(){ // °C
    	Random random = new Random();
    	int distance  = this.getDistance();
    	int minTemp   = this.minTemp;
    	int hotZone   = this.solarSystem.getHotZone();
    	int habZone   = this.solarSystem.getHabitableZone();
    	int coldZone  = this.solarSystem.getColdZone();
    	
    	//heiß - muss planetentypennummern noch ändern, evtl enum
    	if (this.type == 0) maxTemp = minTemp + random.nextInt(700); // Lava
    	if (this.type == 1) maxTemp = minTemp + random.nextInt(250); // Extreme Wüste
    	if (this.type == 2 && distance <= hotZone) maxTemp = minTemp + random.nextInt(250); // Heißer Fels
    	
    	if (this.type == 1 && (distance > hotZone) && (distance <= habZone)) maxTemp = minTemp + random.nextInt(70); // Normale Wüste
    	if (this.type == 2 && (distance > hotZone) && (distance <= habZone)) maxTemp = minTemp + random.nextInt(70); // Normaler Fels
    	if (this.type == 3) maxTemp = minTemp + random.nextInt(65); // Terra
    	if (this.type == 4) maxTemp = minTemp + random.nextInt(35); // Jungle
    	if (this.type == 5) maxTemp = minTemp + random.nextInt(40); // Water
    	
    	if (this.type == 6) maxTemp = minTemp + random.nextInt(70); // Gas
    	if (this.type == 7) maxTemp = minTemp + random.nextInt(100); // Eis
    	
    	return maxTemp;
    }
    
    public int GenerateType() {
    	
    	Random random = new Random();
    	    	    	
    	int type = 0;    	
    	int distance = this.getDistance();
    	int hotZone  = this.solarSystem.getHotZone();
    	int habZone  = this.solarSystem.getHabitableZone();
    	int coldZone = this.solarSystem.getColdZone();
    	
    	// HotPlanet
    	if (distance <= hotZone) {
    		if (random.nextInt(2) == 0) type = 0; // Lava
    		if (random.nextInt(2) == 1) type = 1; // Heiße Wüste
    		if (random.nextInt(2) == 2) type = 2; // Heißer Fels
    	}
    	
    	// NormalPlanet
    	if ((distance > hotZone) && (distance <= habZone)) {
    		if (random.nextInt(3) == 0) type = 1; // Normal Wüste
    		if (random.nextInt(4) == 1) type = 2; // Normal Fels
    		if (random.nextInt(3) == 2) type = 3; // Terra
    		if (random.nextInt(3) == 3) type = 4; // Dschungel
    		if (random.nextInt(3) == 4) type = 5; // Wasser
    	}
    	// Cold Planets
    	if (distance > habZone) {
    		if (random.nextInt(1) == 0) type = 6; // Gas
    		if (random.nextInt(1) == 1) type = 7; // Eis
    	}
    	
    	return type;
    }
	
	private String GenerateName() // Wie der Name schon sagt...
	{
		String    sAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
		String    sName = "";
		Character cRandChar;		
		Random iRandom = new Random();
		                 
		// 3 Anfangsbuchstaben ausdenken
		for (int i = 0; i < 3; i++) 
		{
			cRandChar = sAlphabet.charAt(iRandom.nextInt(sAlphabet.length()));
			sName = sName + cRandChar;
		}		
		// Und Nummern hinzufügen
		sName = sName + "-" + Integer.toString(iRandom.nextInt(899)+100);
		return sName;
	}
	
	private int GenerateDistance() 
	{
		Random iRandom = new Random();
		distance = iRandom.nextInt(99)+1;
		return distance;
	}
}

SolarSystem.java:

Spoiler

import java.util.*;
public class SolarSystem {

	public  int 	sunType, 
	 				hotZoneRadius,       // radius in AU
	 				habitableZoneRadius, // radius in AU
	 				coldZoneRadius;      // radius in AU
	private String  name;
	private Planet planet;	
	
	final List<Planet> planets = new LinkedList<Planet>();
	 
	    // constructor to create an empty solar system
		public SolarSystem(int iSunType) {
			this.sunType 		       = iSunType;
			this.name                  = GenerateName();
			this.hotZoneRadius         = GenerateHotZoneRadius(); // 10-30AU			
			this.habitableZoneRadius   = GenerateHabitableZoneRadius(); // = HotZone+Random(20);
			this.coldZoneRadius		   = GenerateColdZoneRadius();
		}
		
		// add a given planet to this solar system
	    public void   addPlanet(Planet p) {planets.add(p);}
	    public int    getHotZone()        {return hotZoneRadius;}
	    public int    getHabitableZone()  {return habitableZoneRadius;}
	    public int    getColdZone()       {return coldZoneRadius;}	    
	    public int    getPlanetCount()    {return planets.size();}	 // retrieve number of planets in this solar system   
	    public Planet getPlanet(int i)    {return planets.get(i);} // retrieve a planet given by its index, 0 <= i < planetCount
	    public String getName()           {return name;}
		
		private int GenerateHotZoneRadius(){
			int result = 0;
			Random random = new Random();
			// Defines the radius of the area where planets within will get extremely high temperatures
			// Depends maybe later on Suntype;
			result = random.nextInt(20)+10; 
			
			return result;
		}
		
		private int GenerateHabitableZoneRadius(){
			int result = 0;
			Random random = new Random();
			// Defines the outline of the area where planets within get extremely high temperatures
			// Depends maybe later on Suntype;
			result = this.getHotZone() + random.nextInt(30)+10; 
			
			return result;
		}
		private int GenerateColdZoneRadius(){
			int result = 0;
			Random random = new Random();
			// Defines the outline of the area where planets within get extremely high temperatures
			// Depends maybe later on Suntype;
			result = this.getHabitableZone() + 100; 
			
			return result;
		}
		
		private String GenerateName() // Wie der Name schon sagt...
		{
			String    sAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
			String    sName = "SYS ";			
			Character cRandChar;			
			Random iRandom = new Random();			                 
			// 2 Anfangsbuchstaben ausdenken
			for (int i = 0; i < 2; i++) {
				cRandChar = sAlphabet.charAt(iRandom.nextInt(sAlphabet.length()));
				sName = sName + cRandChar;
			}			
			// 3 Nummern hinzufügen
			sName = sName + "-" + Integer.toString(iRandom.nextInt(899)+100);		
			return sName;
		}
	   	 
	    
}

Grüße und danke im Voraus!

 

[Fesker]

Hey, ich bins wieder.. =P
Ich habe den Fehler zwar gefunden, weiß aber nicht, wie ich das ändern kann und möchte nicht wegen jedem Pieps einen neuen Thread aufmachen
.
Das GLWindow wird als allerallererstes initialisiert, scheinbar noch vor der MainWindow.class

Daher gibt es die sysList usw ja noch gar nicht und es folgt ein IndexOutofBound-Error, sofern ich die Variablen global in der GLWindow.class platziere.

Wenn ich die

GLWindow glw = new GLWindow();
				glw.GLMain();

die sich derzeit am Ende der MainWindow() Methode befinden, nun in den MouseListener packe, der zur planetList gehört, dann funktioniert die Sache; weil dann erst, nachdem die MainWindow.class fertig geladen ist, das GL-Window erstellt wird. (Allerdings ja dann immer eins pro Klick! :lol Im sysList-MouseListener passiert jedoch gar nichts :bahnhof:

Wie schaffe ich es, dass das GLWindow erst ganz am Ende geladen wird, nachdem praktisch alle JLists und Frames gebaut und Planeten generiert wurden usw. ?