Erhöhen der Tesselierung

[JavaKing]

Um mit der "OpenGL-Beleuchtung" qualitativ hochwertige Darstellungen erzeugen zu können, ist eine hohe Tesselierung der Geometrie notwendig. Bei der Definition von Texturkoordinaten müssen nun für die vielen Vertices geeignete UV-Koordinaten erzeugt werden.

gl.glBegin(GL_POLYGON);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-6.0f, -3.0f, -3.0f); //Punkt hinten links
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(6.0f, -3.0f, -3.0f); //Punkt hinten rechts
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(6.0f, -3.0f,  3.0f); //Punkt vorne rechts
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-6.0f, -3.0f,  3.0f); // Punkt vorne links
gl.glEnd();

Wie kann ich einfach bei dieser Fläche die Tesselierung erhöhen ?

 

[Marco13]

Ganz allgemein: Mit Schleifen

float w = 6+6;
float h = 3+3;
float xOffset = -6;
float yOffset = -3;
int segments = 10;
for (int x=0; x<segments; x++)
{
    for (int y=0; y<segments; y++)
    {
        // Relative Positionen der 4 Eckpunkte, alle zwischen 0 und 1
        float rx0 = x * (1.0f / segments);
        float ry0 = y * (1.0f / segments);
        float rx1 = (x+1) * (1.0f / segments);
        float ry1 = (y+1) * (1.0f / segments);

        // Positionen der Expunkte des Rechtecks im Raum
        float x0 = xOffset + rx0 * w;
        float y0 = yOffset + ry0 * h;
        float x1 = xOffset + rx1 * w;
        float x1 = yOffset + ry1 * h;

        gl.glBegin(GL_POLYGON);
        gl.glTexCoord2f(rx0,ry1); gl.glVertex3f(x0, -3.0f, y1); //Punkt hinten links
         ...
        gl.glEnd();
    }
}

... so grob jedenfalls. (Falls du das so machst, lieber ein GL_QUADS außenrum, statt immer ein GL_POLYGON in der innersten Schleife)

 

[JavaKing]

