#include <math.h>
#include <GL/glut.h> 
#include <iostream>

using namespace std;

double grauwert=0.0, posx1=0.5, posy1=0.0, posx2, posy2, laenge=0.4, winkel, astwinkel, verkuerzung=0.5;

void display()
{
  glClear(GL_COLOR_BUFFER_BIT); 
  glBegin(GL_LINES);

	double radwinkel=(winkel/180)*M_PI;
	posx2=laenge*cos(radwinkel)+posx1;
	posy2=laenge*sin(radwinkel)+posy1;

  glColor3f(grauwert, grauwert, grauwert);
  glVertex2f(posx1, posy1);
  glVertex2f(posx2, posy2);

		laenge = laenge*verkuerzung;
		double lotwinkel1 = ((winkel-astwinkel)/180)*M_PI; //in Rad
		double lotwinkel2 = ((180-winkel-astwinkel)/180)*M_PI;

		double posx3a=laenge*cos(lotwinkel1)+posx2;
		double posy3a=laenge*sin(lotwinkel1)+posy2;
		glColor3f(1., 0.0, 0.0);
		glVertex2f(posx2, posy2);
		glVertex2f(posx3a, posy3a);

		double posx3b=-laenge*cos(lotwinkel2)+posx2;
		double posy3b=laenge*sin(lotwinkel2)+posy2;
		glColor3f(0.0, 0.0, 0.0);
		glVertex2f(posx2, posy2);
		glVertex2f(posx3b, posy3b);

  glEnd();
  glFlush();
}

int main(int argc, char **argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  glutInitWindowSize(800, 800);
  glutInitWindowPosition(100, 740);
  glutCreateWindow("Test");
  glClearColor(1.0, 1.0, 1.0, 1.0);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

	/*cout<<"Grauwert: ";
	cin>>grauwert;

  cout<<"Position des Stammes (x,y): ";
	cin>>posx1>>posy1;

	cout<<"Laenge: ";
	cin>>laenge; */

	cout<<"Winkel (rechts): ";
	cin>>winkel;

	//cout<<"Verkuerzungsfaktor: ";
	//cin>>verkuerzung;

	cout<<"Astwinkel: ";
	cin>>astwinkel;

  glutDisplayFunc(display);
  glutMainLoop();

}

Wie kann ich die Zeilen 25-39 in eine Schleife packen so, dass an jedem neu entstandenen Zweig zwei weitere dranhängen kann? Das Problem ist, dass ja bei jedem Schritt immer doppelt soviele Punkte entstehen und ich weiß nicht wie ich die speichern soll und dann wie dann die Schleife aussehen muss.

Ansonsten: Was ist dein Plan? Zuerst alle Linien berechnen, dabei die nötigen Vertizes speichern, dann danach alle nacheinander zeichnen? Kann auch funktionieren. Datenstrukturen wie std::vector kennst du, oder? Da kannst du beliebig Elemente speichern. OpenGL kennt mWn auch so etwas wie ein "Vertex Array". Wenn dies eher als eine OpenGL-Frage gedacht ist als eine Frage zu C++-Datenstrukturen, dann kann ich dich auch ins Grafikforum schieben, die können dir dort mehr zu Vertexarrays erzählen (wenn man die überhaupt noch nutzt, mein OpenGL ist stark angerostet und veraltet).

Ist ein Baum nicht das klassische Beispiel für Rekursion? Selbst wenn es nicht effizient sein sollte (ich sehe nichts, was da groß dagegen spricht).

Hallo SeppJ. In dem Grafikforum antwortet mir niemand, weil meine Fragen wohl grundlegend sind. Gegen die Rekursion spricht dass die Funktion

glutDisplayFunc(display)

keine Parameter akzeptiert bzw. ich nicht weiß, wie es gehen soll (Selbst in dem OpenGL Forum stand man solle globale Variablen nehmen). Als Ersatz dachte ich an eine while Schleife, die ab einer bestimmten Länge unterbricht. Ich überlege mir mal, wie man dass mit dem Vektor machen könnte. Danke für den Hinweis.

