package cg; //------------------------------------------------------------------------------ import javax.swing.JFrame; 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.util.FPSAnimator; import com.jogamp.opengl.util.gl2.GLUT; //------------------------------------------------------------------------------ public class Main implements GLEventListener { private GLU glu = new GLU(); private GLUT glut = new GLUT(); private static float rtri =0.0f; //------------------------------------------------------------------------------ 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.add(glcanvas); frame.setSize(width, height); frame.setVisible(true); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); final FPSAnimator animator = new FPSAnimator(glcanvas, 60, true); animator.start(); } //------------------------------------------------------------------------------ // ------ 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 den Vernebelungsmodus gl.glEnable(GL2.GL_FOG); //Hier werden verschiedene Parameter zur Berechnung von Nebel durch den Befehl glFog eingestellt // // Legt den Wert für die Komponente start im linearen Nebelmodell (siehe unten) fest. // ACHTUNG - nur bei linearer Funktion (siehe unten), bei exponenzieller Funktion spielt nur die Dichte eine Rolle. gl.glFogf(GL2.GL_FOG_START, 8f); // Legt den Wert der Komponente end in der linearen Nebelfunktion (siehe unten) fest. // ACHTUNG - nur bei linearer Funktion (siehe unten), bei exponenzieller Funktion spielt's keine Rolle. gl.glFogf(GL2.GL_FOG_END, 11f); gl.glFogi(GL2.GL_FOG_MODE, GL2.GL_LINEAR); /* * ----------------------------- LINEARE VERNEBELUNG (aka lineares 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 linearer (auch bei exponenziellen Modellen) Kombination mit der Nebelfarbe * gemischt werden. * * Die Komponente z steht für die Entfernung (Betrag der z-Koordinate) zwischen der Kamera und einem Objekt. * f wird nach der Berechnung auf die Spanne von 0 bis 1 skaliert. Diese Skalierung schaut so aus: * f ----> 1 - min(max(f, 0), 1). * * Case-Analyse: * 1. bei nicht positiven Werten von f werden diese auf 1 skaliert (d.h. Nebel hat keine Auswirkung auf die gerasterte Pixelfarbe). * * 2. bei f >= 1 kommen wir zum Endwert 0 (gerastertes Pixel wird also komplett zur Nebelfarbe). * * 3. und genau dann wenn f im Interval von 0 bis 1 liegt (die Entfernung z liegt dabei zwischen start und end), * bekommen wir die Farbmischung und zwar es wird zwischen den Pixel- und Nebelfarben linear interpoliert. * * 4. im Fall start > end kriegt man einen umgekehrten Nebel-Effekt in der Szene (Nebel nimmt also mit der * Entfernung ab). */ // Legt die Dichte des Nebels fest, hat keine Auswirkung auf lineare Funktion - nur bei GL_EXP oder GL_EXP2 gl.glFogf(GL2.GL_FOG_DENSITY, 0.1f); // legt die Farbe des Nebels fest gl.glFogfv(GL2.GL_FOG_COLOR, fogColor, 0); //Deaktiviert den Vernebelungsmodus gl.glEnable(GL2.GL_FOG); } //------------------------------------------------------------------------------ // ------ Tetraeder ------ void drawTetrahedron(GL2 gl) { gl.glBegin(GL2.GL_TRIANGLES); // vordere Fläche gl.glColor3f( 1.0f, 0.0f, 0.0f ); // rot gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top gl.glColor3f( 0.0f, 1.0f, 0.0f ); // grün gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Left gl.glColor3f( 0.0f, 0.0f, 1.0f ); // blau gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Right // rechte Fläche gl.glColor3f( 1.0f, 0.0f, 0.0f ); // rot gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top gl.glColor3f( 0.0f, 0.0f, 1.0f ); // blau gl.glVertex3f( 1.0f, -1.0f, 1.0f ); // Left gl.glColor3f( 0.0f, 1.0f, 0.0f ); // grün gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Right // linke Fläche gl.glColor3f( 1.0f, 0.0f, 0.0f ); // rot gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top gl.glColor3f( 0.0f, 1.0f, 0.0f ); // grün gl.glVertex3f( 1.0f, -1.0f, -1.0f ); // Left gl.glColor3f( 0.0f, 0.0f, 1.0f ); // blau gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Right // untere Fläche gl.glColor3f( 0.0f, 1.0f, 0.0f ); // rot gl.glVertex3f( 1.0f, 2.0f, 0.0f ); // Top gl.glColor3f( 0.0f, 0.0f, 1.0f ); // blau gl.glVertex3f( -1.0f, -1.0f, -1.0f ); // Left gl.glColor3f( 0.0f, 1.0f, 0.0f ); // grün gl.glVertex3f( -1.0f, -1.0f, 1.0f ); // Right gl.glEnd(); } //------------------------------------------------------------------------------ // ------ GLUT-Zylinder ------ void drawGlutSoCylinder(GLUT glut, GL2 gl) { gl.glColor3f(1f, 1f, 0); glut.glutSolidCylinder(1, 2, 20, 10); } //------------------------------------------------------------------------------------------- @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); gl.glEnable(GL2.GL_DEPTH_TEST); //gl.glDepthFunc(GL2.GL_LESS); } //------------------------------------------------------------------------------------------- @Override public void display(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT); gl.glMatrixMode( GL2.GL_MODELVIEW ); gl.glLoadIdentity(); glu.gluLookAt(0f, 0f, 3f, 0f, 0f, 0f, 0f, 1f, 0f); gl.glTranslatef( 0f, 0f, -10.0f ); gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f ); gl.glTranslatef( 0f, 0f, -5.0f ); gl.glPushMatrix(); // ------------------ zeichnet ein Tetraeder ------------------- drawTetrahedron(gl); gl.glPopMatrix(); gl.glPushMatrix(); gl.glTranslatef( 0f, 2.0f, 0.0f ); gl.glScalef(0.5f, 0.5f, 0.5f); // ----------------- zeichnet einen GLUT Zylinder ------------------- drawGlutSoCylinder(glut,gl); gl.glPopMatrix(); // ------ rendert Nebel-Effekt ------ makeitfoggy(gl); //------------------------------------------------------------------------------ rtri +=0.4f; } //------------------------------------------------------------------------------------------- @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 ); } }