shader Bumpmapping - Versionsgeschichte

Glawesome: /* Beschreibung */ TBN Matrix verlinkt

2014-01-03T19:45:26Z

‎Beschreibung: TBN Matrix verlinkt

Bergmann89 am 28. Juni 2012 um 07:07 Uhr

2012-06-28T07:07:45Z

Bergmann89: /* Code */

2010-07-13T00:01:16Z

‎Code

Bergmann89: /* Code */

2010-07-13T00:00:36Z

‎Code

Bergmann89: /* Code */

2010-07-13T00:00:00Z

‎Code

Bergmann89: /* Beschreibung */

2010-07-12T23:58:46Z

‎Beschreibung

Bergmann89 am 30. Juni 2010 um 16:47 Uhr

2010-06-30T16:47:48Z

Bergmann89 am 28. Februar 2010 um 23:47 Uhr

2010-02-28T23:47:37Z

Flash: /* Bumpmapping-Shader */

2010-02-28T20:37:10Z

‎Bumpmapping-Shader

Flash: /* Code */ Umgebrochen, so dass der Code auf kleineren Auflösungen nicht das Bild sprengt.

2010-02-28T20:35:15Z

‎Code: Umgebrochen, so dass der Code auf kleineren Auflösungen nicht das Bild sprengt.

@@ Zeile 21: / Zeile 21: @@
 ==Beschreibung==
