DGL
https://delphigl.com/forum/

Standard Werte in struct
https://delphigl.com/forum/viewtopic.php?f=20&t=11333		 Seite 1 von 1
Autor:  mathias [ So Jan 25, 2015 18:05 ]
Betreff des Beitrags:  Standard Werte in struct
Kann man bei struct auch Default-Werte zuweisen ?

Code:
  1. struct Ttest
  2. {
  3.   float x;
  4.   float y;
  5. };
  6.  
  7. uniform Ttest test = (3.3, 4.4); // geht nicht, Syntax-Fehler
  8.  
  9. uniform float UmgebungsLicht = 0.3;  // geht    
Autor:  Bergmann89 [ So Jan 25, 2015 18:47 ]
Betreff des Beitrags:  Re: Standard Werte in struct
So sollte es gehen (untested):
Code:
  1. uniform Ttest test = Ttest(3.3, 4.4);
Autor:  mathias [ So Jan 25, 2015 20:15 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Danke, jetzt geht es, dies kompiliert er ohne Fehler.

Code:
  1. struct Light
  2. {
  3.   vec4 position;
  4.   vec4 ambientColor;
  5.   vec4 diffuseColor;
  6.   vec4 specularColor;
  7.   vec3 specularDirection;
  8. };
  9.  
  10. uniform Light light = Light(
  11.   vec4(-1.5, 1.5, 1.5, 1.0),
  12.   vec4(0.2, 0.2, 0.2, 1.0),
  13.   vec4(0.8, 0.8, 0.8, 1.0),
  14.   vec4(1.0, 1.0, 1.0, 1.0),
  15.   vec3(0.0, 0.0, -1.0)
  16. );    
Autor:  mathias [ Mi Jan 28, 2015 22:49 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Ich habe folgenden Code gefunden.
Code:
  1. layout (std140) uniform Materials {
  2.     vec4 diffuse;
  3. };

Wen ich dort eine Standard-wert zuweisen will, kommt ein Fehler.
Code:
  1. layout (std140) uniform Materials {
  2.   vec4 diffuse = vec4(0.1, 1.0, 1.0, 1.0);
  3. };  

Muss ich da den Umweg über struct machen ?

Was macht layout (std140), mit google habe ich nichts schlaues gefunden ?
Autor:  OpenglerF [ Do Jan 29, 2015 12:15 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Ein Blick ins OpenGL Wiki:
https://www.opengl.org/wiki/GLSL_Interf ... ory_layout
Autor:  mathias [ So Feb 01, 2015 23:09 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Jetzt weiss ich wie man Block-Uniform ansprechen kann.

Shader:

Code:
  1. layout (std140) uniform Materials {
  2.   vec4 diffuse;    // Farbe
  3.   vec4 ambient;    // Umgebungslicht
  4.   vec4 specular;   // Spiegelnd
  5.   float shininess; // Glanz
  6. };


Code:
  1. type
  2.   TMaterial = record
  3.     diffuse: TVector4f;    // Farbe
  4.     ambient: TVector4f;    // Umgebungslicht
  5.     specular: TVector4f;   // Spiegelnd
  6.     shininess: glFloat;    // Glanz
  7.   end;
  8.  
  9. const
  10.   Material: TMaterial = (
  11.     diffuse: (0.2, 0.05, 0.05, 1.0);
  12.     ambient: (0.1, 0.1, 0.1, 1.0);
  13.     specular: (0.1, 0.1, 0.1, 1.0);
  14.     shininess: 0.1);  
  15.  
  16. var
  17.   Mat_ID, buffer: gluint;
  18.   bindingPoint: gluint = 1;  
  19.  
  20. ...
  21.     Mat_ID := glGetUniformBlockIndex(Program_ID, 'Materials');
  22.     glUniformBlockBinding(Program_ID, Mat_ID, bindingPoint);
  23.  
  24.     glGenBuffers(1, @buffer);
  25.     glBindBuffer(GL_UNIFORM_BUFFER, buffer);
  26.  
  27.     glBufferData(GL_UNIFORM_BUFFER, sizeof(Material), @Material, GL_DYNAMIC_DRAW);
  28.     glBindBufferBase(GL_UNIFORM_BUFFER, bindingPoint, buffer);
  29.  
  30. //    glDeleteBuffers(1, @buffer);


Ich nehme mal an, das dies die schnellere Variante ist, als jede Uniform-Variable einzeln zu übergeben.

Sind Uniform Übergabe eine teure Sache ?
Oder merkt man es nicht gross, wen man bei jedem Draw-Scene es aufruft ?
Autor:  TAK2004 [ Mo Feb 02, 2015 08:59 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Uniform bilden aktuell(OpenGL 3 und aufwärts) das größte Bottleneck in deferred rendering engines.
Uniform updates benötigen sehr häufig einen syncpoint, dieser ist eine synchronisierung zwischen GPU und CPU, also beide warten aufeinander, bis sie frei sind und genau die Bus Frequence überlappt. Dann werden Daten ausgetauscht und beide dürfen normal weiter arbeiten. Syncpoints kann man laut "Zero Overhead" Team mit einem Profiler auf spüren, diese Calls kosten in der regel auf der CPU mehr als 1us.
Bindless API und UBO zielt genau auf dieses Problem ab.
UBO benutzt man, um die Anzahl der Syncpoints zu reduzieren, in dem man mehrere Daten in ein Objekt packt und das Objekt dann updated.
Matrizen für Kamera und Licht werden häufig als UBO verpackt oder Shader und deren Settings für ein Material(was deferred rendering sehr exessiv benutzt).

Google mal nach Zero Driver Overhead und da gibt es dann diverse links zu verwandte Paper.
NV hatte glaub bei Command Buffer Object Slide ne Liste von Syncpoint Kaniddaten.
Autor:  mathias [ Mo Feb 02, 2015 18:10 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Wen ich es richtig verstehe, würde so etwas Sinn machen ?

Code:
  1. layout (std140) uniform allUniforms {
  2.   vec4 diffuse;  
  3.   vec4 ambient;
  4.   vec4 specular;
  5.   float shininess;
  6.   mat4 WorldMatrix; // (neu)
  7. };
  8.  
  9. uniform sampler2D myTextureSampler[4]; // wird nur einmal inizialisiert
Autor:  TAK2004 [ Mo Feb 02, 2015 20:01 ]
Betreff des Beitrags:  Re: Standard Werte in struct
allUniforms ist ein viel versprechender UBO Kandidat.
http://www.geeks3d.com/20140704/gpu-buffers-introduction-to-opengl-3-1-uniform-buffers-objects/

Privat benutzt ich GLSL 4.2 location und named UBO.
Dies erlaubt, dann auch die Texturen initial zu binden.
Binding points
Code:
  1.     struct SharedTransformUniforms
  2.     {
  3.         RF_Geo::Mat4f ModelView;
  4.         RF_Geo::Mat4f ModelViewProjection;
  5.     } m_SharedTransformUniforms;
  6.  
  7. // init
  8.     GLfloat points[] = {
  9.         0.0f, 0.5f, 0.0f,
  10.         0.5f, -0.5f, 0.0f,
  11.         -0.5f, -0.5f, 0.0f
  12.     };
  13.     GLfloat colours[] = {
  14.         1.0f, 0.0f, 0.0f,
  15.         0.0f, 1.0f, 0.0f,
  16.         0.0f, 0.0f, 1.0f
  17.     };
  18.     GLuint vbo = 0;
  19.     glGenBuffers(1, &vbo);
  20.     glBindBuffer(GL_ARRAY_BUFFER, vbo);
  21.     glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
  22.     GLuint colours_vbo = 0;
  23.     glGenBuffers(1, &colours_vbo);
  24.     glBindBuffer(GL_ARRAY_BUFFER, colours_vbo);
  25.     glBufferData(GL_ARRAY_BUFFER, sizeof(colours), colours, GL_STATIC_DRAW);
  26.  
  27.     vao = 0;
  28.     glGenVertexArrays(1, &vao);
  29.     glBindVertexArray(vao);
  30.     glBindBuffer(GL_ARRAY_BUFFER, vbo);
  31.     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL); // location 0
  32.     glBindBuffer(GL_ARRAY_BUFFER, colours_vbo);
  33.     glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL); // location 1
  34.     glEnableVertexAttribArray(0);// sagt dem VAO das 0 aktiv sein soll
  35.     glEnableVertexAttribArray(1);// gleiches für 1 und damit brauch man nur VAO binden und nicht mehr setzen
  36.  
  37.     // erzeugt ein Datenblob, dessen struktur im Shader definiert wird
  38.     glCreateBuffers(1, &m_SharedUBO);
  39.     glNamedBufferData(m_SharedUBO, sizeof(SharedTransformUniforms), &m_SharedTransformUniforms, GL_STREAM_DRAW);
  40.  
  41. // game loop
  42.     /// Informiere und update alle Render Komponenten
  43.     RF_Algo::ForEach(m_RenderComponents, [messageIn, messageOut](RF_Collect::Array<ZP_Comp::RenderBehaviour>::EnumeratorType& Enum) {Enum->ProcessMessages(messageIn, *messageOut); });
  44.     RF_Algo::ForEach(m_CameraComponents, [messageIn, messageOut](RF_Collect::Array<ZP_Comp::CameraBehaviour>::EnumeratorType& Enum) {Enum->ProcessMessages(messageIn, *messageOut); });
  45.     m_MessageIn.Clear();
  46.     ProcessRequests();// load/reload shader/textures/meshes
  47.  
  48.     /// Aktive Kamera wurde geändert also auch das UBO updaten.
  49.     m_SharedTransformUniforms.ModelView = m_CameraComponents(m_ActiveCamera).m_Camera.GetMatrix();
  50.     m_SharedTransformUniforms.ModelViewProjection = m_CameraComponents(m_ActiveCamera).GetProjection() * m_SharedTransformUniforms.ModelView;
  51.  
  52.     glBindBufferBase(GL_UNIFORM_BUFFER, 2, m_SharedUBO);// binde UBO auf location 2, kann in Init() wenn jeder Drawcall den nutzen soll
  53.     glNamedBufferSubData(m_SharedUBO, 0, sizeof(SharedTransformUniforms), &m_SharedTransformUniforms);// async update, wenn noch nicht von der GPU benötigt
  54.  
  55.     // Render alle Komponenten in den jeweiligen Pass
  56.     for (RF_Type::Size i = 0; i < m_Passes.Count(); ++i)
  57.     {
  58.         RF_Type::UInt64 Pass = m_Passes(i).Name;
  59.  
  60.         RF_Algo::ForEach(m_RenderComponents, [Pass, messageOut](RF_Collect::Array<ZP_Comp::RenderBehaviour>::EnumeratorType& Enum) {Enum->RenderPass(Pass, *messageOut); });
  61.     }
  62. // render code ^^
  63.     glUseProgram(m_Shader);
  64.     glBindVertexArray(m_VAO);
  65.     glDrawArrays(GL_TRIANGLES, 0, 3);
  66.  


location sagt an welcher Stelle im VAO die Daten liegen und erspart das lästige rum hantieren mit namen im Shader suchen und dann mit den Daten zu verbinden.
Man bindet im VAO die Attribute und im Shader sagt man, in welchen Array die liegen.
Code:
  1. #version 420
  2. layout(location = 0) in vec3 vertex_position;
  3. layout(location = 1) in vec3 vertex_colour;
  4.  
  5. layout(std140, binding=2) uniform SharedTransformUniforms
  6. {
  7.     mat4 ModelView;
  8.     mat4 ModelViewProjection;
  9. };
  10.  
  11. out vec3 colour;
  12.  
  13. void main ()
  14. {
  15.   colour = vertex_colour;
  16.   gl_Position = ModelViewProjection * vec4(vertex_position,1);
  17. }
Autor:  mathias [ Mo Feb 02, 2015 20:22 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Code:
  1. layout(std140, binding=2)


Dafür ist wohl OpenGL 3.3 zu schwach.
Ansonsten wäre es eine gute Sache.

Deine Links werde ich später genauer angucken.
Autor:  mathias [ Mo Feb 02, 2015 23:07 ]
Betreff des Beitrags:  Re: Standard Werte in struct
Wieso geht dir Verschachtelung mit vec3 bei Light.Pos nicht ?
Code:
  1. type
  2.   TMaterial = packed record
  3.     Light: packed record
  4.       Pos: TVector3f;  // ???
  5.     end;
  6.     Material: packed record
  7.       diffuse: TVector4f;    
  8.       ambient: TVector4f;  
  9.       specular: TVector4f;  
  10.       shininess: glFloat;    
  11.     end;
  12.   end;    


Code:
  1. struct Lights {
  2.   vec3 l_dir;   // ???
  3. };
  4.  
  5. struct Materials {
  6.   vec4 diffuse;  
  7.   vec4 ambient;
  8.   vec4 specular;
  9.   float shininess;
  10. };
  11.  
  12. layout (std140) uniform allUniforms {
  13.   Lights lights;
  14.   Materials materials;
  15. };
  16. ...
  17.   float intensity = max(dot(n, lights.l_dir), 0.0);


Ändere ich alle Light.Pos Parameter aus vec4 dann geht es. :?

Code:
  1. type
  2.   TMaterial = packed record
  3.     Light: packed record
  4.       Pos: TVector4f;    // ???
  5.     end;
  6.     Material: packed record
  7.       diffuse: TVector4f;    
  8.       ambient: TVector4f;  
  9.       specular: TVector4f;  
  10.       shininess: glFloat;  
  11.     end;
  12.   end;


Code:
  1. struct Lights {
  2.   vec4 l_dir;   // ???
  3. };
  4.  
  5. struct Materials {
  6.   vec4 diffuse;  
  7.   vec4 ambient;  
  8.   vec4 specular;  
  9.   float shininess;
  10. };
  11.  
  12. layout (std140) uniform allUniforms {
  13.   Lights lights;
  14.   Materials materials;
  15. };
  16. ...
  17.   float intensity = max(dot(n, lights.l_dir.rgb), 0.0);  



Code:
  1. type
  2.   TVector3f = array[0..2] of GLfloat;
  3.   TVector4f = array[0..3] of GLfloat;
  4.  


Nachtrag: Habe ich im Pascal-Code TVector4f und im Shader vec3, dann funktioniert es komischerweise auch.
Seite 1 von 1 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/