DGL • Thema anzeigen - Deferred Shading

Deferred Shading

Moderator: DGL-Team

Seite 1 von 2

[ 23 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Druckansicht

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Pk3

Betreff des Beitrags: Deferred Shading

Verfasst: Di Feb 08, 2011 18:36

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Hallo,

ich versuche gerade einen Szene mittels Deferred Shading zu beleuchten. Dafür sind ja 3 Texturen (Normal-, Vertex- und Colortexture) nötig, die dann an einen 2D - Shader weitergegeben werden. Das Problem liegt beim Erstellen der Vertex - Texture, diese wird nicht korrekt erstellt. Ich verwende folgenden Shader für die Vertex - Texture:

Fragment:

Code:

varying vec3 vVertex;

void main(void) {
   gl_FragColor = vec4(vVertex.xyz / 1000.0, 1.0);
}

Vertex:

Code:

varying vec3 vVertex;

void main(void) {
   vVertex      = vec3(gl_ModelViewMatrix * gl_Vertex);
   gl_Position       = gl_ModelViewProjectionMatrix * gl_Vertex;
}

Ich vermute auch woran es liegt: Daran, dass die Farben die man an "gl_FragColor" gegeben hat, nachträglich verändert wird. Ich habe auch schon versucht den Wert dess Vektors unterhalb von 1.0 zu bekommen (/ 1000.0), aber das ändert leider nichts... Ist es irgentwie möglich die Position in die Textur zu schreiben und diese dann auch gültig wieder auszulesen?

Hier noch der 2D - Shader:

Fragment:

Code:

uniform sampler2D Texture0; // color - texture
uniform sampler2D Texture1; // normal - texture
uniform sampler2D Texture2; // vertex - texture

uniform mat4 matModelView;

const vec3 vAmbient = vec3(0.05, 0.05, 0.05);
const vec3 vSpecular = vec3(0.5, 0.5, 0.5);
const vec3 vDiffuse = vec3(1.0, 1.0, 1.0);
const float fShininess = 128.0;

void main() {
   vec2 texcoord = vec2(gl_TexCoord[0]);

   vec3 vColor = texture2D(Texture0, texcoord).xyz;
   vec3 vNormal = texture2D(Texture1, texcoord).xyz;
   vec3 vVertex = texture2D(Texture2, texcoord).xyz;

   vec3 vLightPos = vec3(matModelView * vec4(100.0, 10.0, 100.0, 1.0)) / 1000.0;

   vec3 vLight    = normalize(vLightPos.xyz - vVertex.xyz);   
   vec3 IDiffuse   = vDiffuse * max(dot(vNormal, vLight), 0.0);

   gl_FragColor.xyz = IDiffuse;

   //gl_FragColor = vec4(normalize(vVertex), 1.0);
   gl_FragColor.w = 1.0;
}

Vertex:

Code:

void main(void) {
   gl_TexCoord[0]   = gl_MultiTexCoord0;
   gl_Position       = ftransform();
}

Nach oben

sharkman

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Di Feb 08, 2011 20:27

DGL Member

Registriert: Fr Dez 11, 2009 08:02
Beiträge: 532
Programmiersprache: pascal (Delphi 7)

1) 8 bit werden für eine Vertextextur wohl zu wenig sein. Mehr bit nehmen und gut ist (möglicherweise)

2) in der Vertextextur speicherst du doch grundsätzlich daten, die du doch eigentlich bereits durch die xy koordinaten des Pixels und den Wert im Tiefenpuffer hast. Projektion rückgängig machen, und du hast auch wieder deine Werte. (Also anstelle von auslesen der Vertextextur)

Nach oben

Lord Horazont

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Di Feb 08, 2011 20:39

DGL Member

Registriert: Do Sep 02, 2004 19:42
Beiträge: 4158
Programmiersprache: FreePascal, C++

(hier war doch vorhin noch… verwirrt…)

Ja, mehr Bits und vorallem eine Floattextur für die Vertex- und Normalendaten bietet sich an. Und was sharkman in Punkt zwei anspricht ist auch richtig. Du brauchst keine Vertextextur in dem Sinne. Projektion zurückrollen anhand von xy und z des Ausgabevertex sollte reichen.

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Nach oben

