DGL
https://delphigl.com/forum/

Per-Pixel Lighting
https://delphigl.com/forum/viewtopic.php?f=20&t=3154		 Seite 1 von 1
Autor:  crt [ So Aug 15, 2004 13:57 ]
Betreff des Beitrags:  Per-Pixel Lighting
Hallo!
Ich fang jezt auch mal mit Shadern an und hab auch shcon ne Frage.
Es reden ja alle immer davon, dass man mit Shadern ganz toll ein Per-Pixel Lighting machen kann.
Aber ich hab einfach keine Peilung, wie ich das machen soll... (das Tutorial hab ich shcon gelesen)
KAnn mir jemand nen Tip geben, wie ich das anstell?
Gibt es zum Per-Pixel Lighting Tutorials?
Autor:  @uzingLG [ So Aug 15, 2004 14:15 ]
Betreff des Beitrags: 
Per-Pixel Lighting ist eigentlich das selbe wie per-Vertex Lighting. Du musst die Berechnungen einfach aus dem Vertex Shader in den Pixel Shader verschieben. Hier gibt es einiges über Beleuchtung: http://www.wolfgang-engel.info/direct3d.net/.
Autor:  LarsMiddendorf [ Mo Aug 16, 2004 10:11 ]
Betreff des Beitrags: 
Unter OpenGL schreibt man dazu einen Vertex Shader und einen Fragment Shader. Das ist recht einfach, weil es mit so einer C ähnlichen Sprache glsl funktioniert. Diese Shader übergibt man dann als String an die jeweiligen OpenGL Funktionen und die Programme werden dann für jeden Vertex bzw. für jedes Fragment/jeden Pixel ausgeführt.

uniform sind Variablen die vom Programm gesetzt werdem.
varying sind Variablen die im VertexShader geschrieben, dann interpoliert und für im Fragment Shader gelesen werden.


Ein einfacher Shader, der nur die Entfernung vom Licht berücksichtigt, könnte z.B. so aussehen:


VertexShader:

Code:
  1.  
  2. varying vec3 lightvec;
  3. uniform vec3 lightpos;
  4. void main()
  5. {
  6.     lightvec = gl_Vertex.xyz-lightpos;
  7.     gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
  8. }



FragmentShader:

Code:
  1.  
  2. uniform vec4 lightcolor;
  3. uniform vec3 lightsize;
  4. varying vec3 lightvec;
  5. void main()
  6. {
  7.     vec3 a = lightvec / lightinvsize;
  8.     gl_Color = lightcolor * clamp(1.0 - dot(a,a),0.0,1.0)
  9. }
Autor:  La Boda [ So Feb 06, 2005 12:56 ]
Betreff des Beitrags: 
Sorry, dass ich diesen alten Thread wiederbelebe, aber warum einen neuen aufmachen?
Da ich nun begonnen habe, glSlang zu erlernen, habe ich mir gleich mal ein paar Aufgaben gesucht, die ich dann nacheinander abarbeiten wollte. Nachdem ich (glaube ich) das Prinzip und die Arbeitsweise der Shader verstanden habe, wollte ich mal eine simple Per-Pixel-Lichtberechnung machen. Aber da fangen die ersten Probleme an.
Bei meiner Planung habe ich mich an diesem Thread (!), dem Phong-Artikel auf Delphi3D.net und Saschas glsl-Tut orientiert.
Nachdem mir letztere mathematisch völlig klar sind, hab ich jetzt Probleme in der Umsetzung. Mir ist nämlich nie (!) klar, aus welchem Bezugssystem ich welchen Vektor berechnen soll.
Zum Beipsiel:
Code:
  1.  
  2.     lightvec = gl_Vertex.xyz-lightpos;      //<--- Bei Per-Pixel-Berechnungen ist doch das Vertex unwichtig?
  3.  


Code:
  1.  
  2. uniform vec4 lightcolor;                        //klar ;)
  3. uniform vec3 lightsize;                         // Lichtgröße ?????
  4. varying vec3 lightvec;                          //klar
  5. void main()
  6. {
  7.     vec3 a = lightvec / lightinvsize;         //lightinvsize ?????
  8.     gl_Color = lightcolor * clamp(1.0 - dot(a,a),0.0,1.0)   //Mehr oder weniger klar
  9. }



EDIT: Das größte Problem ist, das bei den meisten Artikeln zu diesem Thema im Internet immer nur der Code einfach so hingeklatscht wird. Diese funktionieren dann weder per Copy&Paste (man kann ja dann schrittweise nachvollziehen), noch versteht man die Hintergründe. Und bei theoretischen Artikeln (zB der vom Delphi3D.net) vermisse ich dann den praktischen Teil...
Autor:  LarsMiddendorf [ So Feb 06, 2005 14:10 ]
Betreff des Beitrags: 
1) Um den Vektor vom Licht zu einem Punkt zu berechnen muß man natürlich die Position des Punktes im Fragment Shader haben. Man könnte also die Position über eine varying Variable interpolieren.

Code:
  1. varying vec3 fragmentpos;
  2.  
  3. fragmentpos = gl_Vertex.xyz;



und dann im Fragment Shader den Lichtvektor berechnen:

Code:
  1. varying vec3 fragmentpos;
  2.  
  3. vec3 lightvec = fragmentpos - lightpos;


Aber man kann sich die Subtraktion im Fragment Shader auch sparen, weil sie da natürlich viel öfter als im Vertex Shader ausgeführt wird und den Lichtvektor gleich im Vertex Shader ausrechnen und interpolieren.
Die Interpolation der varying Variablen ist, bezogen auf die Welt, eine lineare Funktion. Daher gilt für f(fragmentpos - lightpos)=f(fragmentpos) - f(lightpos)=f(fragmentpos) - lightpos

2) Ja da muß natürlich / lightsize hin oder man dividiert das schon im Programm selber und schreibt das dann in eine andere Variable. Soweit ich weiß, werden Ausdrücke die nur auf uniform Variablen basieren, wie 1/lightsize momentan noch nicht durch den Treiber aus dem Shader herausgenommen und vorher berechnet.
Autor:  La Boda [ So Feb 06, 2005 14:27 ]
Betreff des Beitrags: 
AAHHHHHHHHHHHHHH, mir geht ein Licht auf!
Da wär ich ja nie draufgekommen, dass der Fragment-Shader durch die Interpolation (was mir übrigens ein schleierhafter Begriff ist) der Vertex-Shader-Werte Pixel-genaue Werte bekommt. Das muss ich natürlich gleich ausprobieren 8)
Autor:  DCW_Mr_T [ So Feb 06, 2005 16:04 ]
Betreff des Beitrags: 
Öhm .... ja
Also ich hab zu dem thema auch noch eine Frage: Die Code-Fragmente sehen sehr logisch aus, aber wie darf man das mit den Uniform-Variablen verstehen ... ich mein: Man übergibt ja nun die Position des Lichtes an die Shader, aber wie stellt man das an, wenn man nicht nur ein Licht haben möchte?
Autor:  La Boda [ So Feb 06, 2005 16:19 ]
Betreff des Beitrags: 
Da kann sogar ich dir helfen: http://www.delphigl.com/forum/viewtopic.php?t=3622
Ich glaub, da ist es genau um das Thema gegangen.
Seite 1 von 1 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/