Gegen die Rekursion spricht dass die Funktion

glutDisplayFunc(display)

keine Parameter akzeptiert

Du machst dir eine Unterfunktion.

bzw. ich nicht weiß, wie es gehen soll (Selbst in dem OpenGL Forum stand man solle globale Variablen nehmen).

Ich bin mir sehr sicher, die haben das anders gemeint. Außerdem hat dir bei diesem Thema doch niemand geantwortet.

Du machst eine Funktion, die eine Position, einen Winkel und eine Länge nimmt. Diese zeichnet die dazu gehörige Linie und ruft sich selber noch 2 Mal auf, jeweils mit dem Endpunkt der Linie als neuem Anfangspunkt, der Hälfte (oder einem anderen Anteil) der Länge und mit jeweils um 20-30 Grad versetzten Winkel. Abbruchbedingung ist eine Längenuntergrenze.
Dann bekommst du etwas in dieser Art (je nach genauer Wahl der Parameter):
http://www.bfoit.org/itp/images/tree_1.jpg

Zusätzlich kannst du noch machen, dass unter einer bestimmten Länge die Zweige grün gezeichnet werden, dann sieht es aus wie Blätter. Und wenn du es extra schön willst, dann baust du noch zufällige Variationen für Winkel, Länge, vielleicht sogar für die Zweigzahl ein. Dann sieht das so aus:
http://www.ealnet.com/ealsoft/tree1.gif

So hast du dir das doch sicherlich vorgestellt, oder?

(Ich habe da jetzt richtig Lust drauf bekommen, vielleicht mach ich das nachher mal selber)

glutDisplayFunc(display)

aus der main rausgenommen werden und durch eine andere Funktion ersetzt werden, dessen Bestandteil dann glutDisplayFunc(display) ist?

Ich habe auch mal Glut genutzt, damit du das Programm auch verstehst. Die Grafikprofis würden das Programm bestimmt zerreißen, weil ich mit dem Glut-Framework irgendwelche dummen Anfängerfehler mache. Aber weder globale Variablen noch sonst irgendwelche Schweinereien. Ich hoffe der Code ist auch ohne Kommentare selbsterklärend, falls nicht, frag nach. Ich habe mal einen Baum mit jeweils 5 Ästen gemalt, da 2 Äste doch eher nach Sahelzone aussahen :

#include <GL/glut.h> 
#include <cmath>

using std::sin;
using std::cos;

void draw_line(float fromX, float fromY, float length, float angle)
{
  // Irgendwann muss die Rekursion abbrechen. Man könnte hier auch die 
  // Fenstergröße auswerten und sich ausrechnen, wie viele Pixel eine Linie
  // hat anstatt einer festen Linienlänge. Aber das war mit zu viel Aufwand
  // für das Beispiel:
  if (length < 0.01)
    return;

  // Einfach Mathematik, um den Endpunkt dieser Linie zu berechnen:
  float toX = fromX + sin(angle)*length;
  float toY = fromY + cos(angle)*length;

  // Braun für lange Äste, grün für kurze Äste ( = Blätter): 
  if (length > 0.1)
    glColor3f(0.4,0.0,0.0); 
  else
    glColor3f(0.0,0.7,0.0); 

  // Das Zeichnen der eigentlichen Linie:
  glBegin(GL_LINES);
  glVertex3f(fromX, fromY, 0.0);
  glVertex3f(toX, toY, 0.0);
  glEnd();

  // Nun der rekursive Aufruf, ausgehend vom aktuellen Endpunkt.
  // Hier kannst du wunderbar an den Zahlen und der Zahl der Aufrufe rumspielen, 
  // um andere Formen zu erhalten. Oder ein bisschen Zufall einbauen. So sieht 
  // der Baum ganz gut aus:
  draw_line(toX, toY, length*0.5, angle + 0.5);
  draw_line(toX, toY, length*0.5, angle - 0.5);
  draw_line(toX, toY, length*0.5, angle + 1);
  draw_line(toX, toY, length*0.5, angle - 1);
  draw_line(toX, toY, length*0.5, angle);
}

