netbeans opengl gluPerspective und gluLookAt Verständnis

[JavaKing]

Hallo zusammen,

ich habe ein opengl Projekt gebaut. Bei diesem spiele ich zur Zeit mit den verschiedenen Betrachtunsgwinkeln umher. Leider habe ich hier wohl ein Verständnis Problem.

gl.glMatrixMode(GL.GL_PROJECTION); 
gl.glLoadIdentity(); 
glu.gluPerspective(100.0,((float)width)/((float)height),0.1, 100); //set up a perspective projection matrix 
//C SPECIFICATION // //void gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar) 
// //PARAMETERS //fovy //    Specifies the field of view angle, in degrees, in the y direction.
gl.glMatrixMode(GL.GL_MODELVIEW); 
gl.glLoadIdentity();
glu.gluLookAt(0,0,1.5, 0,1,0, 0,0,1);

Ich kenne die Bedeutung der Übergabeparamter. Bei LookAt (wo ich stehe, auf was ich schaue, Up Vector? )
Ich habe mir einen Würfel aus GL_Quads gebastelt und schaue mit diesen parametern in ihm hinein, jetzt will ich darin weitere Objekte platzieren nur leider fehlt mir hier das Verständnis bei der Angabe der Positionierung. !
Ich hoffe es kann jemand in einfach Worten wiedergeben wie ich mich am besten mit dem Koordinaten System zurecht finde.

 

[Marco13]

Ich müßte jetzt nachsehen, ob das so stimmt - aber ... es irritiert mich ein bißchen, dass du das gluLookAt auf der MODELVIEW Matrix machst - eigentlich sollte das doch die PERSPECTIVE Matrix beeinflussen?!

Ansonsten müßtest dud die Frage ein bißchen präzisieren. Man positioniert die Objekte, indem man eine passende MODELVIEW Matrix setzt, und die Objekte dann rendert....

 

[JavaKing]

Ich müßte jetzt nachsehen, ob das so stimmt - aber ... es irritiert mich ein bißchen, dass du das gluLookAt auf der MODELVIEW Matrix machst - eigentlich sollte das doch die PERSPECTIVE Matrix beeinflussen?!

Das passt schon.

Ansonsten müßtest dud die Frage ein bißchen präzisieren. Man positioniert die Objekte, indem man eine passende MODELVIEW Matrix setzt, und die Objekte dann rendert....

1.Was ist eine passende MODELVIEW Matrix ??

Ich habe jetzt über die Tasten eine Steuerungsansicht geschaffen, damit bekommt man einen sehr guten Überblick und kann sich im Raum bewegen. Man sieht auch genau wo der 0 Punkt ist. Sehr gut für das Verständnis.
Leider habe ich noch Probleme neue Objekte in den Raum genau zu platzieren, da ich ja immer von der letzten Position ausgehen muss oder ?

 

[Soulfly]

Ich würde dir sehr empfehlen OpenGL ingesamt mal einzustudiren

Ich müßte jetzt nachsehen, ob das so stimmt - aber ... es irritiert mich ein bißchen, dass du das gluLookAt auf der MODELVIEW Matrix machst - eigentlich sollte das doch die PERSPECTIVE Matrix beeinflussen?!

Das passt schon.

Das passt nicht! Beschäftige dich mal mit Matrizen und Projection. Modelviewmaxtrix ist die für die Weltmanipulation, Projection für die Projektion der Welt auf eine "Leinwand".

Leider habe ich noch Probleme neue Objekte in den Raum genau zu platzieren, da ich ja immer von der letzten Position ausgehen muss oder ?

Dann beschäftige dich nochmal mit OpenGL. Und diesmal mit dem Scenengraph. Baumstruktur um eine Scene in mehrere Lokole Koordinatensysteme aufzuteilen. Hinweis glPushMatrix() und glPopMatrix.

 

[JavaKing]

Vielen Dank.
Falls ich das falsch verstanden habe, warum funktioniert dann mein Projekt bis hier hin sehr gut ?

Mit opengl beschäftige ich mich schon eine ganze Weile, trotzdem hatte ich hier nachgefragt damit es mir evtl. jemand verständlicher umschreiben / erklären kann. Das opengl Red Book finde ich auch noch selber im Netz.

 

[Marco13]

Mit opengl beschäftige ich mich schon eine ganze Weile, trotzdem hatte ich hier nachgefragt damit es mir evtl. jemand verständlicher umschreiben / erklären kann.