Coolcat

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Di Feb 08, 2011 23:56

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Das Problem an der Sache ist das du mittels FramebufferObject und MRT nicht verschiedene Datentypen schreiben kannst. Also wenn du eine Float-Textur verwendest, dann muss alles Float sein, also auch Farben und Normale. Falls du eine Float-Textur möchtest, dann benutze GL_RGBA32F_ARB oder GL_RGB32F_ARB als internes Format für alle deine Texturen für den Deferred Shader.

Wenn du aber die Vertexposition wie von meinen Vorrednern beschrieben rekonstruierst kannst du dir das sparen. Die Normale müsste sich auch in 4x8bit kodieren lassen und Farben natürlich sowieso. Z.B. zwei Achsen der Normale (z.B. X und Y) in je zwei der Farbkanäle packen. Also den Bereich -1...1 auf den Bereich 0...65535 mappen und das auf zwei Farbkanäle (z.B. R und G) verteilen. (*) Die dritte Achse ergibt sich automatisch daraus, dass die Länge der Normale 1 sein muss. Was noch fehlt ist das Vorzeichen der Z-Achse. Dieses könntest du vielleicht in den Alpha-Kanal der Farbtextur packen, falls dieser nicht anderweitig benötigt wird. Letztlich benötigst du nur 1 Bit dafür.

Hinweis: Das ist jetzt eine spontane Überlegung...also ich hab nicht ausprobiert ob das funktioniert bzw. sinnvoll ist. Wenn du des einfacher möchtest kannst du natürlich auch einfach die Normale auf drei 8bit Farbkanäle verteilen.

Edit: (*) Shader-Output muss immer zwischen 0 und 1 liegen, also jeden Farbkanal einzeln nochmal durch 255 teilen.

_________________
Yeah! :mrgreen:

Nach oben

sharkman

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 12:26

DGL Member

Registriert: Fr Dez 11, 2009 08:02
Beiträge: 532
Programmiersprache: pascal (Delphi 7)

Zitat:

Was noch fehlt ist das Vorzeichen der Z-Achse.

Nein, sollte eigentlich nicht noch fehlen. Sinnvoller weise hat man nämlich eh BackfaceCulling an, und sieht nur die Vorderseite der Primitive. Und dort zeigt dann auch die Normale hin (normalerweise, bzw ich wüsste nicht, wieso man es beim Deferred Shading anders machen sollte). Daraus ergibt sich, dass die Normale eigentlich immer zum Betrachter zeigt.

Natürlich ist es auch möglich, dass man Normalen braucht, die vom Betrachter wegzeigen (zB bei transparenten Objekten möglich, für den Fall dass hier noch eine Erweiterung auf Inferred Lighting geplant ist), dann muss man das natürlich irgendwie speichern.

Nach oben

Coolcat

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 12:36

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

[Unsinn, siehe nächster Post]

Zitat:

Nein, sollte eigentlich nicht noch fehlen. Sinnvoller weise hat man nämlich eh BackfaceCulling an, und sieht nur die Vorderseite der Primitive.

Es geht um das Vorzeichen des Z-Achse, nicht um das der gesamten Normale. Hier zeigen z.B. beide Normalen in Richtung Kamera:

Dateianhang:

Normale.png [ 6.63 KiB | 8839-mal betrachtet ]

Ich muss allerdings zugeben, dass ich auch eine Weile gebraucht habe bis ich realisiert hatte. Ich dachte auch erst man würde das Vorzeichen nicht brauchen und hatte dann eine lang und breite Erklärung geschrieben wieso und warum....bis ich feststellte das es Unsinn ist

[/Unsinn]

_________________
Yeah! :mrgreen:

Zuletzt geändert von Coolcat am Mi Feb 09, 2011 12:57, insgesamt 3-mal geändert.

Nach oben

sharkman

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 12:50

DGL Member

Registriert: Fr Dez 11, 2009 08:02
Beiträge: 532
Programmiersprache: pascal (Delphi 7)

Ähm, wie kann die Kamera in Richtung x Achse schauen (so interpretiere ich zumindest dein Bild)? Soweit ich weiß sind da die Normalen nach der Transformation durch die NormalMatrix interessant (liegt hier mein Denkfehler?).

Nach oben

Coolcat

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 12:55

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Oh....richtig....ich war irgendwie von normalen Worldspace ausgegangen wo die Kamera überall sein kann.

Zitat:

(liegt hier mein Denkfehler?).

Kein Denkfehler...der liegt bei mir.... :roll:

_________________
Yeah! :mrgreen:

Nach oben

