DGL
https://delphigl.com/forum/

Wie Daten aus Shader auslesen?
https://delphigl.com/forum/viewtopic.php?f=20&t=7014
Seite 1 von 2

Autor:  elektrokrach [ Mo Okt 29, 2007 15:39 ]
Betreff des Beitrags:  Wie Daten aus Shader auslesen?

erledigt

Autor:  Sascha Willems [ Mo Okt 29, 2007 15:41 ]
Betreff des Beitrags: 

Das geht so direkt nicht, man kann nich von Aussen auf Werte innerhalb eines Shaders zurückgreifen. Wenn du Rückgabewerte eines Shaders ermitteln willst musst du diese mittels Shader in eine Textur schreiben lassen und diese dann so auslesen.

Autor:  elektrokrach [ Di Okt 30, 2007 17:07 ]
Betreff des Beitrags: 

erledigt

Autor:  elektrokrach [ So Nov 04, 2007 16:55 ]
Betreff des Beitrags: 

lass ma

Autor:  Lord Horazont [ So Nov 04, 2007 19:04 ]
Betreff des Beitrags: 

Ich würde dir zum Auslesen auf jeden fall den Ortho-Modus empfehlen. Dann machst du 1x1 Pixel große Quads. Für jedes Quad solltest du dann die Werte angeben, die dein Shader berechnen soll. Die für die Berechnung gebrauchten Werte könnte man z.B. per Texturkoordinate, die du ja theoretisch nicht brauchst, übergeben. (glMultiTexCoord).

Die Lichtquellen könnte man entweder in Uniform-Matrizen packen oder in eine Textur. Nach möglichkeit solltest du aber die erste Methode verwenden, da du bei der zweiten sehr viele Texturzugriffe machen müsstest und in den Datentypen auch relativ eingeschränkt bist (0.0 .. 1.0).

Im Shader kannst du dann das ergebnis mit gl_FragColor ausgeben, der Pixel, der das Quad darstellt, enthält dann das ergebnis, welches du z.B. mit glReadPixels auslesen kannst.

Gruß Lord Horazont

Autor:  elektrokrach [ Mo Nov 05, 2007 15:34 ]
Betreff des Beitrags: 

Danke

Autor:  oc2k1 [ Mo Nov 05, 2007 16:05 ]
Betreff des Beitrags: 

2x2 , 3x3 oder 4x4

Autor:  Daniellus [ Di Nov 06, 2007 18:29 ]
Betreff des Beitrags: 

Hallo elektrokrach,

ich bin selber intensiv mit GPGPU beschäftigt, und erledige jeglichen Datentransfer vom Applikationsspeicher zum Grafikkartenspeicher und zurück über Texturen (habe sehr viel Daten). Ich kann dir vielleicht helfen.
Was genau hast du denn vor?
Wichtig ist deine Datenmenge zum Shader für die Berechnung und vor allem die Menge, welche du zur Applikation zurücklesen möchtest.

MfG[/code]

Autor:  elektrokrach [ Di Nov 06, 2007 21:01 ]
Betreff des Beitrags: 

erledigt

Autor:  elektrokrach [ Fr Nov 09, 2007 20:15 ]
Betreff des Beitrags: 

erledigt

Autor:  Daniellus [ Mo Nov 12, 2007 18:41 ]
Betreff des Beitrags: 

Hallo, hört sich machbar an...

Fragen:
Zitat:
Also, ich habe einen Haufen Vertices (3 * GLfloat pro Vertex)]

Sind das deine Raumkoordinaten?

Die Berechnete Farbe soll dann für andere Vertizes immer wieder benutzt werden, habe ich das richtig verstanden?
Soll die Farbe dann auf der Grafikkarte verbleiben, oder willst du sie von der Applikation auf das Vertex anwenden?
Welche Grafikkarte hast du?
OpenGL Version?

Hast du Erfahrung mit:

1. FBO's + RTT(Render-To-Texture)?
2. Wahlfreien Zugriff in einem Shader auf Texel einer Textur?

MfG

Autor:  elektrokrach [ Mo Nov 12, 2007 20:41 ]
Betreff des Beitrags: 

is eh wurscht

Autor:  Daniellus [ Di Nov 13, 2007 08:15 ]
Betreff des Beitrags: 

ATI oder NVIDIA ist bei deinem Vorhaben vermutlich egal.
Es gibt auch die Möglichkeit, das du die endgültigen Farben im Grafikspeicher läßt und im Shader die Farbe zuordnest. Jeder Datentransfer zur Grafikkarte kostet Zeit.

Zuerst sollten wir deine OpenGL Version nach 2.0 Abfragen. Ich benutze dafür GLEW.
Ich programmiere allerdings mit C/C++, den Code müsstest du nach Delphi ändern.