Was ist ES? Ein Clown, der kleine Kinder frißt? Oder OpenGL? Zu letzterem gibt es hunderte von Büchern, und ein konkrete Frage, die man beantworten könnte, oder einen konkreten Punkt, den man erklären könnte, hast du eben nicht genannt.

Einen Szenegraph gibt es in OpenGL ja nicht, aber wenn es einen geben würde, dann würde er nicht zuletzt die angesprochenen Matrixoperationen kapseln.

Wenn du einen Würfel zeichnest, mit
glBegin(...);
glVertex(....);
...
glVertex(....);
glEnd();

dann kannst du den gleichen Würfel um 1 nach rechts verschoben zeichnen, indem du

glPushMatrix();
glTranslatef(1,0,0);
[...code von oben...]
glPopMatrix();

ausführst.

 

[Soulfly]

Das mit dem Erklären ist so ne Sache. Da kann man gleich ne ganze Ausarbeitung schreiben. schau vllt mal hier. Google ist dein Freund: z.B. Ergebnis http://graphics.cs.uni-sb.de/Courses/ws9900/cg-seminar/Ausarbeitung/Philipp.Walter/index.htm

Scenegraph, Matrixstack, sind übliche Begriffe für die Methoden von OpenGL, wie OpenGL die Scenen erstellt/aufbaut Sie sind analog zu den Projektionen und Transformation in der normalen Mathematik. Wenn du dass verstehst, verstehst du auch, wie der Scenengraph aufgebaut werden kann (Push n Pop).

Und warum es vorher gut funktioniert hat. Tja, QuicknDirty muss nicht immer zu fehlern führen und kann eine Zeit lang richtig arbeiten. Aber ob es richtig bleibt ist eine andere Sache.

EDIT:

http://en.wikipedia.org/wiki/Scene_graph
http://www.swiftless.com/tutorials/opengl/pop_and_push_matrices.html
http://www.short-link.de/7928


PS: Ändere mal deinen ersten Post (den Code), das zerstört das ganz layout

 

[JavaKing]

private void drawScene(GL gl, boolean select)
{ 
        gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        gl.glLoadIdentity();
        gl.glMatrixMode(GL.GL_PROJECTION); 
        gl.glLoadIdentity(); 
        glu.gluPerspective(100.0,((float)width)/((float)height),0.1, 100); 
        gl.glMatrixMode(GL.GL_MODELVIEW); 
        gl.glLoadIdentity();
        glu.gluLookAt(0,-2,0, 0,1,0, 0,0,1);
        gl.glPushMatrix();
        gl.glTranslated(-10,-8,-8);

        // OpenGL Primitiv zeichnen        
        // Würfel Casino
        gl.glCallList(wuerfel_vorne); // Boden
        gl.glCallList(wuerfel_hinten); //Decke
        gl.glCallList(wuerfel_links); // links
        gl.glCallList(wuerfel_rechts); //rechts
        gl.glCallList(wuerfel_boden); //Decke nicht sichtbar
        gl.glCallList(wuerfel_decke); // hinten
        gl.glPopMatrix();
  }

So mit diesem Code habe ich es jetzt geschafft in meinen Würfel reinzuschauen.
Leider sind die Seiten irgendwie verschoben. Ich habe das in den kommentaren versucht anzudeuten. Also links und rechts passt. nur Boden,Decke,vorn,hinten sind um 1 verschoben.
Ich möchte einfach von vorne in den Würfel hineinschauen. Wo muss ich hier anfassen ?

 

[duces]

Schau mal in dem Code nach, den ich dir geschickt hab. In der "OpenGL.java" ab Zeile 626 wird vieles vom Würfel erzeugt.

Dort wird der Würfel erstellt und die Textur auf die jeweiligen Koordinaten gebunden.

 

[JavaKing]

Schau mal in dem Code nach, den ich dir geschickt hab. In der "OpenGL.java" ab Zeile 626 wird vieles vom Würfel erzeugt.

Dort wird der Würfel erstellt und die Textur auf die jeweiligen Koordinaten gebunden.

Ja das habe ich ja schon. Mein Würfel wird gezeichnet, die Texturen werden an die Flächen gebunden. Ich schaue nur von oben nicht von vorne auf den Würfel, das ist mein Problem.

 

[Guest]

Dann muss ich bei mir nochmal kucken, wo die Perspektive der Scene festgelegt wird.

 

[Fancy]

Moin,

gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);

