GLSL Licht und Schatten: Unterschied zwischen den Versionen

Version vom 6. Juni 2006, 13:50 Uhr

Hinweis: Dieser Artikel wird gerade Offline bearbeitet! Bitte haben Sie etwas Geduld und nehmen Sie keine Änderungen vor, bis der Artikel hochgeladen wurde. (weitere Artikel)

Vorwort

Willkommen zu meinem erstem Tutorial. Schatten können sowohl Traum als auch Albtraum eines jeden OpenGLprogramieres werden. Im Gegensatz zur einfachen Beleuchtung mit Lichtquellen, steigt der Rechenaufwand hier extrem an und ohne Optimierung zwingen die Schatten selbst die modernste Hardware in die Knie. Für Schatten gibt es zwei praktikable Algoritmen: Den Stencilschatten und den projezierten Schatten. Hier möchte ich mich auf den projezierten Schatten beschränken, er bietet gegenüber dem Stencilschatten einige Vorteile:

Die komplette Berechnung kann von der Grakfikkarte übernommen werden Es ist möglich Softshadows zu realisieren Die Shadowmaps können unter Umständen für mehr als ein Frame verwendet werden

Um den Rechenaufwand zu veringern werde ich hier eine zusätzliche Projektionstechnik zeigen, die über den Vertexshader realisiert wird: Das parabolide Mapping. Es ermöglicht nicht nur die Simulation eine Fischaugenoptik, sondern kann auch die Cubemap vollständig ersetzen. Durch einen geringfügig höheren Rechen und Programieraufwand genügen zwei Renderpasses um eine vollständige Tiefen oder Reflektionsmap zu erstellen. Was gegen über der klassischen Cubemap den Prozessor und Vertexpipline um den Faktor 3 entlastet.

Vorkentnisse

Dieses Tutorial basiert auf den Grundlegenden Techniken, die erst in den letzten Jahren entwickelt wurden. Jeder der hier mit anfängt, sollte die zwei anderenen GLSL Tutorials gelesen haben und einfache Fragmentshader schreiben können. Auch das Laden und Einbinden von Texturen in die Shader sollte kein Problem mehr darstellen.

Für das Erstellen von dual paraboliden Tiefentexturen ist noch das Rendern in Framebufferobjekten Voraussetztung. (zu denen es leider noch kein Tutorial gibt.)

Ich empfehle auch die zu Renderden Daten als Vertexbufferobjekte zu übergeben, da sonst die Mehrfachverwendung der Daten zu einer extremen Bremse wird.

Grundlagen

Von OpenGL kennen wir zwei Projektionsmöglichkeiten: Orthografische und perspektivische Projektion. Beide Projektionen arbeiten ohne Verzerrung. Jede gerade bleibt beim Transformieren eine gerade. Wenn man dagegen das Bild eines Fischeyeobjektives betrachtet, allen einem sofort die zu Kurven verzerten Geraden auf. Der entscheidene Vorteil an einer Fisheyeaufnahme ist, dass ein Öffnungswinkel von 180Grad erfasst werden kann. Zwei entgegensetzte Aufnahmen können so problemlos den kompletten Raum um die Kammera erfassen.

Für das Erstellen der Tiefenmap ist es notwendig den Raum um das Reflektierende Objekt in eine Textur zu rendern. Meistens wird hier eine Cubemap verwendet. Soll diese dynamisch generiert werden, ist es auffälig, dass die Scene ganze 6 mal gerendert werden muss. Mit der dual paraboliden Map sind nur noch zwei Rendervorgänge nötig, es wird zwar keine Füllrate eingespart, dafür müssen nun nur noch 1/3 der Daten Transformiert werden, so das die Vertexshader und die CPU entlastet werden.

Eine weitere Optimierung ist unter umständen möglich: Wenn bei einer Cubemap auf eine der Flächen verzichte werden kann. z.B. wird die Reflektion im Lack eines Autos so gut wie nie verdeckte Straße zeigen. Auch ist für eine an einer Wand befestigten Lampe nur eine halbkugelförmige Shadowmap nötig. Wenn sie einen Abstand zur Wand hat, genügt es auch hier den Blickwinkel von 180 Grad etwas zu erweitern.