Ich habe das jetzt so gelöst :

          size= 200;
          for (float x = -6.0f, u=0; x < 6.0f; x+=12.0f/size,u+=1/size) {
             for (float y = -3.0f,v=0; y < 3.0f; y+=3.0f/size,v+=1/size) {             
                gl.glBegin(GL_POLYGON);
//                    gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-6.0f, -3.0f, -3.0f); //Punkt hinten links
//                    gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(6.0f, -3.0f, -3.0f); //Punkt hinten rechts
//                    gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(6.0f, -3.0f,  3.0f); //Punkt vorne rechts
//                    gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-6.0f, -3.0f,  3.0f); // Punkt vorne links
                  gl.glTexCoord2f(u,v+1/size); gl.glVertex3f(-x,-3.0f,y+6/size);  
                  gl.glTexCoord2f(u,v); gl.glVertex3f(x,-3.0f,y);
                  gl.glTexCoord2f(u+1/size,v); gl.glVertex3f(x+12/size,-3.0f,y+6/size);
                  gl.glTexCoord2f(u+1,v+1/size); gl.glVertex3f(-x+12/size,-3.0f,y);
                gl.glEnd();

leider ist meine Texture irgendwie verschwommen bzw. verändert sich wenn ich durch den Raum gehe. Sieht ganz komisch aus. Auf jeden Fall ist es nichtmehr grün sondern braun wie einige andere Texturen im Raum.

 

[Marco13]

Vielleicht sollte "size" ein float sein. Oder es ist noch irgendwo ein Rechenfehler drin. Schwer zu erkennen, weil... besonders übersichtlich ist das jetzt nicht. Genaugenommen ist das sogar EXTREM häßlich :autsch: Du wirst ja vermutlich mehr als EIN Rechteck zeichnen. Und überleg' mal, welchen Aufwand es bedeuten würde, ein weiteres Rechteck zu zeichnen, oder wenn dort jetzt nichtmehr das Rechteck (-6,-3)-(6,3) zeichnen willst, sondern (-7,-4)-(4,1) :autsch:


Das, was ich dort andeutungsweise geschrieben hatte, könnte man leicht einbauen in eine Methode

void drawTesselatedRectangle(int segments, float x0, float y0, float x1, float y1) { .... }

die man in deinem Fall mit

drawTesselatedRectangle(10, -6, -3, 6, 3);

aufrufen könnte, und im anderen Fall mit

drawTesselatedRectangle(10, -7, -4, 4, 1);

Ggf. könnte oder sollte man das noch mehr verallgemeinern, so dass man x/y/z Koordinaten angeben kann.

 

[Marco13]

So als Nachtrag: Wenn man mit Beleuchtung hantiert, kann es sinnvoll sein, die Normalen anzugeben (außer wenn du sowas zum Automatischen Berechnen der Normalen verwendest)

 

[JavaKing]

size ist natürlich ein float. Leider habe ich deine Methode überhaupt nicht verstanden. besonders nicht was bei ... noch folgen soll.
Sicher ist es schöner verschiedene Rechteck einer Methode zu übergeben, nur leider verstehe ich deine Ansätze nicht und hab es mir extrem hässlich einfacher gemacht.

 

[Marco13]

"Einfacher" ist es, wie angedeutet, nur so lange, wie das ganze nicht verändert, erweitert oder auch nur (von jemand anderem) verstanden werden soll.

Im Prinzip berechnet die Methode erstmal nur die Texturkoordinaten (rx0....ry1). Das sind alles Werte zwischen 0 und 1, die die "relative Position" der einzelnen Punkte im gesamten Recheteck beschreiben. Wenn man das ganze in 2 segmente (jeweils in x- und y-Richtung) aufteilen will, berechnet man also die Koordinaten

0/0    0.5/0     1.0/0
 -----------------
|        |        |
|        |        |
|        |        |
|     0.5/0.5     |
|-----------------|...
0/0.5    |        |
|        |        |
|        |        |
|        |        |
 ----------------- ...

Das sind dann schonmal die Texturkoordinaten. Der Punkt in der Mitte hat also die Texturkoordinaten (0.5,0.5). Diese Zahlen kann man aber auch leicht umrechnen in die "Raumkoordinaten" der Punkte für ein Rechteck mit einer bestimmten Position und Größe: Wenn die obere Linke Ecke bei (x0,y0) = (3,4) liegt, und das Rechteck eine Größe von (Breite,Höhe) = (5,6) hat, dann kann man die "Raumkoordinaten" aus den Texturkoordinaten berechnen. Der Punkt in der Mitte liegt dann bei (x0+0.5*Breite, y0+0.5*Höhe). Der Obere Linke Punkt hat die Texturkoorindaten (0,0) und liegt demnach bei (x0+0* Breite, y0+0*Höhe) = (3,4) (wo er ja sein soll).

Der Vorteil ist, dass man die ganzen Berechnungen zur Segmentierung allgemeingültig aufschreiben kann. Man rechnet ja nur mit den Zahlen zwischen 0 und 1, und die sind für alle Rechtecke gleich. Um dann die tatsächlichen Positionen der Punkte für ein bestimmtes Rechteck zu berechnen, braucht man nurnoch die Position (x0,y0) und Größe (w,h) des Rechtecks (oder analog dazu die Positionen (x0,y0) und (x1,y1)).

Vielleicht hilft eine andere Formulierung: Die "relativen Koordinaten" sind sozusagen "Prozentwerte", an denen das Rechteck in Segmente unterteilt werden soll. Und diese "Prozentwerte" hängen NUR davon ab, wieVIELE Segmente es geben soll, und nicht davon, wie groß das Rechteck ist.

Btw: Die Schleifen in meinem Code müßten jeweils bis x/y<=segments (kleinerGLEICH) laufen.

 

[Marco13]

Und NOCH ein Nachtrag: Eine andere Interpretation wäre folende: Man berechnet IMMER ein Segmentiertes Rechteck der Größe (1,1) das an der Position (0,0) liegt. Wenn man dieses segmentierte Rechteck hat, dann skaliert man es auf die geüwnschte Breite/Höhe, und verschiebt es an die gewünschte Position. (Dieses Skalieren und Verschieben wird hier aber nicht "nachträglich" gemacht, sondern direkt in der Schleife)

 

[JavaKing]

Ich habe das ... mal ausgefüllt

 gl.glTexCoord2f(rx0,ry1); gl.glVertex3f(x0, -3.0f, y1); //Punkt hinten links 
gl.glTexCoord2f(rx0,ry0); gl.glVertex3f(x1, -3.0f, y1); //Punkt hinten rechts
gl.glTexCoord2f(rx1,ry0); gl.glVertex3f(x1, -3.0f, y0); //Punkt vorne rechts
gl.glTexCoord2f(rx1,ry1); gl.glVertex3f(x0, -3.0f, y0); // Punkt vorne links

das sollte doch so richtig sein für mein Beispiel oder ? Dann hätte ich es nämlich verstanden

 

[Marco13]

Eigentlich sollten (schon für die Übersichtlichkeit) die "Indizes" übereinstimmen ... also

Texturkoordinaten (rx0,ry0) -> Raumkoordinaten (x0,y0)
Texturkoordinaten (rx0,ry1) -> Raumkoordinaten (x0,y1)
Texturkoordinaten (rx1,ry0) -> Raumkoordinaten (x1,y0)
Texturkoordinaten (rx1,ry1) -> Raumkoordinaten (x1,y1)

also hier

gl.glTexCoord2f(rx0,ry1); gl.glVertex3f(x0, -3.0f, y1); //Punkt hinten links
gl.glTexCoord2f(rx0,ry0); gl.glVertex3f(x0, -3.0f, y0); //Punkt hinten rechts
gl.glTexCoord2f(rx1,ry0); gl.glVertex3f(x1, -3.0f, y0); //Punkt vorne rechts
gl.glTexCoord2f(rx1,ry1); gl.glVertex3f(x1, -3.0f, y1); // Punkt vorne links

Vom Aussehen her ist es wohl nicht so wichtig, aber so ist es aufgeräumter und die Zusammenhänge zwischen Eckpunkten und Texturkoordinaten offensichtlicher.....

 

[JavaKing]

Wahrscheinlich bin ich einfach nur zu blöd. Aber warum verdreht er mir bei diesem Beispiel die Texture ??? Diese steht nun auf dem Kopf, habe schon versucht die glTexCoord2f anzupassen. Ohne Erfolg.

Vorher (Texture wird richtig angezeigt)

      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();

Nachher (Texture steht auf dem Kopf)

        wuerfel_hinten = gl.glGenLists(1); 
        gl.glNewList(wuerfel_hinten, GL_COMPILE);
        gl.glEnable(GL_TEXTURE_2D);
        twuerfel_hinten.bind();

        float w = 12+12; 
        float h = 12+12; 
        float xOffset = -12; 
        float yOffset = -12; 
        int segments = 200; 
        for (int x=0; x<segments; x++) { 
            for (int y=0; y<segments; y++)     { 
        // Relative Positionen der 4 Eckpunkte, alle zwischen 0 und 1 
        float rx0 = x * (1.0f / segments); 
        float ry0 = y * (1.0f / segments); 
        float rx1 = (x+1) * (1.0f / segments); 
        float ry1 = (y+1) * (1.0f / segments); 

        // Positionen der Expunkte des Rechtecks im Raum 
        float x0 = xOffset + rx0 * w; 
        float y0 = yOffset + ry0 * h; 
        float x1 = xOffset + rx1 * w; 
        float y1 = yOffset + ry1 * h; 

        gl.glBegin(GL_QUADS); 
        gl.glTexCoord2f(rx0,ry1); gl.glVertex3f(x1, y1,-12.0f); //Punkt hinten links 
        gl.glTexCoord2f(rx0,ry0); gl.glVertex3f(x1, y0,-12.0f); //Punkt hinten rechts
        gl.glTexCoord2f(rx1,ry0); gl.glVertex3f(x0, y0,-12.0f); //Punkt vorne rechts
        gl.glTexCoord2f(rx1,ry1); gl.glVertex3f(x0, y1,-12.0f); // Punkt vorne links
        gl.glEnd();         
    } 
}

 

[Marco13]

Wenn sie nur auf dem Kopf steht, würde es eigentlich schon reichen, das Rechteck umzudrehen:

Vorher

// Positionen der Expunkte des Rechtecks im Raum
float x0 = xOffset + rx0 * w;
float y0 = yOffset + ry0 * h;
float x1 = xOffset + rx1 * w;
float y1 = yOffset + ry1 * h;

Nachher

// Positionen der Expunkte des Rechtecks im Raum
float x0 = xOffset + rx0 * w;
float y0 = yOffset + h - ry0 * h;
float x1 = xOffset + rx1 * w;
float y1 = yOffset + h - ry1 * h;


???:L So ungefähr zumindest.... Hab grad nicht viel Zeit

 

[JavaKing]

        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();

So dieses ist jetzt um eins nach links gedreht. Also -90Grad. Warum ist das so ? Ich versteh das irgendwie nicht.

 

[Marco13]

Inzwischen hast du bei glVertex3f(-12.0f, -12.0f, -12.0f) alle Varianten durch: Mal war Y konstant, dann Z, und jetzt X. Nicht gerade hilfreich. Überleg' dir, wie das Rechteck liegen soll. Wenn du das weißt, stell dir vor, es liegt vor dir wie ein Blatt Papier. Dann Kann di linke untere Ecke die Texturkoordinaten (0,0) haben, die rechte untere hat (1,0), die rechte obere (1,1) und die linke obere (0,1) - und dann ist die Textur "richtig" rum auf dem Blatt. Wenn man die Texturoordinaten der unteren Ecken mit den oberen vertauscht, steht die Textur auf dem Kopf. Schua auch mal hier, das oberste Bild...
http://www.siggraph.org/education/materials/HyperGraph/mapping/r_wolfe/r_wolfe_mapping_5.htm

 

[Fancy]

Moin,

Ihr solltet vielleicht auch beachten, dass die Quads eine Vorder- und eine Rückseite haben. Wenn die ursprüngliche Seite des Quads durch die Tesselierung ganz (oder nochschlimmer teilweise) gedreht wird, könnte das langfristig zu Problemen führen. Deshalb vielleicht lieber jetzt schon ein Auge drauf halten. (Bei den verschiedenen Varianten die hier im Thread auftauchen hab ich keine Ahnung inwieweit bereits darauf geachtet wurde.)

(Außerdem halt ich die Tesselierung eines planaren Quads nur für mäßig sinnvoll. Als Fingerübung und für komplexere Objekte ganz interessant. Aber um die Beleuchtung zu verbessern wäre per Pixel Lighting langfristig vermutlich die bessere Alternative.)

Gruß,
Michael

 

[Marco13]

(Außerdem halt ich die Tesselierung eines planaren Quads nur für mäßig sinnvoll. Als Fingerübung und für komplexere Objekte ganz interessant. Aber um die Beleuchtung zu verbessern wäre per Pixel Lighting langfristig vermutlich die bessere Alternative.)

Das stimmt sicher (hätte man vielleicht schon früher mal erwähnen sollen ) aber ... ohne jetzt nochmal in der Doku danach gesucht zu haben: Für per-pixel-lighting braucht man soweit ich weiß ja Shader?!
Eine Einteilung eines kleinen Rechtecks in 200x200 Rechecke ist sicher übertrieben (um die üblichen Gouraud-Artefakte zu vermindern sollte es schon 10x10 oder sogar weniger tun)

 

[JavaKing]

Leute Leute ! ;-)

Ich will doch einfach nur die unten aufgelisteten Flächen hoch tesselieren damit mein licht darauf fällt. Mehr nicht.

void List(GL gl)
{
        // Casino Würfel Vorne
        wuerfel_vorne = gl.glGenLists(1); 
        gl.glNewList(wuerfel_vorne, GL_COMPILE);
        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(); 

        // Casino Würfel Hinten
        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();         

        // Casino Würfel Links
        wuerfel_links = gl.glGenLists(1); 
        gl.glNewList(wuerfel_links, GL_COMPILE);
        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();
        
        // Casino Würfel Rechts
        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();
        
        // Casino Würfel Boden 
        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(); 
        
        // Casino Würfel Decke
        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(); 
}

 

[Fancy]

Moin,

@Marco:
Da hast Du allerdings recht, ohne Shader geht da leider nichts. Praktisch ist das jedoch nur eine Frage der Zielplattform, noch nicht mal des Aufwands. Shader zur per Pixel Phong Beleuchtung sind im Allgemeinen relativ simpel und intuitiv.

Wenn die Zielplattform GLSL hergibt ist es sogar noch simpler: Einfach den zur Beleuchtung passenden Shader laden, aktivieren und das wars. Da man aus dem GLSL Shader heraus auf die mit glLight und glMaterial gesetzten Eigenschaften zugreifen kann, muss man praktisch so gut wie nichts an seinem Programm ändern. Und der Shader für z.B. direktionales Licht ist gerade mal 16 Zeilen lang (7 vertex und 9 fragment).

Wenn die Zielplattform keine Shader hergibt geht das leider natürlich nicht. Dann ist aber auch die Frage inwieweit eine Einteilung eines Quads in 200x200 Rechtecke sinnvoll ist. Da werden aus einem Quad ja erstmal 40k Quads dann 80k Triangles und anschließend irgendwo mal 240k Verticies. Wenn der Treiber da nicht ordentlich die Optimierungskeule schwingt ist das ruckeln nicht mehr fern. Deine 10x10 klingen da schon wesentlich realistischer.

Schwierig wird es allerdings wenn die Zielplattform zwar bereits Shader aber noch kein GLSL bietet. Also ich zumindest mag diesen Assembler ähnlichen Shadercode gar nicht.

Langfristig ist es aber sowieso klar: Bei OpenGL3 im forward compatible context kriegt man ohne Shader nicht mal ein simples Dreieck auf den Bildschirm.
(Bis es aber in der breiten Installationsbasis soweit sein wird, wird es allerdings Jahre oder nochlänger dauern.)



@JavaKing:

Ich will doch einfach nur die unten aufgelisteten Flächen hoch tesselieren damit mein licht darauf fällt. Mehr nicht.

Klingt für mich als verfolgst Du den falschen Ansatz. Deine Flächen werden, sofern die Beleuchtung gesetzt ist, immer beleuchtet! Egal ob Du tesselierst oder Shader verwendest, beide Techniken verhindern lediglich einige falsch aussehende Phänomene um die Beleuchtung natürlicher aussehen zu lassen.

Die Standart OpenGL Beleuchtung berechnet die aktuelle Beleuchtung für jeden Eckpunkt und interpoliert dann diesen Wert über die gesamte Fläche. Befindet sich also einer der Eckpunkte im Licht, so ist die Fläche teilweise beleuchtet!

Fällt kein Licht auf deine Flächen, liegt der Fehler vermutlich wo anders und weder Tesselierung noch Shader würden etwas an der aktuellen Situation ändern!

Mein Tipp: Kommentiere in Deinem Programm alles aus was nicht unbedingt gebraucht wird (auch die Tesselierung). Anschließend spielst Du solange an den Beleuchtungsparametern (insbesondere Position, Ausrichtung und Material) bis Deine Flächen beleuchtet sind. Wenn sie es dann sind, kannst Du entscheiden ob das was Du siehst ausreichend gut aussieht oder nicht. Und dann kannst Du überlegen was Du tun willst um die Beleuchtung zu verbessern. Aber dafür muss sie erstmal da sein!

Gruß,
Michael

 

[JavaKing]

Ich habe mein Tesselierungsproblem jetzt einen Tick einfacher gelöst :

void List2(GL gl)
{
        liste = gl.glGenLists(1);
        gl.glNewList(liste, GL_COMPILE);
        for (float x = -12f, rx=0; x < 12f; x+=24/size,rx+=1/size) {
             for (float y = -12f,ry=0; y < 12f; y+=24/size,ry+=1/size) {    
                gl.glBegin(GL_POLYGON);  
                gl.glTexCoord2f(rx,ry+1/size); gl.glVertex3f(x,y+24/size,0);  
                gl.glTexCoord2f(rx+1/size,ry+1/size); gl.glVertex3f(x+24f/size,y+24/size,0);
                gl.glTexCoord2f(rx+1/size,ry); gl.glVertex3f(x+24f/size,y,0);
                gl.glTexCoord2f(rx,ry); gl.glVertex3f(x,y,0);
                gl.glEnd();
             }
        }  
        gl.glEndList();
        
        
       listeg = gl.glGenLists(1); 
       gl.glNewList(listeg, GL_COMPILE);
       gl.glPushMatrix();
       gl.glTranslatef(0,0,12);
       gl.glEnable(GL_TEXTURE_2D);
       mat_eigen( gl,0.5f,0.1f,0.1f,1,0.6f,0.6f,0.6f,1,0.2f,0.20f,0.26f,1,20);
       twuerfel_vorne.bind();
       gl.glRotated(180,1,0,0);
       gl.glCallList(wuerfel_seite); 
       gl.glDisable(GL_TEXTURE_2D); 
       gl.glPopMatrix();
       gl.glFrontFace(GL.GL_CCW);
       gl.glCullFace(GL.GL_BACK);
       gl.glEnable(GL.GL_CULL_FACE);
       gl.glPushMatrix();
       gl.glTranslatef(0,0,-12);   
       gl.glEnable(GL_TEXTURE_2D);
       mat_eigen( gl,0.5f,0.1f,0.1f,1,0.6f,0.6f,0.6f,1,0.2f,0.20f,0.26f,1,20);
       twuerfel_hinten.bind();
       gl.glRotated(180,1,0,0);
       gl.glCallList(wuerfel_seite);
       gl.glDisable(GL_TEXTURE_2D); 
       gl.glPopMatrix();
[...]
}

Damit spare ich mir dann auch die Translation der Z-Achse. ;-)