DGL
https://delphigl.com/forum/

unerklärlicher Beleuchtungs winkel
https://delphigl.com/forum/viewtopic.php?f=20&t=7181		 Seite 1 von 1
Autor:  Sellmann [ So Jan 06, 2008 00:13 ]
Betreff des Beitrags:  unerklärlicher Beleuchtungs winkel
Hi, ich habe mich gerade gefreut, dass ich einen Phongshader in glsl geschrieben habe und der auch soweit richtig gut aussieht, allerdings will ich nicht nur diffuse und specular texturabhängig haben, sondern auch die normalen, also bump mapping (oder normal mapping, kA was richtiger ist).

Ich habe dazu diverse papers im Netz durchgelesen und verschieden Varianten ausprobiert aus dem phong shader einen bump shader zu machen. Im Prinzip habe ich den light und den View vector mit der TBN matrix an den Normalspace angepasst und berechne ansonsten alles so wie vorher. Die Texturen und Daten werden komplett richtig übergeben, aber irgendwie scheint in dem bumpshader ein Problem mit dem Beleuchtungswinkel aufzutauchen. ebenfalls verändert sich as verhalten der Specular auf der Oberfläche erheblich.

Wenn jemand eine Ahnung hat, was ich falschgemacht habe, oder so, dann darf er mich das ruhig wissen lassen.

Das phong shader vertex object:
Code:
  1.  
  2. varying vec3 normal;
  3. varying vec3 v;
  4. varying vec3 lightvec;
  5.  
  6. void main(void)
  7. {
  8.   normal          = normalize(gl_NormalMatrix * gl_Normal);
  9.   v               = vec3(gl_ModelViewMatrix * gl_Vertex);
  10.   lightvec        = normalize(gl_LightSource[0].position.xyz - v);
  11.  
  12.   gl_Position     = gl_ModelViewProjectionMatrix * gl_Vertex;
  13.  
  14.   gl_TexCoord[0]  = gl_MultiTexCoord0;
  15. }
  16.  


Das phong shader fragment object:
Code:
  1.  
  2. uniform sampler2D diffspec;
  3.  
  4. varying vec3 normal;
  5. varying vec3 v;
  6. varying vec3 lightvec;
  7.  
  8. void main(void)
  9. {
  10.  vec3 Eye             = normalize(-v);
  11.  vec3 Reflected       = normalize( 2.0 * dot(normal, lightvec) * normal - lightvec);
  12.  vec3 base        = texture2D(diffspec,vec2(gl_TexCoord[0])).xyz;
  13.  
  14.  vec4 IAmbient        = gl_LightSource[0].ambient;
  15.  
  16.  vec4 IDiffuse        = gl_LightSource[0].diffuse * max(dot(normal, lightvec), 0.0);
  17.  
  18.  float lambertTerm    = dot(normal,lightvec);
  19.  
  20.  vec4 finalcolor      = gl_LightSource[0].ambient * vec4(base,1.0) * (1.0-lambertTerm);
  21.  
  22.     if (lambertTerm > 0.0)
  23.     {
  24.         finalcolor += gl_LightSource[0].diffuse * vec4(base,1.0) * lambertTerm;
  25.        
  26.         vec3 E = normalize(-v);
  27.         vec3 R = reflect(-lightvec, normal);
  28.         float specular = pow( max(dot(R, E), 0.0),
  29.                          120.0 );
  30.         finalcolor += gl_LightSource[0].diffuse * texture2D(diffspec,vec2(gl_TexCoord[0])).a * (specular*3.0); 
  31.     }
  32.  
  33.  gl_FragColor         = vec4(finalcolor.xyz,1.0);
  34. }
  35.  



Das bump shader vertex object:
Code:
  1.  
  2. varying vec3 eyevec;
  3. varying vec3 lightvec;
  4.  
  5. attribute vec3 vTangent;
  6.  
  7. void main(void)
  8. {
  9.   gl_Position     = gl_ModelViewProjectionMatrix * gl_Vertex;
  10.   gl_TexCoord[0]  = gl_MultiTexCoord0;
  11.  
  12.   vec3 v          = vec3(gl_ModelViewMatrix * gl_Vertex);
  13.   vec3 tmpvec     = normalize(gl_LightSource[0].position.xyz - v);
  14.  
  15.   vec3 n = normalize(gl_NormalMatrix * gl_Normal);
  16.   vec3 t = normalize(gl_NormalMatrix * vTangent);
  17.   vec3 b = cross(t, n);
  18.  
  19.   lightvec.x = dot(tmpvec, t);
  20.   lightvec.y = dot(tmpvec, b);
  21.   lightvec.z = dot(tmpvec, n);
  22.  
  23.   tmpvec = -v;
  24.   eyevec.x = dot(tmpvec, t);
  25.   eyevec.y = dot(tmpvec, b);
  26.   eyevec.z = dot(tmpvec, n);
  27. }
  28.  


