DGL • Thema anzeigen - Normalen für TRIANGLE

Normalen für TRIANGLE_STRIP

Moderator: DGL-Team

Seite 1 von 2

[ 29 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Pk3

Betreff des Beitrags: Normalen für TRIANGLE_STRIP

Verfasst: So Jul 04, 2010 17:13

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Ich habe ein Terrain aus TRAINGLES_STRIPS gemacht und dazu die Normalen gesetzt. Leider sieht das Terrain aber sehr "fleckig" aus...
Hier mal ein Bild:

http://xyross.de/file.php?id=53

Hier der Code zum Berechnen der Normalen:

Code:

            for(z = 0; z < length-1; z++) {
                glBegin(GL_TRIANGLE_STRIP);
                for(x = 0; x < width-1; x++) {
                    Vector.Conv(&vec1, x, heightmap[x][z], z);      // Vertex - Daten in den Vektor "vec1"
                    Vector.Conv(&vec2, x+1, heightmap[x+1][z], z);   // Vertex - Daten in den Vektor "vec2"
                    Vector.Conv(&vec3, x, heightmap[x][z+1], z+1);   // Vertex - Daten in den Vektor "vec3"
                    Vector.Conv(&vec4, x+1, heightmap[x+1][z+1], z+1);   // Vertex - Daten in den Vektor "vec4"

                    Vector.Normal(&vec1, &vec2, &vec3, &norm1);      // Normale 1 berechnen
                    Vector.Normal(&vec2, &vec4, &vec3, &norm2);      // Normale 2 Berechnen

                    glNormal3f(norm1.X, norm1.Y, norm1.Z);      // Normale

                    glTexCoord2f((float)x/TERRAIN_TEXTURE_RES_X, (float)z/TERRAIN_TEXTURE_RES_Y);
                    glVertex3f(x, heightmap[x][z], z);

                    glTexCoord2f((float)(x+1)/TERRAIN_TEXTURE_RES_X, (float)z/TERRAIN_TEXTURE_RES_Y);
                    glVertex3f(x+1, heightmap[x+1][z], z);

                    glTexCoord2f((float)x/TERRAIN_TEXTURE_RES_X, (float)(z+1)/TERRAIN_TEXTURE_RES_Y);
                    glVertex3f(x, heightmap[x][z+1], z+1);

                    glNormal3f(norm2.X, norm2.Y, norm2.Z);      // Normale

                    glTexCoord2f((float)(x+1)/TERRAIN_TEXTURE_RES_X, (float)(z+1)/TERRAIN_TEXTURE_RES_Y);
                    glVertex3f(x+1, heightmap[x+1][z+1], z+1);
                }
                glEnd();
            }

Die Normal-Funktion:

Code:

void clVector::Normal(stVec3 *vec1, stVec3 *vec2, stVec3 *vec3, stVec3 *normal) {
    GLfloat a, b, c;
    GLfloat d, e, f;
    GLfloat l, x, y, z;

    a = (*vec1).X - (*vec2).X;
    b = (*vec1).Y - (*vec2).Y;
    c = (*vec1).Z - (*vec2).Z;

    d = (*vec2).X - (*vec3).X;
    e = (*vec2).Y - (*vec3).Y;
    f = (*vec2).Z - (*vec3).Z;

    x = b * f - c * e;
    y = c * d - a * f;
    z = a * e - b * d;

    l = (GLfloat)sqrt((x * x) + (y * y) + (z * z));
    if(l == 0.0f) l = 1.0f;

    (*normal).X = x/l;
    (*normal).Y = y/l;
    (*normal).Z = z/l;
}

Weiß jemand, wo der Fehler liegt? Freue mich auf jede Antwort

.
Mfg, Pk3

Nach oben

Coolcat

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: So Jul 04, 2010 18:00

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Normalen werden in jedem Fall pro Vertex gespeichert. Du scheinst hier Per-Face-Normalen verwenden zu wollen, bei GL_TRIANGLES würde hier die Normale einfach dreimal gespeichert. Bei GL_TRIANGLE_STRIP ist das nicht so einfach möglich, da die Vertices ja wieder verwendet werden.

Empfehlung:
Verwende Per-Vertex-Normalen, das sieht bei einem Terrain sowieso besser aus als Per-Face-Normalen. Berechne dazu für jeden Vertex den Durchschnitt aus den Normalen der 6 umliegenden Dreiecke. Wenn du willst kannst du auch noch eine Gewichtung z.B. nach Öffnungswinkel des Dreiecks am Vertex vornehmen. => So wirkt die Oberfläche wesentlich runder als sie eigentlich ist.

Falls du aus einem bestimmten Grund Per-Face-Normalen brauchst/willst, schau dir mal glShadeModel(GL_FLAT) an. Dort wird jeweils die Normale des letzten Vertex eines Dreiecks genommen.

_________________
Yeah! :mrgreen:

Nach oben

Pk3

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: So Jul 04, 2010 18:38

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Vielen Dank!
Hab das mit den Per-Vertex-Normalen gemacht und es hat funktioniert

.
Aber das Terrain wirkt jetzt so "weich", man sieht nicht richtig die Tiefe, weil zu viel beleuchtet ist...
Ist das normal? Oder kann ich da an den Normalen was verändern damit das "detalliertert" beleuchtet wird?

Hier ein Bild:

http://xyross.de/file.php?id=54

Mfg, Pk3

Nach oben

Coolcat

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: So Jul 04, 2010 19:19

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Ich würde sagen deine Normalen sind alle gleich bzw. nahezu gleich. Da ist irgendwas falsch in der Berechnung.

_________________
Yeah! :mrgreen:

Nach oben

damadmax

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 00:26

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

Hat jetzt zwar nichts mit den Normalen zu tun:

Kann es sein, dass du die Dreiecke doppelt zeichnest?

In der 2. Schleife wird x jeweils um 1 inkrementiert. Dann werden 4 Punkte ausgegeben. Einmal mit x und einmal mit x+1.

Soweit ich mich an Strips erinnere, gibt man doch zu Beginn 2 Punkte aus, die den Anfang bilden. Danach immer nur 2 weitere für jedes Stück vom Strip. Sprich für 2 Dreiecke braucht man 4 Punkte. Für 4 Dreiecke braucht man 6 Punkte. etc.

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next

Nach oben

Flash

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 07:55

Guitar Hero

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)

