DGL
https://delphigl.com/forum/

Dependent Textures
https://delphigl.com/forum/viewtopic.php?f=20&t=4113		 Seite 1 von 1
Autor:  Blechwolf [ Mo Mai 09, 2005 13:00 ]
Betreff des Beitrags:  Dependent Textures
Servus,

Ich brauche für meine Anwendung eine Farbtabelle. Da diese aber vom Nutzer gestellt werden soll, sollte das ganze möglichst flexibel sein und auch hinreichend schnell. Meine Volumen-Datensätze (128x128x128 im Schnitt) stelle ich mit VolumeSlicing dar. Wem das jetzt nix sagt, kann mich ja mal fragen oder einfach mal suchen.

Die Idee ist jetzt die folgende:
Anhand des Alpha-Wertes meiner 3D Textur [0..1] möchte ich dem entsprechenden Pixel eine Farbe zuweisen.
Letztlich sollte man das mit nem Fragment-Shader realisieren können.

Mein Code sieht folgendermassen aus:

Code:
  1.  
  2. uniform sampler3D DataTexture;
  3. uniform sampler1D ColorMap;
  4.  
  5. void main(void)
  6. {
  7.   vec4 DepVec;
  8.   vec3 NewVec;
  9.   // get Alpha-Value of 3D Texture
  10.   DepVec.rgba = texture3D(DataTexture,vec3(gl_TexCoord[0]));
  11.   NewVec.rgb = vec3(texture1D(ColorMap,DepVec.a));
  12.  
  13.   gl_FragColor = vec4(NewVec.rgb,DepVec.a);
  14. }
  15.  


Das ganze linkt und compiliert wunderbar. Nur wenn ich das dann in meinem Programm verwende, bekomme ich nen schwarzen Bildschirm.

Hat jemand ne Idee?
Autor:  Blechwolf [ Fr Mai 13, 2005 08:42 ]
Betreff des Beitrags: 
Habe es jetzt aus diversen Gründen erstmal mit nem GL_FRAGMENT_PROGRAM_ARB gemacht.

Code:
  1.  
  2. !!ARBfp1.0
  3.  
  4. TEMP vol;
  5. TEX vol, fragment.texcoord[0], texture[0], 3D;
  6. TEX result.color, vol.w, texture[1], 1D;
  7. MOV result.color.a, vol.w;
  8. END
  9.  


Allerdings hat es hier auch erst funktioniert, als ich Multitexturing (GL_TEXTURE0_ARB, etc.) verwendet habe.
Werde das jetzt mal für Shader umschreiben und Performance-Vergleiche anstellen. Und Euch dann wieder berichten.
Autor:  Blechwolf [ Mo Mai 23, 2005 10:04 ]
Betreff des Beitrags: 
Hier mal die zwei Shader sowie ein paar Hinweise zum Aufruf aus dem Programm...

