Postprocessing und Auflösungswechsel

http://www.opserver.de/ubb7/ubbthreads.php?ubb=showflat&Number=374494&page=2

Nötige Schritte:
1.) Irgendein Objekt erstellen und rendern
2.) Einen Effekt an die Kamera hängen der einfach nur TargetMap sampled.
3.) Mit F5 die Auflösung wechseln.

Erwartetes Ergebnis:
Die Auflösung wird größer, TargetMap passt sich an und es sieht bis auf die höhere Auflösung genauso aus wie in der geringeren. Wenn nach wiederholtem F5 Drücken die Auflösung wieder klein wird, sollte wieder alles angepasst werden und das Ergebnis bei kleinerer Auflösung ansonsten genau wie vorher aussehen.

Tatsächliches Ergebnis:
Die Auflösung wird größer, TargetMap passt sich an und es sieht bis auf die höhere Auflösung genauso aus wie in der geringeren. Wenn nach wiederholtem F5 Drücken die Auflösung wieder klein wird, ist nurnoch der in das kleinere Fenster passende Ausschnitt von TargetMap sichtbar.

Anmerkungen:
Ich hoffe so wird das Problem deutlicher... Und bin mir ziemlich sicher, dass es nicht so sein soll.

Woran das liegt und wie man in richtiger Auflösung ins Target rendert, ist schon in diesem Thread erklärt worden:

http://www.opserver.de/ubb7/ubbthreads.php?ubb=showflat&Number=374494&page=2

Falsch.
Und jetzt schieb den Thread bitte wieder zurück.

Ok, ich schiebe ihn wieder zurück. Ich dachte, du kennst den anderen Thread nicht, in dem das gleiche schon beantwortet wurde.

Ich schätze deshalb, dieser Post hat im Bugforum nur eine minimale Lebensdauer...

Tja, ich weiss auch nicht, wie ich Ihnen hier helfen kann oder was ich für Sie implementieren soll. Wieso stellen Sie genau die gleiche Frage nochmal? Und was haben Sie an der ersten Antwort nicht verstanden?

Benutzen Sie pp_set mit einem der Materials aus mtlView.c und drücken Sie ein paar mal F5. Das soll sich doch anders verhalten, oder?

Und um nochmal zu den Tangenten zurück zu kommen, weshalb benötigt das Modell bei mir dann 26.5 ms mit Tangenten und 0.1ms ohne Tangenten?
Ohne Vertexanimationen und beides mit dem gleichen Shader.
Die Bones werden übrigens im Code animiert.

Von den vordefinierten Postprocessing Shadern passt sich nur der letzte, der HDR Shader, an die aktuelle Auflösung automatisch an. Bei den anderen ist dies nicht implementiert, das wird aber für PSSM und die anderen im Lauf der Zeit noch passieren.

Wenn Ihre Bones per CPU animiert sind, müssen natürlich die Tangenten ständig neu berechnet werden, da sich ja das Mesh verändert. Wenn die Bones dagegen per GPU animiert sind, verändert sich das Mesh nicht und folglich auch nicht die Tangenten. Falls doch, hat es eine andere Ursache.

Wenn Sie die Lösung nicht selbst finden, laden Sie uns das Projekt hoch - wir gehen der Sache dann nach.

Das Skinning passiert natürlich auf der GPU, sonst würde mein Thread ja keinen Sinn ergeben...
Die Bones selbst werden allerdings per Lite-C direkt gesetzt und nicht indirekt durch ent_animate oder so.


Das Modell und der Lite-C Teil stammt nicht von mir, aber wenn ich die Erlaubnis bekomme, werde ich das tun.


Weshalb erwähnen Sie nur HDR und PSSM, die einzigen Shader die noch zusätzliche Rendertargets zu "render_target" nutzen? Und wenn sich da nichts anpasst, weshalb wird render_target bei Auflösungswechsel größer?