X ist "links - rechts"
Y ist "unten – oben"
Z ist "rein – raus"

gluLookAt(0, -2, 0, 0, 1, 0, 0, 0, 1);

Du verschiebst also die Eye Position um 2 Einheiten nach unten unten und siehst nach "oben".

Versuch mal, sollte dein Würfel um den Koordinatenursprung liegen (keine Ahnung wo Dein Würfel ohne ModelView Transformation liegt):

gluLookAt(0, 0, -2, 0, 1, 0, 0, 1, 0);

Alternativ kannst Du auch eine 90° Rotation auf deine ModelView Matrix anwenden (nach glTranslated()):

glRotatef(90.0f, -1.0f, 0.0f, 0.0f);

gluLookAt macht im Übrigen nichts anderes, als aus den gegebenen Parametern eine Transformationsmatrix zu erstellen und dessen Inverse auf die aktuelle ModelView Matrix aufzumultiplizieren.

www.opengl.org/resources/faq/technical/viewing.htm:

As far as OpenGL is concerned, there is no camera. More specifically, the camera is always located at the eye space coordinate (0., 0., 0.). To give the appearance of moving the camera, your OpenGL application must move the scene with the inverse of the camera transformation.

The GL_PROJECTION matrix should contain only the projection transformation calls it needs to transform eye space coordinates into clip coordinates.

The GL_MODELVIEW matrix, as its name implies, should contain modeling and viewing transformations, which transform object space coordinates into eye space coordinates. Remember to place the camera transformations on the GL_MODELVIEW matrix and never on the GL_PROJECTION matrix.

Think of the projection matrix as describing the attributes of your camera, such as field of view, focal length, fish eye lens, etc. Think of the ModelView matrix as where you stand with the camera and the direction you point it.

gluLookAt gehört also auf die ModelView und nicht auf die Projection.

Es reicht außerdem Deine Projection Matrix lediglich bei Veränderungen des Viewport anzupassen und nicht bei jedem Aufruf deiner drawScene().

Und wenn wir grade schon bei Optimierungen sind (und davon ausgehend das dein Würfel lediglich aus 6 Quads oder 12 Triangles besteht), macht es nicht allzu viel sinn für 1 Quad / 2 Triangles eine Display Liste zu erstellen, pack den ganzen Würfel besser in eine einzige und render den ganzen Würfel mit einem glCallList().

Gruß,
Michael

 

[JavaKing]

@Fancy
Vielen lieben Dank für deine kompetente Hilfe, da können sich andere noch ein Stückchen von abschneiden ;-)

Nachdem ich jetzt schon an meinen Verstand gezweifelt habe, denke ich das ich nun (halbwegs) die Lösung gefunden habe. Man muss sich bei gluLookAt wirklich nur das Koordinatensystem vorstellen und die Kamera entsprechend positionieren. Leider war das nicht das einzigste Problem. Mein Würfel wurde zwar gezeichnet, aber
meine Rückseite lag auf z=22 und meine Vorderseite auf z=0. Größere z Werte liegen also vor kleineren. Meine Rückseite liegt damit intuitiv vor meiner Vorderseite. Aber kein Problem, das Koordinatensystem wird ja eh die ganze Zeit hin und her Transformiert. <-- Danke nochmal an Fancy

2. Problem war die Texturierung, diese wurde gespiegelt und verkehrt angezeigt. Somit bin ich nun völlig aus dem Konzept gekommen.

3. Die Kamera war auf z -40 bedeutet ich schaue von hinten auf meinen Würfel, dadurch ändert sich ja wieder die Texture Ansicht. Da ich echte Bilder verwende und nicht nur Streifen z.b. fällt das sofort auf.


Lösung :

//Im Würfel
glu.gluLookAt(0,0,10, 0,0,-24, 0,1,0);