Pk3

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 15:55

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Zitat:

1) 8 bit werden für eine Vertextextur wohl zu wenig sein. Mehr bit nehmen und gut ist (möglicherweise)

8Bit? Ich dachte immer das wären 32Bit.... Na dann erklärt sich ja vieles von selbst.

Zitat:

2) in der Vertextextur speicherst du doch grundsätzlich daten, die du doch eigentlich bereits durch die xy koordinaten des Pixels und den Wert im Tiefenpuffer hast. Projektion rückgängig machen, und du hast auch wieder deine Werte. (Also anstelle von auslesen der Vertextextur)

Stimmt, dadurch spare ich sogar einen Renderpass. Habs gerade so versucht, aber so wies aussieht funktionierts net richtig.

Fragment:

Code:

uniform sampler2D Texture0; // color - texture
uniform sampler2D Texture1; // normal - texture
uniform sampler2D Texture2; // depth - texture

varying mat4 matProjectionInverse;
varying mat4 matModelView;

const vec3 vAmbient = vec3(0.05, 0.05, 0.05);
const vec3 vSpecular = vec3(0.5, 0.5, 0.5);
const vec3 vDiffuse = vec3(1.0, 1.0, 1.0);
const float fShininess = 128.0;

const float f = 5000.0;
const float n = 0.1;

void main() {
   vec2 texcoord = vec2(gl_TexCoord[0]);

   vec3 vColor = texture2D(Texture0, texcoord).xyz;
   vec3 vNormal = texture2D(Texture1, texcoord).xyz;
   float zOverW = texture2D(Texture2, texcoord).r;

   vec4 H = vec4(texcoord.x * 2.0 -1.0, (1.0 - texcoord.y) * 2.0 -1.0, zOverW, 1.0);
   vec4 D = H * matProjectionInverse;
   vec3 vVertex = vec3(D / D.w);


   vec3 vLightPos = vec3(matModelView * vec4(100.0, 10.0, 100.0, 1.0));
   vec3 vLight    = normalize(vLightPos.xyz - vVertex.xyz);   
   vec3 IDiffuse   = vDiffuse * max(dot(vNormal, vLight), 0.0);

   gl_FragColor = vec4(IDiffuse, 1.0);
   gl_FragColor.w = 1.0;
}

Zitat:

Ich verwende normale Texturen, also keine Framebuffer. Aber ich glaube das ist egal. Das mit der Float-Textur muss ich mal ausprobieren, thx

Nach oben

Coolcat

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 16:07

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Zitat:

Ich verwende normale Texturen, also keine Framebuffer.

Ein FramebufferObject (FBO) verwendet ebenfalls "normale" Texturen. Der Vorteil ist aber das du direkt in die Textur rendern kannst. Ansonsten renderst du nämlich erst in einen Framebuffer und musst dann die Daten nochmal extra in eine Textur kopieren.

Des weiteren kannst du mittels FBO in mehrere Texturen gleichzeitig rendern. Stichwort: MultipleRenderTargets (MRT). Im Fragmentshader benutzt du dann statt gl_FragColor einfach gl_FragData[0], gl_FragData[1] usw... Ist auch im FBO Tutorial erklärt. Mit dem Deferred Shading willst du ja vermutlich Performance rausholen, also die Szene nicht öfter als notwendig rendern

_________________
Yeah! :mrgreen:

Nach oben

Pk3

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 17:08

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Zitat:

Mit dem Deferred Shading willst du ja vermutlich Performance rausholen, also die Szene nicht öfter als notwendig rendern

Richtig, aber ich habe erstmal keine FrameBuffer verwendet, weil das ganze auch auf älterer Hardware laufen soll. Aber ich werde noch alle 2 Varianten einbaun, also falls die Hardware FrameBuffer unterstützt, werden die genutzt, ansonsten wird so gerendert wie ichs momentan mach.

Das mit der Float-Textur geht glaub ich nicht, liegts an der Initialisierung?