Wie die Bones gesetzt werden, sollte auf die Tangentenberechnung keine Wirkung haben. Es kommt nur darauf an, ob das Mesh verändert wird oder nicht. - Das Rendertarget muss mindestens so groß sein wie die größte Stage. Daher das Größerwerden bei Auflösungswechsel. Das hatte ich in dem anderen Thread schon erklärt. Dies hat nichts mit einer Anpassung an die Stage-Auflösung zu tun, die bei einem von allen Stages gemeinsam verwendeten Target logischerweise keinen Sinn macht. Anpassen an die Stage-Auflösung können Sie nur individuelle Rendertargets.

D.h. ich sollte mir für Effekte wie Entsättigen, FXAA, Einfärben und was auch immer sonst einfach nur mit der aktuellen Auflösung arbeitet immer einmalig zwei eigene Rendertargets in aktueller Fensterauflösung erstellen, bei Auflösungswechsel gegen passende austauschen und und immer abwechselnd setzen?
Aber dann wird "render_target" doch plötzlich total überflüssig?
Und wenn im shader skaliere, dann hab ich schlechtes Multisampling, wenn die Auflösung plötzlich kleiner ist als vorher, denn es wird ja interessanter weise trotzdem in das gesammte, zu große rendertarget gerendert.
Außerdem hab ich dann noch den kleinen Nachteil, dass eine größere Textur gesampled werden muss als eigentlich nötig wäre.

Sie brauchen in 99% aller Fälle kein eigenes Target, schon gar nicht zwei, sondern können das Standard-Rendertarget ruhig benutzen. Es macht ja nichts, wenn es zu groß ist, es darf nur nicht zu klein werden.

Im Shader sollten Sie nur skalieren, wenn der Shader dies erfordert, z.B. für Downsampling. Zur Einstellung der Render-Größe brauchen Sie keine Skalierung im Shader, sondern nur korrekte size_x und size_y Werte des View. Wenn Sie diese Werte nicht setzen, verwendet der View automatisch die Target-Größe, d.h. die Größe des Engine-Fensters oder Rendertargets. Wenn also Ihr Rendertarget größer ist als Sie wollen, beschränken Sie einfach den Renderbereich, indem Sie size_x und size_y entsprechend setzen.

Bei komplexen Renderchains brauchen Sie natürlich individuelle Targets, wenn deren Größe und Format eine Rolle spielt oder Sie den Inhalt zwischenspeichern müssen.

Und genau dies funktioniert nicht korrekt.
Mehr will ich doch garnicht -.-.

Auch dieses Problem kann ich nicht bestätigen. Dann würden ja auch die meisten Shader gar nicht funktionieren. Wann immer Sie meinen, irgendetwas verhält sich anders als im Handbuch beschrieben, posten Sie einfach ein konkretes Beispiel. Dann kommen wir viel schneller voran als mit ellenlangen Diskussionen.

Deshalb habe ich die Templates erwähnt...
Aber das Problem tritt auch hier auf (wobei das drumherum hier etwas unübersichtlich und noch ziemlich suboptimal ist): http://files.slindev.com/codes/SDSF_V2.zip
Einfach main.c kompilieren aud ausführen und dann ein paar mal F5 drücken, bis das Fenster wieder klein ist.

Ich habe mir Ihr Beispiel angesehen - Glückwunsch zum netten Shadereffekt, aber F5 verhält sich offensichtlich exakt so wie es sollte. Die View-Größe wird in Ihrem Beispiel nicht angepasst und so sieht es dann auch aus.

Wenn Sie versprechen, mir dafür mal ein Bier auszugeben, schreibe ich Ihr Beispiel in 2 Minuten um, so dass die Anpassung klappt.

D.h. ich muss camera.size_x und camera.size_y selbst auf window_size setzen und das gleiche auch für die stage views?
Und weshalb passt es sich beim größer werden der Auflösung korrekt an?
Ich find ja super dass sich alles so verhält wie es soll, aber ich verstehe noch nicht wie ich es hinbekomme dass es zum von mir eigentlich erwarteten Ergebnis kommt.

Sie müssen die size_x/y Werte bei allen Stages immer auf die gewünschte Rendergröße setzen, es sei denn, Sie wollen, dass die Views auf die volle Größe des jeweiligen Targets rendern. Dann können Sie size_x/y bei 0 belassen.