Das bump shader fragment object:
Code:
  1.  
  2. uniform sampler2D diffspec;
  3. uniform sampler2D normhei;
  4.  
  5. varying vec3 eyevec;
  6. varying vec3 lightvec;
  7.  
  8. void main(void)
  9. {
  10.  vec3 normal          = texture2D(normhei,vec2(gl_TexCoord[0])).xyz;
  11.  vec3 Reflected       = normalize( 2.0 * dot(normal, lightvec) * normal - lightvec);
  12.  vec3 base        = texture2D(diffspec,vec2(gl_TexCoord[0])).xyz;
  13.  
  14.  float lambertTerm    = dot(normal,lightvec);
  15.  
  16.  vec4 finalcolor      = gl_LightSource[0].ambient * vec4(base,1.0) * (1.0-lambertTerm);
  17.  
  18.     if (lambertTerm > 0.0)
  19.     {
  20.         finalcolor += gl_LightSource[0].diffuse * vec4(base,1.0) * lambertTerm;
  21.        
  22.         vec3 E = normalize(-eyevec);
  23.         vec3 R = reflect(-lightvec, normal);
  24.         float specular = pow( max(dot(R, E), 0.0),
  25.                          120.0 );
  26.         finalcolor += gl_LightSource[0].diffuse * texture2D(diffspec,vec2(gl_TexCoord[0])).a * (specular*3.0); 
  27.     }
  28.  
  29. gl_FragColor          = vec4(finalcolor.xyz,1.0);
  30. }
  31.  


Ich denke, es ist offensichtlich, dass sich kaum etwas geändert hat, trotzdem strahlt das Lich aus einer falschen Richtung.
dank vorweg;

[Edit] -> falsch c&p;
Autor:  oc2k1 [ So Jan 06, 2008 03:52 ]
Betreff des Beitrags: 
Beim dot3 bumpmapping gibt es zwei Varianten: Eine arbeitet im texturspace das war füher nötig, da Register combiner keine matrixmultiplikation durchführen konnten, Der nachteil ist, das jede Lichtquelle ebenfalls in den texturspace transformiert werden muss.

Heute kann man es sich ohne Probleme erlauben. Den Normalvektor aus der normalmap in den modelviewspace zu projezieren. Über gib einfach die TBN matrix an den Fragmentshader. Da dieser Code immer wieder gebraucht wird hab ich ihn hier als Tutorial abgelegt:
http://lumina.sourceforge.net/?id=23
Autor:  Sellmann [ So Jan 06, 2008 14:20 ]
Betreff des Beitrags: 
Aller besten Dank!

Ich habe nichtbeachtet, dass die Normalmap einen Bereich von 0 bis 1 besitzt, die normalen aber einen bereich von -1 bis +1.
Richtig siehts so aus:

Code:
  1.  
  2. vec3 normal       = texture2D(normhei,vec2(gl_TexCoord[0])).xyz -0.5;
  3.  


wichtig ist das -0.5 am ende der Zeile gewesen, die den Bereich verschiebt/korrigiert.
Ja dumm gelaufen, dieser Fehler hat mich verfolgt.

Danke du hast mir sehr geholfen!!


Freude~
Autor:  Lord Horazont [ So Jan 06, 2008 14:44 ]
Betreff des Beitrags: 
Moment, fehlt da nicht noch ein * 2.0?
Wenn du werte von 0 bis 1 hast und diese -0.5 nimmst, hast du werte von -0.5 bis 0.5. Da müsstest du doch noch mal zwei nehmen, damit du werte von -1.0 bis 1.0 hast, oder?

Gruß Lord Horazont
Autor:  oc2k1 [ So Jan 06, 2008 15:00 ]
Betreff des Beitrags: 
in dem Fall nicht, da in der nächten Zeile. der normalmapvektor aus dem texturspace ind den Modelviewspace rotiert wird und dann anschließend normalisiert wird. Noch besser wäre die variante ein signed texture format zu verweden...
Seite 1 von 1 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/