Ich habe eine 3D Textur, deren Textur-Koordinaten automatisch erzeugt werden.
Code:
  1.  
  2. type
  3.   VV_TVector  = array[0..3] of Single;
  4. [...]
  5. const
  6.   VV_XVEC : VV_TVector = (1,0,0,0);
  7.   VV_YVEC : VV_TVector = (0,1,0,0);
  8.   VV_ZVEC : VV_TVector = (0,0,1,0);
  9. [...]
  10.   TexData      : GluInt;
  11.   TexColorMap  : GluInt;
  12. [...]
  13. // Automatic Texture Coordinate Generation
  14. glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
  15. glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
  16. glTexGeni (GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
  17. glTexGenfv(GL_S, GL_EYE_PLANE, PGLFloat(@VV_XVEC));
  18. glTexGenfv(GL_T, GL_EYE_PLANE, PGLFloat(@VV_YVEC));
  19. glTexGenfv(GL_R, GL_EYE_PLANE, PGLFloat(@VV_ZVEC));
  20. glEnable  (GL_TEXTURE_GEN_S);
  21. glEnable  (GL_TEXTURE_GEN_T);
  22. glEnable  (GL_TEXTURE_GEN_R);
  23. [...]
  24.  


Sowie eine 1D Textur [0..1] die Farbwerte enthält. (Eine Colormap quasi, wie sie in Visualisierungs Anwendungen öfter vorkommt)

Binden der beiden Texturen an den Shader:
Code:
  1.  
  2. glUniform1iARB(glGetUniformLocationARB(SlangProg,PGLCharARB('DataTexture')),0);
  3. glUniform1iARB(glGetUniformLocationARB(SlangProg,PGLCharARB('ColorMap')),1);
  4.  

wobei die Texturen vorher mit
Code:
  1.  
  2. glActiveTexture(GL_TEXTURE0);
  3. glBindTexture(GL_TEXTURE_3D,TexData)
  4. glEnable(GL_TEXTURE_3D)
  5.  

respektive
Code:
  1.  
  2. glActiveTexture(GL_TEXTURE1);
  3. glBindTexture(GL_TEXTURE_1D,TexColorMap);
  4. glEnable(GL_TEXTURE_1D);
  5.  

an die Textur-Einheiten 0 und 1 gebunden wurden.

Hier nun die zwei Shader:

Vertex-Shader:
Berechnet die Textur-Koordinaten, da diese bei automatischer Generierung nicht an gl_TexCoord[i] weitergegeben werden.
Code:
  1.  
  2. void main(void) {
  3.   vec4 EyeVertex = gl_ModelViewMatrix*gl_Vertex;
  4.   gl_TexCoord[0].s = dot(EyeVertex, gl_EyePlaneS[0]);
  5.   gl_TexCoord[0].t = dot(EyeVertex, gl_EyePlaneT[0]);
  6.   gl_TexCoord[0].p = dot(EyeVertex, gl_EyePlaneR[0]);
  7.   gl_TexCoord[0].q = dot(EyeVertex, gl_EyePlaneQ[0]);
  8.   gl_Position = ftransform();
  9. }
  10.  


Fragment-Shader:
Holt sich die Werte aus der Daten Textur und nutzt den Alpha-Wert als Index für die Colormap.
Der Alpha-Wert bleibt der gleiche wie in der Ausgangstextur, da er für Filter-Zwecke genutzt wird.
Code:
  1.  
  2. uniform sampler3D DataTexture;
  3. uniform sampler1D ColorMap;
  4.  
  5. void main(void) {
  6.   vec4 DepVec;
  7.   vec4 NewVec;
  8.   // get Alpha-Value of 3D Texture
  9.   DepVec.rgba = texture3D(DataTexture,gl_TexCoord[0].stp);
  10.   NewVec.rgba = texture1D(ColorMap,DepVec.a);
  11.   gl_FragColor = vec4(NewVec.rgb,DepVec.a);
  12. }
  13.  
Autor:  Blechwolf [ Mo Mai 23, 2005 10:12 ]
Betreff des Beitrags:  Performance
Größe der 3D Textur:
128x128x128 Pixel
OS:
Win XP Pro SP2
Treiber:
Max. 1 Woche alt (heute: 23.05.2005)

zu Hause:
Athlon 900 MHz, 512MB RAM, ATI 9600 128MB (??)
ARB_Fragment-Program: ~12 fps
GLSLang : ~12fps

Arbeit:
Celeron 2GHz, 256MB RAM, GF 6600 256MB
ARB_Fragment-Program: ~2 fps
GLSLang: ~2 fps

Also scheinbar macht es keine grossen Unterschiede in der Performance ob ich nun GLSLang oder ARB_Fragment-Programme verwende.
Autor:  LarsMiddendorf [ Mo Mai 23, 2005 15:31 ]
Betreff des Beitrags: 
Mir ist aufgefallen, dass bei NVidia Karten GLSL teilweise sogar schneller ist als ARB_fp. Vermutlich weil der Compiler die Befehle geschickt anordnet.
Das kann aber auch am Shader liegen. Bei dem Benchmark von Sascha ist GLSL bei der GF6800 geringfügig schneller aber bei der Radeon 9800 pro ist GLSL fehlerhaft und langsamer als ARB_fp.
Seite 1 von 1 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/