HI,

ich hab mich gestern mit Bumpmaping beschäftigt und irgendwie bekomm ich's nich so richtig auf die Reihe. Ich hab mich strikt ans Tutorial gehalten, aber ich bekomm nur nen schwarzen Bildschirm. Jmd ne Idee was ich falsch mach? hier mein Code dazu:


MfG & Thx Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Ich habs auch nach dem Tutorial gemacht ... Leider mit geringen / keinem Erfolg. Außerdem sind die Funktionen (zumindest theoretisch) auf nVidia beschränkt. Wenn also jemand eine Lösung dazu weiß... Ich bin damals zu Shadern übergelaufen.

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Also Bumpmapping schreit förmlich nach Shadern. Dürfte wahrscheinlich wesentlich einfacher sein als irgendwelche komischen Extensions zu benutzen.

Vorgehen:

1. fange mit einem einfachen Per-Pixel-Light-Shader an, siehe Shadersammlung
2. gebe deinem Mesh zusätzlich zur Normale auch noch eine Tangente mit auf den Weg
3. füge die Normalmap als Textur im Fragmentshader hinzu
4. konstruiere im Fragmentshader aus Normale, Tangente und cross(Normale, Tangente) eine Matrix (alle drei Vektoren müssen normalisiert werden)
5. lade die Normale aus der Normalmap...also Farbwert (RGB) lesen und in Normale (XYZ) umwandeln, meist -0.5 und dann normalisieren.
6. transformiere die Normale aus der Normalmap mit der konstruierten Matrix
7. verwende den resultierenden Vektor als Normale bei der Lichtberechnung

_________________
Yeah!

Uff,

da muss ich mich erstma in die Shader einarbeiten... naja wollt ich früher oder später sowieso machen^^
Spricht was dagegen das ich gleich den BumpMapShader nehm, bzw was hat deine Methode für Vorteile?

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Der von dir verlinkte Shader funktioniert, wenn ich das auf den ersten Blick richtig sehe, nur auf einer ebenen Fläche. Die Normalen der Normalmap müssen transformiert werden, das wird in den meisten Samples vergessen...sobald man dann echte Objekte (schon bei einer Kugel würde es Probleme geben) mit einer Bumpmap versehen möchte steht man auf den Schlauch.

Zudem handelt es sich nicht um einen GLSL-Shader, sondern um einen Cg-Shader, würde also eh nur wenig helfen.

Mir fällt da übrigens ein das natürlich auch die Vertex-Normale und -Tangente noch mit gl_NormalMatrix transformiert werden müssen bevor man die Matrix baut.

_________________
Yeah!

Das Tutorial ist wirklich nicht mehr zeitgemäß. Die Lichtrichtung muss für jeden Vertex in seiner Farbe gespeichert werden. Weiß ich jetzt nicht ob du daran gedacht hast, kann man in dem Code ja nicht sehen.

Ansonsten kann ich den anderen nur zustimmen. GLSL ist um einiges intuitiver und ich hab' es bisher in keinster Weise bereut, es gelernt zu haben.
Was aber ein bischen nervig werden kann, ist die Berechnung der Tangente, die in die Richtung zeigen soll wo bei der Textur oben (oder unten?) ist. Einen ganz wasserdichten Weg hab' ich da auch noch nicht gefunden.
In dem Zusammenhang ist es vielleicht auch gut, sich anzuschauen wie das mit den Attributen und VBOs funktioniert, was mich damals auch einige Zeit gekostet hat.
Mit anderen Worten: Es kann unter Umständen lange dauern bis das alles dann so funktioniert wie es soll, ABER es lohnt sich.

Es darf gern auch ein funktionierender GLSL Bumpmap Shader in die Übersicht gestellt werden.

Wir sind da gar nicht so....

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

Für nen Bumpmapping-shader in glsl hab ich da mal ein Beispiel, das bei mir ganz gut funktioniert hat, ALLERDINGS hab ich bei mir für die Tangente das Tangent Attribute benutzt, wofür ich kritisiert worden bin, weil es hieß, dass es das nicht geben würde und auch nicht funktionieren kann. Bei mir jedenfalls zeigte es korrekte Resultate. Aus diesem Grund habe ich das Attribute provisorisch in ein Uniform umgewandelt, so, dass man die Tangente im Vorwege selbst errechnen muss.
Des Weiteren berechne im Fragmentshader die Normale, in dem ich die Y-Komponente der Bumpmap umdrehe. Das hat was damit zu tun, dass meine Bumpmap früher in die falsche Richtung zeigte. Je nachdem, wie die Bumpmap erstellt wird muss das geändert werden.
Ich werde den Shader selbst nicht in die Shadersparte stellen, da ich mir bei dem Stück nicht sicher bin, ob es tatsächlich allgemeingültig funktioniert, nur weil es bei mir funktionierte. Den Code der Anwendung in der das lief habe ich nicht mehr zu Verfügung, jedoch kann ich auf Wunsch eine Win32.exe bereitstellen, allerdings ohne passende Texturen, da ich selbst welche zu eigenen Zwecken irgendwo bei Google genommen habe ohne auf irgendwelche Rechte zu achten.

Hier der Vertexshader:


Und passend dazu der Fragmentshader:


An der Stelle im Fragmentshader, an der ich das Specular berechne, benutze ich derzeit eine Konstante, aber die kann variabel gestaltet werden, um einen härteren oder weicheren Glanz zu erzeugen. Die Sichtbarkeit des Specular ist der Alphawert der Colormap (könnte man auch in den Alphawert der Bumpmap packen).

Alles in allem wünsche ich viel Spaß damit.