Hauptprogramm

Achtung hier ist C code stat Pascal geschrieben. Minimale Stolpersteine könnten vorhanden sein...

Als erstes müssen die nötigen Extensions initialisiert werden Dann sollten die benötigten Modelle als VBO in die Grafikkarte hochgeladen werden. Nun muss das Framebufferobjekt (FBO) für die Schattenmaps erzeugt werdern. So könnte die Initialsierung des FBOs aussehen:

GLuint shadow_map = 0; // 
GLuint shadow_fbo = 0; // the shadow texture
GLuint shadow_size = 4096; //Muss kleiner sein als die maximale Texturgröße sein

glGenTextures (1, &shadow_map); //In Pascal das & durch ein @ ersetzten
glBindTexture (GL_TEXTURE_2D, shadow_map);
glTexImage2D (GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT16, shadow_size, shadow_size, 0,GL_DEPTH_COMPONENT , GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

glGenFramebuffersEXT (1, &shadow_fbo); //In Pascal das & durch ein @ ersetzten
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, shadow_fbo);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,shadow_map, 0);
glDrawBuffer (GL_FALSE);
glReadBuffer (GL_FALSE);
GLenum status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT); //noch ein wenig Code anfügen um den Status zu überprüfen.

Jetzt Sollten die Shader und weiter Texturen geladen werden.

Nach diesem Prinzip muss dann in der Haupschleife jeder Rendervorgang abgearbeitet werden der Code dürfte in Pascal und C sehr ähnlich sein.

//Shader für Dualparabolische Mpas aktivieren
glUseProgramObjectARB(shadow);

//Framebufferobjekt aktivieren
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, shadow_fb);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//Die 8 Lichtquellen Rendern
for (int light;light<8;light++){
        glViewport (shadow_size/2*(lights/4),shadow_size/4 *(light%4),shadow_size/4,shadow_size/4);
        glUniform1iARB(glGetUniformLocationARB(parabol, "light"),light);
        glUniform1iARB(glGetUniformLocationARB(parabol, "renderpass"),0);
        render();
        glViewport (shadow_size/4+shadow_size/2*(lights/4), shadow_size/4*(light%4),shadow_size/4 ,shadow_size/4);
        glUniform1iARB(glGetUniformLocationARB(parabol, "renderpass"),1);
        render();
        }

// Framebufferobjekt deaktivieren
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);

//Richtigen Shader aktivieren
glUseProgramObjectARB(final);
//Vieport an Fenstergröße anpassen
glViewport(0, 0,Windowsize_X,Windowsize_Y);

//Frame rendern
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
render();

Die Shader

Shader zum Rendern der Schattenmaps

parabol.vert

  uniform int renderpass;
  uniform int light;
  varying vec3 normal;
  varying vec3 pos;

  void main(void){

	gl_Position = gl_ModelViewMatrix * gl_Vertex - gl_LightSource[light].position ;

	float L= length (gl_Position.xyz);
	gl_Position /= -L;
	if (renderpass == 1) gl_Position.z *=-1.0;
	gl_Position.z += 1.0;
	gl_Position.xy /= gl_Position.z;
	if (gl_Position.z >= 0.01){
		gl_Position.z = L / 15.0;
		gl_Position.w = 1.0;
		}
	else{
		gl_Position.z = -1.0;
		gl_Position.w = -1.0;
		}
	pos=gl_Position.xyz;
	}

parabol.frag

varying vec3 pos;
void main(void)
{
	if (length(pos.xy)>1.005)discard;
	gl_FragDepth  =  pos.z;
}

Es gibt zwei Uniformaviablen, die gesetzt werden müssen: Eine ist die Nummer der aktuellen Lichtquelle und die zweite der Renderpass, der angibt ob die Vorder oder Rückseite der parabolischen Map gerendert werden soll. Eine automatische Berechnung der Texturkoordinaten wäre zwar möglich, jedoch ist die Änderung des Viewports deutlich weniger Rechenaufwendig.

