Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

OpenGL - NeHe Lesson 22: Ich versteh nur Bahnhof. :(

Werbeanzeige

EyesKiller

Frischling

  • »EyesKiller« ist der Autor dieses Themas

Beiträge: 13

  • Private Nachricht senden

1

01.02.2010, 23:07

OpenGL - NeHe Lesson 22: Ich versteh nur Bahnhof. :(

Hi Leute, ich arbeite NeHe-Tuts durch. Mir ist bewusst daß diese Tut nicht besonders aktuell ist, aber wenigstens ist es eine ziemlich gute Tutorium, auch wenn es leider häufiger Fehler enthält.

Bis Lesson 21 war für mir absolut kein Problem und habe ziemlich alles verstanden. Aber Lesson 22... :shock:

Exakt so fühle ich mich dabei:
NeHe-Lesson22 ->

(Link)
<- Ich

Es geht zwar um BumpMap, aber kennt vielleicht jemand bessere/einfachere Erklärung? Wenigstens habe ich die Source "erfolgreich" in QT4 "portiert".

cu Floh

Alyx

Treue Seele

Beiträge: 236

Wohnort: Hannover

Beruf: Head Of Software Development

  • Private Nachricht senden

2

02.02.2010, 11:15

Ich kann dir gerne bei Detailfragen helfen, da ich das alles schonmal irgendwann gemacht habe, allerdings kann ich natürlich hier keinen kompletten Roman schreiben und dir Zeilenweise das ganze Tutorial erläutern ;-).

Davon aber mal ganz ab muss ich dir gleich sagen, dass das Tutorial extrem veraltet ist, denn Offset Bump Mapping hab ich glaube ich zuletzt 2003 verwendet... und da wir mittlerweile das Jahr 2010 schreiben.... joar ;-).

Im Prinzip läuft es aber so:
Du zeichnest drei Texturen, einmal die Basistextur, einmal die Graustufen-Höhenkarte und einmal die invertierte Graustufenkarte.

Wenn das Licht genau hinter dir wäre, würde keine der Offset-Maps verschoben, das Ergebnis wäre also z. Bsp.

Basistextur * ((0.76 (Höhenkarte) + 0.24 (inv. Höhenkarte))*0.5+0.5).

Es würde also gar nichts passieren, da der Farbwert der Textur ja mit 1.0 multipliziert würde.

Je nach Winkel zwischen dir, dem Objekt und dem Licht verschiebst du die nicht invertierte Höhenkarte. Dadurch erhälst du dann eine Aufhellung bzw. Verdunklung an den entsprechenden Stellen und damit den erwünschten Bump-Effekt.

Heute verwendet man andere Techniken wie Dot3-Bumpmapping.

LG
Alyx

EyesKiller

Frischling

  • »EyesKiller« ist der Autor dieses Themas

Beiträge: 13

  • Private Nachricht senden

3

02.02.2010, 11:22

Hi, ich versuche mein Verständnisprobleme in kleinere Teilen (Fragen) aufzuteilen um die Erklärungen in Lesson22 wenigstens StepByStep zu verstehen.

Die erste Frage geht um die N-Vektor, S-Vektor und T-Vektor.

N-Vektor ist die Normale d.h. von der Vorderseite ausgehend weg (einfach ausgedrück N-Vektor = Vektor die man in glNormal3f(...) eingibt) soweit richtig verstanden?

Und S-Vektor und T-Vektor??? Ich habe schon versucht mit 3-Finger-Regel (Daumen=N, Zeigefinger-S, T-Stinkefinger) an der 0,0 (von TexturKoordinaten) anzuwenden. Das klappt zumindest die ersten 3Flächen ganz gut:

Quellcode

 
1
2
3

    // front face
    // back face
    // top face


Bei "bottom face" scheiterts aber die 3-Finger-Regel.
Gegeben ist die Flächenkoordinaten in der Reihenfolge:
2xTexCoord X, Y 3xVertCoord X, Y, Z

Quellcode

 
1
2
3
4
5

    // bottom face
    1.0f, 1.0f, -1.0f,-1.0f,-1.0f,
    0.0f, 1.0f,  1.0f,-1.0f,-1.0f,
    0.0f, 0.0f,  1.0f,-1.0f, 1.0f,
    1.0f, 0.0f, -1.0f,-1.0f, 1.0f,


Laut NeHe-Tut in der Funktion doMesh1TexelUnits (kommentar von mir zu Verständnis eingefügt):

Quellcode

 
1
2
3
4
5
6
7
8
9
10

// bottom face
n[0]=0.0f;
n[1]=-1.0f; // nach unten
n[2]=0.0f;
s[0]=-1.0f; // nach links
s[1]=0.0f;
s[2]=0.0f;
t[0]=0.0f;
t[1]=0.0f;
t[2]=-1.0f; // "zu mir"


Ich hätte es so verstanden und gemacht:

Quellcode

 
1
2
3
4
5
6
7
8
9
10

// bottom face
n[0]=0.0f;
n[1]=-1.0f; // nach unten
n[2]=0.0f;
s[0]=0.0f;
s[1]=0.0f;
s[2]=-1.0f; // "zu mir"
t[0]=-1.0f; // nach links
t[1]=0.0f;
t[2]=0.0f;
Die Paare s[0] - s[2] und t[0] - t[2] sind also vertauscht.

Wo ist meine Denkfehler oder einfach gesagt wie erkenne ich in welche Richtung T und S gehen? Liege ich überhaupt richtig daß man immer an die Ecke von TexCoord 0,0 anwendet? Ist die 3-Finger-Regel (meine Idee) vielleicht gar nicht anwendbar?

cu Floh

EyesKiller

Frischling

  • »EyesKiller« ist der Autor dieses Themas

Beiträge: 13

  • Private Nachricht senden

4

02.02.2010, 11:32

Hi Alyx,
vielen Dank für die Feedback! :)

Zitat von »"Alyx"«

Davon aber mal ganz ab muss ich dir gleich sagen, dass das Tutorial extrem veraltet ist, denn Offset Bump Mapping hab ich glaube ich zuletzt 2003 verwendet... und da wir mittlerweile das Jahr 2010 schreiben.... joar ;-).
Ich hätte das sowieso später gefragt wie das heutzutage angewendet wird. ;) Nur wollte ich nicht, daß man antwortet "Brauchst Du heute eh nicht." weil ich mich dafür auch interessiere und immer versuche es zu verstehen.

Zitat

Im Prinzip läuft es aber so:
Du zeichnest drei Texturen, einmal die Basistextur, einmal die Graustufen-Höhenkarte und einmal die invertierte Graustufenkarte.
Soweit habe ich bisher grob verstanden außer daß es invertierte Graustufenkarte gibt. (Irgendwie hab ich vergessen daß noch invertierte Bump existiert :oops: )
Aber wenn ich nachdenke (vorsicht, ich denke viel! ;) )
die "Höhenkarte" (für Licht) geht in die Richtung wo die Licht ist (natürlich bleibt es auf selbe Fläche wie die Farbtextur aber etwas versetzt) und die Invertierte Texture (für Schatten) wird vom Licht weggeschoben.

Zitat

Wenn das Licht genau hinter dir wäre, würde keine der Offset-Maps verschoben, das Ergebnis wäre also z. Bsp.

Basistextur * ((0.76 (Höhenkarte) + 0.24 (inv. Höhenkarte))*0.5+0.5).

Es würde also gar nichts passieren, da der Farbwert der Textur ja mit 1.0 multipliziert würde.
Soweit ich verstanden habe wäre N-Vektor mit L-Vektor (das ist doch die Vektor zum Licht, oder?) identisch und die beide Texturen (Höhenkarte und Invertierte Textur) werden um 0 nach "vorne" (zum Licht) und nach "hinten" (weg von Licht) verschoben und hebt sich gegenseitig auf. Habe ich soweit korrekt verstanden?

Sind das die Zahlen 0.76 und 0.24 Konstanten? Oder eher Werte die man "justieren" kann. Irgendwo hab ich in etwa so verstanden: Je höher die Wert, desto mehr unerwünschte Artefakten (glaub am Rand) können auftauchen. Ist das dieselbe Wert von dem wir sprechen?

Zitat

Je nach Winkel zwischen dir, dem Objekt und dem Licht verschiebst du die nicht invertierte Höhenkarte. Dadurch erhälst du dann eine Aufhellung bzw. Verdunklung an den entsprechenden Stellen und damit den erwünschten Bump-Effekt.
So wie ich diese Abschnitt lese, scheine ich mit die letzten 2 Absätze (wohin die 2 Texturen verschoben werden) falsch verstanden zu haben, oder? Ich bin heute ab Mittag den ganzen Tag unterwegs. Aber wenn ich wieder Zeit habe, werde ich versuchen, das was ich verstanden habe hier in Grafik darzustellen.

cu Floh

Alyx

Treue Seele

Beiträge: 236

Wohnort: Hannover

Beruf: Head Of Software Development

  • Private Nachricht senden

5

02.02.2010, 11:35

Bzgl. der 0.76: Nein, das waren nur Beispielwerte :-). Angenommen du hast eine Höhentextur, die von 0.0 (ganz unten) bis 1.0 (ganz oben geht). Und an einer Stelle hast du nun 0.76 als Farbwert in deiner Graustufenhöhenkarte. Dann ist der invertierte Wert 0.24. Addierst du die beiden Zahlen erhälst du 1.0. Wenn du das mit dem Farbwert deiner Basistextur multiplizierst, passiert genau gar nichts, sprich wenn weder die normale Graustufenkarte noch die invertierte verschoben sind, heben sie sich gegenseitig auf, so dass keine Aufhellung/Abdunklung auftritt.
Je nachdem wie der Winkel zwischen dem Licht, dem Objekt und dir aussieht, verschiebst du nun eine der beiden Texturen, wodurch du dann an den Höhenkannten zum Teil plötzlich 0.9 und an anderen Stellen zum Beispiel 1.1 erhälst, wodurch die Kannten auf der einen Seite aufgehellt werden (als würde das Licht dagegen strahlen) und an der anderen abgedunkelt (als lägen sie im Schatten).