Code:

    glGenTextures(1, &glColorTex);
    glBindTexture(GL_TEXTURE_2D, glColorTex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, pSystem->pRender->Window->nWidth, pSystem->pRender->Window->nHeight, 0, GL_RGBA, GL_FLOAT, 0);

    glGenTextures(1, &glNormalTex);
    glBindTexture(GL_TEXTURE_2D, glNormalTex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, pSystem->pRender->Window->nWidth, pSystem->pRender->Window->nHeight, 0, GL_RGBA, GL_FLOAT, 0);

    glGenTextures(1, &glVertexTex);
    glBindTexture(GL_TEXTURE_2D, glVertexTex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, pSystem->pRender->Window->nWidth, pSystem->pRender->Window->nHeight, 0, GL_RGBA, GL_FLOAT, 0);

    glGenTextures(1, &glDepthTex);
    glBindTexture(GL_TEXTURE_2D, glDepthTex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
    glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, pSystem->pRender->Window->nWidth, pSystem->pRender->Window->nHeight, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);

Oder vielleicht beim Kopieren der Textur?

Code:

    glBindTexture(GL_TEXTURE_2D, glColorTex);
    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, 0, 0, pSystem->pRender->Window->nWidth, pSystem->pRender->Window->nHeight, 0);

    glBindTexture(GL_TEXTURE_2D, glDepthTex);
    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, pSystem->pRender->Window->nWidth, pSystem->pRender->Window->nHeight, 0);

Nach oben

Coolcat

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Mi Feb 09, 2011 17:15

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

glCopyTexImage2D kopiert aus dem primären Framebuffer. Dieser ist immer 8bit RGB oder 8bit RGBA. Selbst wenn also glCopyTexImage2D in der Lage wäre das in Float umzuwandeln, das wird dir nichts bringen da zwischen durch immer in 8bit umgewandelt wird.

=> Wenn du in Float-Texturen rendern möchtest musst du ein FramebufferObject benutzen. Des weiteren solltest du testen ob deine Hardware das überhaupt kann, d.h. die Extension GL_ARB_texture_float muss verfügbar sein. Wenn du davon ausgehst das deine User nicht mal Support für FBOs haben, kannst du die Nutzung von Float-Texturen vermutlich vergessen.

Bei glCopyTexImage2D mit GL_DEPTH_COMPONENT könnte es ein ähnliches Problem geben. Bin ich mir aber nicht sicher. Jedenfalls ist GL_DEPTH_COMPONENT im Wiki nicht als mögliches Argument aufgezählt.

_________________
Yeah! :mrgreen:

Nach oben

AlexMaRu

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Do Feb 10, 2011 10:29

DGL Member

Registriert: Do Mai 20, 2010 10:54
Beiträge: 10
Programmiersprache: C/C++

Hi, vielleicht hilft dir mein Deferred Shading Programmbeispiel weiter:

http://www.spieleprogrammierung.net/2011/01/opengl-tutorial-version-33-deferred.html

Nach oben

Pk3

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Fr Feb 11, 2011 15:25

DGL Member

Registriert: Sa Jun 05, 2010 16:15
Beiträge: 94

Ok, bin jetzt doch auf Framebuffer umgestiegen und jetzt funktionierts auch endlich

. Aber die Performance hat sich dadurch nicht verbessert, im Gegenteil sie hat sich verschlechtert. Wenn ich die Auflösung auf 1024x768 lasse hab ich 60 FPS (mehr geht nicht, kann VSync zurzeit komischerweise nicht abschalten). Wechsel ich die Auflösung auf 1680x1050 fällt die Framerate auf 40 - 45 FPS, was sich auch beim Rotieren der Kamera bemerkbar macht (wirkt unflüssig). Dabei besteht die Szene nur aus 2426 Vertices.

Ich verwende 4 Float-Texturen (Normal-, Vertex-, Color-, und Speculartexture). Jede dieser Texturen wird so initialisiert:

Code:

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, pSystem->pRender->Window->nWidth, pSystem->pRender->Window->nHeight, 0, GL_RGBA, GL_FLOAT, 0);

Shader, der auf jede Geometrie angewendet wird:

Fragment:

Code:

varying vec3 vNormal;
varying vec3 vVertex;
uniform sampler2D Texture0;

void main(void) {
   gl_FragData[0] = texture2D(Texture0, gl_TexCoord[0]);   // Color - Texture
   gl_FragData[1] = vec4(vNormal, 1.0);   // Normal - Texture
   gl_FragData[2] = vec4(vVertex, 1.0);   // Vertex - Texture
   gl_FragData[3] = vec4(gl_FrontMaterial.specular.xyz, gl_FrontMaterial.shininess); // Specular - Texture
}

Vertex:

Code:

varying vec3 vNormal;
varying vec3 vVertex;