Stat einer Multiplikation des gl_Vertex mit der gl_ModelViewProjektionMatrix wird hier nur mit der gl_ModelViewMatrix multipliziert. Dadurch werden nur die Transformationen durchgeführt und die Projektion übersprungen. Die Division durch -L entspricht weitgehend einer Normalsierung, speigelt die Welt jedoch in die richtige Lage. L enthält jetzt die Tiefeninformation, gl_Position einen Vektor, der von der Kammera auf den Vertex Zeigt. Mit den 2 Folgenden Zeilen wird dieser wird der Vektor parabolisch auf die Bildschirmkoordinaten projeziert (Interwalle von -1.0 bis 1.0) . Mit hilfe der folgenden if abfrage werden alle Vertices hinter der Kammera geclipt. Nur sichtbare Verices bekommen gültige z Werte für den Zbugffer im Interwall von 0.0 bis 1.0. Da die komplette Projektionsmatrix von OpenGL irgnoriert wird, sind die Werte in gl_FragCoord nicht brauchbar und enthalten Teilweise Werteaus der festen Pipeline. Damit die eigenen Werte zuverlässig an den Fragmentshader übergeben wird die varying vec3 pos benutzt.

Der Fragmentshader ist extrem einfach, da wir Aufgrund des nicht vorhandem Colorbuffers keinen Frabwert benötigen lassen wir diesen einfach undeffiniert. Zudem verlassen wir den Shader mit discard, wenn der der Pixel außerhalb der aktuellen paraboliden Map liegt. Die nachfolgende Zeile ersetzt den für uns inkorrekten Z-Bufferwert aus der festen Pipeline. Dadurch können wir in späteren Shadern die Tiefenmap wie eine normale Textur auslesen.

Shader für den finalen Renderdurchgang

final.vert

varying vec3 Normal;
varying vec3 ModelVertex;

void main(void){
	Normal = gl_NormalMatrix * gl_Normal;
 	ModelVertex  = vec3 (gl_ModelViewMatrix * gl_Vertex);
	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
	gl_TexCoord[0] = gl_MultiTexCoord0;
 	}

final.frag

varying vec3 Normal;
varying vec3 ModelVertex;

uniform sampler2D Texture0; // Eine normale Textur 
uniform sampler2D Shadowmap;  //Damit ist auch die 4. TMU belegt..
uniform int MaxLights;

//Achtung folgende Zeile ist nicht GLSL konform. 
//Workaround: Array als Uniform übergeben oder durch sehr aufwendige berechnung erstzten
//Sollte es auch auf ATI Karten funktinieren, frage ich mich warum es nicht erlaubt ist...
const vec2 texofset[8] = {vec2 (0.125,0.125), vec2 (0.125,0.375), vec2 (0.125,0.625), vec2 (0.125,0.875),
			  vec2 (0.625,0.125), vec2 (0.625,0.375), vec2 (0.625,0.625), vec2 (0.625,0.875)};
void main(void){
	vec4 light=vec4 (0.2, 0.2, 0.2, 0.0); //Emmitiertes Licht
	vec3 normalvec =normalize(Normal.xyz);
	for (int LightNum = 0;LightNum < MaxLights; LightNum++){
		vec3 lightvec = ModelVertex - gl_LightSource[LightNum].position.xyz;
		vec3 lightdir = normalize( lightvec );
		vec2 parabol = texofset[LightNum];
		if (lightdir.z > 0.0){
			parabol.t += 0.25;
			}
                // parabolische Projektion für subtextur
		parabol -=  lightdir.xy * 0.125/ (abs (lightdir.z) + 1.0); 
		vec4 shadow = step (length(lightvec)/15.0 -0.05, texture2D(Shadowmap, parabol).r );
		light += shadow * gl_LightSource[LightNum].diffuse * abs(dot(normalvec, lightdir));
		}
	vec4 color = texture2D(Texture0, vec2(gl_TexCoord[0]));	//Textur auslesen; 
	gl_FragColor = light * color ;
	}

