Klassen-Vererbung

[Franky]

Hallo Jens!

Danke für deine Hilfe!

Plane ist ein ungeschickter Name für dein Objekt, schließlich ist es keine zweidimensionale unbegrenzte Ebene sondern eine begrenzte Fläche.

"Plane" wird aber laut Leo mit "Fläche", "Ebene" übersetzt. Insofern passt mir der Name eigentlich ganz gut!?

Laut deinem Quellcode, ist der Würfel eher nicht von der Fläche abgeleitet sondern hat sechs Flächen als Attribute.

Ich könnte das Attribut auch protected setzen. Wenn ich aber aus "Plane" Objekte erstellen will brauch ich zumindest die Referenz auf Plane. Das muss ich nicht zwingend als Attribut anlegen, das stimmt wohl.

bottomPlane.drawPlane() setzt die vertices des Attributs bottomPlane deines "Würfels", das Atribut vertices deines Würfels wird nicht gesetzt (da drawPlane() bzw. this.drawPlane() nicht aufgerufen wird), wenn du dann in draw() auf die vertices des Würfels zugreifst, sind diese natürlich null.

Also würde es funktionieren wenn ich Cube.bottomPlane.draw(gl) aufrufe?
Klingt logisch. (grad getestet, funktioniert)
Aber das ist nict unbedingt das was ich will, da ich den Würfel ja "im ganzen" zeichnen will. Also liegt der Fehler ist mal an der fehlerhaften Klassenerweiterung?!

Ich weiß nicht, wie OpenGL funktioniert, aber ich schätze mal die Vertices sind die Ecken eines Polygons (dann kommst du prinzipiell auch mit 4 Flächen statt mit 6 aus (und selbst dann werden zwei Kanten doppelt gezeichnet)); bei einem Drahtgittermodell würde ich vermutlich eher von 12 Kanten ausgehen als mit Flächen zu arbeiten.

Ja, die Vertices sind Ecken von Polygonen. Das mit den doppelten Kanten ist mir auch bereits aufgefallen. Ich tu mich aber mit der Berechnung der Vertices sehr schwer, deshalb dachte ich mir wär es einfacher einfach 2 Grundflächen zu erstellen (Rechteck, Dreieck) und daraus alle Objekte und Flächen zu konstruieren.

Die Berechnung des Planes hab ich irgendwo im Internet gefunden allerdings hab ich sie nicht genug verstanden um daraus die Berechnung eines Würfels ableiten zu können. Der Code war leider auch nicht kommentiert.
Vielleicht könntest du mir dabei helfen?

  
public class Plane extends Mesh {  
	  
	private short[] indices;  
	private float[] vertices;  
	// plane with 1 segment width and 1 segment height by  
	// 1 segment over width and height  
	public Plane(){  
		this(1, 1, 1, 1);  
	}  
	  
	 // let you decide the size of the plane but still only one segment  
	public Plane(float width, float height){  
		this(width, height, 1, 1);  
	}  
	  
	// setting up the plane with different settings  
	public Plane(float width, float height, int widthSegments, int heightSegments){  
		// calculate the buffers  
		vertices = new float[(widthSegments + 1) * (heightSegments + 1) * 3];  
		indices = new short[(widthSegments + 1) * (heightSegments + 1) * 6];  
		  
		float xOffset = width / -2;  
		float yOffset = height / -2;  
		float xWidth = width / (widthSegments);  
		float yHeight = height / (heightSegments);  
		  
		int currentVertex = 0;  
		int currentIndex = 0;  
		int x;  
		int y;  
		int n;  
		  
		short w = (short) (widthSegments + 1);  
		  
		// each columns with each rows  
		for (y = 0; y < heightSegments + 1; y++) {  
			for (x = 0; x < widthSegments + 1; x++) {  
				vertices[currentVertex] = xOffset + x * xWidth;  
				vertices[currentVertex + 1] = yOffset + y * yHeight;  
				vertices[currentVertex + 2] = 0;  
				  
				currentVertex += 3;  
				  
				n = y * (widthSegments + 1) + x;  
				  
				if (y < heightSegments && x < widthSegments) {  
				    // face one  
				    indices[currentIndex] = (short) n;  
				    indices[currentIndex + 1] = (short) (n + 1);  
				    indices[currentIndex + 2] = (short) (n + w);  
				    // face two  
				    indices[currentIndex + 3] = (short) (n + 1);  
				    indices[currentIndex + 4] = (short) (n + 1 + w);  
				    indices[currentIndex + 5] = (short) (n + 1 + w - 1);  
		  
				    currentIndex += 6;  
				}  
			}  
		}  
		//setIndices(indices);  
		//setVertices(vertices);  
	}  
	// draw the plane  
	public void DrawPlane(){  
		setIndices(indices);  
		setVertices(vertices);		  
	}  
  
}  

Was passiert ist, dass ein Rechteck mit X Segementen (je 2 Dreiecke) pro Breite und Höhe gezeichnet wird. Z.B. ein Rechteckt mit der Größe 4*5 und 4 Segmente für Breite und 5 Segmente für die Höhe: new Plane(4f, 5f, 4, 5);
Was die Berechnung angeht, scheitert mein Verständnis bereits bei "// calculate the buffers".
Wieso werden die Segmente um 1 erhöht und wieso *3 bzw *6?
Die weiteren Schritte der Berechnung erschließen sich mir leider auch nicht.

Danke für Hilfe!