DGL
https://delphigl.com/forum/

Wieso funktioniert dies ?
https://delphigl.com/forum/viewtopic.php?f=20&t=11045		 Seite 1 von 3
Autor:  mathias [ Fr Dez 13, 2013 18:49 ]
Betreff des Beitrags:  Wieso funktioniert dies ?
Wieso kann dieser VertexShader überhaupt funktionieren.
Anstelle von inColor und inPos, habe ich Fantasienamen geschrieben.
Wie kann OpenGL überhaupt wissen was ich mit diesen Namen meine.
Der Namen xxxin... ist im Delphi-Quellcode auch nirgends erwähnt.

Die Variable Color kann ich auch einen anderen Namen geben, nur muss sie im Fragment und im VertexShader gleich heissen. Diese Variable ist wohl die Verbindung zwischen den beiden Shadern.
Code:
  1. #version 330
  2. // Input vom VBO:
  3. in vec3 xxxinPos;
  4. in vec4 xxxinColor;
  5.  
  6. uniform vec3 meinMove;
  7. uniform mat4 meinMatrix;
  8. uniform mat4 CameraMatrix;
  9.  
  10. uniform float col;
  11.  
  12. // Ausgabe an den Fragmentshader:
  13. out vec4 Color;
  14.  
  15. void main(void)
  16. {
  17.   gl_Position = CameraMatrix * meinMatrix * vec4(xxxinPos.xyz + meinMove, 1.0);
  18.   Color = xxxinColor + col;
  19. }            
Autor:  glAwesome [ Fr Dez 13, 2013 19:25 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Mit welchen Werten die in-Variablen eines Vertexshaders belegt werden sollen, legst du beim Aufruf von glVertexAttribPointer fest. Tust du dies nicht, sind die Werte undefiniert, würde ich sagen.

mathias hat geschrieben:
Die Variable Color kann ich auch einen anderen Namen geben, nur muss sie im Fragment und im VertexShader gleich heissen. Diese Variable ist wohl die Verbindung zwischen den beiden Shadern.
Korrekt. Zu jeder in-Variable im Fragmentshader muss es eine gleichnamige out-Variable im Vertexshader geben. Früher hieß das nicht in und out, sondern varying.
Autor:  mathias [ Fr Dez 13, 2013 20:00 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Hier steht nirgends was von xxxinColor oder inColor.

Code:
  1.   glBindVertexArray(uiVAO[0]);
  2.  
  3.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);
  4.   glBufferData(GL_ARRAY_BUFFER, sizeof(fTriangle), @fTriangle, GL_STATIC_DRAW);
  5.   glEnableVertexAttribArray(0);
  6.   glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, nil);
  7.  
  8.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[1]);
  9.   glBufferData(GL_ARRAY_BUFFER, sizeof(fTriangleColor), @fTriangleColor, GL_STATIC_DRAW);
  10.   glEnableVertexAttribArray(1);
  11.   glVertexAttribPointer(1, 3, GL_FLOAT, False, 0, nil);