Meines Erachtens ist dies ein logisches Verhalten.

Ja, aber ich belasse sie ja einfach bei 0.

Wenn tatsächlich ich etwas falsch mache, bin ich natürlich gern bereit dafür ein Bier auszugeben. Und sonst, naja, vielleicht auch .

Hier nochmal das Problem in Bildern:


Und für beide Probleme schicke ich jetzt auch nochmal eine Mail an den Support.
Ich würde übrigens nichts als Bug posten wo ich mir nicht relativ sicher bin, dass es sich nicht so verhält wie es soll...

Und Danke übrigens schonmal für die bisherigen Antworten.

Gilt das mit dem Bier auch für mich?

Das Problem ist dass laut Handbuch wenn du keine View size setzt die Views immer auf das volle Target rendern.

Dein Camera View rendert also in das 1024x1024 Rendertarget. Das ist schon der erste Fehler denn du hast nur einen 640x480 Bildschirm, der Camera View rendert also zuviel, also schlechte Framerate.

Das zweite Problem ist dass dein PP View auf den 640x480 Screen rendert. Wenn dein Shader nicht skaliert rendert er jedes Pixel 1:1 vom 1024x1024 Rendertarget auf den View. Du siehst also nur den oberen linken Teil des Rendertargets. Genau so sieht dein Screenshot aus.

Um das Problem zu lösen musst du nur die camera auf die Größe setzen die du haben willst, also 640x480.

camera.size_x = screen_size.x;
camera.size_y = screen_size.y;

Dann rendert die camera nur in den Bereich der dann vom PP View auf den Screen gerendert wird, so wie es sein soll. Bekomme ich jetzt ein Bier?

Nö, DU bekommst dafür kein Bier
Ich will ja, dass die Kamera in das gesammte rendertarget rendert, ich will aber gleichzeitig auch, dass das render target so groß wie screen_size ist. Und finde eigentlich, dass es nur logisches Verhalten ist, dass wenn ich die Auflösung erhöhe und sich das render target mitskaliert, dass es das auch wieder tut, wenn ich die Auflösung veringere. Oder zumindest, dass camera nicht über die Fensterauflösung hinaus in die Textur rendert, wenn ich nicht explizit einen Bereich festlege.
Zumindest sollte das jetzige Verhalten dann irgendwo verständlich Dokumentiert sein und entweder benutze ich zwei eigene rendertargets (eines zum reinrendern, wärend ich aus dem anderen lese) die ich selbst anpasse, oder ich passe camera.size_xy an, wobei ersteres sogar schneller ist, sollten dann die default render targets garnicht erst erstellt werden. Denn bei Auflösungswechsel müssen Rendertargets ja sowiso neu erstellt werden und das geht bei kleineren Texturen etwas schneller als bei größeren und auch samplen und reinrendern wird dadurch zumindest nicht langsamer. Ob der Unterschied auf aktueller Hardware bemerkbar ist, ist natürlich wieder was anderes...

Und wo dieser Thread eh schon relativ große ausmaße angenommen hat:
AMD Grafikkarten sind nicht besonders tolerant wenn es darum geht vs2.0 und ps3.0 zu mischen und wie das mit fixed function und 3.0 gemischt ist, weiß ich auch nicht so genau, außerdem kann es manchmal Sinn machen im Vertexshader ein paar Dinge zu berechnen. Was müsste ein Vertexshader machen um sich so zu verhalten wie ohne eigenen?
Einfach texcoords weiterreichen und mit matProj die Position projizieren? Oder ist die Position schon Projiziert? Ist matProj überhaupt gesetzt, oder sollte ich matWorldViewProj benutzen und das passt dann schon?
Muss ich da sonst noch irgendwas beachten? Die Texcoords aus den Positionen selbst zusammenbasteln oder so?

Edit: Im Moment wird der Vertexshader offenbar einfach ignoriert bei Postprocessing effekten, lässt sich das irgendwie einfach ändern? Wäre sicher manchmal nützlich...