DGL
https://delphigl.com/forum/

Phantasie und Theorie
https://delphigl.com/forum/viewtopic.php?f=20&t=2405		 Seite 1 von 1
Autor:  La Boda [ Mo Jan 19, 2004 11:26 ]
Betreff des Beitrags:  Phantasie und Theorie
Hallo,
da ich mich bald intensiv mit Shadern beschäftigen will, habe ich mir schon eine umfangreiche Sammlung an Docs und Files zusammengedownloaded :-) (Vor allem SoS Tut ist super gelungen, aber noch über meinem Niveau)
Aber mir hat es den Anschein als hätte ich schon mit den Basics Probleme. Deshalb wollte ich fragen, ob ihr nicht ein paar theoretische Docs kennt, die ich mir mal anschauen sollte. Probleme hab ich vor allem damit, mir vorzustellen, wie ein Vertex (nach meinen Erfahrungen ein Punkt) verändert werden kann, so dass zum Schluss eine Fläche verändert wird (hört sich komisch an, aber so hab ich das verstanden ;-)
Weis jemand von euch auch ein Seite, in der die Auswirkungen der Befehlssatz-Instruktionen erklärt werden (vielleicht mit Bildern), unter reproduzieren zum Beispiel verstehe ich nur Bahnhof.
Und zum Schluss noch eine kurze Frage, um das ganze abzurunden:
Kann jede Graka mit entsprechend neuen Treibern mit der neuen HLSL umgehen?

Vielen dank im Voraus für die Antworten,
La_Boda
Autor:  Lossy eX [ Mo Jan 19, 2004 11:50 ]
Betreff des Beitrags: 
Also wo du solche Docs herbekommst kann ich dir nicht sagen. Ich habe bisher noch keine Notwendigkeit gehabt Shader einzusetzen.

Aber zum Thema HLSL kann ich dir etwas sagen. Natürlich kann nicht jede Karte automatisch damit umgehen. HLSL ist eine (vier?) Extension(s) deiner Grafikkarte. Werden diese unterstützt kannst du sie auch einsetzen.

GL_ARB_shading_language_100 Als Shadersprache

ARB_shader_objects, ARB_vertex_shader und ARB_fragment_shader als Shaderobjekte.

Zusätzlich dazu gibt es noch die "Assemblerversionen" davon. ARB_vertex_program und ARB_fragment_program . Auch wenn die beiden Programme unterstützt werden heißt es noch lange nicht, dass auch die HLSL unterstützt wird. Die ist vom Aufbau her ein wenig komplexer. Aber wie du aus SOS's übersicht entnehmen kannst ist HLSL ab einer Radeon 9500 (und aufwärts) verfügbar und demnächst (bald) auch auf der Geforce FX.

Als Flichtlektüre kann ich dir eigentlich nur die Opengl 2.0 Spezifikation von 3DLabs empfehlen. Da findest du alles über die HLSL. Unter Downloads findest du auch noch ein SDK mit vielen Shaderbeispielen.

PS: Ein wenig C++ Sprachwissen ist auch nicht von Nachteil.
Autor:  Sascha Willems [ Mo Jan 19, 2004 13:07 ]
Betreff des Beitrags: 
Dein Problem haben meiner Meinung nach wohl viele Leute die ins Gebiet Shader einsteigen wollen und zugegeben ists nicht einfach. Auch ich hab mich zuerst gefragt ob/wofür die Dinger gut sind, hab dann aber schnell herausgefunden was man damit machen und v.a. das vieles weit einfacher zu realisieren ist als über die feste Funktionspipeline.
So eine "Auswirkungsübersicht" gibts natürlich keine, denn es wird ja niemals nur ein Befehl benutzt, sondern ein Shader besteht aus ner mehr oder weniger umfangreichen Befehlskombination. Aber eigentlich sollte die Befehlsübersicht in meiner glSlang-Einführung reichen, denn viele der Befehle finden sich ja auch in Delphi (und anderen Hochsprachen) wieder. Im Endeffekt ist glSlang nix anderes als ein auf Vektoren und Matrizen angepasstes (und minimales) C++.