void main(void) {
   vNormal    = normalize(gl_NormalMatrix * gl_Normal);
   vVertex      = vec3(gl_ModelViewMatrix * gl_Vertex);

   gl_TexCoord[0]    = gl_MultiTexCoord0;
   gl_Position       = gl_ModelViewProjectionMatrix * gl_Vertex;
}

2D - Shader

Fragment:

Code:

uniform sampler2D Texture0; // color - texture
uniform sampler2D Texture1; // normal - texture
uniform sampler2D Texture2; // vertex - texture
uniform sampler2D Texture3; // specular - texture

void main() {
   vec2 texcoord = vec2(gl_TexCoord[0]);

   vec3 vColor = texture2D(Texture0, texcoord).xyz;
   vec3 vNormal = texture2D(Texture1, texcoord).xyz;
   vec3 vVertex = texture2D(Texture2, texcoord).xyz;
   vec4 vMatSpecular = texture2D(Texture3, texcoord);

   vec3 IDiffuse = vec3(0.0, 0.0, 0.0);
   vec3 ISpecular = vec3(0.0, 0.0, 0.0);
   vec3 vEye = normalize(-vVertex);
   float lightFactor;

   for(int i = 0; i < 8; i++) {
      if(gl_LightSource[i].constantAttenuation > 0.0) {

         if(gl_LightSource[i].position.w == 1.0) {
            lightFactor = 1.0 - min(distance(gl_LightSource[i].position.xyz, vVertex) / gl_LightSource[i].constantAttenuation, 1.0);
         }
         else {
            lightFactor = 1.0;
         }

         if(lightFactor > 0.0) {
            vec3 vLight = normalize(gl_LightSource[i].position.xyz - vVertex.xyz);
            vec3 Reflected = normalize(reflect(-vLight, vNormal));
            vec3 vProductSpecular = vMatSpecular.xyz * gl_LightSource[i].specular.xyz;

            IDiffuse  += (gl_LightSource[i].diffuse * max(dot(vNormal, vLight), 0.0)) * lightFactor;
            ISpecular += (vProductSpecular * pow(max(dot(Reflected, vEye), 0.0), vMatSpecular.w)) * lightFactor;
         }
      }
   }

   gl_FragColor = vec4((IDiffuse + ISpecular) * vColor, 1.0);
}

@AlexMaRu
Danke, werde ich mir mal anschauen

Nach oben

Coolcat

Betreff des Beitrags: Re: Deferred Shading

Verfasst: Fr Feb 11, 2011 15:50

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Zitat:

Wechsel ich die Auflösung auf 1680x1050

Du benutzt RGBA32F Texturen und davon 4 Stück, richtig? Dann ist jedes Fragment 64 Byte groß. Bei dieser Bildschirmauflösung erzeugst du so also 107 MB Daten. Das ganze kaust in jedem Frame zweimal durch (einmal schreiben, einmal lesen). Bei 45 fps erzeugst du also 9.4 GB/sek Speicherzugriffe. Ich hoffe das ist dir klar...

=> Versuche die Daten zu komprimieren!
Tipps:

Brauchst du die Vertex-Textur oder reicht die Tiefe und errechnest dann später daraus die Position. Die Vertex-Position war der einzige Grund für 32bit Floats, oder?
Kannst du die Normale komprimieren wie oben beschrieben?
Brauchst du wirklich den Alpha-Kanal bei der Farbe?
Brauchst du wirklich die Specular-Farbe? Reicht vielleicht auch ein Graustufenwert oder ist die gar immer nur weiß?
Brauchst du den Shininess-Parameter?
Welche der obigen Werte müssen eigentlich Floats sein? Du kannst bis zu drei 8bit-Werte in einen 32bit Float packen! Werte zwischen 0 und 2^24 lassen sich verlustfrei in einem Float darstellen.

Zitat:

Dabei besteht die Szene nur aus 2426 Vertices.

Deferred Shading ist dafür gedacht wenn du komplexe Geometrie und gleichzeitig mehr Lichtquellen hast als du in einem Pass verarbeiten könntest. Die Idee ist das du nicht für jeden Pass die komplette Geometrie verarbeiten musst. Da deine Szene aber nun mit 2000 Vertices nicht wirklich komplex ist der Deferred Shading Ansatz natürlich eher kontraproduktiv.

_________________
Yeah! :mrgreen:

Nach oben

Seite 1 von 2

[ 23 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Foren-Übersicht » Programmierung » Shader

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 22 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.