DGL
https://delphigl.com/forum/

Bloom
https://delphigl.com/forum/viewtopic.php?f=20&t=6688
Seite 1 von 2

Autor:  Gaukler [ Mi Jun 20, 2007 23:31 ]
Betreff des Beitrags:  Bloom

Ich will eine Textur blurren und zwar wurde die vorher gerendert über Renderpass. Also gewissermassen ein Postfilter.

Nun weiss ich auch wie ichs machen möchte und zwar nach einer Methode, die dieser: http://www.gamasutra.com/features/20040 ... es_pfv.htm ziemlich ähnlich ist. Das heisst erstmal blurre ich das Bild vertikal, dann horizontal und dann wird das ganze so verrechnet, dass eben dieser Bloom Effekt entsteht.

Ich habe schon die ganzen Renderpass Sachen vorbereitet, allerdings weiss ich nicht wie ich Blurren kann. Ich brauche da irgendwie die nebenliegenden Pixel. Aber wie ich die krieg, keine Ahnung.

Wäre echt froh um Hilfe, vielen Dank!

Autor:  dj3hut1 [ Do Jun 21, 2007 04:44 ]
Betreff des Beitrags: 

Hallo,

ist eigentlich nicht weiter schwer.
Wenn deine Texturkoordinaten auf [0,1]x[0,1] gemappt sind :

w = Breite der Textur in Pixel
h = Höhe der Textur in Pixel

vec2 tc = vec2( gl_TexCoord[0] );

//Pixel unten
texture2D(texSampler, tc.u, tc.v + 1.0f/h);

//Pixel links oben
texture2D(texSampler, tc.u - 1.0f/w, tc.v - 1.0f/h);

...

usw.

Viele Grüße
dj3hut1

Autor:  Gaukler [ Fr Jun 22, 2007 13:54 ]
Betreff des Beitrags: 

thx dafür.

noch ne frage:

warum kann er die folgende Zeile nicht kompilieren? (Error: Internal compiler error:unexpected operator):

col += texture2D(Texture0, tco) * sample[i];

wobei es aber kompiliert, wenn ich sample[i] wegnehme...

das i stammt aus einer Schleife und sample ist so definiert:

float sample[9];
sample[0] = 1.0000;
sample[1] = 0.9394;
......


wirklich komisch.

Autor:  dj3hut1 [ Fr Jun 22, 2007 14:03 ]
Betreff des Beitrags: 

Hallo,

könnte vielleicht möglich sein, dass dein Grafikkartentreiber keine Schleifen unterstützt.


Viele Grüße
djehut1

Autor:  Gaukler [ Fr Jun 22, 2007 18:30 ]
Betreff des Beitrags: 

Danke, hat wieder gestummen. Jetzt hab ich das ganze einfach mit kopieren gemacht.

nächstes problem, grml:

col += texture2D(Texture0, vec2(tc.s+(1.0*xp), tc.t)) * sample[1];

Das mit dem Kopieren geht zwar, aber nur mit bis zu 3 solchen befehlen. Bei mehr Befehlen Rendert er einfach nix mehr. Weiss jemand woran, dass dies liegt, bzw wie man es umgehen kann?

Eine Fehlermeldung gibt es keine. Aber wenn ich den Shader über eine Textur laufen lasse, dann warte ich z.B. 2-3min und der Shader wurde immer noch nicht ausgeführt... bzw. die CPU ist zwar auf hohen touren anzufinden, aber rendern tut er gar nichts.

mfg

Autor:  Gaukler [ Di Jun 26, 2007 15:26 ]
Betreff des Beitrags: 

keiner ne ahnung woran es liegen könnte?