Mein Würfel : Hier musste ich die glTexCoord2f Koordinaten anpassen, die Bilder wurden reihenweise nämlich gespiegelt oder vertauscht. Jetzt funktioniert es aber

        wuerfel_vorne = gl.glGenLists(1); 
        gl.glNewList(wuerfel_vorne, GL_COMPILE);
        gl.glColor3f(1,1,1);
        gl.glEnable(GL_TEXTURE_2D);
        twuerfel_vorne.bind();
        gl.glBegin(GL_QUADS);
	gl.glTexCoord2f(0.0f,1.0f); gl.glVertex3f(-12.0f, -12.0f,  12.0f);
	gl.glTexCoord2f(1.0f,1.0f); gl.glVertex3f(12.0f, -12.0f,  12.0f);
        gl.glTexCoord2f(1.0f,0.0f); gl.glVertex3f(12.0f,  12.0f,  12.0f);
        gl.glTexCoord2f(0.0f,0.0f); gl.glVertex3f(-12.0f,  12.0f,  12.0f);
	gl.glEnd();        
        gl.glDisable(GL_TEXTURE_2D);
        gl.glEndList(); 

        wuerfel_hinten = gl.glGenLists(1); 
        gl.glNewList(wuerfel_hinten, GL_COMPILE);
        gl.glEnable(GL_TEXTURE_2D);
        twuerfel_hinten.bind();
        gl.glBegin(GL_QUADS);
	gl.glTexCoord2f(0.0f,1.0f); gl.glVertex3f(-12.0f, -12.0f, -12.0f);
	gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-12.0f,  12.0f, -12.0f);
        gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(12.0f,  12.0f, -12.0f);
        gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(12.0f, -12.0f, -12.0f);
	gl.glEnd();
        gl.glDisable(GL_TEXTURE_2D);
        gl.glEndList();         

        wuerfel_links = gl.glGenLists(1); 
        gl.glNewList(wuerfel_links, GL_COMPILE);
        gl.glColor3f(1,1,1);
        gl.glEnable(GL_TEXTURE_2D);
        twuerfel_links.bind();
       gl.glBegin(GL_QUADS);
	gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-12.0f, -12.0f, -12.0f);
	gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-12.0f, -12.0f,  12.0f);
        gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-12.0f,  12.0f,  12.0f);
        gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-12.0f,  12.0f, -12.0f);
	gl.glEnd();
        gl.glDisable(GL_TEXTURE_2D);
        gl.glEndList();
        
         wuerfel_rechts = gl.glGenLists(1); 
        gl.glNewList(wuerfel_rechts, GL_COMPILE);
        gl.glColor3f(1,1,1);
        gl.glEnable(GL_TEXTURE_2D);
        twuerfel_rechts.bind();
       gl.glBegin(GL_QUADS);
	gl.glTexCoord2f(0.0f,1.0f); gl.glVertex3f(12.0f, -12.0f, -12.0f);
	gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(12.0f,  12.0f, -12.0f);
        gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(12.0f,  12.0f,  12.0f);
        gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(12.0f, -12.0f,  12.0f);
	gl.glEnd();
        gl.glDisable(GL_TEXTURE_2D);
        gl.glEndList();
        
         wuerfel_boden = gl.glGenLists(1); 
        gl.glNewList(wuerfel_boden, GL_COMPILE);
        gl.glColor3f(1,1,1);
        gl.glEnable(GL_TEXTURE_2D);
        twuerfel_boden.bind();
       gl.glBegin(GL_QUADS);
	gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-12.0f, -12.0f, -12.0f);
	gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(12.0f, -12.0f, -12.0f);
        gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(12.0f, -12.0f,  12.0f);
        gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-12.0f, -12.0f,  12.0f);
	gl.glEnd();        
        gl.glDisable(GL_TEXTURE_2D);    
        gl.glEndList(); 
        
         wuerfel_decke = gl.glGenLists(1); 
        gl.glNewList(wuerfel_decke, GL_COMPILE);
        gl.glColor3f(1,1,1);
        gl.glEnable(GL_TEXTURE_2D);
        twuerfel_decke.bind();
       gl.glBegin(GL_QUADS);
	gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-12.0f,  12.0f, -12.0f);
	gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-12.0f,  12.0f,  12.0f);
        gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(12.0f,  12.0f,  12.0f);
        gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(12.0f,  12.0f, -12.0f);
	gl.glEnd();
        gl.glDisable(GL_TEXTURE_2D);    
        gl.glEndList();

Diesen Würfel habe ich jetzt als Vorlage genommen :

