Hey Leute,

Ich musste leider feststellen, dass Schatten, bei einer größerer Entfernungen zur Lichtquelle, immer unschwärfer werden.
Das liegt wohl am Depthbuffer, da die Genauigkeit mit steigender Entfernung abnimmt. Doch wie löst man sowas? Gerade bei Sonnenlicht geht man ja (theoretisch) von einer unendlich entfernten Lichtquelle aus aber da gehts ja schon los. Wie setz ich sowas um?

Das lässt sich so einfach nicht beantworten da es von der räumlichen Aufteilung abhängt. Bei einen BSP-baum ala id-software lässt sich das relativ einfach gestalten da hier deine Geometrie immer innerhalb eines Würfels liegt. Dadurch kannst du für jeden Würfel ganz leicht den Inhalt, hierachisch nach außen oder umgekehrt projezieren. Die jeweiligen verschiebungen der Projektionsebene ergeben dann die Eigentliche Entfernung. Im Falle von Sonne kann dies sogar soweit gehen das man nachschaut was der Pixel von der Skybox empfängt.

Einige alte RPGs benutzen sowas ähnliches für die Sprites, nur halt auf XY Ebene.

_________________
Meine Homepage

Okay das macht durchaus Sinn. Danke.


Dann nochmal eine kleine Frage: Seit ich meine Shadows auf Shader umgestellt habe, werden Schatten leider komplett auf die Geometrie angewandt und Alpha-Texturen werden nicht berücksichtigt. Das man dann bei Bäumen nur was Viereckiges sieht ist dann eher weniger schön
Ich konnte nur leider nix finden wie ich das behebe?

Wenn ich jetzt im Shader bei der texture2DProj den den Alphawert checke (.a), dann kriege ich halt den Wert von dem Baum z.B. raus (also wo der Transparent ist) aber das hilft mir ja leider nicht wirklich weiter! Ich will ja schließlich den projezierten Schatten auf dem Boden ermitteln. Hoffe das Problem wird deutlich

Für Lichtquellen wie die Sonne, bei denen die Strahlen (annähernd) parallel sind, kann man für die Shadowmap eine orthogonale Projektion wählen, dann ist der Tiefenbuffer linear. Die tatsächliche Entfernung der Lichtquelle interessiert dann nicht, solange sie weit genug entfernt ist um alle schattenwerfenden Objekte im Blickfeld zu haben. Außerdem nimmt die Lichtintensität mit der Entfernung dann nicht ab, außer durch Absorbtion in der Atmosphäre, wodurch man das auch ignorieren kann.

Zu dem Problem mit den Bäumen: Wenn du die Shadowmap erzeugst musst du den Alphatest benutzen, sodass nur die Pixel einen Schatten werfen, die nicht durchsichtig sind. Man hat dann natürlich keine Halbschatten oder so, aber andere genauere Verfahren sind wiederum sehr rechenintensiv.
Beim Zeichnen der Schatten auf die Geometrie, wird der Schatten/die Beleuchtung nur auf die 3 Farbkanäle angewandt und der Alphakanal bleibt der Wert den man aus der Textur für das Objekt gelesen hat. Dadurch beeinflusst das Licht nicht die Transparenz, was zwar interessant aussieht, aber eigentlich falsch ist.

Das macht durchaus Sinn Also schonmal danke!
Nochmal eine Frage zu der Orthogonalen Projektion:

Ich habe jetzt einfach mal gluPerspective mit glOrtho ersetzt aber wie ich es schon erwartet habe, läuft es nicht.
So sieht erstmal die glOrtho Zeile aus:
glOrtho(0, ShadowMapSize, 0, ShadowMapSize, 1, 1000);