Code:
  1.  
  2. //check if OpenGL 2.0 is supported
  3. if (glewIsSupported("GL_VERSION_2_0"))
  4. {
  5.     cout<<"OpenGL 2.0 is supported...\nGLSL is integrated in core...\n";
  6. }
  7. else
  8. {
  9.     cout<<"OpenGL 2.0 not supported\n";
  10. }

Autor:  elektrokrach [ Di Nov 13, 2007 15:05 ]
Betreff des Beitrags: 

egal

Autor:  Daniellus [ Mi Nov 14, 2007 08:49 ]
Betreff des Beitrags: 

1. Ohne Fenster nix zu zeichnen
Code:
  1. // init window management
  2. glutInit ( &argc, argv );
  3. glutCreateWindow("IPGPU");
  4.  

2. Orthogonale Projektion,Viewport und Render-Textur einstellen
Dein Viewport muss die gleichen Ausmaße wie deine Render-Textur haben.
Du musst dazu wissen wie viel Farben entstehen.

Bsp:
Code:
  1. glMatrixMode(GL_PROJECTION);                                       // set up projection matrix
  2. glLoadIdentity();
  3. gluOrtho2D(0.0, renderTextureX_m, 0.0, renderTextureY_m);   // 2d projection  
  4.    
  5. glMatrixMode(GL_MODELVIEW);                         // set up modelview matrix
  6. glLoadIdentity();
  7. glViewport(0, 0, renderTextureX_m, renderTextureY_m);   // size of viewport
  8.  


Code:
  1. //create render texture
  2. glGenTextures (1, &renderTexture_m);
  3. glBindTexture(TexTarget_m, renderTexture_m);
  4. // set up texture parameters, turn off filtering
  5. glTexParameteri(TexTarget_m, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  6. glTexParameteri(TexTarget_m, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  7. glTexParameteri(TexTarget_m, GL_TEXTURE_WRAP_S, GL_CLAMP);
  8. glTexParameteri(TexTarget_m, GL_TEXTURE_WRAP_T, GL_CLAMP);
  9. // define texture with same size like viewport
  10. glTexImage2D(TexTarget_m, 0, internes_Format , renderTextureX_m, renderTextureY_m, 0, Format, Datentyp_Deiner_Farben, 0);
  11. //use original values of texture (no mix with default color of quad)
  12. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  13.  


3.Offscreen-Memory mit FBO verwalten(nähere Infos siehe Tutorial)
Code:
  1. //generate valid handle to fbo
  2. glGenFramebuffersEXT(1, &Fbo_m);
  3. //bind fbo to skip screen as render target and use the frame buffer
  4. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dwFbo_m);
  5. // attach texture to framebuffer(use texture/framebuffer as render target)
  6. glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, TexTarget_m, renderTexture_m, 0);
  7.  

Du kannst mit einem fbo mehrere Speicherbereiche auf der Grafikkarte reservieren. GL_COLOR_ATTACHMENT0_EXT ist ein Speicherbereich, GL_COLOR_ATTACHMENT1_EXT währe dann der nächste, natürlich mit einer anderen Textur.

4. Zeichne ein Quad über den gesamten Viewport, wähle vorher deinen Speicherbereich zum Rendern ( wenn du mehr als einen reserviert hast )
Code:
  1. //choose buffer/attachment point for drawing
  2. glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
  3.  

Weise den Fragmenten über einen Shader versuchsweise verschiedene Farben zu, diese müssten dann im folgenden Schritt aus dem Memory gelesen werden.
5. Lesen des Speicherbereiches
Code:
  1. glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
  2. glReadPixels(0, 0, renderTextureX_m, renderTextureY_m, Format, Datentyp_Deiner_Farben, Array_Im_Applikationsspeicher);


Das ist so ziemlich das Grundprinzip. Fehler inklusive...Bring das mal zum Laufen und melde dich dann...auch wenn es nicht läuft.

Kleiner Ausblick was noch kommt:

Deine Positionen und Farben für die Lichter packst du jeweils in eine Textur.
Die Texturen machst du im Shader zugänglich. Die Koordinaten der Positionen und Farben der Lichter, sollten mit den Koordinaten der dazugehörigen Farben in der Render-Textur übereinstimmen. Zum Beispiel enthält Koordinate (0;0) in der Positionstextur und der Lichtfarbentextur, genau die Werte um die entsprechende Farbe in der Render-Textur mit der gleichen Koordinate (0;0) zu berechnen. Dies ist einfach zu handhaben, aber nicht immer möglich...

Seite 1 von 2 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/