Autor:  glAwesome [ Fr Dez 13, 2013 20:09 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Du rufst zwei Mal glVertexAttribPointer auf und zwar mit 0 und 1 als erstes Argument. "Zufällig" sind das offenbar die Nummern, die dein Grafiktreiber für deine in-Variablen vergeben hat. Darauf kannst du dich nicht verlassen. Korrekterweise müsstest du diese IDs erst mit glGetAttribLocation abfragen (nach dem Linken) oder vor dem Linken mit glBindAttribLocation festlegen.

Edit: Eine weitere Möglichkeit ist es, die IDs der VS-Inputs mit dem keyword layout festzulegen. Beispiel:
Code:
  1. #version 330
  2. layout(location = 345) in vec3 xxxinPos;
  3. layout(location = 123) in vec4 xxxinColor;
Dies geht in älteren GLSL-Versionen jedoch nicht. Kann sogar sein, dass dies erst mit #version 330 dazu gekommen ist.
Autor:  mathias [ Fr Dez 13, 2013 21:39 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Ich habe ein Tutorial dazu gefunden, dank deiner Befehle.

Ich hoffe das es jetzt so richtig ist. Wen ich jetzt die xxx reinschreibe, bleibt das OpenGL-Fenster leer. Ich habe die Werte von Pos_id und col_id abgefragt und da kommt -1, wen ich die xxx reinschreibe und das ist richtig so.
Somit ist wieder eine Fehlerquelle ausgeschlossen. :)
In dem Tutorials, es waren 2, nach denen ich mein Programm geschrieben habe, finde ich nichts von glGetAttribLocation. Bei den ids kommen 0 und 1 raus und dies wird wohl der Programmierer des Tutorials ausgenutzt haben

Code:
  1. var
  2.   uiVBO: array[0..5] of UINT;
  3.   uiVAO: array[0..2] of UINT;
  4.  
  5.   pos_id, col_id: GLint;
  6.  
  7. procedure TForm1.InitScene;
  8. begin
  9.   ProgramID := InitShader;
  10.   glUseProgram(programID);
  11.  
  12.   glClearColor(0.0, 0.5, 1.0, 1.0); //Hintergrundfarbe: Hier ein leichtes Blau
  13.  
  14.   // Enable depth test
  15.   glEnable(GL_DEPTH_TEST);
  16.   // Accept fragment if it closer to the camera than the former one
  17.   glDepthFunc(GL_LESS);
  18.  
  19.   //--- Transparente Elemente
  20.   //  glEnable(GL_BLEND);
  21.   //  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  22.   //---
  23.  
  24.   pos_id := glGetAttribLocation(ProgramID, 'inPos');
  25.   col_id := glGetAttribLocation(ProgramID, 'inColor');
  26.  
  27.   glGenVertexArrays(3, uiVAO); // Generate two VAOs, one for triangle and one for quad
  28.  
  29.   glGenBuffers(6, uiVBO); // And four VBOs
  30.  
  31.   // Setup whole triangle
  32.   glBindVertexArray(uiVAO[0]);
  33.  
  34.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);
  35.   glBufferData(GL_ARRAY_BUFFER, sizeof(fTriangle), @fTriangle, GL_STATIC_DRAW);
  36.   glEnableVertexAttribArray(pos_id);
  37.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  38.  
  39.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[1]);
  40.   glBufferData(GL_ARRAY_BUFFER, sizeof(fTriangleColor), @fTriangleColor, GL_STATIC_DRAW);
  41.   glEnableVertexAttribArray(col_id);
  42.   glVertexAttribPointer(col_id, 3, GL_FLOAT, False, 0, nil);
  43.  
  44.   // Setup whole Quad
  45.   glBindVertexArray(uiVAO[1]);
  46.  
  47.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[2]);
  48.   glBufferData(GL_ARRAY_BUFFER, sizeof(fquad), @fQuad, GL_STATIC_DRAW);
  49.   glEnableVertexAttribArray(pos_id);
  50.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  51.  
  52.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[3]);
  53.   glBufferData(GL_ARRAY_BUFFER, sizeof(fQuadColor), @fQuadColor, GL_STATIC_DRAW);
  54.   glEnableVertexAttribArray(col_id);
  55.   glVertexAttribPointer(col_id, 3, GL_FLOAT, False, 0, nil);
  56.  
  57.   // Setup whole Cube
  58.   glBindVertexArray(uiVAO[2]);
  59.  
  60.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[4]);
  61.   glBufferData(GL_ARRAY_BUFFER, sizeof(fCube), @fCube, GL_STATIC_DRAW);
  62.   glEnableVertexAttribArray(pos_id);
  63.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  64.  
  65.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[5]);
  66.   glBufferData(GL_ARRAY_BUFFER, sizeof(fCubeColor), @fCubeColor, GL_STATIC_DRAW);
  67.   glEnableVertexAttribArray(col_id);
  68.   glVertexAttribPointer(col_id, 3, GL_FLOAT, False, 0, nil);
  69.  
  70. end;
