Postprocessing und Auflösungswechsel

Folgende Situation: Ich habe eine View-stage-Kette mit 2 oder mehr stages, in etwa wie folgt:

Dabei hat letzterer View folgenden Effekt:

Ändere ich die Auflösung (per default.c und F5) in eine höhere, so gibt es kein Problem. Ist die neue Auflösung jedoch kleiner als die vorherige (bzw. kleiner als die größte, die bisher bei Laufzeit gewählt worden ist), so wird "CameraSampler" inkorrekt gelesen. "bmp_camera" wird stets an die aktuelle Bildschirmauflösung angepasst, daher sollte diese Bitmap zudem die gleiche Auflösung wie "TargetMap" besitzen. Es sieht aber aus, als wäre "Tex.xy" bei dieser Bitmap fälschlicherweise zu klein, weshalb nur ein Ausschnitt aus jener gerendert wird.


Zudem lässt sich beobachten, dass "render_target->width" beim Übergang in eine höhere Auflösung größer wird, jedoch niemals kleiner.


Hier ein lauffähiges Minimalbeispiel: http://www.superku.de/bloom_problem.zip

Ich danke im Voraus!


EDIT: Verwendete Version: 8.20.1

Think about it: If the standard render buffer between view stages would change its size for every stage, you had to reallocate it many times per frame in a view chain with different stage sizes. You would not be happy with the frame rate.

The standard render buffer has a fixed size, only determined by the largest stage in all your chains. This is why you observe that it grows when the view resolution grows, but it never shrinks. If you need a stage buffer of a smaller size, just use an individual buffer for that stage, as you already did with the camera view buffer.

Ok, nehme ich zur Kenntnis.
Aber erklärt das denn auch, warum obiger Code den "CameraSampler" anscheinend inkorrekt liest?
Zudem sind oder sollten alle stages gleich groß sein, von unterschiedlichen Größen zwischen stages war nie die Rede.

Ich glaub hier liegt ein Missverständnis vor, Superku ging einfach nur darum, dass wenn die Auflösungen vom backbuffer verändert wird, dann auch die render targets aller stages von pp-effect Ketten angepasst werden. Und das eben nicht nur wenn die Auflösung vergrößert wird.

Nein, Stages sind oft verschieden groß. Z.B. enthält der HDR Shader Stages, die sich um den Größenfaktor 1/4 unterscheiden. Auch bei Bloom-Effekten ist in der Regel die Bloom-Stage wesentlich kleiner als die Screen Stage.

Im Pixel-Shader müssen Sie dann die verschiedenen Größen berücksichtigen. Hierzu multiplizieren Sie die Texturkoordinaten mit dem Größenfaktor, also z.B.:

Color = 0.5*tex2D( BloomSampler, factor*Tex) + tex2D( CameraSampler, Tex);

Sonst bekommen Sie falsche Koordinaten, sobald Ihr BloomSampler und Ihr CameraSampler unterschiedlich groß sind.

Aber das sind sie ja nicht, die bmap von camera ist stets so groß wie die Auflösung des Bildschirms, Bloom läuft (momentan) auch noch über den ganzen Screen. Dennoch wird CameraSampler falsch gelesen, ich verstehe nicht, warum.

Laut Superku werden die Größen der Stage aber nich angepasst wenn die Auflösung vom Backbuffer verringert wird. Zum Beispiel wäre ein RT, welches 1/4 so groß wie der Backbuffer vor dem Ändern der Auflösung war, nach dem Verringern der Auflösung um ein Viertel, dann plötzlich genau so groß wie der Backbuffer.

Weil beide Bitmaps verschieden gross sind. Ein Pixelshader weiß nichts von der Größe des Bildschirms. Er kennt nur die Größe des Rendertargets und läuft über dessen X/Y-Koordinatenbereich. Da das Rendertarget normalerweise viel größer als der Bildschirm ist, entspricht eine Rendertarget-Koordinate nicht der gleichen Bildschirm-Koordinate. Deshalbt können Sie nicht einfach Werte von den gleichen Koordinaten aus verschiedenen Bitmaps addieren. Ich hoffe, das ist nun verständlich.

Sie müssen entweder Bitmaps gleicher Größe verwenden, oder Ihr Shader-Code muss die unterschiedliche Größe berücksichtigen. Sehen Sie sich Beispielshader an, z.B. HDR - da werden individuelle Größen für die einzelnen Stages verwendet.

Das klappt wunderbar, danke! Problem gelöst.

EDIT: Falls folgendes legitim ist:

if(old_screen_size_x != screen_size.x) {
old_screen_size_x = screen_size.x;
if(render_target) ptr_remove(render_target);
render_target = bmap_createblack(screen_size.x,screen_size.y,32);
}

Das ist nicht ganz legitim, denn am render_target sollen Sie nichts ändern. Legitim wäre folgendes:

if(old_screen_size_x != screen_size.x) {
if(bloom_view.bmap) ptr_remove(bloom_view.bmap);
bloom_view.bmap = bmap_createblack(screen_size.x,screen_size.y,32);
}

Hm ich habe es fast befürchtet. Das heißt ja aber, dass ich für meine insgesamt 5 zusätzlichen (stage-) Views jeweils eine Bitmap und somit Videospeicher verbraten muss, nur weil die eine Bitmap ganz am Ende "nicht korrekt" gelesen wird.

Ich verstehe auch noch nicht so ganz, warum, wenn man obiges 1,4Kb-Beispiel einmal laufen lässt, beim stetigen Erhöhen der Auflösung mit F5 ein anderes Verhalten sichtbar wird, wenn man die höchste solche überschreitet, als beim schrittweisen Verringern der Auflösung mit Shift+F5? (Ich kann es nicht wirklich in Worte fassen.)

Ob Sie 5 Bitmaps brauchen, hängt nur von Ihren Shadern ab. Wenn die Bitmaps alle die gleiche Größe haben, brauchen Sie nur eine, bzw. zwei zum kombinieren. Das Standard Rendertarget ist ja auch nur eine Bitmap, die von allen Stages gemeinsam benutzt wird.

Ok, ich danke!

Eins? Ich dachte man kann nicht aus einem target lesen und gleichzeitig hereinschreiben?

Kann man auch nicht. War sicherlich nur unglücklich ausgedrückt.

Das ist richtig. Das Standard Rendertarget ist auch nicht eine Bitmap, wie ich fälschlicherweise behauptet habe, sondern zwei, die wechselweise benutzt werden.