Das ist nicht richtig. Es wird für jedes(!) weitere Vertex ein neues Dreieck mit den beiden letzten Punkten des vorhergehenden Vertex erzeugt.
Gut zu sehen ist das hier: glBegin

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Nach oben

damadmax

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 08:02

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

Code:

Danach immer nur 2 weitere für jedes Stück vom Strip

Mit Stück meinte ich ein Quad.

Ist zugegebenermaßen nicht korrekt...habe das zu stark im Zusammenhang mit Terrainrendering betrachtet.

IMHO wird trotzdem zu viel gezeichnet.

Nach oben

Sellmann

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 13:30

DGL Member

Registriert: Fr Jan 04, 2008 21:29
Beiträge: 419
Wohnort: Lübeck

also entweder sind die normalen falsch berechnet, oder der Shader hat nen Fehler. Sieht so aus, als würde das Terrain mit zunehmender Entfernung vom Betrachter dunkler werden, was ja nicht ganz richtig ist. Ich würde mal darauf tippen, dass die falschen Vertexnormalen zusammen gerechnet wurden.

Sowas hab ich auch schonmal gemacht und hatte da ein ähnliches Problem. Am ende sah es dann aber so aus wie im angehängten Bild. Bei Bedarf schau ich heute Abend zu Hause gerne mal in meinen Sourcecode und guck ob ich da die entsprechenden Codezeilen ausfindig machen kann.

Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

_________________
Klar Soweit?

Nach oben

Pk3

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 14:35

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Zitat:

Kann es sein, dass du die Dreiecke doppelt zeichnest?

Hm...moeglich....leider gibt es so gut wie kein Tutorial zum Rendern eines
Terrains mit Triangle-Strips.

Passt das so?:

Code:

...
Vector.Conv(&vec1, x, heightmap[x][z], z);
Vector.Conv(&vec2, x+1, heightmap[x+1][z], z);
Vector.Conv(&vec3, x, heightmap[x][z+1], z+1);
Vector.Conv(&vec4, x+1, heightmap[x+1][z+1], z+1);

Vector.Normalize(&norm[0], &vec1);   // Vektor normalisieren und in norm[0] speichern
Vector.Normalize(&norm[1], &vec2);   // Vektor normalisieren und in norm[1] speichern
Vector.Normalize(&norm[2], &vec3);   // Vektor normalisieren und in norm[2] speichern
Vector.Normalize(&norm[3], &vec4);   // Vektor normalisieren und in norm[3] speichern

