/**
 * @author tavkhelidze
 */

package cg;

import java.io.File;
import java.io.IOException;
import java.nio.FloatBuffer;

import javax.swing.JFrame;

import com.jogamp.common.nio.Buffers;
import com.jogamp.opengl.GL2;

import com.jogamp.opengl.GLAutoDrawable;
import com.jogamp.opengl.GLCapabilities;
import com.jogamp.opengl.GLEventListener;
import com.jogamp.opengl.GLProfile;
import com.jogamp.opengl.awt.GLCanvas;
import com.jogamp.opengl.glu.GLU;
import com.jogamp.opengl.glu.GLUquadric;
import com.jogamp.opengl.util.FPSAnimator;
import com.jogamp.opengl.util.gl2.GLUT;
import com.jogamp.opengl.util.texture.Texture;
import com.jogamp.opengl.util.texture.TextureIO;


/**
 * JOGL Example #: basic frame with supported animation, different primitive 3D-objects,
 * GLU and GLUT 3D-objects, fog effect and texturing
 * @param <IOException>
 */

public class Main implements GLEventListener {
	
	private GLU glu = new GLU();
	private GLUT glut = new GLUT();
	
	private static float rtri =0.0f;
	private int tc, tt;
	
	
	// ---------Main method-------------
	
	
	public static void main(String[] args) {
		 
	      final GLProfile profile = GLProfile.get(GLProfile.GL2);
	      GLCapabilities capabilities = new GLCapabilities(profile);
	  
	      final GLCanvas glcanvas = new GLCanvas(capabilities);

	      final int width = 800;
	      final int height = 600;
	     
	      Main m = new Main();
	      glcanvas.addGLEventListener(m);
	  
	      final JFrame frame = new JFrame ("OpenGL Fenster");
	  
	      frame.getContentPane().add(glcanvas);
	      
	      frame.setSize(width, height);
	      frame.setVisible(true);
	      
	      final FPSAnimator animator = new FPSAnimator(glcanvas, 60, true);
	      animator.start();
	}

	
	// ------ beschreibt eine Bezier-Fläche ------
	
	
	void drawBezSur (GL2 gl) {
	
	int numPlines = 3; // Anzahl der Linienzüge im Gitternetz der Fläche (siehe Details unter http://www-lehre.inf.uos.de/~cg/2008/skript/node132.html)
	float ctrlPoints[] = {
	// Erster Linienzug
	-4.0f, 0.0f, 4.0f, // erster Kontrollpunkt
	-2.0f, 2.0f, 4.0f, // zweiter Kontrollpunkt
	4.0f, 0.0f, 4.0f, // dritter Kontrollpunkt
	// Zweiter Linienzug
	-4.0f, 0.0f, 0.0f, // erster Kontrollpunkt
	-2.0f, 2.0f, 0.0f, // zweiter Kontrollpunkt
	4.0f, 0.0f, 0.0f, // dritter Kontrollpunkt
	// Dritter Linienzug
	-4.0f, 0.0f,-4.0f, // erster Kontrollpunkt
	-2.0f, 2.0f,-4.0f, // zweiter Kontrollpunkt
	4.0f, 0.0f,-4.0f}; // dritter Kontrollpunkt
	
	// Deklaration einer Variablen vom Typ Gleitkommazahlenpuffer und Angabe von passender Zielgröße dieses Pufferelements
	FloatBuffer ctrlPointsBf = Buffers.newDirectFloatBuffer(ctrlPoints.length);
	
	// Einspeisen von Daten aus dem Datenfeld ctrlPoints in den deklarierten Puffer
	for (int i = 0; i < ctrlPoints.length; i++) { ctrlPointsBf.put(ctrlPoints[i]); }
	ctrlPointsBf.rewind();
	
	// Haupteinstellungsbefehl, der einen zweidimensionalen Evaluator zur Erstellung von Beziergitter definiert - mehr Details unter https://wiki.delphigl.com/index.php/glMap2
	gl.glMap2f(GL2.GL_MAP2_VERTEX_3, 0.0f, 10.0f, 3, 3, 0.0f, 10.0f, 9, 3, ctrlPointsBf);
	
	// Aktiviert (überhaupt) die Funktionalität zum Zeichnen von Bezier-Flächen
	gl.glEnable(GL2.GL_MAP2_VERTEX_3);
	
	// Zeichnen von Kontrollpunkten (man darf dies weglassen und nur die Fläche rendern lassen) 
	gl.glPointSize(0.5f);
	gl.glBegin(GL2.GL_POINTS);
	for (int i = 0; i < numPlines*3; i++) {
	gl.glVertex3f(ctrlPoints[3*i], ctrlPoints[3*i+1], ctrlPoints[3*i+2]);
	}
	gl.glEnd();
	
	// erzeugt ein zweidimensionales Punkte-Gitter - mehr Details unter https://wiki.delphigl.com/index.php/glMapGrid
	gl.glMapGrid2f(10, 0.0f, 10.0f, 10, 0.0f, 10.0f);
	
	gl.glColor3f( 0f,1f,0f );
	// zeichnet ein zweidimensionales Gitter - mehr Details unter https://wiki.delphigl.com/index.php/glEvalMesh
	// Anstelle des Parameters GL_FILL (gefullte Fläche) stehen auch GL_LINE und GL_POINT zur Verfügung - damit zeichnet man die Fläche als ein Linien- bzw. Punktengitter
	gl.glEvalMesh2(GL2.GL_FILL, 0, 10, 0, 10);
	}
	
	
	// ------ beschreibt einen Nebel-Effekt ------
	
	
	void makeitfoggy(GL2 gl) {
	// legt die Nebelfarbe durch die Einführung einer Variablen fest (hier - weiß)
	float[] fogColor = {1.0f, 1.0f, 1.0f, 1.0f};
	
	//Aktiviert die Unterstützung von Nebelerzeugung
    gl.glEnable(GL2.GL_FOG);
    /*
	 * Hier werden verschiedene Parameter zur Berechnung von Nebel durch den Hauptbefehl glFog eingesetzt - 
	 * mehr unter https://wiki.delphigl.com/index.php/glFog, obwohl ein paar Details findet Ihr auf dieser Webseite nicht - 
	 * deswegen wird's empfohlen, auch die langweiligen Erläuterungen hier unten in Kommentaren durchzulesen oder 
	 * mindestens zu überfliegen :)
	 */
    // Bestimmt den Wert für die Komponente start im linearen Nebelmodell (siehe unten).
    // ACHTUNG - nur bei linearer Funktion (siehe unten), bei exponenzieller Funktion spielt nur die Dichte eine Rolle.
    gl.glFogf(GL2.GL_FOG_START, 8f);
    // Bestimmt den Wert der Komponente end in der linearen Nebelfunktion (siehe unten).
    // ACHTUNG - nur bei linearer Funktion (siehe unten), bei exponenzieller Funktion spielt nur die Dichte eine Rolle.
    gl.glFogf(GL2.GL_FOG_END, 11f);
    /*
     * Bestimmt die Art und Weise (durch eine Funktion), auf die die Intensität mit zunehmender Entfernung abnimmt.
     * Außer GL_EXP2 (am Anfang schwächer als exponentielle Sichtbarkeitsabnahme, aber danach wird's deutlich stärker) 
     * stehen auch GL_EXP (exponenziell - Standardwert, d.h. dieser Modus wird bei aktiviertem Nebeleffekt ohne 
     * explizite Bestimmung eingesetzt, wenn aber andere Funktion gewollt, muss dies durch glFog bestimmt werden) 
     * und GL_LINEAR (linear) zur Verfügung.
     * ----------------------------- LINEARER NEBEL-FUNKION (NEBELMODELL) ------------------------------------------
     * Die lineare Funktion sieht so aus: f = (end - z) / (end - start), wobei f einen Mischungsfaktor darstellt, mit dem
     * die gerasterten Pixel eines Objektes in (immer linearer - auch bei exponenziellen f) Kombination mit der Nebelfarbe 
     * gemischt werden. 
     * 
     * Die Komponente z steht für die Entfernung (Betrag von z-Koordinate) zwischen der Kamera und einem Objekt.
     * f wird nach der Berechnung auf die Spanne von 0 bis 1 skaliert: dies erfolgt mittels der Funktion mit dem Namen
     * clamp (gehört zur GLSL Programmiersprache (wurde auch von Khronos entwickelt), die für Shaders verwendet wird 
     * (Shaders sind halt die Programme, die auf GPU durchgeführt werden - es gibt diverse Shaders, klassische sind 
     * Vertex-, Fragment-, Geometrie- und Tesselation-Shaders) - beim letzten Unterricht haben wird darüber kurz gesprochen.
     * 
     * Also genauer gesagt, sieht diese Skalierung so aus: f wandelt sich um 1-clamp(f, 0, 1)= 1 - min(max(f, 0), 1).
     * Dies heißt u.a. dass beispielsweise bei nicht positiven Werten von f, werden diese auf 1 skaliert (Nebel hat dabei 
     * keine Auswirkung auf die gerasterte Pixelfarbe). 
     * 
     * Andere Beobachtungen: bei f >= 1 kommen wir zum Endwert 0 (dann wird das gerasterte Pixel komplett zur Nebelfarbe 
     * (also hier - zum Weiß).
     * 
     * Und genau dann, wann f von 0 bis 1 fällt (dies passiert dann, wann sich die Entfernung z genau von start bis end
     * befindet), haben wir die von der Neberfarbe teilweise betroffene Endfarbe eines Pixels (betroffen heißt in diesem
     * Fall ein Ergebnis der linearen Interpolation zwischen den Pixel- und Nebelfarben).
     * 
     * Letztes Beispiel dazu: wenn man (sagen wir mal, die positive) start- und end-Werte so angibt, dass wir quasi 
     * die umgekehrte Ungleichung start > end haben, bekommt man einen umgekehrten Nebel-Effekt in der Szene - also wenn der 
     * mit der Entfernung abnimmt.
     * 
     * Zu einfacher Veranschaulichung versucht ihr mal die angegebenen start- und end-Werte zu vertauschen und dann sieht
     * ihr genau diesen umgekehrten Nebel-Effekt.
     */
    gl.glFogi(GL2.GL_FOG_MODE, GL2.GL_LINEAR);
    // Bestimmt die Dichte des Nebels, hat keine Auswirkung auf lineare Funktion - nur bei GL_EXP oder GL_EXP2
    gl.glFogf(GL2.GL_FOG_DENSITY, 0.1f);
    // Bestimmt die Farbe des Nebels (nutzt die oben deklarierte Variable)
    gl.glFogfv(GL2.GL_FOG_COLOR, fogColor, 0);
	}
	
	
	// ------ Importieren von 2D-TexturDateien - Würfel ------
	
	
	void impTexCube(GL2 gl) {
		
	     /*
	      * weil es sich hier ums Importieren von (Textur)Dateien handelt, erfordert Java die Fehlerverfolgungs-
	      * und Ausnahmebehandlungsmaßnahmen dabei einzusetzen und deswegen werden die entsprechenden Befehlen
	      * (also hier - Importieren von Dateien) in try/catch-Rahmen umgeschloßen. Sonst geht's nicht weiter 
	      * (zum Beispiel, sowas wird in der Programiersprache C nicht streng verlangt).
	      * 
	      * Anmerkung: man kann und es wird sogar empfohlen bei Bedarf die Variablen in anderen
	      * Teilen des Codes und mit entsprechenden Attributen zu deklarieren oder einige in Datenfelder/Puffer 
	      * einzugruppieren (sowie auch die Befehle(zB glEnable-glDisable)/Methoden/ Klassen effektiver zu 
	      * splitten und da wo es benötigt wird diese zu initiieren) - hier konzentrieren wir uns lediglich 
	      * auf die 2D-Texturierung durch die importierten Dateien.
	      * 
	      * Als Beispiel dazu: man kann ein Objekt in einer separaten void-Methode beschreiben, für die
	      * Texturierung dieses Objekts durch eine bestimmte Datei(oder eine Gruppe von Texturdateien) könnte aber 
	      * eine andere Methode auch separat erstellt werden (oder all die möglichen Texturierungen unter einer,
	      * entsprechend parametrisierten Methode eingesetzt werden).
	      * 
	      * Also, solche Variationen stehen natürlich zur Verfügung, allerding wird's am Anfang nicht empfohlen 
	      * sowas in erster Linie zu praktizieren weil dann scheint dabei sogar ein einfaches Thema überkompliziert.
	      * 
	      * Fazit: versucht erstmal zB die Texturierung basisch einzurichten und danach Schritt für Schritt den Code mit
	      * erhöhter Saubarkeit und (allgemeiner) Effektivität zu versehen.
	      */
	 	try
	    {
		     /*
	        * Die Datei muss erst zum Projekt hinzugefügt werden und zwar zum Ordner mit dem Namen src 
	        * (abgekürzt nach eng. source) oder dessen Unterordner (man könnte erst auch einen erstellen):
	        * dies erfolgt entweder durch "ziehen und ablegen" mit der Maus zum Eclipse-Project Explorer
	        * Verzeichnis (lasst ihr die Maustaste über dem Zielordner los) oder auch durch Kopieren-Einfügen
	        * durchs Kontexmenu des Zielordners. 
	        * Andere Möglichkeiten sind natürlich der übliche Dateimanager oder auch 'ne Kommandokonsole
	        * Ihres Betriebssystems.
	        */
	 		
		//Texturbild für die Würfelseiten (alle Seiten mit derselber Texturbild und Texturierungstechnik)
		String TexCubePath="src\\res\\crate.png";
	    File TexCube = new File(TexCubePath);
	    Texture textureCube = TextureIO.newTexture(TexCube, true);
	    tc = textureCube.getTextureObject(gl);
	    }
	    catch(IOException e)
	    {
	       e.printStackTrace();
	    }

	}
	
	
	// ------ Importieren von 2D-Texturdateien - Quadrat ------
	
	
	void impTexSquare(GL2 gl) {
		//Transparentes Texturbild eines Baumes fürs Quadrat
	    String TexTreePath="src/res/tree.png";
		try
	    {
	    File TexTree = new File(TexTreePath);
	    Texture textureTree = TextureIO.newTexture(TexTree, true);
	    tt = textureTree.getTextureObject(gl);
	    }
	    catch(IOException e)
	    {
	       e.printStackTrace();
	    }
		
	}
		