-Der Bumpmapping Shader basiert auf dem [[shader_PerPixelLighting|Per Pixel-Beleuchtung]]-Shader. Der Unterschied zu diesem besteht darin, das wir die Normale nicht einfach so benutzen, wie sie an den Shader übergeben wurde, sondern wir sie erst mit den Daten aus der NormalMap manipulieren müssen. Dazu basteln wir uns eine Matrix aus der Sicht der Textur zusammen: x-Achse = Tangente, y-Achse = Bitangente und z-Achse = Normale.Die Berechnung der Vektoren erfolgt gemäß [http://hacksoflife.blogspot.com/2009/11/per-pixel-tangent-space-normal-mapping.html diesem Artikel].
+Der Bumpmapping Shader basiert auf dem [[shader_PerPixelLighting|Per Pixel-Beleuchtung]]-Shader. Der Unterschied zu diesem besteht darin, das wir die Normale nicht einfach so benutzen, wie sie an den Shader übergeben wurde, sondern wir sie erst mit den Daten aus der NormalMap manipulieren müssen. Dazu basteln wir uns eine [[TBN Matrix]] aus der Sicht der Textur zusammen: x-Achse = Tangente, y-Achse = Bitangente und z-Achse = Normale.Die Berechnung der Vektoren erfolgt gemäß [http://hacksoflife.blogspot.com/2009/11/per-pixel-tangent-space-normal-mapping.html diesem Artikel].
 Um weiter zu rechnen setzen wur nun die 3 Achsen zu einer Matrix zusammen:

@@ Zeile 40: / Zeile 40: @@
+{
 	gl_TexCoord[0]  = gl_MultiTexCoord0;
-	N          	= normalize(gl_Normal);
+	N          	= normalize(gl_NormalMatrix * gl_Normal);
 	V		= vec3(gl_ModelViewMatrix * gl_Vertex);
 	for(int i = 0; i < LIGHT_COUNT; i++){

@@ Zeile 85: / Zeile 85: @@
 	EndColor += gl_FrontMaterial.emission;
-	gl_FragColor = (gl_FrontLightModelProduct.sceneColor + EndColor + EndSpec) * texture2D(Texture0, vec2(gl_TexCoord[0]));
+	gl_FragColor = (gl_FrontLightModelProduct.sceneColor + EndColor + EndSpec) * texture2D(Texture0, TexCoord);
 }</source>

@@ Zeile 50: / Zeile 50: @@
 Fragmentshader:
-<source lang="glsl">void main(void){
+<source lang="glsl">const int LIGHT_COUNT = 1;
 	vec2 TexCoord = vec2(gl_TexCoord[0]);
 	vec3 Eye = normalize(-V);

@@ Zeile 50: / Zeile 50: @@
 Fragmentshader:
-<source lang="glsl">const float PI = 3.14159265;        //Pi, zur Berechnung der Rotation
+<source lang="glsl">void main(void){
-const int LIGHT_COUNT = 1;          //Anzahl der berücksichtigten Lichter
+	vec2 TexCoord = vec2(gl_TexCoord[0]);
-varying vec3 N;                     //NormalenVektor
+	vec3 Eye = normalize(-V);
-//dreht einen Punkt um eine Achse im Raum
+	vec3 q0 = dFdx(Eye.xyz);
-//@a: Achse um die gedreht wird
+	vec3 q1 = dFdy(Eye.xyz);
-//@p: Punkt der gedreht werden soll
+	vec2 st0 = dFdx(TexCoord.st);
-//@rad: Winkel im BogenMaß
+	vec2 st1 = dFdy(TexCoord.st);
-vec3 rotate(vec3 a, vec3 p, float rad){
-	vec3 p1 = cos(rad) * p +
+	vec3 S = normalize( q0 * st1.t - q1 * st0.t);
-         	  sin(rad) * cross(a, p);
+	vec3 T = normalize(-q0 * st1.s + q1 * st0.s);
-        //normale aud den NormalMapDaten und den Matricen errechnen
+	mat3 M = mat3(-T, -S, N);
-	vec3 normal = normalize((vec3(texture2D(Texture1, TexCoord)) - vec3(0.5, 0.5, 0.5)) * M);
+	vec3 normal = normalize(M * (vec3(texture2D(Texture1, TexCoord)) - vec3(0.5, 0.5, 0.5)));
 	vec4 EndColor = vec4(0.0, 0.0, 0.0, 0.0);
 	for(int i = 0; i < LIGHT_COUNT; i++){
 		vec3 Reflected = normalize(reflect(-lightvec[i], normal));
 		vec4 IAmbient  = gl_LightSource[i].ambient  * gl_FrontMaterial.ambient;
-		vec4 IDiffuse  = gl_LightSource[i].diffuse  * gl_FrontMaterial.diffuse  *
+		vec4 IDiffuse  = gl_LightSource[i].diffuse  * gl_FrontMaterial.diffuse  * max(dot(normal, lightvec[i]), 0.0);
-				 max(dot(normal, lightvec[i]), 0.0);
+		vec4 ISpecular = gl_LightSource[i].specular * gl_FrontMaterial.specular * pow(max(dot(Reflected, Eye), 0.0), gl_FrontMaterial.shininess);
-		vec4 ISpecular = gl_LightSource[i].specular * gl_FrontMaterial.specular *
+		EndColor += (IAmbient+IDiffuse);
-				 pow( max( dot(Reflected, Eye), 0.0), gl_FrontMaterial.shininess);
+		EndSpec  += ISpecular;
+	}
 	EndColor += gl_FrontMaterial.emission;
-	gl_FragColor = (gl_FrontLightModelProduct.sceneColor + EndColor) * texture2D(Texture0, TexCoord);
+	gl_FragColor = (gl_FrontLightModelProduct.sceneColor + EndColor + EndSpec) * texture2D(Texture0, vec2(gl_TexCoord[0]));
 }</source>

@@ Zeile 21: / Zeile 21: @@
 ==Beschreibung==
-Der Bumpmapping Shader basiert auf dem [[shader_PerPixelLighting|Per Pixel-Beleuchtung]]-Shader. Der Unterschied zu diesem besteht darin, das wir die Normale nicht einfach so benutzen, wie sie an den Shader übergeben wurde, sondern wir sie erst mit den Daten aus der NormalMap manipulieren müssen. Dazu basteln wir uns eine Matrix aus der Sicht der Textur zusammen: x-Achse = Tangente, y-Achse = Bitangente und z-Achse = Normale. Zunächst berechnen wir aus den Ableitungen der TexturKoordinaten den Gradienten, dieser liegt auf der X-Y-Ebene (z = 0) und zeigt an in welche Richtung die Funktion am stärksten ansteigt. Demzufolge zeigt der Gradient in die selbe Richtung wie die Tangente, wenn man sie auf die X-Y-Ebene vereinfachen würde:
+Der Bumpmapping Shader basiert auf dem [[shader_PerPixelLighting|Per Pixel-Beleuchtung]]-Shader. Der Unterschied zu diesem besteht darin, das wir die Normale nicht einfach so benutzen, wie sie an den Shader übergeben wurde, sondern wir sie erst mit den Daten aus der NormalMap manipulieren müssen. Dazu basteln wir uns eine Matrix aus der Sicht der Textur zusammen: x-Achse = Tangente, y-Achse = Bitangente und z-Achse = Normale.Die Berechnung der Vektoren erfolgt gemäß [http://hacksoflife.blogspot.com/2009/11/per-pixel-tangent-space-normal-mapping.html diesem Artikel].
 Um weiter zu rechnen setzen wur nun die 3 Achsen zu einer Matrix zusammen:
@@ Zeile 41: / Zeile 30: @@
 <source lang="glsl">vec3 normal = normalize((vec3(texture2D(Texture1, TexCoord)) - vec3(0.5, 0.5, 0.5)) * M);
 normal = gl_NormalMatrix * normal;</source>
 ==Code==

@@ Zeile 6: / Zeile 6: @@
 !width=20%|Version
 |-
-|Beleuchtet Primitiven per Pixel unter der zuhilfenahme einer Normalmap um einen Bumpmapping Effekt zu erzeugen.
+|per-Pixel-Beleuchtung unter Zuhilfenahme einer Normalmap um einen Bumpmapping Effekt zu erzeugen.
 |Bergmann
 |1.0