glNormal3f(norm[0].X, norm[0].Y, norm[0].Z);
glTexCoord2f((float)x/TERRAIN_TEXTURE_RES_X, (float)z/TERRAIN_TEXTURE_RES_Y);
glVertex3f(x, heightmap[x][z], z);

glNormal3f(norm[1].X, norm[1].Y, norm[1].Z);
glTexCoord2f((float)(x+1)/TERRAIN_TEXTURE_RES_X, (float)z/TERRAIN_TEXTURE_RES_Y);
glVertex3f(x+1, heightmap[x+1][z], z);

glNormal3f(norm[2].X, norm[2].Y, norm[2].Z);
glTexCoord2f((float)x/TERRAIN_TEXTURE_RES_X, (float)(z+1)/TERRAIN_TEXTURE_RES_Y);
glVertex3f(x, heightmap[x][z+1], z+1);

glNormal3f(norm[3].X, norm[3].Y, norm[3].Z);
glTexCoord2f((float)(x+1)/TERRAIN_TEXTURE_RES_X, (float)(z+1)/TERRAIN_TEXTURE_RES_Y);
glVertex3f(x+1, heightmap[x+1][z+1], z+1);

...

Das mit dem Durchschnitt berechnen hab ich jetzt nich mit gepostet, da es sonst unübersichtlich wird :wink:

.

Hier noch der Vertex- und Fragmentshader:

Code:

varying vec3 pos;
varying vec3 vNormal;
varying vec4 color;

void main(void) {
   vNormal = normalize(gl_NormalMatrix * gl_Normal);
   pos = vec3(gl_ModelViewMatrix * gl_Vertex);

   color     = gl_Color;
   gl_TexCoord[0] = gl_MultiTexCoord0;
   gl_Position    = gl_ModelViewProjectionMatrix * gl_Vertex;
}

Code:

varying vec3 pos;
varying vec3 vNormal;
varying vec4 color;
uniform sampler2D Texture0;

void main(void) {
   vec3 normal = normalize(vNormal);
   vec3 lightDistance = normalize(gl_LightSource[0].position - pos);
   vec3 dir = dot(normal, lightDistance);
   vec3 Eye       = normalize(-pos);
   vec3 Reflected = normalize(reflect(dir, normal)); 

   vec4 IAmbient  = gl_LightSource[0].ambient * gl_FrontMaterial.ambient;
   vec4 IDiffuse  = gl_LightSource[0].diffuse * dot(normal, lightDistance) * gl_FrontMaterial.diffuse;
   vec4 ISpecular = gl_LightSource[0].specular * 1 * gl_FrontMaterial.specular;

   gl_FragColor = vec4((gl_FrontLightModelProduct.sceneColor + IAmbient + IDiffuse) * texture2D(Texture0, vec2(gl_TexCoord[0])) + ISpecular);
   gl_FragColor.w = 1.0;
}

Nach oben

Coolcat

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 14:53

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Code:

vec4 ISpecular = gl_LightSource[0].specular * 1 * gl_FrontMaterial.specular;

Soll dein Specular-Licht immer mit voller Stärke addiert werden? Normalerweise berechnet man da einen Faktor etwa so:

Code:

float specularFactor = max(dot(Reflected, Eye), 0.0);
specularFactor = pow(specularFactor, gl_FrontMaterial.shininess);
vec4 ISpecular = gl_LightSource[0].specular * specularFactor * gl_FrontMaterial.specular;

Zitat:

Das mit dem Durchschnitt berechnen hab ich jetzt nich mit gepostet, da es sonst unübersichtlich wird :wink:

*hust, wenn wie hier von einigen vermutet deine Normalen falsch sind solltest du vielleicht den Abschnitt in dem du die Normalen berechnest posten

Code:

Vector.Conv(&vec1, x, heightmap[x][z], z);
Vector.Conv(&vec2, x+1, heightmap[x+1][z], z);
Vector.Conv(&vec3, x, heightmap[x][z+1], z+1);
Vector.Conv(&vec4, x+1, heightmap[x+1][z+1], z+1);

Vector.Normalize(&norm[0], &vec1);   // Vektor normalisieren und in norm[0] speichern
Vector.Normalize(&norm[1], &vec2);   // Vektor normalisieren und in norm[1] speichern
Vector.Normalize(&norm[2], &vec3);   // Vektor normalisieren und in norm[2] speichern
Vector.Normalize(&norm[3], &vec4);   // Vektor normalisieren und in norm[3] speichern