Code:
  1. uniform sampler2D Texture0;
  2.  
  3. uniform float width;
  4. uniform float height;
  5. uniform float facwidth;
  6. uniform float facheight;
  7.  
  8. const int samples = 8;
  9. const float sum   = 3.0359;
  10.  
  11. void main(void)
  12. {
  13.   //Gausssche Normalverteilung:
  14.   float sample[9];
  15.   sample[0] = 1.0000;
  16.   sample[1] = 0.9394;
  17.   sample[2] = 0.7788;
  18.   sample[3] = 0.5697;
  19.   sample[4] = 0.3678;
  20.   sample[4] = 0.2096;
  21.   sample[5] = 0.1053;
  22.   sample[7] = 0.0467;
  23.   sample[8] = 0.0183;
  24.  
  25.  vec2 tc = vec2(gl_TexCoord[0]);
  26.  float xp = facwidth/width;
  27.  
  28.  vec4 col = texture2D(Texture0, tc);
  29.  vec2 tco = tc;
  30.  
  31.  col = texture2D(Texture0, vec2(tc.s-(1.0*xp), tc.t)) * sample[1];
  32.  col = texture2D(Texture0, vec2(tc.s+(1.0*xp), tc.t)) * sample[1];
  33.  
  34.  /*col = texture2D(Texture0, vec2(tc.s-(2.0*xp), tc.t)) * sample[2];
  35.  col += texture2D(Texture0, vec2(tc.s+(2.0*xp), tc.t)) * sample[2];
  36.  
  37.  col += texture2D(Texture0, vec2(tc.s-(3.0*xp), tc.t)) * sample[3];
  38.  col += texture2D(Texture0, vec2(tc.s+(3.0*xp), tc.t)) * sample[3];
  39.  
  40.  col += texture2D(Texture0, vec2(tc.s-(4.0*xp), tc.t)) * sample[4];
  41.  col += texture2D(Texture0, vec2(tc.s+(4.0*xp), tc.t)) * sample[4];
  42.  
  43.  col += texture2D(Texture0, vec2(tc.s-(5.0*xp), tc.t)) * sample[5];
  44.  col += texture2D(Texture0, vec2(tc.s+(5.0*xp), tc.t)) * sample[5];
  45.  
  46.  col += texture2D(Texture0, vec2(tc.s-(6.0*xp), tc.t)) * sample[6];
  47.  col += texture2D(Texture0, vec2(tc.s+(6.0*xp), tc.t)) * sample[6];
  48.  
  49.  col += texture2D(Texture0, vec2(tc.s-(7.0*xp), tc.t)) * sample[7];
  50.  col += texture2D(Texture0, vec2(tc.s+(7.0*xp), tc.t)) * sample[7];
  51.  
  52.  col += texture2D(Texture0, vec2(tc.s-(8.0*xp), tc.t)) * sample[8];
  53.  col += texture2D(Texture0, vec2(tc.s+(8.0*xp), tc.t)) * sample[8]; */
  54.  
  55.  gl_FragColor = col/(1.0+2.0*sum);
  56. }


Wie gesagt, wenn ich die Klammern ( /* und */ ) wegnehme gehts nicht mehr, sonst schon.

Autor:  dj3hut1 [ Di Jun 26, 2007 20:38 ]
Betreff des Beitrags: 

Hallo Gaukler,

das einzige was mir aufgefallen ist, dass du vergessen hast sample[6] mit einem Wert zu belegen, aber ansonsten scheint dein Shader-Code ok zu sein...

Viele Grüße
dj3hut1

Autor:  Sascha Willems [ Di Jun 26, 2007 21:14 ]
Betreff des Beitrags: 

Du machst in deinem Shader jede Menge Texturelookups, und je nach Hardware sind dass evtl. zu viele. Auf welcher Karte läuft denn der Shader?

Autor:  Gaukler [ Di Jun 26, 2007 21:35 ]
Betreff des Beitrags: 

ati radeon 9700 (mobile)

aber wie soll ich denn blurren, wenn ich nicht mal mehr als 3! texturlookups machen kann?

Autor:  Sascha Willems [ Di Jun 26, 2007 22:24 ]
Betreff des Beitrags: 

Die Radeon 9700 ist dein Problem. Das hat ich damals auch schon, die kann nur eine begrenzte Zahl abhängiger Texturenlookups im Shader, bei mir war damals auch mit 4 Zugriffen Schluß. Entweder machst du den Blur also Multipass oder gleich ganz ohne Shader.

Autor:  Gaukler [ Di Jun 26, 2007 23:18 ]
Betreff des Beitrags: 

und wie mach ich das am gescheitesten ohne shader? Weil Multipass scheint mir unangebracht zu sein (könnt mich gerne auch überzeugen, dass multipass besser ist. Evtl kann man ja sogar nocht im Vertexshader 3mal zugreifen)

Autor:  TAK2004 [ Di Jun 26, 2007 23:41 ]
Betreff des Beitrags: 

https://linuxprofessionals.org/svn/xdream/branches/0.2v/core/XD_Fake_HDR.pas
Dies sollte dir vieleicht helfen, es ist eine realisierung eines Papers.

So sieht das aus.
Bild

Autor:  LarsMiddendorf [ Mi Jun 27, 2007 00:13 ]
Betreff des Beitrags: 

ARB_fragment_program ist bei der Radeon 9700 wesentlich besser. Damit kann man dann auch die vollen 32 Texturezugriffe und 64 arithmetischen Befehle erreichen. Einziger Nachteil ist, dass diese Extension im Gegensatz zu glsl nicht zwangsläufig Bestandteil von OpenGL 2.x ist.
Das ist halt das Problem, dass die Shader Compiler nicht richtig funktionieren.

Autor:  dj3hut1 [ Mi Jun 27, 2007 17:50 ]
Betreff des Beitrags: 

Hallo,

achso noch was : du machst 3 Zuweisungen an col, bei den letzten beiden sollte wahrscheinlich '+=' statt '=' stehen

Autor:  Gaukler [ Do Jun 28, 2007 12:32 ]
Betreff des Beitrags: 

ja das stimmt, hab ich vergessen wieder rauszunehmen. war wegen testzwecken drin.

ich werds nun wahrscheinlich ohne shader realisieren, wenn überhaupt.

mfg

Seite 1 von 2 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/