	//------ defines a square ------


	void drawSquare(GL2 gl) {
		
	// Aktiviert die Wahrnehmung von allen 2D-texturierungsbezogenen Befehlen
	gl.glEnable(GL2.GL_TEXTURE_2D); 
	
    /*
 	 * Bestimmmt die Eigenschaften für die Texturvergrößerungsfilter falls ein Pixel (eines zu texturierenden 
 	 * Objekts) kleiner oder gleich einem Texel (d.h. Pixel einer Textur) ist. Hier wird (pixelweise) die 
 	 * lineare Filter verwendet - heißt das gewichtete Mittel aus den vier am nächsten zum Pixelzentrum 
 	 * liegenden Texeln.
 	 * Mehr zu diesem Thema und zu anderen möglichen Parametern siehe unten https://wiki.delphigl.com/index.php/glTexParameter
 	 */
 	gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_LINEAR);
 	/*
 	 * Bestimmmt die Eigenschaften für die Texturvergrößerungsfilter falls Pixel (eines zu texturierenden 
 	 * Objekts) größer als Texel (d.h. Pixel einer Textur) ist.
 	 * Mehr zu diesem Thema und zu anderen möglichen Parametern siehe unten https://wiki.delphigl.com/index.php/glTexParameter
 	 */
 	gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_LINEAR);
 	
 	gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_REPLACE);

    /*
	  	 * Der Befehl gl.glEnable(GL2.GL_BLEND) aktiviert die pixelweise RGBA-Farbkomponentenskalierung und anschließende
	  	 * Mischung von Quell- (d.h. die ankommende) und Zielfarbkomponenten (d.h. die sich schon im Framepuffer befinden).
	  	 * 
	  	 * Die Art und Weise der Skalierung von der Quelle und dem Ziel bestimmt der 2-stellige Befehl gl.glBlendFunc,
	  	 * dessen erste Komponente für die Quelle- und zweite Komponente - fürs Ziel steht.
	  	 * 
	  	 * Die RGBA-Werte werden auf die Spanne von 0 bis 1 skaliert, konkrete Skalierungsformel sind unte
	  	 * https://wiki.delphigl.com/index.php/glBlendFunc in der entsprechenden Tabelle zu finden.
	  	 * 
	  	 * Beispiel #1: GL_ZERO konvertiert alle RGBA-Werte zu 0, GL_ONE - zu 1.
	  	 * 
	  	 * Beispiel #2: Parameter GL_SRC_ALPHA und GL_ONE_MINUS_SRC_ALPHA geben dem entsprechenden Objekt (oder auch
	  	 * auf einmal einer Menge von Objekten - je nach dem wo im Code und wie man die entsprechenden blend-bezogenen 
	  	 * Befehle schreibt) die volle Transparenz. Damit wird unser Quadrat vollauf transparent und dies ermöglicht 
	  	 * anschließend einen transparenten Baum "sauber und nahtlos" darauf abzubilden.
	  	 * 
	  	 * Die Art und Weise der anschließenden Mischung von skalierten Werten (so genannten Blendfaktoren) beschreibt 
	  	 * der Befehl glBlendEquation (Standardfunktion ist eine einfache RGBA-komponentweise Addition der Produkte
	  	 * von Farbkomponenten mit deren Blendfaktoren). Mehr unter https://wiki.delphigl.com/index.php/glBlendEquation
	  	 * 
	  	 */
	  	gl.glEnable(GL2.GL_BLEND);
	  	gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
	
	gl.glBegin(GL2.GL_POLYGON); 
	
	/*
	 * glTexCoord2f setzt die 2D-Texturkoordinaten (s,t), die jeweils von 0 bis 1 verlaufen.
	 * Zb (0,0) entspricht der unteren linken Ecke eines 2D-Texturbildes, (1,1) - der oberen rechten usw.
	 * 
	 * Wenn unmittelbar vor einem Knoten (Vertex) gesetzt, werden die entsprechenden Texturkoordinaten an
	 * diesen Vertex quasi angeheftet und damit aufs entsprechende Objekt (hier - Quadrat) aufgespannt.
	 * 
	 * Damit wird die Textur aufs Objekt abgebildet.
	 * 
	 * Ein wenig mehr zu diesem Befehl könnt ihr unter https://wiki.delphigl.com/index.php/glTexCoord finden.
	 * 
	 */
		gl.glTexCoord2f(1f, 1f); gl.glVertex3f( 1.0f, 1.0f, 1.0f ); // Top Right
		gl.glTexCoord2f(0f, 1f); gl.glVertex3f( -1.0f, 1.0f, 1.0f ); // Top Left
		gl.glTexCoord2f(0f, 0f); gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Bottom Left
		gl.glTexCoord2f(1f, 0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Bottom Right
    
    gl.glEnd();
    
    gl.glDisable(GL2.GL_BLEND);
    
    // Deaktiviert die Wahrnehmung von allen 2D-texturierungsbezogenen Befehlen
    gl.glDisable(GL2.GL_TEXTURE_2D); 
    
	}
	
	
	// ------ defines a tetrahedron ------
	
	
	void drawTetrahedron(GL2 gl) {
	
	gl.glBegin(GL2.GL_TRIANGLES); 
    
    // Front
    gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
    gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
    gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
    gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Left
    gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
    gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Right
    
    // Right
    gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
    gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
    gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
    gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Left
    gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
    gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Right
    
    // Left
    gl.glColor3f( 1.0f, 0.0f, 0.0f ); // Red
    gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
    gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
    gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Left
    gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
    gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Right
    
    // Bottom
    gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Red
    gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top
    gl.glColor3f( 0.0f, 0.0f, 1.0f ); // Blue
    gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Left
    gl.glColor3f( 0.0f, 1.0f, 0.0f ); // Green
    gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Right
    
    gl.glEnd();
}
	
	
	// ------ defines a cube ------
	
	
	void drawCube(GL2 gl) {
		
		gl.glEnable(GL2.GL_TEXTURE_2D);
		
		gl.glBegin(GL2.GL_QUADS);
	      
			// Top
		  //gl.glColor3f( 1f,0f,0f );   //red color
		  gl.glTexCoord2f(1f, 1f); gl.glVertex3f( 1.0f, 1.0f, -1.0f ); // Top Right
		  gl.glTexCoord2f(0f, 1f); gl.glVertex3f( -1.0f, 1.0f, -1.0f); // Top Left
		  gl.glTexCoord2f(0f, 0f); gl.glVertex3f( -1.0f, 1.0f, 1.0f ); // Bottom Left
		  gl.glTexCoord2f(1f, 0f); gl.glVertex3f( 1.0f, 1.0f, 1.0f ); // Bottom Right
	      
			// Bottom	      
		  //gl.glColor3f( 0f,1f,0f ); //green color
	      gl.glTexCoord2f(1f, 1f); gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Top Right
	      gl.glTexCoord2f(0f, 1f); gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Top Left 
	      gl.glTexCoord2f(0f, 0f); gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Bottom Left 
	      gl.glTexCoord2f(1f, 0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Bottom Right
	     
			// Front
	      //gl.glColor3f( 0f,0f,1f ); //blue color
	      gl.glTexCoord2f(1f, 1f); gl.glVertex3f( 1.0f, 1.0f, 1.0f ); // Top Right
	      gl.glTexCoord2f(0f, 1f); gl.glVertex3f( -1.0f, 1.0f, 1.0f ); // Top Left
	      gl.glTexCoord2f(0f, 0f); gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Bottom Left
	      gl.glTexCoord2f(1f, 0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Bottom Right
	      
			// Back
	      //gl.glColor3f( 1f,1f,0f ); //yellow (red+green)
	      gl.glTexCoord2f(0f, 0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Bottom Left 
	      gl.glTexCoord2f(1f, 0f); gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Bottom Right
	      gl.glTexCoord2f(1f, 1f); gl.glVertex3f( -1.0f, 1.0f, -1.0f ); // Top Right
	      gl.glTexCoord2f(0f, 1f); gl.glVertex3f( 1.0f, 1.0f, -1.0f ); // Top Left
	     
			// Left
	      //gl.glColor3f( 1f,0f,1f ); //purple (red+green)
	      gl.glTexCoord2f(1f, 1f); gl.glVertex3f( -1.0f, 1.0f, 1.0f ); // Top Right
	      gl.glTexCoord2f(0f, 1f); gl.glVertex3f( -1.0f, 1.0f, -1.0f ); // Top Left
	      gl.glTexCoord2f(0f, 0f); gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Bottom Left
	      gl.glTexCoord2f(1f, 0f); gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Bottom Right
	      
			// Right
	      //gl.glColor3f( 0f,1f, 1f ); //sky blue (blue+green)
	      gl.glTexCoord2f(1f, 1f); gl.glVertex3f( 1.0f, 1.0f, -1.0f ); // Top Right
	      gl.glTexCoord2f(0f, 1f); gl.glVertex3f( 1.0f, 1.0f, 1.0f ); // Top Left
	      gl.glTexCoord2f(0f, 0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Bottom Left
	      gl.glTexCoord2f(1f, 0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Bottom Right
	      
	      gl.glEnd();
	      
	      /*
			 * Hier wird den Wert des am nächsten zum Pixelzentrum liegenden Texels als Endwert genommen.
		 	 * Mehr zu diesem Thema und zu anderen möglichen Parametern siehe unten https://wiki.delphigl.com/index.php/glTexParameter
		 	 */
			gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST);
	        gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_NEAREST);
	        
	        gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_REPLACE);
	      
	      gl.glDisable(GL2.GL_TEXTURE_2D); 
}
	
	
	// ------ defines a GLUT-solid-sphere ------
	
	
	void drawGlutSoSphere(GLUT glut, GL2 gl) {
		
	gl.glColor3f(0f, 1f, 0f);
	
	glut.glutSolidSphere(1, 20, 10);
}
	
	
	// ------ defines a GLU-solid-sphere ------
	
	
	void drawGluSoSphere(GLU glu, GL2 gl) {
		
	GLUquadric quad;
	quad = glu.gluNewQuadric();
	
	glu.gluQuadricDrawStyle(quad, GLU.GLU_FILL);
	glu.gluQuadricNormals(quad, GLU.GLU_SMOOTH);
	glu.gluQuadricOrientation(quad, GLU.GLU_OUTSIDE);
	
	gl.glColor3f(1,0,0);
	
	glu.gluSphere(quad,1,50,25);
	
}
	
	
	// ------ defines a GLUT-solid-cylinder ------
	
	
	void drawGlutSoCylinder(GLUT glut, GL2 gl) {
		
		gl.glColor3f(1f, 1f, 0);
		
		glut.glutSolidCylinder(1, 2, 20, 10);
		
	}
	
	
	// ------ defines a GLUT-solid-cone ------
	
	
	void drawGlutSoCone(GLUT glut, GL2 gl) {
		
		gl.glColor3f(1f, 1f, 1f);
		
		glut.glutSolidCone(1, 2, 20, 10);
		
	}
	
	
	// ------ defines a GLUT-solid-disk ------
	
	
	void drawGlutSoDisk(GLUT glut, GL2 gl) {
		
		gl.glColor3f(0f, 1f, 1f);
		
		glut.glutSolidCone(1, 0, 20, 10);;
		
	}
	
	
	 // ------ Implement methods declared in GLEventListener ------
	

	@Override
	public void init(GLAutoDrawable drawable) {
		
		GL2 gl = drawable.getGL().getGL2();
		
	      gl.glClearColor(0.000f, 0.749f, 1.000f, 1.0f);
	      gl.glClearDepth(1.0f);
		 
			 /* 
			  * aktiviert den Tiefentest - wenn deaktiviert oder nicht explizit (durch glEnable) aktiviert, hat man keinen
			  * Überlappungseffekt für (teilweise) hintereinander liegende Objekte
			  */
		     gl.glEnable(GL2.GL_DEPTH_TEST);
		     /*
		      * Näher liegende Objekte werden gezeichnet - dies ermöglicht die (korrekte, wenn so gewünscht) Überlappung 
		      * von tiefer liegenden Objekten durch näher liegenden Objekten für jedes Pixel (also jedes Pixel geht durch
		      * diesen Tiefentest) 
		      */
		     gl.glDepthFunc(GL2.GL_LESS);
		     
	  // ------ importiert Texturen ------
	     impTexSquare(gl);
	     impTexCube(gl);
	}

	@Override
	public void display(GLAutoDrawable drawable) {
		
		GL2 gl = drawable.getGL().getGL2();
		
	      gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);

	      
	      // -------------------------------------- //
	      
	      gl.glLoadIdentity();                       
	      
		      gl.glTranslatef( -0.5f, 1.0f, -10.0f );        
		      gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );
	               
	      // ------------------ draws the tetrahedron ------------------- /
	      
	      gl.glPushMatrix();
	      
		      drawTetrahedron(gl);
	      
	      gl.glPopMatrix();
	      
	      // ------------------ zeichnet die Bezier-Fläche ------------------- 
	      
	      gl.glPushMatrix();
	      
		      gl.glTranslatef( -0.0f, -4.0f, 0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
		      
		      drawBezSur(gl);
	      
	      gl.glPopMatrix();
	      
	      // ------------------ draws the cube ------------------- 
	      
	      
	      gl.glPushMatrix();
	      
		      gl.glTranslatef( -0.0f, -2.0f, 2.0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
		      
		      gl.glBindTexture(GL2.GL_TEXTURE_2D, tc);
		      
		      drawCube(gl);
	      
	      gl.glPopMatrix();
	      
	      // ---------------- draws the GLU sphere --------------------
	      
	      gl.glPushMatrix();
	      
		      gl.glTranslatef( 2f, 0.0f, 0.0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
		      
		      drawGluSoSphere(glu,gl);
	      
	      gl.glPopMatrix();
	      
	      // ------------------ draws the solid GLUT sphere ------------------
	      
	      gl.glPushMatrix();
		      
		      gl.glTranslatef( -2f, 0.0f, 0.0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
		      
		      drawGlutSoSphere(glut,gl);
	      
	      gl.glPopMatrix();
	      
	      // ----------------- draws the solid GLUT cylinder -------------------
	      
	      gl.glPushMatrix();
	      
		      gl.glTranslatef( 0f, 2.0f, 0.0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
		      
		      drawGlutSoCylinder(glut,gl);
		      
	      gl.glPopMatrix();
	      
	      // ----------------- draws the solid GLUT disk -------------------
	      
	      gl.glPushMatrix();
	      
		      gl.glTranslatef( 0f, 0.0f, 2.0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
	      
		      drawGlutSoDisk(glut, gl);
	      
	      gl.glPopMatrix();
	      
	      // ----------------- draws the solid GLUT disk -------------------
	      
	      gl.glPushMatrix();
	      
		      gl.glTranslatef( 0f, 0.0f, -2.0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
	      
		      drawGlutSoCone(glut, gl);
	      
	      gl.glPopMatrix();
	      
	      // ------------------ draws the square ------------------- 
	      
	      gl.glPushMatrix();
	      
		      gl.glTranslatef( 2.0f, -2.0f, 0f );
		      gl.glScalef(0.5f, 0.5f, 0.5f);
		      
		      gl.glDepthMask(false);
		      
		      /*
		       * Dieser Befehl setzt die Textur mit dem Namen (hier) tt als die zu verwendende 2D-Textur ein.
		       * Wenn eine andere 2D-Textur benötigt wird, kann man einfach nochmal denselben Befehl mit dem neuen 
		       * Texturnamen verwenden - damit wird die soweit aktuelle 2D-Textur mit der Neuen ersetzt.
		       * Der Befehl gl.glBindTexture(GL2.GL_TEXTURE_2D, 0) wird die Texturierung entnehmen.
		       * Siehe mehr unter https://wiki.delphigl.com/index.php/glBindTexture
		       */
		      gl.glBindTexture(GL2.GL_TEXTURE_2D, tt);
		      
		      drawSquare(gl);
		      
			  gl.glDepthMask(true);
	      
	      gl.glPopMatrix();
	      

	      // -------------------------------------- //
	      
	      
			// ------ rendert Nebel-Effekt ------
		   
			makeitfoggy(gl);
	      
	      gl.glFlush();
		
		rtri +=0.2f;
	}
	
	@Override
	public void dispose(GLAutoDrawable drawable) {		
	}

	@Override
	public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
		
		final GL2 gl = drawable.getGL().getGL2();

	      final float h = (float) width / (float) height;
	      
	      gl.glViewport( 0, 0, width, height );
	      
	      gl.glMatrixMode( GL2.GL_PROJECTION );
	      gl.glLoadIdentity();
	      
	      glu.gluPerspective( 45.0f, h, 1.0, 40.0 );
	      
	      gl.glMatrixMode( GL2.GL_MODELVIEW );
	      gl.glLoadIdentity();
	      
	      glu.gluLookAt(0f, 0f, 3f, 0f, 0f, 0f, 0f, 1f, 0f);
	}
}
// ------ End of Code ------