Das sieht so aus als würdest du die Vertexposition normalisieren und dann als Normale benutzen. Ich vermute das ist der Teil wo du Code ausgelassen hast. Allerdings würde es ziemlich genau deinen Screenshot erklären...die Normalen sind alle nahezu gleich, aber ändern sich doch...daher der leichte Farbverlauf.

_________________
Yeah! :mrgreen:

Nach oben

Pk3

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 15:03

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Zitat:

Soll dein Specular-Licht immer mit voller Stärke addiert werden?

Das klappt net ganz, weil manchmal ein Teil der Fläche komplett schwarz ist, deswegen lass ichs immer auf 1 :wink:

.

Hier der gesamte Code:

Code:

BYTE cnt = 0;
for(z = 0; z < length-1; z++) {
    glBegin(GL_TRIANGLE_STRIP);
    for(x = 0; x < width-1; x++) {
        Vector.Conv(&vec1, x, heightmap[x][z], z);
        Vector.Conv(&vec2, x+1, heightmap[x+1][z], z);
        Vector.Conv(&vec3, x, heightmap[x][z+1], z+1);
        Vector.Conv(&vec4, x+1, heightmap[x+1][z+1], z+1);

        Vector.Normal(&vec2, &vec4, &vec3, &norm3);

   // Normalen dieses Triangle_Strips zu den anderen Normalen hinzufügen
        Vector.Normalize(&normal[cnt][0], &vec1);
        Vector.Normalize(&normal[cnt][1], &vec2);
        Vector.Normalize(&normal[cnt][2], &vec3);
        Vector.Normalize(&normal[cnt][3], &vec4);

        // Normalen zurücksetzen
        Vector.Conv(&norm[0], 0, 0, 0);
        Vector.Conv(&norm[1], 0, 0, 0);
        Vector.Conv(&norm[2], 0, 0, 0);
        Vector.Conv(&norm[3], 0, 0, 0);

   // Alle Normalen der letzten Triangle_Strips addieren
        for(j = 0; j < cnt; j++) {
            // Alle Normalen zusammenzählen
            norm[0].X += normal[j][0].X;
            norm[0].Y += normal[j][0].Y;
            norm[0].Z += normal[j][0].Z;

            norm[1].X += normal[j][1].X;
            norm[1].Y += normal[j][1].Y;
            norm[1].Z += normal[j][1].Z;

            norm[2].X += normal[j][2].X;
            norm[2].Y += normal[j][2].Y;
            norm[2].Z += normal[j][2].Z;

            norm[3].X += normal[j][3].X;
            norm[3].Y += normal[j][3].Y;
            norm[3].Z += normal[j][3].Z;
        }
        // Alle Normalen durch die Anzahl der Additionen teilen
        norm[0].X /= cnt;
        norm[0].Y /= cnt;
        norm[0].Z /= cnt;
        norm[1].X /= cnt;
        norm[1].Y /= cnt;
        norm[1].Z /= cnt;
        norm[2].X /= cnt;
        norm[2].Y /= cnt;
        norm[2].Z /= cnt;
        norm[3].X /= cnt;
        norm[3].Y /= cnt;
        norm[3].Z /= cnt;

        // Counter erhoehen
        cnt++;
   // Nicht mehr als 6 Triangle_Strips!
        if(cnt>6) cnt=6;

        glNormal3f(norm[0].X, norm[0].Y, norm[0].Z);
        glTexCoord2f((float)x/TERRAIN_TEXTURE_RES_X, (float)z/TERRAIN_TEXTURE_RES_Y);
        glVertex3f(x, heightmap[x][z], z);

        glNormal3f(norm[1].X, norm[1].Y, norm[1].Z);
        glTexCoord2f((float)(x+1)/TERRAIN_TEXTURE_RES_X, (float)z/TERRAIN_TEXTURE_RES_Y);
        glVertex3f(x+1, heightmap[x+1][z], z);

        glNormal3f(norm[2].X, norm[2].Y, norm[2].Z);
        glTexCoord2f((float)x/TERRAIN_TEXTURE_RES_X, (float)(z+1)/TERRAIN_TEXTURE_RES_Y);
        glVertex3f(x, heightmap[x][z+1], z+1);

        glNormal3f(norm[3].X, norm[3].Y, norm[3].Z);
        glTexCoord2f((float)(x+1)/TERRAIN_TEXTURE_RES_X, (float)(z+1)/TERRAIN_TEXTURE_RES_Y);
        glVertex3f(x+1, heightmap[x+1][z+1], z+1);
    }
    glEnd();
}

Nach oben