Die Szene ist halt komplett schwarz (so sieht es auch, wenn Objekte hinter der Blickrichtung der Kamera von der Lichtquelle liegen. Ich habe nämlich die Blickrichtung der Sonne mit gluLookAt bestimmt, meine aber mal gelesen zu haben, dass glOrtho und gluLookAt sich nicht so gut vertragen sollen.
Was muss ich also noch anpassen damit es läuft?

mit glOrtho hab ich noch keine Shadows gemacht, aber um die Transparenz der Bäume hinzubekommen, könntest du beim Rendern der ShadowMap einfach den Alphatest aktivieren.

EDIT: SORRY hatte nich gelesen das dies schon beantwortet wurde

Das mit dem Alphatest läuft schon. Einfach während der Erstellung der ShadowMap einen Shader aktiviert, der das jeweils überprüft. Klappt also

Nur die Orthogonale Projektion will nicht laufen.

Beim Erzeugen der Shadowmap verwende ich einen Shader der nur dann erfolgreich abschliesst wenn der Alphatest durchläuft (Schwellwert 0.5) und ansonsten den Pixel einfach mittels 'discard' verwirft.

Bei glOrtho verwende ich für die Tiefe angepasste Werte. Im Moment sind sie noch statisch und eben auf die Szene angepasst, so dass alles mehr oder weniger beleuchtet wird.

z.B.


Mittels gluLookAt wird die Sonnenkamera dann auf einen Punkt, der 'shadowSettings.width' Einheiten entfernt in der Blickrichtung der Szenenkamera liegt, gerichtet.

_________________
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

Das mit dem gluLookAt klappt schon, man muss es nur ein bischen anders angehen:

Width und Height sind die Breite und Höhe des Bereiches den die Shadowmap abdecken soll, im Koordinatensystem deiner Welt. Die Abmessungen der Shadowmap sind natürlich ShadowMapWidth und ShadowMapHeight, die wiederum in Pixel angegeben sind.
pos, look und up sind jeweils die Position der Lichtquelle, deren Richtung und ein Vektor der "nach Oben" zeigt und für die Ausrichtung der Shadowmap entlang der Richtung dient.

Hm also irgendwie will das nicht
Wenn ich am Anfang das FBO initalisiere, dann erstelle ich die Projectionsmatrix auch einmal und pack die Werte in ein Array:

Mit der gluPerspective Variante funktioniert es ohne Probleme.

Im Code selbst dann halt nur noch die Matrix laden:



Danach kommt gleich gluLookAt:



Den Viewport passe ich dann nach dem binden des FBO's an, was aber nicht weiter schlimm sein sollte.
Und so sieht das dann ingame aus (mit glOrtho) - die Geometrie ist komplett schwarz:

Hier holst du die ModelView-Matrix und später setzt du damit die Projection-Matrix.
Ansonsten könnte es vllt auch am Shader liegen. Bin mir nicht sicher ob man dann noch texture2DProj verwenden muss.

Zum Debuggen vllt noch ein paar Tipps: Um zu überprüfen ob die Shadowmap richtig befüllt wird, kannst du sie mal auf ein Quad oder deine Geometrie ausgeben. Dann erhält man im Normalfall ein Graustufenbild.
Außerdem kannst du mal die Texturkoordinaten der Shadowmap als Farbe auf den zu beleuchtenden Objekten ausgeben. Die Werte müssten zwischen 0 und 1 liegen, ansonsten sind die Koordinaten falsch.

Ja wie gesagt, ich erstelle die Projektionsmatrix einmal zu begin. Da ist gerade die Modelview Matrix aktiv, wodurch ich die Werte halt darin berechne! Bei gluPerspective nehm ich ja auch die Modelview Matrix und es geht.

texture2DProj nutze ich Shader, die Idee mit der DepthMap ausgeben auf einem Quad werde ich aber mal probieren.
Ich finde es halt merkwürdig, dass der Code eben vorher komplett funktioniert und eben nur der Austausch von gluPerspective durch glOrtho den Fehler verursacht.

Durch die Bias-Matrix sollten die Koordinaten auch zwischen 0 und 1 liegen.

Ich habe mir zum Debuggen die beiden Depth-Textures mal ausgeben lasse aber mit sehr unterschiedlichem Ergebnis.
Im Anhang ist einmal mit gluPerspective und einmal mit glOrtho - bei Ortho ist die gesamte Szene in der Depthtexture und das aus meiner Sicht unerklärlichen Position, zumal die Szene auch wirklich sehr klein ist in der DepthTexture.

Edit// Wenn ich so drüber nachdenke, dann macht die Größe ja schon etwas Sinn. Bei gluPerspective wird die Sichtgröße in der Ferne hin immer stärker, wo hingegen es bei Orthogonaler Projektion vom Anfangs bis zum Endpunkt gleich bleibt.
Unter dem Aspekt habe ich zwar letztendlich 2 DepthTextures aber trotzdem keine Schatten


Edit2// Vllt. liegt es an der Berechnung der Matrix, welche ich dann an den Shader übergebe:


LightProjMatrix enthält die Informationen von glOrtho und die LightMatrix von gluLookAt.

Versuch' es auf jeden Fall mal noch mit texture2D, wenn du das noch nicht hast. Das texture2DProj ist dazu da um die perspektivische Korrektur vorzunehmen, weil entfernte Objekte auf der Shadowmap kleiner sind. Bei glOrtho benötigt man das aber nicht.

Reden wir wirklich über texture2D/texture2DProj? Zur Darstellung der Schatten nutze ich nämlich shadow2DProj.

Hier einfach mal der Shader:


Konnte man den Code hier im Forum nicht irgendwie für C auslegen? Also sowas wie [code=C] oder so?!
Edit by i0n0s:
Ja, mit [code=C]...