Zu s & t:

Mit s und t sind hier Tangenten und Binormal-Vektor gemeint, sprich in welche Richtung die U (X-Achse) und die V (Y-Achse) deiner Textur in der Welt zeigen.

Sprich wenn du flach vor einen Würfel guckst, der simpel von vorne texturiert ist, dann zeigt die U-Achse der Textur nach rechts (+X) und die U-Achse nach oben (+Y).

Schaust du vor die linke Seite, dann zeigt die U-Achse nach +Z und die V-Achse nach wie vor nach oben (+Y).

Schaust du oben auf den Würfel, dann schaut U nach +X und V nach -Z.

Stell dir vor du malst zwei Pfeile auf deine Textur, einen blauen von links nach rechts und einen roten von unten nach oben. In die Richtung, in die diese Pfeile dann zeigen, das sind die zwei Vektoren die du brauchst :-):

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

for( int i=0; i<~mlIndices/3; ++i )
   {         
      int off = i*3;
      AVector3DD   p21      = mVertices[mlIndices[off+1]].mCoord-mVertices[mlIndices[off+0]].mCoord,
         p31      = mVertices[mlIndices[off+2]].mCoord-mVertices[mlIndices[off+0]].mCoord,
         uv21   = mVertices[mlIndices[off+1]].mTexCoords[0]-mVertices[mlIndices[off+0]].mTexCoords[0],
         uv31   = mVertices[mlIndices[off+2]].mTexCoords[0]-mVertices[mlIndices[off+0]].mTexCoords[0];

      AVector3DD   tangent      = (p21*uv31.mY)-(p31*uv21.mY),
         binormal   = (p31*uv21.mX)-(p21*uv31.mX);

      for( int side=0; side<3; ++side )
      {         
         mVertices[mlIndices[off+side]].mTangent += tangent.Normalize();
         mVertices[mlIndices[off+side]].mBinormal += binormal.Normalize();
      }

      /*
      (v3 - v1).(p2 - p1) - (v2 - v1).(p3 - p1)
      T = ---------------------------------------
      (u2 - u1).(v3 - v1) - (v2 - v1).(u3 - u1)

      (u3 - u1).(p2 - p1) - (u2 - u1).(p3 - p1)
      B = ---------------------------------------
      (v2 - v1).(u3 - u1) - (u2 - u1).(v3 - v1)   */
   }


LG
Alyx

EyesKiller

Frischling

  • »EyesKiller« ist der Autor dieses Themas

Beiträge: 13

  • Private Nachricht senden

6

05.02.2010, 15:41

Hi, vielen Dank für die Mühe. Ich habe mir Zeit genommen, Deine Erklärung in der Ruhe zu lesen.
Außerdem habe ich zusätzlich eine 3D-Skizze von der Würfel angefertigt und festgestellt daß ich vor paar Tagen bei der Bottom-Face die Koordinaten vertauscht habe. :roll: Nun scheint meine "3-Finger-Regel" doch zu funktionieren und anhand Deiner Erklärung, bezüglich n-, s-, t-Vektoren, (Danke!) konnte ich mich bestätigen daß ich bisher doch richtig verstanden habe. :)

Bevor ich Deine Code-Beispiel verstehe muß ich noch wissen, was der Unterschied zwischen Verticles (Vertex) und Indicles (Index) ist. Besteht ein Vertex aus 3 Indexen, richtig?

AVector3DD ist ein Vektor mit 3 Werte (Doubles), stimmts?

Ich hoffe ich stelle mich nicht dämlich an. (Deutsch ist nicht unbedingt meine Stärke :( )

cu Floh

Alyx

Treue Seele

Beiträge: 236

Wohnort: Hannover

Beruf: Head Of Software Development

  • Private Nachricht senden

7

05.02.2010, 15:55

Indices = Index in der Vertex-Liste... man könnte auch sagen "Pointer" ;-)
Vertex = Koordinate, Texturkoordinate etc.

Am "runden Kannten" teilen sich die Indices das selbe Vertex, an eckigen hat jedes Dreieck seine eigenen.

Und genau, AVector3DD enthält XYZ. :-).

LG
Alyx

EyesKiller

Frischling

  • »EyesKiller« ist der Autor dieses Themas

Beiträge: 13

  • Private Nachricht senden

8

05.02.2010, 23:21

Ok, alles klar! Vielen Dank! :)

Werbeanzeige