Diese Shader besitzen 3 Uniformvariablen, die umbedingt mit den richtigen Werten gefüllt werden müssen. zwei davon sind Texturen, die dritte die Anzahl der aktiven Lichtquellen. Es ist wichtig zu wissen, dass der Shader nicht den OpenGLstatus der Lichquellen berücksichtigt und nur die Daten der Ersten bis MaxLights hohlt. Wärend bei den Schattenmaps die meiste Arbeit im Vertexshader erledigt werden könnte, ist dieser sehr Fragmentshaderlastig. Die Texturkoordinatenberechnung ist sehr ähnlich zu der im shadow.vert. Die größte Änderung ist, dass hier abhängig von der Lichtquellennummer ein Offset aufaddiert wird um die Untertextur auszuwählen. Ein zusätzlicher Offset wird dazuaddiert, wenn auf die zweite parabolide Map einer Lichtquelle zugegriffen wird. Um ein dynamisches Branching zu vermeiden, wird mit der Stepfunktion ermittelt ob sich das Fragment im Schatten befindet.

Optimierungen und Verbesserungen

Hier sind noch einige Vorschläge, die helfen können um besser Qualität oder Leistungen im eigenem Programm zu bekommen.

Zweite parabolische Map vermeiden

Lichtquellen, die nur in eine Richtung Licht werfen können, wie z.B. Spotlichter oder Lichter, die in Bodenähe oder Wandnähe befestigt sind, benötigen keinen vollständig erfassten Tiefenraum. Die Parabolische Map kann problemlos herein oder heraussakiert werden, so das Öffnungs Winkel von 0 Grad bis ca 240 Grad möglich sind. Das verfkleinern des Öffnungswinkels für zusätzliche Spotlicher ermöglicht auch kleinere Tiefenmaps, die in die 9 Zwischenräume der großen gepackt werden können. Die Zwischenräume können noch Maps mit einem Durchmesser von 40% der großen Maps aufnehmen.

Texturelookups vermeiden

Wenn das Kreutzprodukt zwischen normalvec und -lightdir negativ ist, dann ist die Oberfläche von der Lichtquelle abgewandt und kann komplett übersprungen werden. Diverse Multiplikationen und Texturelookups könne so überspungen werden. Besonders Algoritmen wie Selbstschattierende Bumpmaps, können so beschleunigt werden. Realistisch betrachtet sind es meistens deulich weniger weniger als 50% lichquellenabgewante Fragmente.

Für die Beleuchtung sollte dann allerdings auch folgende Zeile verwendet werden. (Das Kreutsprodukt von vor der if Abfrage aber umbedingt wiederverwerten!)

 light += gl_LightSource[0].diffuse * max(dot(normalvec, -lightdir), 0.0);

Reichweite der Lichtquellen

Leider bietet QpenGL nicht direkt die Möglichkeit die maximale Reichweite einer Lichquelle anzugeben. In den Shadern wird zur Zeit der Wert 15.0 als maximale Entfernung zur Lichtquelle verwendet. Für ein einfaches Programm ist es sicher ausreichend, ansonsten macht es Sinn diesen Wert durch eine Unformvariable zu ersetzten, oder um mehr Flexibiltät zu bekommen durch ein Array aus 8 Uniformfloats.

Oversampling der Schattenmap

Die Qualität lässt sich dadurch mehere Samples auf der Schattenmap verbessern. Das folgende Codefragment nimmt 3 stat des einem Samples und glättet die Ränder des Schattens.

const float pof =1.0 /4096.0 *0.7;
vec4 shadow = step (length(lightvec)/15.0 -0.05, texture2D(Shadowmap, parabol +vec2(pof,0)).r );
shadow += step (length(lightvec)/15.0 -0.05, texture2D(Shadowmap, parabol+vec2(-pof/2.0,-pof/1.2) ).r );
shadow += step (length(lightvec)/15.0 -0.05, texture2D(Shadowmap, parabol+vec2(-pof/2.0,pof/1.2)).r );
light += shadow * 0.33 * gl_LightSource[LightNum].diffuse * abs(dot(normalvec, lightdir));