Autor:  mathias [ So Dez 15, 2013 17:32 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Ich habe noch was komisches in meinem Quelltext gefunden.

Wen ich es richtig verstehe, ist outColor auch undefiniert.
In verschiedenen Tutorials über Licht habe ich gelesen, das man gl_FragColor nehmen kann.
Auch diese Zeilen sind verschieden.
alt: in vec4 Color;
neu: varying vec4 Color;

Code:
  1. #version 330
  2. in vec4 Color;     // interpolierte Farbe vom Vertexshader
  3. out vec4 outColor; // ausgegebene Farbe
  4.  
  5. void main(void)
  6. {
  7.   outColor = Color;
  8. }  

Code:
  1. #version 330
  2. varying vec4 Color      // interpolierte Farbe vom Vertexshader
  3.  
  4. void main(void)
  5. {
  6.   gl_FragColor = Color;
  7. }
Autor:  glAwesome [ So Dez 15, 2013 17:40 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
gl_FragColor und varying sind deprecated. Bei deren Benutzung in #version 330 wird der Compiler mindestens eine Warnung ausspucken. Aktuell sind in und out. outColor kannst du allerdings benennen, wie du willst. Da es die einzige out-Variable im Fragmentshader ist, weiß der Compiler, dass die Farbe gemeint ist.

Man kann auch mehr als nur eine Farbe im Fragmentshader ausgeben. Wie man dem Treiber dann sagt, welche Variable was sein soll, wüsste ich auch gerne. Vielleicht weiß das ja jemand hier.
Autor:  OpenglerF [ So Dez 15, 2013 17:48 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Zitat:
alt: in vec4 Color;
neu: varying vec4 Color;

Nein, genau andersrum.

Wenn im Fragmentshader in mehrere Colorbuffer gerendert wird, muss man, glaube ich, einfach ein Array verwenden.

Bei Tutorials musst du darauf achten, das es OpenGL 3.3 Tutorials sind. Bei den Shadern war früher die Syntax etwas anders.
Autor:  mathias [ So Dez 15, 2013 17:56 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Dann habe ich da wieder mal was altes erwischt, als ich was über Licht suchte. http://wiki.delphigl.com/index.php/Tuto ... l-Lighting

Momentan suche ich was über Licht.
Autor:  glAwesome [ So Dez 15, 2013 18:16 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
mathias hat geschrieben:
Dann habe ich da wieder mal was altes erwischt, als ich was über Licht suchte. http://wiki.delphigl.com/index.php/Tuto ... l-Lighting

*alten Post rauskram*
glAwesome hat geschrieben:
Die Sprache hat sich nicht soo grundsätzlich geändert. Die wesentlichen Änderungen sind:
  • Alle eingebauten Variablen sind verschwunden (Ausnahme: gl_Position und gl_PointSize im Vertexshader, gl_FragCoord im Fragmentshader und wenige andere). Sie werden nun bei Bedarf selbst deklariert und übergeben.
  • Statt attribute wird im Vertexshader nun in geschrieben.
  • varying gibt es nicht mehr. Stattdessen werden diese Variablen im VS mit out und im FS mit in deklariert.
  • In der ersten Zeile jedes Shaders wird nun eine #version-Direktive geschrieben, z.B. #version 330 oder #version 120
  • Da die OpenGL-Funktionen zum Verwalten der Shader inzwischen im Kern angekommen sind, fällt natürlich das ARB am Ende weg.
Autor:  OpenglerF [ So Dez 15, 2013 18:46 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Also bei Licht muss man jetzt ein wenig anders vorgehen, weil im Gegensatz zu früher als eine kleine feste Menge an Möglichkeiten vorgegeben war, man jetzt das Lighting selber programmieren kann.

Im Gegensatz zu früher, solltest du dir jetzt also erstmal überlegen, was du überhaupt benötigst um genau das dann in GLSL umzusetzen. Ich würde für den Anfang mal ein Pointlight umsetzen. Directionallight kann man damit im Prinzip ersetzen, wenn man die Lichtquelle weit genug weg setzt und Spotlights sind eher selten notwendig und sind außerdem genau genommen ein Pointlight mit einen Schatten außenrum. Viele Anwendungen brauchen auch kein Lighting oder es läuft da komplett anders ab. (2D) Wie in einen anderem Thema bereits ausgeführt, würde ich auch davon absehen, die Materialeigenschaften farbig zu speichern wie es auch früher in der Fixed-Pipeline der Fall war. Außerdem macht es heutzutage Sinn, die Lichtberechnung pro Fragment und nicht pro Vertex auzuführen. Gerade Glanzlicht sieht dann einfach deutlich besser aus und die Modelle müssen für gute Lichter nicht mehr unterteilt werden.

Diesen Code sollte für ein Point Light funktionieren, du musst ihn also möglicherweise noch erweitern. (zb. mehrere Lichter) Da ich ihn jetzt auf die Schnelle nicht ausprobiert habe keine 100% Funktionsgarantie.
Code:
  1.  
  2. in vec3 Normal;
  3. in vec3 Position; //Modelspace
  4. in vec4 Color;
  5. in vec2 TextureCoord;
  6.  
  7. uniform float AmbientStrength;
  8. uniform float DiffuseStrength;
  9. uniform float SpecularStrength;
  10. uniform float Shininess;
  11. uniform vec3 LightPosition;
  12. uniform vec4 LightColor;
  13.  
  14. uniform sampler2D Texture0;
  15.  
  16. out FragColor;
  17. void main()
  18. {
  19.     vec3 EyeNormal = normalize(Position);
  20.     vec3 NormalizedNormal = normalize(Normal);
  21.     vec3 LightDirection = normalize(Position - LightPosition);
  22.     vec3 ReflectedLight = normalize(reflect(LightDirection, NormalizedNormal));
  23.  
  24.     float DiffusePart = max(dot(NormalizedNormal, LightDirection), 0.0);
  25.     float SpecularPart = pow(max(dot(ReflectedLight , EyeNormal), 0.0), Shininess);
  26.  
  27.     float Light = AmbientStrength +
  28.                      DiffuseStrength * DiffusePart +
  29.                       SpecularStrength * SpecularPart;
  30.  
  31.     vec4 FinalColor = Color * texture2D(Texture0, TextureCoord);
  32.     FragColor = vec4(Light, Light, Light, 1) * FinalColor;
  33. }
  34.  
Autor:  mathias [ So Dez 15, 2013 22:45 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Ich habe die Werte durch Konstanten ersetzt und die Texturenfunktion gelöscht. Von Licht keine Spur. Das einzige die Farben sehen komisch aus. Wen wenigsten die Farben beim drehen sich ändern würden.
Habe ich da mit Normal und Position einen Fehler ?

Fragmentshader:
Code:
  1. #version 330
  2.  
  3. in vec3 Normal;
  4. in vec3 Position; //Modelspace
  5.  
  6. in vec4 Color;
  7. float AmbientStrength = (0,1);
  8. float DiffuseStrength = (0,1);
  9. float SpecularStrength = (0,1);
  10. float Shininess = (0,1);
  11. vec3 LightPosition = vec3(1.0, 0.0, 0.0);
  12. vec4 LightColor = vec4(1.0, 1.0, 1.0, 1.0);
  13.  
  14. out vec4 FragColor;
  15.  
  16. void main()
  17. {
  18.     vec3 EyeNormal = normalize(Position);
  19.     vec3 NormalizedNormal = normalize(Normal);
  20.     vec3 LightDirection = normalize(Position - LightPosition);
  21.     vec3 ReflectedLight = normalize(reflect(LightDirection, NormalizedNormal));
  22.  
  23.     float DiffusePart = max(dot(NormalizedNormal, LightDirection), 0.0);
  24.     float SpecularPart = pow(max(dot(ReflectedLight , EyeNormal), 0.0), Shininess);
  25.  
  26.     float Light = AmbientStrength +
  27.                      DiffuseStrength * DiffusePart +
  28.                       SpecularStrength * SpecularPart;
  29.  
  30.     vec4 FinalColor = Color;
  31.     FragColor = vec4(Light, Light, Light, 1) * FinalColor;
  32. }

Vertexshader:
Code:
  1. #version 330
  2. // Input vom VBO:
  3. in vec3 inPos;
  4. in vec4 inColor;
  5.  
  6. uniform mat4 meinMatrix;
  7. uniform mat4 CameraMatrix;
  8.  
  9. out vec4 Color;
  10.  
  11. out vec3 Position;
  12. out vec3 Normal;
  13.  
  14. void main(void)
  15. {
  16.   Position = inPos;
  17.   Normal = inPos;
  18.  
  19.   gl_Position = CameraMatrix * meinMatrix * vec4(inPos, 1.0);
  20.   Color = inColor;
  21. }


Dateianhänge:
Zwischenablage-1.jpg
Zwischenablage-1.jpg [ 6.27 KiB | 20383-mal betrachtet ]
Autor:  glAwesome [ So Dez 15, 2013 23:28 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Zum Fragmentshader:
Code:
  1. float AmbientStrength = (0,1);
Fließkommazahlen schreibt man in GLSL nicht mit Komma, sondern mit Punkt. Die Klammern brauchst du dabei nicht. Schluckt der Compiler das einfach so?

Zum Vertexshader:
Du solltest nicht den Positionsvektor als Normalenvektor missbrauchen. Steck die Normalen einfach mit ins VBO.
Möglicherweise möchtest du inPos nicht einfach nach Position kopieren, sondern vorher mit meinMatrix multiplizieren. Dann vergiss nicht, Dies mit dem Normalenvektor ebenfalls zu tun:
Code:
  1. Position = meinMatrix * inPos;
  2. Normal = mat3(meinMatrix) * inNormal;
Autor:  OpenglerF [ Mo Dez 16, 2013 14:12 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Ich vermute, die Normalen stimmen nicht. Du kannst auch einfach mal zum Testen die eizelnen Wertei wie Normalen im Shader ausgeben lassen. Also einfach zum Beispiel: "FragColor = vec4(NormalizedNormal, 1.0);"
Zitat:
Dann vergiss nicht, Dies mit dem Normalenvektor ebenfalls zu tun:

Das stimmt, allerdings sollte das so nicht funktionieren. Ich habe gerade so im Kopf, dass man Normalen mit der transponierten inversen Matrix multiplizieren muss. Warum das so ist, kann ich allerdings auch gerade nicht sagen, aber es gibt sicher einen mathematischen Grund.
Autor:  mathias [ Mo Dez 16, 2013 17:47 ]
Betreff des Beitrags:  Re: Wieso funktioniert dies ?
Zitat:
Fließkommazahlen schreibt man in GLSL nicht mit Komma, sondern mit Punkt. Die Klammern brauchst du dabei nicht. Schluckt der Compiler das einfach so?

Komisch der Compiler hat das ',' geschluckt, sonst hätte ich dies gemerkt. Vielleicht hat der Compiler dies als Array angenommen. Ich habe die Klammern weggenommen und die ',' durch '.' ersetzt.
Der Vertexshader habe ich abgeändert aber es kommt zur Fehlermeldung bei diesen beiden
Zeilen.
Was kommt in inNormal ?
Code:
  1.   Position = meinMatrix * inPos;
  2.   Normal = mat3(meinMatrix) * inNormal;


Dateianhänge:
Zwischenablage-1.jpg
Zwischenablage-1.jpg [ 37.85 KiB | 20344-mal betrachtet ]
Seite 1 von 3 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/