GLvoid glDrawCube()					// Zeichne einen Würfel
{
		glBegin(GL_QUADS);			// Beginne Qudrate zu zeichnen
		// Front Face
		glNormal3f( 0.0f, 0.0f, 1.0f);		// Normalen die forwärts zeigen
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);	// Unten Links der Textur und des Qudrats
		glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);	// Unten rechts der Textur und des Qudrats
		glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);	// Oben rechts der Textur und des Qudrats
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);	// Oben Links der Textur und des Qudrats
		// Back Face
		glNormal3f( 0.0f, 0.0f,-1.0f);		// Normal Facing Away
		glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);	// Unten rechts der Textur und des Qudrats
		glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);	// Oben rechts der Textur und des Qudrats
		glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);	// Oben Links der Textur und des Qudrats
		glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);	// Unten Links der Textur und des Qudrats
		// Top Face
		glNormal3f( 0.0f, 1.0f, 0.0f);		// Normal Facing Up
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);	// Oben Links der Textur und des Qudrats
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f,  1.0f);	// Unten Links der Textur und des Qudrats
		glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f,  1.0f);	// Unten rechts der Textur und des Qudrats
		glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);	// Oben rechts der Textur und des Qudrats
		// Bottom Face
		glNormal3f( 0.0f,-1.0f, 0.0f);		// Normal Facing Down
		glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);	// Oben rechts der Textur und des Qudrats
		glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);	// Oben Links der Textur und des Qudrats
		glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);	// Unten Links der Textur und des Qudrats
		glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);	// Unten rechts der Textur und des Qudrats
		// Right face
		glNormal3f( 1.0f, 0.0f, 0.0f);		// Normal Facing Right
		glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);	// Unten rechts der Textur und des Qudrats
		glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);	// Oben rechts der Textur und des Qudrats
		glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);	// Oben Links der Textur und des Qudrats
		glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);	// Unten Links der Textur und des Qudrats
		// Left Face
		glNormal3f(-1.0f, 0.0f, 0.0f);		// Normal Facing Left
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);	// Unten Links der Textur und des Qudrats
		glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);	// Unten rechts der Textur und des Qudrats
		glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);	// Oben rechts der Textur und des Qudrats
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);	// Oben Links der Textur und des Qudrats
	glEnd();					// Done Drawing Quads
}

 

[Fancy]

Moin,

2. Problem war die Texturierung, diese wurde gespiegelt und verkehrt angezeigt. Somit bin ich nun völlig aus dem Konzept gekommen.

es hilft Dir vielleicht zu wissen, das Quads und Triangles jeweils eine Vorder- und Rückseite haben. OpenGL erkennt die entsprechenden Seiten anhand der Orientierung der Vertices. Sind diese aus Sicht der "Kamera" (genauer: Der projizierten Fensterkoordinaten) gegen den Uhrzeigersinn, handelt es sich um die Vorderseite sonst um die Rückseite (in der Standarteinstellung).

Normalerweise gehört die "linke untere" Ecke der Textur (0, 0) auf die "linke untere" Ecke des Primitiv, die "rechte obere" Ecke der Textur (1, 1) auf die "rechte obere" Ecke des Primitiv. Die anderen Ecken entsprechend analog.

Siehst Du die Textur trotzdem spiegelverkehrt, so siehst Du sie von der Rückseite!

Siehst Du die Textur kopfstehend, so liegt das an unterschiedlichen Koordinatensystemen zwischen der Textur und OpenGL. OpenGL nimmt den Koordinatenursprung (0, 0) als "unten links". In vielen Bilddateiformaten ist der Koordinatenursprung alternativ aber als "oben links" definierbar. Entsprechend steht die Textur dann kopf.

Wenn Du Dir die Texturkoordinaten über die Texture Klasse erzeugen lässt, wird dieser Umstand berücksichtigt und die Textur entsprechend gedreht:

Texture texture = TextureIO.newTexture(getClass().getResource("/v0.jpg"), true,  null);
                      
System.out.println("Must flip: " + texture.getMustFlipVertically());
                      
// [..]

texture.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
texture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
texture.setTexParameteri(GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP);
texture.setTexParameteri(GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP);
                      
TextureCoords textureCoords = texture.getImageTexCoords();
                   
// [..]

gl.glBegin(GL.GL_QUADS);
gl.glTexCoord2f(textureCoords.left(),  textureCoords.bottom());  gl.glVertex3f(-1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(textureCoords.right(), textureCoords.bottom());  gl.glVertex3f( 1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(textureCoords.right(), textureCoords.top());     gl.glVertex3f( 1.0f,  1.0f, 1.0f);
gl.glTexCoord2f(textureCoords.left(),  textureCoords.top());     gl.glVertex3f(-1.0f,  1.0f, 1.0f);
gl.glEnd();

@Fancy
Vielen lieben Dank für deine kompetente Hilfe

Kein Problem.

Gruß,
Michael