Coolcat

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 15:25

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

1. Du initialisierst die Variable cnt (wozu auch immer sie gut sein soll) mit 0 und teilst dann norm[*][*] durch cnt, also 0. Division durch Null!
2. Du betrachtest nur vier Vertices. Um die Normalen der umliegenden 6 Dreiecke eines Vertex zu berechnen musst du aber insgesamt 7 Vertices betrachten:

Dateianhang:

terrain.png

3. Du gibst pro Quad immer noch 4 Vertices aus, obwohl es nur zwei sein dürften (zuzüglich den beiden Startvertices)

Zitat:

Das klappt net ganz, weil manchmal ein Teil der Fläche komplett schwarz ist,

Das wird daran liegen das die Normalen falsch sind. Aber da hilft es dann auch nichts das Terrain mit Specular-Licht aufzuhellen

. Zum aufhellen ist eigentlich auch das Ambient-Licht da.

Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

_________________
Yeah! :mrgreen:

Nach oben

Pk3

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 15:49

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Das mit den Normalen berechnen ist richtig oder?
Ich berechne für jedes Triangle-Strip 4 Normalen von den 4 Vertexen.

Code:

                    Vector.Conv(&vec1, x, heightmap[x][z], z);
                    Vector.Conv(&vec2, x+1, heightmap[x+1][z], z);
                    Vector.Conv(&vec3, x, heightmap[x][z+1], z+1);
                    Vector.Conv(&vec4, x+1, heightmap[x+1][z+1], z+1);

        Vector.Normalize(&normal[cnt][0], &vec1);
        Vector.Normalize(&normal[cnt][1], &vec2);
        Vector.Normalize(&normal[cnt][2], &vec3);
        Vector.Normalize(&normal[cnt][3], &vec4);

Nach oben

Coolcat

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 16:02

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Zitat:

Ich berechne für jedes Triangle-Strip 4 Normalen von den 4 Vertexen.

....nochmal....es sollten nur 2 Vertices sein. Versuchst du vielleicht die Triangle-Strips als Quads zu benutzen und hast deswegen immer 4 Vertices?

_________________
Yeah! :mrgreen:

Nach oben

Pk3

Betreff des Beitrags: Re: Normalen für TRIANGLE_STRIP

Verfasst: Mo Jul 05, 2010 16:07

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Ne, aber mit 2 Vertices wird garnichts angezeigt :/.

Edit: Doch, jetzt wirds angezeigt

Code:

                    Vector.Conv(&vec1, x, heightmap[x][z], z);
                    Vector.Conv(&vec2, x+1, heightmap[x+1][z+1], z+1);

                    Vector.Normalize(&normal[cnt][0], &vec1);
                    Vector.Normalize(&normal[cnt][1], &vec2);

                    // Normalen zurücksetzen
                    Vector.Conv(&norm[0], 0, 0, 0);
                    Vector.Conv(&norm[1], 0, 0, 0);

                    // Counter erhoehen
                    cnt++;
                    if(cnt>7) cnt=7;

                    for(j = 0; j < cnt; j++) {
                        // Alle Normalen zusammenzählen
                        norm[0].X += normal[j][0].X;
                        norm[0].Y += normal[j][0].Y;
                        norm[0].Z += normal[j][0].Z;

                        norm[1].X += normal[j][1].X;
                        norm[1].Y += normal[j][1].Y;
                        norm[1].Z += normal[j][1].Z;
                    }

                    // Alle Normalen durch die Anzahl der Additionen teilen
                    norm[0].X /= cnt;
                    norm[0].Y /= cnt;
                    norm[0].Z /= cnt;
                    norm[1].X /= cnt;
                    norm[1].Y /= cnt;
                    norm[1].Z /= cnt;

                    glNormal3f(norm[0].X, norm[0].Y, norm[0].Z);
                    glTexCoord2f((float)x/TERRAIN_TEXTURE_RES_X, (float)z/TERRAIN_TEXTURE_RES_Y);
                    glVertex3f(x, heightmap[x][z], z);

                    glNormal3f(norm[1].X, norm[1].Y, norm[1].Z);
                    glTexCoord2f((float)(x+1)/TERRAIN_TEXTURE_RES_X, (float)(z+1)/TERRAIN_TEXTURE_RES_Y);
                    glVertex3f(x+1, heightmap[x+1][z+1], z+1);

Das mit den drumherumliegenden Vertices hab ich ja mit dieser For - Schleife gemacht.

Nach oben

Seite 1 von 2

[ 29 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.