Hallo,
ich habe eine Szene, über die ich vorher nichts weiss, die von OpenGL gerendert wird. Nun möchte ich zu jedem (sichtbaren) Punkt des gerenderten Bildes die Normale wissen (die Normierung ist logischerweise egal, es handelt sich ja um einzelne Punkte), die Z-Richtung bzgl der Kamera ist auch nicht wichtig.
Es gibt viele Programme, die einen sogenannten G-Buffer für jeden Pixel haben, aber irgendwie habe ich dazu noch keinen Code (am besten in C++) finden können. Die Lösung sollte Grafikkarten- und Betriebssystemunabhängig sein. Man könnte einen ganzen Renderer schreiben, aber ich denke, es gibt eine sehr einfache Lösung, die ich bisher übersehen habe !?
Hat jemand eine Idee ? Gibts ein Tutorial, dass ich noch nicht gefunden habe ? Vielen Dank schonmal,... orph

Wenn du den Rendervorgang selbst beeinflussen kannst wäre das Problem deutlich leichter und exakter zu lösen.
Sonst fällt mir da auf Anhieb nur ein, dir die x,y,z koords des Pixels sowie der angrenzenden Pixel zu besorgen (siehe GluUnproject) und daraus dann die Normale zu berechnen. Das ist jedoch erstens ungenau, und lieftert 2. an kanten, also dort wo sich die Z koordinate im Buffer stark ändert, wohl unsinnige Ergebnisse.

Jep, über den Z-Buffer mit Anlegen von Tangenten ist es sehr unschön und auch nicht sehr exakt, das hab ich bereits ausprobiert. Ich habe gedacht, dass OpenGL vielleicht irgendwo die relevanten Normalen speichert, so dass ich sie mir ausgeben lassen kann - ohne mich mit den Normalen verdeckter Polygone rumzuärgern,..

Also, was ich habe, sind ja eine Szene mit einer Kameraposition,
- entweder kann man daraus irgendwie die Normalen angeben lassen (das hatte ich gehofft)
- oder aber man kopiert die Szene und macht einen netten Trick (der mir noch nicht eingefallen ist) und rendert die Szene, sodass man danach nicht das normale Bild, sondern (wie beim Z-Buffer) z.B. die X-Normalen zu jedem Pixel angezeigt bekommt (wiederum als Pixel), das gleiche dann nochmal mit den Y-Normalen und fertig - oder einen Wert in Rot und den nächsten in Grün (je nach gewünschter Genauigkeit) speichert
- oder etwas ganz anderes, an das ich noch nicht gedacht habe,...

Ist das eine Szene die du selber renderst oder aus einem vollkommen anderen Programm?
Versucht du herraus zu finden was OpenGL mit deinen Normalen gemacht?

Irgendwie muss ich gerade gestehen, dass mir der Zusammenhang da ein bisschen verborgen bleibt. Weil wenn du es selberst hast du ja mehr oder weniger schon die Normalen. Entweder durch die Vertices oder wie auch immer. Ich hoffe du verstehst mein Problem und kannst etwas licht ins Dunkel bringen.

PS: Das Auslesen der Normalen bringt auch nichts, da OpenGL Normalen (genau so wie die Farbe) auch interpoliert.

ja, ich render die Szene selbst. Die Normalen habe ich aber nie berechnet und auch die Szene nicht, das kommt woanders her. Ich möchte nur, so wie ich die Szene normal oder als Z-Buffer-Image rendern kann auch als "Normalenbild" rendern, oder halt die Werte ausspucken lassen (für die X- und die Y-Komponente in Bezug zur Kamera - oder eben allen 3 Richtungen, dann müsste ich halt noch ins Kamerasystem umrechnen). Ob die jetzt ein wenig interpoliert sind, ist egal, auf jeden Fall sind sie ja so gut Interpoliert, wie bei geschickter Wahl einer Lichtquelle es auch die Helligkeitsverteilung ist,..

Ich hoffe eigentlich, dass ich recht leicht an die Normalen komme - nur möchte ich eben zu grossen Aufwand verhindern,..

Mit einem shader ist es ganz einfach:

Vertexshader




Um wieder aus der Farbe nach dem Pixellesen einen Vektor zu machen müssen die Farbwerte durch 128 geteilt werden und anschließend 1 abgezogen werden. Ansonsten gibt der shader schöne Bonbon farbene Bilder

Aha. Das erklärt das ganze doch schon mal mehr. Es geht aber noch anders als mit Shadern. Das haben wir sogar schon in dem Cubemap Tutorial beschrieben. Na ja so halb.

Ich denke das sollte als Vorlage für die Textur genügen und zum Zeichnen bräuchtest du dann nur noch folgendes tun.

Damit werden deine Texturkoordinaten automatisch an deine Normalen angepasst. Für den Rest dann einfach Werte auslesen und das sollte genügen.

So, erstmal danke für die schnellen Antworten, ich habe mich heute mal wieder um das Problem kümmern können. Mit einem Shader kann ich es Projektbedingt leider nicht machen, also hab ich mir das mit den Cubemaps mal angeschaut. Da mich nur die vordere Seite interssiert, hab ich auch nur an GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT die Daten geschickt. Wenn ich das richtig verstehe, ist das Erzeugen der Cubemap statisch und irgendeine trickreiche Map, um die Normalen zu berechnen ? Also jeder Punkt auf der vorderen Würfelseite wird in diese Map gespeichert und normalisiert. Wozu glScaleVector und glAddVector gut sind, habe ich leider nicht verstehen können, da man im Internet keine zweite Seite zu den Befehlen bekommt. Durch glTexImage2D werden die Daten an gl geschickt.
Durch glTexGeni(GL_<X>, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP); werden die Texturen anhand der Normalen-Map konstruiert und durch glEnable(GL_TEXTURE_GEN_<X>); auch beim rendern beachtet ??
Sollte ich das halbwegs richtig verstanden haben - bis auf glScaleVector und glAddVector hab ich auch alles in C++ implementiert. Wenn ich z.B. einen Quader rendern lasse mit Texturen, werden diese nicht mehr richtig angezeigt, sondern man sieht Graustufen an den Seiten, die stark variieren beim Ändern des Betrachtsungswinkels. Innerhalb einer Fläche bleibt jedoch das Grau gleich - ich habe aber den Eindruck, das dies nur ein Fehler ist und mit der normalen-Map überhaupt nichts zu tun hat - vermutlich bin ich einfach nur nicht in der Lage, sie auszugeben.