DGL • Thema anzeigen - DeferredShading + SSAO Performance

DeferredShading + SSAO Performance

Moderator: DGL-Team

Seite 1 von 1

[ 1 Beitrag ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Thmfrnk

Betreff des Beitrags: DeferredShading + SSAO Performance

Verfasst: Do Jul 28, 2011 15:40

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

Moinsen,

ich habe zu meiner DFS Pipeline noch SSAO hinzugefügt. Ich berechne bei mir die Position nur durch die Tiefentextur. Aber im SSAO Shader muss ja für jedes Pixel mehrfach die Position errechnen...

Und hier gibts gleich nochn kostenlosen SSAO Shader

Code:

 
uniform sampler2D Tex0, Tex1, Tex2;
uniform vec2 screenSize;
float random_size =64.0; // size of random texture
 
 
uniform mat4 proM;
uniform mat4 InvViewMat;
uniform float zFar;
uniform float SampleRad;
uniform float Intensity;
uniform float Scale;
uniform float Bias;
 
vec3 GetDFSpos(vec2 uv)
{
    float fDepth = texture2D(Tex2, uv).x;   
    
        vec4 vVertex;       
        vVertex.xy = uv  * 2.0 - 1.0 ;                          
        vVertex.z = fDepth * 2.0 - 1.0;  
        vVertex.w = 1.0;
        vVertex =  proM * vVertex;               
        vVertex *= 1.0 / vVertex.w;
        return  vVertex.xyz ;
}
 
float calcAO(vec2 uv, vec2 coord, vec3 pos, vec3 norm)
{
    vec3 diff = GetDFSpos(uv + coord).xyz - pos;
    vec3 v = normalize(diff);
    float d = length(diff) * Scale;
    return max(0.0, dot(norm, v) - Bias) * (1.0 / (1.0 + d)) * Intensity;
}
 
void main(void)
{
    vec2 rand;
    vec3 n;
 
    vec2 vec[4];
    vec[0] = vec2(1, 0);
    vec[1] = vec2(-1, 0);
    vec[2] = vec2(0, 1);
    vec[3] = vec2(0, -1);
    vec2 uv = gl_TexCoord[0].st;
        
    vec2 randomMap = texture2D(Tex0, vec2(screenSize) * uv / random_size).xy;
    vec3 normalMap = texture2D(Tex1, uv).xyz; 
 
    vec3 pos = GetDFSpos(uv);
 
    n = (normalMap * 2.0 - 1.0);
    rand = normalize(randomMap * 2.0 - 1.0);
    
    float ao = 0.0; 
    float rad = SampleRad / pos.z;
    
 
    int iterations = int(mix(4.0, 1.0, -pos.z / zFar));
    for (int i = 0; i < iterations; ++i) {
        vec2 coord1 = reflect(vec[i], rand) * rad;
        vec2 coord2 = vec2(coord1.x * 0.707 - coord1.y * 0.707, coord1.x * 0.707 + coord1.y * 0.707);
        
        ao += calcAO(uv, coord1 * 0.25, pos, n);
        ao += calcAO(uv, coord2 * 0.5, pos, n);
        ao += calcAO(uv, coord1 * 0.75, pos, n);
        ao += calcAO(uv, coord2, pos, n);   
    }
         
    ao /= float(iterations) * 4.0;
    
    gl_FragColor = vec4(1.0-ao);
}
 

Nun frage ich mich obs nicht doch besser is eine richtige Positionstextur in eine 32 Bit Texture zu packen... Aktuell merk ich noch keine Performance einbussen, doch es kommt ja noch (viel) mehr...

Hier noch schnell meine 2. Frage:
Hinzu kommt jetzt noch das wichtigste für meine Engine.. das Sonnenlicht (mit Schatten). Ich frage mich nun ob ich das auch gleich über die DFS Pipeline machen sollte oder per Pixel. Die DFS Daten hab ich ja schon vorliegen.. Die Frage ist allerdings ob das Sonnenlicht nicht schneller berechnet ist (sofern keine andere Lampe da is) wenn ichs über normale Pipeline berechne..

EDIT und hier noch ein schönes bildchen vom Resultat:

Dateianhang:

ssao.JPG

Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

Nach oben

Seite 1 von 1

[ 1 Beitrag ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 5 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.