void display()
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  // Unten, von der Mitte an, zur Bildmitte hin:
  draw_line(0.0, -1.0, 1.0, 0.0);

  glutSwapBuffers();
}

int main(int argc, char *argv[])
{
  glutInit(&argc, argv);
  glutInitWindowSize(500,500);
  glutCreateWindow("Baum");
  glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

  glutDisplayFunc(display);

  glutMainLoop();
}

Wunderschön, oder?

edit: Ich gönne dir mal ein paar Kommentare im Code

Eine Frage hätte ich allerdings. Was macht
glutSwapBuffers();
in Zeile 50 ?

Wahnsinn, dankeschön!

Eine Frage hätte ich allerdings. Was macht
glutSwapBuffers();
in Zeile 50 ?

Das ist Doublebuffering, ich zeichne erst im Hintergrund, dann wird das komplette Bild mit einem Schlag angezeigt und der alte Vordergrundpuffer ist nun der Puffer in den im Hintergrund gezeichnet wird. So sieht man nicht, wie jeder Frame nach und nach gezeichnet wird, sondern die Frames gehen sauber ineinander über. Ist eine ziemlich grundlegende Technik, aber zu Hintergründen und Techniken fragst du besser im Grafikforum, ich bin da nicht so der Experte für.

da wirst du wohl doch globale Variablen verwenden müssen, da die GLUT-Funktionen keine weiteren Parameter akzeptieren (üblicherweise einfach ein "void *user").

Am besten du packst die ganzen benötigten Werte in eine Struktur und verwendest diese dann:

struct DisplayValues
{
    double grauwert, posx1, posy1, posx2, posy2,
           laenge, winkel, astwinkel, verkuerzung;
};

Alternativ könntest du auch eine statische Klasse verwenden (quasi ein Singleton).

#include <math.h>
#include <GL/glut.h> 
#include <iostream>

using namespace std;

float grauwert=0.0, vonX=0.5, vonY=0.0, laenge, winkel, astwinkel, kuerzungsfaktor;

void draw_line(float vonX, float vonY, float laenge, float winkel) 
{ 

	if (laenge < 0.001) 
		return; 

	float zuX = vonX + cos(winkel)*laenge; 
	float zuY = vonY + sin(winkel)*laenge; 

	if (laenge > 0.01) 
		glColor3f(0.4,0.0,0.0); 
	else 
		glColor3f(0.0,0.7,0.0);   

	glBegin(GL_LINES); 
	//glColor3f(grauwert,grauwert,grauwert);
	glVertex2f(vonX, vonY); 
	glVertex2f(zuX, zuY); 
	glEnd(); 

	laenge*=kuerzungsfaktor;

	draw_line(zuX, zuY, laenge, winkel + astwinkel); 
	draw_line(zuX, zuY, laenge, winkel - astwinkel); 

} 

void display() 
{ 
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

	draw_line(vonX, vonY, laenge, winkel); 

	glutSwapBuffers(); 

}

int main(int argc, char **argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  glutInitWindowSize(600, 600);
  glutInitWindowPosition(100, 740);
  glutCreateWindow("Baum");
  glClearColor(1.0, 1.0, 1.0, 1.0);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

	/*cout<<"Grauwert: ";
	cin>>grauwert;

  cout<<"Position des Stammes (x,y): ";
	cin>>vonX>>vonY; */

	cout<<"Laenge: ";
	cin>>laenge; 

	float grad_winkel=90;
	/*cout<<"Winkel (rechts): ";
	cin>>grad_winkel;  */

	winkel=(grad_winkel/180)*M_PI;

	cout<<"Verkuerzungsfaktor: ";
	cin>>kuerzungsfaktor;

	double grad_astwinkel;
	cout<<"Astwinkel: ";
	cin>>grad_astwinkel;

	astwinkel=(grad_astwinkel/180)*M_PI;

  glutDisplayFunc(display);
  glutMainLoop();

}

Ich hab den Grenzwert um eine Größenordnung verkleinert und solang der Kürzungsfaktor nicht größer als 0.7 ist, rechnet er sich nicht tot.