_________________
Klar Soweit?

Die Tangente muss genau wie die Normale pro Vertex geliefert werden. Das mit dem Uniform ist daher etwas sinnlos. Im Standbild wirst du da zwar vermutlich keine Probleme feststelle, aber wenn du die Objekte in einer Animation rotierst möglicherweise schon. Vermutlich hattest du damals so was hier verwendet:

Selbst definierte Attribute gibt es noch nicht solange, vermutlich wurdest du deshalb damals kritisiert. Müsste aber Teil von OpenGL 2.1 sein und sollte somit mittlerweile überall verfügbar sein. In OpenGL 3.x und OpenGL ES 2.0 bzw. WebGL gibt es gar nichts anderes mehr.

_________________
Yeah!

@Coolcat: Stimmt, das mit der Tangente pro Vertex macht Sinn! Kann sein, dass ich das deshalb nicht gemerkt habe, weil ich wie im Beispiel nur Klötze damit gerendert habe und da eine Tangente pro Face reicht. Man müsste also die Tangente im Vertexshader anhand der Vertexnormale und Texturkoordinaten errechnen. Ich glaub ich hab da auch noch nen Code schnippsel zu. Da muss ich dann aber erstmal ne ganze Weile suchen. Also wenn jemand sowas fix parat hat, dann kann man das oben im Code sicherlich schnell einbauen.

_________________
Klar Soweit?

Direkt im Shader wird wohl nicht gehen, weil man auch die Texturkoordinaten von den angrenzenden Vertices braucht und auf die kann man im Vertexshader meines Wissens nicht zugreifen. Möglicherweise geht das mit Geometry-Shadern, ist aber auch ein bischen sinnlos, die immer wieder neu zu berechnen.

bei nicht-animierten Modellen macht das natürlich kein Sinn, dann sollte man die Tangenten tatsächlich im vorraus berechnen und fix mit übergeben. Ist das Modell allerdings in ständiger Animation, so ändern sich die Normalen höchstwahrscheinlich, da sich das Mesh ja verformen könnte und dann muss man die Normalen eh neu berechnen und kann dann auch die Tangenten im Geometry Shader gleich mit berechnen. Ich glaube das ist besser, als wenn man das auf der CPU macht.

Bis ich das ausprobieren kann dauerts wohl (leider) noch ne Weile...

Nebenbei: Falls jemand nen Ansatz hat, um aus vorhandener Normal, Texturkoordinaten und Adjazenzvertieces die Tangenten zu berechnen, ist herzlich dazu eingeladen den Schritt zu ergänzen, denn ohne ist ein Bump-Mapping-Shader nutzlos (bzw. sehr eingeschränkt nutzbar).

_________________
Klar Soweit?

Wie wäre es die Ableitung der Texturkoordinaten zu verwenden? Im Fragmentshader gibt es die Funktionen dFdx() und dFdy() um die Ableitung zu berechnen. Dazu wird Information von benachbarten Pixeln verwendet. Damit hätte man den Gradienten (x,y) der Texturkoorinaten der Schlüsse auf die Ausrichtung der Textur zulässt. Durch das Kreuzprodukt von Normale und Gradient (x,y,0) könnte man damit eine Tangente gewinnen. Diese Tangente muss man dann glaub ich noch um 45 Grad entlang der Normale drehen, damit das richtig ist. Keine Ahnung ob das funktioniert, aber könnte ja mal jemand implementieren Hätte den Vorteil das man keinen Geometryshader braucht.

_________________
Yeah!

Hey,

ich hab mich gestern erfolgreich in glSlang eingearbeitet. Und jetz hab ich 2 Fragen:
1. Wo hin genau zeigt jetzt die Tangente? Wenn ich das richtig verstanden habe ist das die Normale des Triangles, oder?
2. Wie übergeb ich die jetzt am bessten? Über ne Uniform und dann jedesmal bevor ich glVertex aufruf, oder geht das doch anders?

€: Hab grad was dazu gefunden: wenn die zeichnung (siehe anhang) so stimmt, dann müsste man das VectorProdukt von Gradient und Normale um 90° mit der Normalen als Achse drehen, um auf die tangente zu kommen, is das so richtisch?

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Normal, Tangent und Bitangente beschreiben das Koordinatensystem der Textur auf der Fläche. Wenn ich mich nicht irre, dann ist die Tangente die räumlich betrachtete X-Achse der Textur auf der Fläche und die Bitangente die räumliche Y-Achse der Textur auf Fläche. Die Normale ist dem entsprechend die räumliche Z-Achse der Fläche UND Textur, die man glücklicherweiße ganz einfach aus dem Kreuzprodukt der FlächenKanten bekommt. Die Normale steht also Senkrecht auf der Fläche (im übertragenden Sinne, denn je nach umliegenden Faces kann die endgültige Normale auch ein Mittelwert der umliegenden Face-Normalen sein). Bei den 3 Vektoren darf man natürlich das normalisieren nicht vergessen, sonst kommt da murks rauß.

Die Normalen kann man im immediate-mode vor glVertex3f mit dem Befehl glNormal3f(); übergeben. Bei VBOs braucht man dafür ein Format, dass Normalen berücksichtigt, dass ist aber in der Regel kein Problem, da es mehrere passende Formate dafür gibt.

Ob das mit dem Gradient funktioniert weiß ich nicht genau, ich arbeite immer noch an einem Ansatz um Tangente und Bitangente aus den Texturkoordinaten und Vertex-Koordinaten zu errechnen, da diese ausschlaggebend dafür sind.

_________________
Klar Soweit?