DUrch 9x Oversampling lässt sich schon eine sehr gute Qualität ereichen, sorgt aber bei 8 Lichtquellen durch die 72 Texturelookups für einen zusammenbruch der Framerate. Wichtig ist auch, dass man beachtet, dass die dualparaboliden Maps an Ihren Ränden undefiniert sind und so zu Artefakten kommen kann wenn man außerhalb des gültigem Bereichs sampled. Eine möglichkeit wäre einen Bereich zu erfassten der etwas größer als 180 Grad ist um am Rand zusätzliche Texel zu schaffen.

Ein zusätzlicher Renderpass

Nach dem die Tiefenmap gerendert würde, wäre es möglich in einem weiterem Framebufferobjekt eine zusätzliche Map zu rendern, in der mit hilfe einer Kantenerkennung die Helligkeit der Softshadows vorberechnet wird. Auch hier muss berücksichtigt werden, dass die dualparaboliden Maps einen Übergang haben.

Dynamische Lichter in statische Lightmaps Rendern

Wenn sich Lichtquellen nicht relativ zur Umgebung nicht bewegen, ist es möglich sie in eine Lightmap zu rendern. Unter der Annahme, dass Lightmapcoordinaten vorhanden sind (ohne geht es echt nicht gut), müssen diese nur per Vertexshader an den Pixelshader weitergegeben werden. Im Pixelshader kann dann wie im final.frag die Helligkeit berechnet werden und in der Lightmap abgespeichert werden.

Statische Anteile in den Schattenmaps

Es ist möglich mit einer zusätzlichen Matrix die Tiefenmaps zu den Weltkoordinaten auszurichten. Statische Anteile können dann aus einer zweiten Tiefenmap kopiert werden. Ein wenig problematisch ist das Entfernen der Rotation aus der gl_ModelViewMatrix.

//unvollständig
mat4 ModelMatrix = {length(vec3(gl_ModelViewMatrix[0])), 0.0, 0.0, gl_ModelViewMatrix[0][3],
                    0.0, length(vec3(gl_ModelViewMatrix[1])), 0.0, gl_ModelViewMatrix[1][3],
                    0.0, 0.0, length(vec3(gl_ModelViewMatrix[2])), gl_ModelViewMatrix[2][3],
                    0.0, 0.0, 0.0, gl_ModelViewMatrix[3][3]};

Vereinfachung für die Anname, das weder gestaucht noch gespiegelt wird:

float scale = length(vec3(gl_ModelViewMatrix[0]));
mat4 ModelMatrix = {scale, 0.0, 0.0, gl_ModelViewMatrix[0][3],
                    0.0, scale, 0.0, gl_ModelViewMatrix[1][3],
                    0.0, 0.0, scale, gl_ModelViewMatrix[2][3],
                    0.0, 0.0, 0.0  , gl_ModelViewMatrix[3][3]};

Funktioniert leider nichct, da die Lichtquellen bereits mit der ModelViewMatrix Multipliziert sind. Irgend wie scheit es da besser zu sein den Lichtvektor der Schattenmap mit einer Transponierten Normalmatrix zurückzudrehen. Vieleicht sollte ich diesen Teil doch besser erst mal weglassen

 
mat4 T-ModelViewMatrix = {gl_ModelViewMatrix[0][0],gl_ModelViewMatrix[1][0],gl_ModelViewMatrix[2][0],
                          gl_ModelViewMatrix[0][1],gl_ModelViewMatrix[1][1],gl_ModelViewMatrix[2][1],
                          gl_ModelViewMatrix[0][2],gl_ModelViewMatrix[1][2],gl_ModelViewMatrix[2][2]}

Da kann man nur hoffen, das der Compiler das wegoptimiert :/