Theoretische Doks sind auch eher rar gesäht, was aber daran liegt das man durch theoretische Beschreibungen nicht viel lern. Am besten gehst du hin, schaust die Beispielshader and und veränderst dann hier und da mal was, und es dürfte recht schnell klar werden was welcher Befehl bewirkt. Ansonsten gibts ja immernoch das Forum hier, wo du dann auch zu bestimmten Befehlen konkrete Fragen stellen kannst.

Zum Thema glSlang-Support : Rein theoretisch ist jede Grafikkarte die ARB_Vertex_Program und ARB_Fragment_Program unterstützt auch glSlang-fähig. Allerdings wurde glSlang zukunftsorientiert erdacht, so dass dann auf aktuellen Grafikkarten einige Funktionen per Software ablaufen (z.B. Noise-Funktionen). Aber im Prinzip sollten DX9-Karten per Treiber (wies ATI ja gemacht hat) in der Lage sein mit glSlang umzugehen.
Autor:  La Boda [ Di Jan 20, 2004 11:27 ]
Betreff des Beitrags: 
Danke für die Antworten.
Also werde ich mit meiner GF 4 Ti 4200 weiter mit Assembler rumschlagen müssen. Und Fragmentprogramme werden auch nicht unterstützt... :(
Naja, mein erstes Ziel war ja eigentlich ein Wasser wie bei Morrowind (DX 8.1), also könnte ich ja zunächst sowas machen. Weis jemand, was da für Shader-Extensions verwendet wurden und wer so was schon mal nachgemacht hat? (Humus` Wasser ist ja leider Pixelshader 2.0 :( )

Ciao,
La_Boda
Autor:  LarsMiddendorf [ Di Jan 20, 2004 15:21 ]
Betreff des Beitrags: 
Das Wasser bei Morrowind kann man mit NV_texture_shader oder nv_texture_shader3(nur gf4) machen.
Es gibt den Shader gl_dot_product_reflect, mit dem man den Reflektionsvektor berechnen und dann mit dem reflektierten Vektor aus einer Cubemap lesen kann. Eine Alternative ist planare Reflektion mit Bumpmapping. Das geht aber perspektivisch nur korrekt mit NV_texture_shader3.

Wenn man die Reflektion in einer Cubemap (Texture3) speichert und die Normalmap in Texture0, dann stellt man für "True reflective bumpmapping" die Texture Shader folgendermaßen ein:

Code:
  1. glenable(GL_TEXTURE_SHADER_NV);
  2. glActiveTextureARB(GL_TEXTURE0_ARB);
  3. gltexenvi(GL_TEXTURE_SHADER_NV,GL_SHADER_OPERATION_NV,gl_texture_2d);
  4.  
  5. glActiveTextureARB(GL_TEXTURE1_ARB);
  6. gltexenvi(GL_TEXTURE_SHADER_NV,GL_SHADER_OPERATION_NV,GL_DOT_PRODUCT_NV);
  7. gltexenvi(GL_TEXTURE_SHADER_NV,GL_PREVIOUS_TEXTURE_INPUT_NV,GL_TEXTURE0_ARB);
  8.  
  9. glActiveTextureARB(GL_TEXTURE2_ARB);
  10. gltexenvi(GL_TEXTURE_SHADER_NV,GL_SHADER_OPERATION_NV,GL_DOT_PRODUCT_NV);
  11. gltexenvi(GL_TEXTURE_SHADER_NV,GL_PREVIOUS_TEXTURE_INPUT_NV,GL_TEXTURE0_ARB);
  12.  
  13.  
  14. glActiveTextureARB(GL_TEXTURE3_ARB);
  15. gltexenvi(GL_TEXTURE_SHADER_NV,GL_SHADER_OPERATION_NV,GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV);
  16. gltexenvi(GL_TEXTURE_SHADER_NV,GL_PREVIOUS_TEXTURE_INPUT_NV,GL_TEXTURE0_ARB);
  17. glActiveTextureARB(GL_TEXTURE0_ARB);


Die Texturecoordinaten muß man dann folgendermaßen belegen:
Texture0: Koordinaten der Normalmap
Texture1: xyz: 1.Zeile der Matrix w: V.x
Texture2: xyz: 2.Zeile der Matrix w: V.y
Texture3: xyz: 3.Zeile der Matrix w: V.z

Die Matrix muß den Normalvektor aus der Normalmap vom Tangent Space in den World Space transformieren. Also genau andersherum wie beim Bumpmapping. Der Vektor v ist der eye vector und für einen Punkt p gilt: v=p-Kameraposition.

Die Farbe aus der reflektierten Cubemap erhält man als Ergebnis von Texture3. Wenn man für jeden Punkt Tangente und Normale speichert, dann kann man die Berechnung auch in einem Vertex Program vornehmen.Natürlich wäre es idealer die Matrix direkt in jedem Vertex zu speichern, aber so hat man ein einheitliches Vertex Format, denn Tangente und Normale benötigt man sowieso immer.

Code:
  1. !!ARBvp1.0
  2. ATTRIB normal=vertex.attrib[2];
  3.  
  4. ATTRIB tangent=vertex.attrib[6];
  5.  
  6. PARAM mvp[4]={ state.matrix.mvp }
  7. PARAM cam_pos=program.local[2];
  8.  
  9. TEMP binormal,eye_vec,matrix1,matrix2,matrix3;
  10.  
  11. DP4 result.position.x, mvp[0], vertex.position;
  12. DP4 result.position.y, mvp[1], vertex.position;
  13. DP4 result.position.z, mvp[2], vertex.position;
  14. DP4 result.position.w, mvp[3], vertex.position;
  15.  
  16. MUL binormal,normal.zxyw,tangent.yzxw;
  17. MAD binormal,normal.yzxw,tangent.zxyw,-binormal;
  18. MOV result.texcoord[0],vertex.texcoord[0];
  19.  
  20. ADD eye_vec,vertex.position,-cam_pos;
  21.  
  22. MOV matrix1.x,tangent.x;
  23. MOV matrix1.y,binormal.x;
  24. MOV matrix1.z,normal.x;
  25.  
  26. MOV matrix2.x,tangent.y;
  27. MOV matrix2.y,binormal.y;
  28. MOV matrix2.z,normal.y;
  29.  
  30. MOV matrix3.x,tangent.z;
  31. MOV matrix3.y,binormal.z;
  32. MOV matrix3.z,normal.z;
  33.  
  34. MOV result.texcoord[1].xyz,matrix1;
  35. MOV result.texcoord[2].xyz,matrix2;
  36. MOV result.texcoord[3].xyz,matrix3;
  37.  
  38. MOV result.texcoord[1].w,eye_vec.x;
  39. MOV result.texcoord[2].w,eye_vec.y;
  40. MOV result.texcoord[3].w,eye_vec.z;
  41.  
  42. MOV ocolor,icolor;
  43. END
Autor:  La Boda [ Do Jan 22, 2004 11:22 ]
Betreff des Beitrags: 
Vielen Dank für den Code!
Werde das mal ausprobieren, kann aber ein bisschen Dauern :D

Hast du eigentlich das Wasser in deiner Engine-Demo auch auf diese Weise gemacht?
Autor:  La Boda [ Mi Jan 28, 2004 09:39 ]
Betreff des Beitrags: 
Hallo,
ich habs jetzt mal versucht, aber ich kriegs einfach nicht auf die Reihe.
Das Herzstück ist folgender Teil:
Code:
  1.  
  2.   glTranslatef(0, 0, -2);
  3.   glDisable(GL_TEXTURE_2D);
  4.  
  5.  
  6.   glDisable(GL_BLEND);
  7.   glEnable(GL_TEXTURE_SHADER_NV);
  8.  
  9.  
  10.   for i:= 0 to 2 do
  11.    for j:= 0 to 2 do
  12.     matrot[i, j]:= 1.0;   //die verwendung einer Rotationsmatrix hab ich aus einem NVidia - Sample,
  13.                           //wie kann ich sie unten bei den glMultiTexCoords weglassen, wenn
  14.                           //ich nur ein einfaches Quad von vorne hab?
  15.                           //(Erstmal will ich keine Bewegung einbauen)    
  16.  
  17.   glEnable(GL_TEXTURE_SHADER_NV);
  18.   glActiveTextureARB(GL_TEXTURE0_ARB);
  19.   glBindTexture(GL_TEXTURE_2D, NormalMap);
  20.   glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);              
  21.  
  22.   glActiveTextureARB(GL_TEXTURE3_ARB);
  23.   glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, CubeMap);
  24.   glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV);
  25.   glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
  26.   glEnable(GL_TEXTURE_2D);
  27.  
  28.   glColor4f(1, 1, 1, 1);
  29.  
  30.   glBegin(GL_QUADS);
  31.                
  32.   glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0,0);
  33.   glMultiTexCoord4fARB(GL_TEXTURE3_ARB, matRot[2,0], matRot[2,1], matRot[2,2],  1);
  34.   glVertex2f(-1,-1);
  35.                
  36.   glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1,0);
  37.   glMultiTexCoord4fARB(GL_TEXTURE3_ARB, matRot[2,0], matRot[2,1], matRot[2,2],  1);
  38.   glVertex2f( 1,-1);
  39.                
  40.   glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1,1);
  41.   glMultiTexCoord4fARB(GL_TEXTURE3_ARB, matRot[2,0], matRot[2,1], matRot[2,2],  1);
  42.   glVertex2f( 1, 1);
  43.  
  44.   glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0,1);
  45.   glMultiTexCoord4fARB(GL_TEXTURE3_ARB, matRot[2,0], matRot[2,1], matRot[2,2],  1);
  46.   glVertex2f(-1, 1);
  47.                
  48.   glEnd;
  49.  

Es wird eigentlich nur die Normalmap angezeigt. :oops:
Den Shader lade ich halt so normal beim Init.
Danke,
La_Boda
Autor:  LarsMiddendorf [ Mi Jan 28, 2004 12:58 ]
Betreff des Beitrags: 
1) Man muß für die Texturen 1 und 2 auch den entsprechenden Shader aktivieren, wie ich im Beispiel angegeben habe. Diese spezielle Shader geht nämlich nur in bestimmten Kombinationen. Und da eine Matrix berechnet wird, braucht man 3 mal ein Skalarprodukt und eine Shaderstufe reicht nicht aus.


2)
Das Ergebnis des Shaders wird verwendet, als würde es direkt von einer Texture kommen. Man kann also in den Register Combinern oder hier einfacher mit dem Texture Env aus GL_TEXTURE3_ARB lesen und erhält das was der Shader, der an Texture 3 gebunden ist, ausgerechnet hat. In diesem Fall ist das die Reflektion. Auch mit den Texture Shadern kann man die Register Combiner und die normalen Texture Env Befehle weiterhin benutzen. Der einzige Unterschied ist, daß statt dem Farbwert aus der Texture dann der berechnete Wert aus dem Shader genommen wird.
Hier geht es mit Multitexturing, daß du für Texture3 statt dem voreingestellen GL_MODULATE GL_REPLACE wählst:

Code:
  1. glActiveTextureARB(GL_TEXTURE3_ARB);
  2. glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
Autor:  Gast [ Di Feb 03, 2004 14:57 ]
Betreff des Beitrags: 
JUHUUUU! Endlich funzts :D
Vielen Dank nochmal, Lars.
Ihr könnt euch gar nicht vorstellen, was das für ein Ansporn war, Shader weiterzuproggen :lol:
Das Spiel, in das ich das Wasser zurzeit einbaue, werde ich wahrscheinlich bald in den Projects veröffentlcihen 8)

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