Posts by 2#4u

    Jetzt ohne, dass ich alle angegebenen Quellen durchforste...


    Es kommt zuerst einmal darauf an, was du unter Material verstehst. Wenn du von einer Materialfarbe redest, dann wird das eine Farbe sein, die sich rein auf den diffusen Teil des Modells auswirkt. Daher kannst du schon beim GBuffer befüllen diese Farbe mit der Texturfarbe kombinieren (z.B. Multiplikation). Kommt darauf an, was du vorhast. ZB Gras rot machen (warum auch immer).


    Was man allerdings machen kann und das ist Teil der Materialeigenschaften - Die Specularity. Also wenn ein Objekt unterschiedlich specular ist an unterschiedlichen Stellen (wird beschrieben durch eine Specular Map). D.h. man hat eine extra Grauwerttextur neben jeder diffusen Textur die angibt wie spiegelnd der jeweilige Punkt des Objektes ist. Das soll nur den spekularen Anteil und nicht den diffusen Anteil beeinflussen und wird daher extra gespeichert, bis das Beleuchtungsmodell berechnet wird. Für sowas, braucht man eine extra Textur oder einen extra Eintrag (zB Alpha Channel der diffusen GBuffer Textur) im GBuffer.


    Wie der GBuffer (Google: gbuffer layout oder gbuffer format) aussehen soll, was er alles enthält, ist leider kein einfaches Thema. Es gibt da keine allgemeine Antwort und kommt in erster Linie darauf an was das Beleuchtungsmodell alles braucht und können soll.
    Beispiele für den GBuffer:
    http://tomgillen.blogspot.co.at/2010/07/gbuffer-layout.html
    http://www.catalinzima.com/xna…na/creating-the-g-buffer/
    http://www.slideshare.net/DICE…field-3-for-playstation-3 (Slide 12)

    Es geht hier um UV Mapping bzw. UV Unwrapping. Das wird typischerweise im Modellierungsprogram (zB Blender) gemacht und ist teilweise eine künstlerische Tätigkeit. Nachdem ihr sehr einfache (Block-)Geometrie habt, ist es noch sehr einfach. Ihr könnt zB mit einer "Cube projection" in Blender arbeiten. Etwas Information dazu hier: http://www.chocofur.com/5-uv-mapping.html


    Zusätzlich kann es sein, dass ihr sogennante "seams" braucht, um richtig zu mappen. D.h. das sind Kanten an denen die Geometrie für das UV Mapping "aufgerissen" wird, um die 3dimensionale Geometrie in die 2dimensionale Ebene (für eure Textur) abzubilden.

    Erst einmal, tut mir leid für die verspätete Antwort.


    Nein, es gibt keine Effektliste von der man wählen kann. Die Idee ist, dass ihr in diesem Teil des Studiums bereits einen Überblick über Echtzeiteffekte habt (z.B. aus der Computergraphik UE). D.h. ihr wählt euch Effekte selbst und gebt dabei Quellen an, in denen diese beschrieben sind. Im best case sind das Papers. Mehr Informationen dazu sind auch in der Vorbesprechung vorgetragen worden, die Videoaufzeichnung dazu ist online.


    Ihr werdet einen Vorschlag (bis 17.10., 0. Abgabe) ausarbeiten und dort 2 oder mehr Effekte mit Quellen angeben. Ihr bekommt dann Feedback, vor allem ob der Umfang passt.


    Bezüglich Folien: Solange die Folien von diesem Semester nicht online gegangen sind, könnt ihr euch gerne an die des letzten Jahres halten, viel wird sich nicht geändert haben. Aber ich klär das mit der LVA Leitung ab wann die Folien online gehen.

    Ihr könnt gerne so etwas implementieren. Distance adaptive Tessellation oder dergleichen.
    Bei allen Effekten ist es wichtig, dass es auch optisch überprüfbar ist.


    Ich sehe da jetzt 2 Möglichkeiten:
    1. Ihr baut uns eine Taste ein mit der wir in den Wireframe Modus wechseln können und es uns so anschauen können
    2. Ihr rendert die Geometrie ein zweites Mal mit Wireframe Modus und einem einfachen Fragment Shader in ein FBO und überblendet dieses Bild mit der eigentlichen gerenderten Szene.


    Nummer 1 ist straight forward und relativ langweilig, aber in Ordnung.
    Nummer 2 kann man sehr interessant machen zB mit halbe Geometrie Wireframe überlagert und die andere Hälfte normal gerendert oder eine Animation in der das Wire sich über die Geometrie bewegt.
    ZB sowas: https://www.youtube.com/watch?v=MSC1SMv5HgY


    Überlegt euch auch ein Modell zu nehmen wo Level of Detail tatsächlich Sinn macht. Ein Planet mit Bergen und Tälern macht Sinn. Eine einfache Kugel weniger. Also nicht einfach irgendwas tessellieren wo kein Unterschied zwischen grober und feiner Geometrie besteht.

    Ich kann euer Projekt aufgrund Linker Fehler nicht ausführen. Aber sei's drum...


    Vielleicht übernehmt ihr die Attribute (position, up, target) nicht richtig von der aktuellen Kamera?


    Ihr könnt die View-Matrix eurer aktuellen Kamera hernehmen und alles was ihr braucht aus der Matrix entnehmen:

    Code
    1. [COLOR=blue]const[/COLOR] glm::[COLOR=#2b91af]vec4[/COLOR] camPos = glm::inverse(viewMatrix) * glm::[COLOR=#2b91af]vec4[/COLOR](0, 0, 0, 1);
    2. [COLOR=blue]const[/COLOR] glm::[COLOR=#2b91af]vec3[/COLOR] camDir = glm::[COLOR=#2b91af]vec3[/COLOR](-viewMatrix[0][2], -viewMatrix[1][2], -viewMatrix[2][2]);
    3. [COLOR=blue]const[/COLOR] glm::[COLOR=#2b91af]vec3[/COLOR] camUp = glm::[COLOR=#2b91af]vec3[/COLOR](viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);


    Ansonsten hilft es vielleicht einmal durch die Reflektionskamera durchzusehen (d.h. die Szene mit dieser zu rendern) und nachzusehen, ob die passt bzw. wo sie ist...

    Ich kann nicht sagen was das Problem ist, aber es hat was mit dem Blur Pass zu tun.
    Wenn ich im Blur-Depth Fragment-Shader einfach nur die screenTexture auslese und als FragColor zurückgebe, hat der Schatten bereits ein Loch.
    Da ist irgendwas faul beim Blur-Pass.


    Eine Sache zu generateMipMaps. Das ist oben schon erwähnt worden, mach das 1 x nachdem die Variance Shadow Map erstellt hast und nicht bevor du renderst.


    Ansonsten, wie gesagt - versuch einen Debug Context einzubauen.

    Ok. Ich hab mir das jetzt mal eine Stunde angesehen und versucht es nachzuvollziehen.


    Mipmapping ist meiner Meinung nach aktiv für die Variance Shadow Maps. In CodeXL kann ich die generierten Mipmaps sehen. Ihr wollt vielleicht softere Schatten haben, das geht aber nur mit Bluren.
    Das Artefakt auf der Plane, wie im Screenshot den du gepostet hast, tritt bei mir nicht auf.


    Was mir auffällt:
    - Ihr habt keinen Debug Context. Ihr habt zwar kein glfw eingesetzt, aber habt ihr etwas vergleichbares zum Debuggen? Vielleicht gibt es die ganze Zeit Fehler auf deinem System und du weißt es nicht.
    - Die Variance Shadow Map ist als RGB definiert, ihr speichert jedoch vec4 im Fragment Shader. Das ist an sich nicht das Problem, allerdings verstehe ich folgendes Phänomen nicht: Wenn man im Alpha Kanal der Variance Shadow Map 0 speichert, dann sind die Schatten hin. Nur wenn man 1 speichert, funktioniert's. Irgendwelche Ideen warum?
    Sprich:
    gl_FragColor = vec4(gl_FragCoord.z, pow(gl_FragCoord.z, 2.0) + 0.25*(dx*dx+dy*dy), 0.0, 0.0);
    geht nicht. Ich kann aber nicht nachvollziehen warum.
    Das ist übrigens unabhängig davon, ob man eine RGB oder RGBA Textur erstellt.
    Auch hier würde ich einmal einen Debug-Context erstellen.

    Also 4 texture units sollte kein Problem darstellen. Das schließe ich aus, sofern ihr die richtig benutzt.


    Um die 2 Punkte zu bekommen, sollte es bewegende Wellen, als auch die Refraktion anhand der normal map geben. Eine dudv map müsst ihr nicht benutzen.
    Tutorial: http://http.developer.nvidia.c…2/gpugems2_chapter19.html


    Wenn die UV Koordinaten wirklich stimmen, müsstet ihr ja eine beliebige Textur (die ihr zB schon einmal erfolgreich eingesetzt habt) korrekt auf das Wasser gemappt werden können. Ihr könntet das mal ausprobieren.


    Vielleicht ladet ihr die Normal map initial auch im falschen Format in euer System?

    @Vertices in der Mitte heller: Rendert ihr die Backfaces in die Shadow-Map? Das würd es erklären.


    @Shadow-Map kopfüber: Rendert ihr die Shadow-Map am Bildschirm mit einem Fullscreen-Quad? Dann sind vielleicht die UV-Koordinaten falsch. Schaut euch die Shadow-Map in CodeXL an.


    Ansonsten: Wie ich es jeder Gruppe rate, rendert die Szene einmal aus der Sicht der Lichtquelle und schaut euch an, ob die Ausrichtung etc. passt. D.h. benutzt die Projektions- und View- Matrix des directional lights anstatt eurer normalen Kamera in eurem 'normalen' Renderpass. Mit einer wirklich gerenderten Szene (d.h. mit Farben, etc.) kann man sich viel leichter orientieren.

    Zur Kameraposition der Reflektioncam:


    Ich hab das in der Vergangenheit wie folgt gelöst:



    Diese 2.75f sind anzupassen, je nachdem auf welcher Höhe eure Waterplane liegt.
    Der Umweg den up-vector zu berechnen über den right-vector ist dann sinnvoll, wenn die Kamera auch um die 'Roll' Axis gedreht ist.
    Ich bin mir grad nicht sicher, ob das Invertieren der Y-Achse beim right-Vektor notwendig ist, aber es hat damals funktioniert.
    Voraussetzung ist, dass ihr von der aktuellen Kamera die korrekten Parameter (up, target, pos) berechnen könnt.


    Zur Textur: Stimmen denn die UV Koordinaten?


    Zu dem roten Fenster: Dazu kann ich nicht viel sagen. Sagt der DebugContext etwas aus? Ansonsten: Ein häufiger Fehler zwischen Debug und Release ist Membervariablen nicht zu initialisieren und sie einfach so zu benutzen. Was ich machen würde, ist den Fehler einzugrenzen, das heißt das Programm minimal zu halten und alles was geht auszukommentieren und schaun, ob der Fehler verschwindet. Dann sukzessive Code wieder einkommentieren und schauen, ab wann das Verhalten sich ändert.

    Ich vermute ihr seid nach diesem Tutorial vorgegangen?


    Dort steht:

    Quote

    A relatively simple exposure tone mapping algorithm looks as follows


    Es ist tatsächlich eine sehr einfache Umrechnung, daher sind die Ergebnisse auch eher bescheiden.


    Wenn ich mir eure Ergebnisse ansehe, dann geschieht hier die Umwandlung von einer sehr farbenfrohen Szene in ein konstrastarmes Endergebnis.
    Das mag an der Exposure liegen, aber ich sehe das Problem hier an dem unflexiblen Tonemapping Algorithmus.


    Wenn ein implementierter Effekt das Spiel grundsätzlich verschlechtert, ist das eher ein schlechtes Zeichen.
    Ich würde euch dringend empfehlen einen anderen Tonemapper zu benutzen.
    Einen Überblick und meinen Hinweis auf den Uncharted 2 Operator hab ich in diesem Post gegeben.


    Ich möchte euch auch nochmal darauf hinweisen, dass die Szene einen gewissen Kontrastumfang aufweisen sollte, damit Tonemapping überhaupt Sinn macht (siehe Post weiter oben).


    Versucht bitte einfach euer Spiel nicht unnötig zu verschlechtern, nur um Effektpunkte abhacken zu können..

    HDR macht vor allem dann Sinn, wenn es starke Unterschiede in den Helligkeiten euer Szene gibt.
    Wenn sich die Ergebnisse eurer Beleuchtung hauptsächlich im Float Bereich [0,1] abspielen, wird HDR so gut wie keinen Einfluss haben.
    Daher muss man ja auch sinnvollerweise ein anderes Texturformat für das FBO wählen, sodass auch Werte < 0 und > 1 möglich sind, die der Tonemapper dann in den Range [0,1] bringt.


    D.h. man kann eine Szene so gestalten, dass gleichzeitig sehr dunkle und sehr helle Stellen in einer Szene sichtbar sind oder man kann zwischen sehr hellen und sehr dunklen Bereichen hin- und herschauen...

    Hmm. Ja, du hast recht.
    Es stellen sich jedoch die Fragen, ob
    - das numerisch stabil ist
    - das einfacher/schneller zu berechnen ist


    Bei der Berechnung von L_w kann man so vorgehen:
    1.: In einem Pass: Für die Textur mit der gerenderten Szene pixelweise im Fragment-Shader log(delta + L(x,y)) berechnen -> in neue Textur
    2.: Arithmetisches Mittel mit Mipmaps berechnen. D.h. generateMipMaps von der neuen Textur
    3.: Im obersten Mipmaplevel den Wert auslesen und potenzieren (exp) -> fertig


    Und ja, sollte log-nat sein.


    Du kannst natürlich gerne auch einen anderen Tonemapping Operator benutzen.
    Ich persönlich hab mit dem Uncharted 2 Tonemapper gute Ergebnisse erzielt.
    Überblick über Tonemapper:
    https://mynameismjp.wordpress.…ser-look-at-tone-mapping/
    http://filmicgames.com/archives/75
    Uncharted 2: http://www.gdcvault.com/play/1…Uncharted_2__HDR_Lighting

    Wichtig ist, dass du verstehst was hier passiert.
    Dein 'V' ist ein Dreikanalbild weil es pro (x,y) Eintrag einen 3-dimensionalen Vektor enthält.
    Jetzt willst du jeden Vektor von 'V' mit den Tiefenwerten 'Z' strecken.
    Wie du einen Vektor streckst, wirst du ja wissen. Und ja, entweder du machst es elementweise oder dir kann auch die Funktion 'repmat' helfen. Wie das anzuwenden ist, haben wir in früheren Übungsbeispielen kennengelernt.