DGL
https://delphigl.com/forum/

shader rendert immer die selbe Textur
https://delphigl.com/forum/viewtopic.php?f=20&t=6890		 Seite 1 von 1
Autor:  Der Zerhackte [ Fr Sep 07, 2007 07:01 ]
Betreff des Beitrags:  shader rendert immer die selbe Textur
So, ich wollte mich gerade vergewiisern, dass die Art wie ich meinen Shader einlese funktioniert. Das tut er natürlich nicht.
Ist ne ganz simple Sache, ich lade zwei Texturen im Programm, übergebe sie dem Shader und speicher sie dort in zwei sampler2d.
Wenn ich die nu an die gl_FragColor gebe, dann zeichnet mir das Programm, egal welche Textur ich nehme immer nur die letzte.
Wieso das so ist versteh ich nicht. Habe gestern abend rund 6 Stunden daran rum getüfftelt und Tut+foren durchwühlt um ne Lösung zu finden...
aber irgendwie kam ich nicht damit klar.

Das ist jetzt alles TForm1.OnCreate; zusammen mit der OGl initialisierung etc., aber das sollte mit dem shader (die init) ja nicht viel zu tun haben, d.h. nur der shader part und die Texturen zuweisung:
Code:
  1.  
  2.   ProgramObject        := glCreateProgramObjectARB;
  3.   ShaderCode           := TStringlist.Create;
  4.  
  5.   VertexShaderObject   := glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
  6.   FragmentShaderObject := glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
  7.  
  8.   //Vertex und Fragmentshader mit code füllen, ...
  9.   ShaderCode.LoadFromFile(basispfad + 'vertex.txt');
  10.   ShaderCodeText := ShaderCode.Text;
  11.   ShaderCodeLength := length(ShaderCode.Text);
  12.   glShaderSourceARB(VertexShaderObject, 1, @ShaderCodeText, @ShaderCodeLength);
  13.  
  14.   ShaderCode.LoadFromFile(basispfad + 'fragment.txt');
  15.   ShaderCodeText := ShaderCode.Text;
  16.   ShaderCodeLength := length(ShaderCode.Text);
  17.   glShaderSourceARB(FragmentShaderObject, 1, @ShaderCodeText, @ShaderCodeLength);
  18.  
  19.   //... compilieren und checken
  20.   glCompileShaderARB(VertexShaderObject);
  21.   ShowMessage(glSlang_GetInfoLog(VertexShaderObject));
  22.   glCompileShaderARB(FragmentShaderObject);
  23.   ShowMessage(glSlang_GetInfoLog(FragmentShaderObject));
  24.  
  25.   //Shader an das Programmobjekt binden
  26.   glAttachObjectARB(ProgramObject, VertexShaderObject);
  27.   glAttachObjectARB(ProgramObject, FragmentShaderObject);
  28.  
  29.   //löschen der Shader, nach Anbindung an das Programmobjekt
  30.   glDeleteObjectARB(VertexShaderObject);
  31.   glDeleteObjectARB(FragmentShaderObject);
  32.  
  33.   //Programmobjekt linken
  34.   glLinkProgramARB(ProgramObject);
  35.   ShowMessage(glSlang_GetInfoLog(ProgramObject));
  36.  
  37.   glUseProgramObjectARB(ProgramObject);
  38.  
  39.   //Textur1 einlesen (RGB + Glanz)
  40.   Loadtexture( ExtractFilePath(ParamStr(0)) +  'textures/DiffuseSpecular.tga' , DiffuseSpecular , false );
  41.   glActiveTexture(GL_TEXTURE0);
  42.   glBindTexture(GL_TEXTURE_2D, DiffuseSpecular);
  43.   glUniform1iARB(glGetUniformLocationARB(ProgramObject, PGLCharARB('DiffuseSpecular')), 0);
  44.  
  45.   //Textur2 einlesen (Normal.xyz + Bumpmap)
  46.   Loadtexture( ExtractFilePath(ParamStr(0)) + 'textures/NormalHeight.tga'  , NormalHeight , false );
  47.   glActiveTexture(GL_TEXTURE1);
  48.   glBindTexture(GL_TEXTURE_2D, NormalHeight);
  49.   glUniform1iARB(glGetUniformLocationARB(ProgramObject, PGLCharARB('NormalHeight')), 1);
  50.  
  51.   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  52.   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  53.  


Im render wird dann nur noch das hier veranstaltet:
Code:
  1.  
  2. {------------------3D Teil---------------------------}
  3.   glMatrixMode(GL_PROJECTION);
  4.   glLoadIdentity;
  5.   gluPerspective(45.0, ClientWidth/ClientHeight, NearClipping, FarClipping);
  6.   glMatrixMode(GL_MODELVIEW);
  7.   glLoadIdentity;
  8.  
  9.   glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
  10.   glMatrixMode(GL_MODELVIEW);
  11.   glLoadIdentity;
  12.  
  13.     MyCam.use;
  14.     MyCube.draw;
  15.  
  16. {------------------2D Teil---------------------------}
  17.   glMatrixMode(GL_PROJECTION);
  18.   glLoadIdentity;
  19.   glOrtho(0,800,0,600, 0,-128);
  20.   glMatrixMode(GL_MODELVIEW);
  21.   glLoadIdentity;
  22.  
  23.   SwapBuffers(DC);
  24.  


Cam.use; ruft ne gl_translatef(); und drei gl_rotatef(); auf, um die Szene auszurichten und Cube.draw; rotiert und transferiert den Würfel und zeichnet ihn anschließend mit Texturkoordinaten. Ich glaube die draw; geb ich auch nochmal mit, falls ich hier noch nen Texturen-fehler gemacht haben sollte:
Code:
  1.  
  2. procedure TCube.draw;
  3. begin
  4.  
  5.   gltranslatef(self.pos.x,self.pos.y,self.pos.z);
  6.   glrotatef(self.rot.x,1,0,0);
  7.   glrotatef(self.rot.y,0,1,0);
  8.   glrotatef(self.rot.z,0,0,1);
  9.  
  10.   glBegin(GL_QUADS);
  11.     //oben
  12.     glTexCoord2f(0,1); glVertex3f( self.Size.x/2, self.Size.y/2, self.Size.z/2);
  13.     glTexCoord2f(1,1); glVertex3f( self.Size.x/2, self.Size.y/2, -self.Size.z/2);
  14.     glTexCoord2f(1,0); glVertex3f( -self.Size.x/2, self.Size.y/2, -self.Size.z/2);
  15.     glTexCoord2f(0,0); glVertex3f( -self.Size.x/2, self.Size.y/2, self.Size.z/2);
  16.  
  17.     //unten
  18.     glTexCoord2f(0,1); glVertex3f( self.Size.x/2, -self.Size.y/2, -self.Size.z/2);
  19.     glTexCoord2f(1,1); glVertex3f( self.Size.x/2, -self.Size.y/2, self.Size.z/2);
  20.     glTexCoord2f(1,0); glVertex3f( -self.Size.x/2, -self.Size.y/2, self.Size.z/2);
  21.     glTexCoord2f(0,0); glVertex3f( -self.Size.x/2, -self.Size.y/2, -self.Size.z/2);
  22.  
  23.     //rechts
  24.     glTexCoord2f(0,1); glVertex3f( -self.Size.x/2, self.Size.y/2, self.Size.z/2);
  25.     glTexCoord2f(1,1); glVertex3f( -self.Size.x/2, self.Size.y/2, -self.Size.z/2);
  26.     glTexCoord2f(1,0); glVertex3f( -self.Size.x/2, -self.Size.y/2, -self.Size.z/2);
  27.     glTexCoord2f(0,0); glVertex3f( -self.Size.x/2, -self.Size.y/2, self.Size.z/2);
  28.  
  29.     //links
  30.     glTexCoord2f(0,1); glVertex3f( self.Size.x/2, -self.Size.y/2, self.Size.z/2);
  31.     glTexCoord2f(1,1); glVertex3f( self.Size.x/2, -self.Size.y/2, -self.Size.z/2);
  32.     glTexCoord2f(1,0); glVertex3f( self.Size.x/2, self.Size.y/2, -self.Size.z/2);
  33.     glTexCoord2f(0,0); glVertex3f( self.Size.x/2, self.Size.y/2, self.Size.z/2);
  34.  
  35.     //vorne
  36.     glTexCoord2f(0,1); glVertex3f( self.Size.x/2, -self.Size.y/2, self.Size.z/2);
  37.     glTexCoord2f(1,1); glVertex3f( self.Size.x/2, self.Size.y/2, self.Size.z/2);
  38.     glTexCoord2f(1,0); glVertex3f( -self.Size.x/2, self.Size.y/2, self.Size.z/2);
  39.     glTexCoord2f(0,0); glVertex3f( -self.Size.x/2, -self.Size.y/2, self.Size.z/2);
  40.  
  41.     //hinten
  42.     glTexCoord2f(0,1); glVertex3f( self.Size.x/2, self.Size.y/2, -self.Size.z/2);
  43.     glTexCoord2f(1,1); glVertex3f( self.Size.x/2, -self.Size.y/2, -self.Size.z/2);
  44.     glTexCoord2f(1,0); glVertex3f( -self.Size.x/2, -self.Size.y/2, -self.Size.z/2);
  45.     glTexCoord2f(0,0); glVertex3f( -self.Size.x/2, self.Size.y/2, -self.Size.z/2);
  46.   glend;
  47.  
  48.   glrotatef(-self.rot.x,1,0,0);
  49.   glrotatef(-self.rot.y,0,1,0);
  50.   glrotatef(-self.rot.z,0,0,1);
  51.   gltranslatef(-self.pos.x,-self.pos.y,-self.pos.z);
  52.  
  53. end;
  54.  

sowas hat ja garantiert auch schon jeder geschrieben... an dieser stelle mal ein einschub: ist es sinnvoller
push und pop zu verwenden, oder die Szene zurück zu tranformieren?

Als Shader verwende ich wie oben schon ersichtlich stinknormale *.txt files, weils halt simple ist.
Hier mal der Vertex Shader, bei dem ich glaube, dass ich alles richtig gemacht habe (sieht halt so aus wie im tut):
Code:
  1.  
  2. void main(void)
  3. {
  4.   gl_Position = ftransform();
  5.  
  6.   gl_TexCoord[0] = gl_MultiTexCoord0;
  7.   gl_TexCoord[1] = gl_MultiTexCoord1;
  8. }
  9.  


So und dann noch der Fragment Shader, der ja auch sehr üersichtlich klein und einfach ist:
Code:
  1.  
  2. uniform sampler2D DiffuseSpecular;
  3. uniform sampler2D NormalHeight;
  4.  
  5. void main()
  6. {
  7.   gl_FragColor = texture2D(NormalHeight, vec2(gl_TexCoord[0]));
  8. }
  9.  


Ich denke, dass dieser Code den meisten sehr bekannt vorkommt, weil das irgendwie die absolute minimum basis an Code ist und außerdem sehr stark auf das Shadertut von Sascha aufbaut.

Also wenn mir jetzt jemand erklären kann, warum immer nur die NormalHeight-textur gezeichnet wird, obwohl ich DiffuseSpecular im Fragment-shader stehen habe(jetzt stehts zwar nicht da, aber wenn ich es austausche, dann ändert das nichts am Ergebnis), wäre das echt klasse... außerdem gibt mir zu denken, dass die Texturen komplett gezeichnet werden, obwohl beide Texturen im alpha ne map gespeichert haben und dieser wert ja laut shader automatisch an die gl_FragColor.a komponente geht.
Autor:  Lossy eX [ Fr Sep 07, 2007 08:12 ]
Betreff des Beitrags: 
Mal ungeachten davon ob der Shader funktioniert oder nicht. Dein Problem liegt wohl eher beim Einlesen der Texturen.

Code:
  1. //Textur1 einlesen (RGB + Glanz)
  2. Loadtexture( ExtractFilePath(ParamStr(0)) + 'textures/DiffuseSpecular.tga' , DiffuseSpecular , false );
  3. glActiveTexture(GL_TEXTURE0);
  4. glBindTexture(GL_TEXTURE_2D, DiffuseSpecular);
  5.  
  6. //Textur2 einlesen (Normal.xyz + Bumpmap)
  7. Loadtexture( ExtractFilePath(ParamStr(0)) + 'textures/NormalHeight.tga' , NormalHeight , false );
  8. glActiveTexture(GL_TEXTURE1);
  9. glBindTexture(GL_TEXTURE_2D, NormalHeight);


Zum Einlesen der Texturen muss diese gebunden werden, da man sonst keine Daten übergeben kann und in dem Falle überschreibst du dir die bereits gebundene DiffuseSpecular.

Das sollte eher folgendermaßen aussehen. Bzw das Aktivieren später dann beim Zeichnen. Und wenn du sie nicht mehr brauchst musst du auch beide TMUs deaktivieren.
Code:
  1. Loadtexture( ExtractFilePath(ParamStr(0)) + 'textures/DiffuseSpecular.tga' , DiffuseSpecular , false );
  2. Loadtexture( ExtractFilePath(ParamStr(0)) + 'textures/NormalHeight.tga' , NormalHeight , false );
  3.  
  4. glActiveTexture(GL_TEXTURE0);
  5. glBindTexture(GL_TEXTURE_2D, DiffuseSpecular);
  6. glEnable(GL_TEXTURE_2D);
  7.  
  8. glActiveTexture(GL_TEXTURE1);
  9. glBindTexture(GL_TEXTURE_2D, NormalHeight);
  10. glEnable(GL_TEXTURE_2D);


PS: Technisch gesehen würde es auch auch ausreichen die GL_TEXTURE1 vor dem Laden der zweiten Textur zu aktivieren. Aber ich würde die Schritte lieber komplett voneinander trennen.
Autor:  littleDave [ Fr Sep 07, 2007 08:17 ]
Betreff des Beitrags: 
Ich rate mal ganz ins blaue:
kann das sein, dass vielleicht manche Treiber probleme mit
Code:
  1.  
  2.   glActiveTexture(GL_TEXTURE0);
  3.  

haben? Ich persönlich versuche immer die ARB-Variante zu benutzen
Code:
  1.  
  2.   glActiveTextureARB(GL_TEXTURE0_ARB);
  3.  

Hab dafür bisher keine Beweise/Andeutungen/etc. Ist mir nur gerade so in den Kopf gekommen!
Autor:  Der Zerhackte [ Fr Sep 07, 2007 08:44 ]
Betreff des Beitrags: 
hi Lossy ex, hab deinen Vorschlag mal ausprobiert, nu zeichnet er nur noch die DiffuseSpecular Textur, aber die NormalHeight nicht mehr...
wenn ich allerdings glActiveTexture unmittelbar vor dem glLoadTexture für die zweite Textur aufrufe, dann zeichnet er nur noch diese.

Ich verstehe das nicht wirklich... Ich bin ja nicht der einzige, der mehrere Txturen für eine 3D anwendung braucht, gibs da nicht jemanden,
der soetwas schon in funktionierend hat?

Im Prinzip müsste es ja egal sein, wann ich glLoadTexture aufrufe, solange ich es vor der Übergabe an den Shader mache, da ich damit ja
bloß die textur an ein GLuint koppel, dass ich später der TMU übergebe. Für mich klingt es logisch, dass ich die Textur lade, dann die
Textureinheit aktiviere und als letztes die Textur an den Shader schicke.

Der unterschied zwischen _ARB und nicht _ARB macht sich bei mir im Moment nicht bemerkbar... leider.

kann es daran liegen, dass ich die Texturen lade, nachdem ich das ProgramObject gelinkt ( glLinkProgramARB(ProgramObject); ) und aktiviert ( glUseProgramObjectARB(ProgramObject); )habe?
Autor:  Lossy eX [ Fr Sep 07, 2007 09:06 ]
Betreff des Beitrags: 
@littleDave: Also bei den Konstanten ist es egal, da bekommt der Treiber in beiden Fällen nur $84C0 übergeben. Bei den Methoden ist es etwas anders. Genau genommen muss man dort überprüfen ob man OpenGL in Version 1.3 hat oder die Multitexturing Erweiterung unterstützt wird. Aber eigentlich sollten beide Methode sogar intern auf die gleiche Funktion zeigen. Also die sollten den gleichen Adresspointer haben. Ich habe es aber schon teilweise erlebt, dass die Treiber eine Erweiterung im Kern zur Verfügung stellen aber diese nicht einmal seperat als Erweiterung anbieten. Andersrum natürlich sobald der Kern nicht voll unterstützt wird.

Aber das eindeutigste Zeichen, dass es nicht geht ist eine Zugriffsverletzung an Adresse 0, da die Methode keine Adresse hat (der Treiber sie nicht bietet). ;) Sonst ist es aber eher gleich.

@Der Zerhackte: Du musst auch noch für jede TMU extra die Texturkoordinaten setzen. Also anstelle von glTexCoord musst du dann glMultiTexCoord benutzen. Also für jeden Vertex 2 Mal aufrufen. Oder aber du greifst in deinem Shader nur auf die erste Texturkoordinate zu. Denn dort liest du Koordinaten aus die gar nicht existieren.

Sonst wüsste ich nicht woran es liegen könnte. Denn der Shader wird ja erst dann ausgeführt, wenn du auch tatsächlich etwas renderst. Und, dass er sich die Texturen merkt fänd ich etwas sehr seltsam.
Autor:  Der Zerhackte [ Fr Sep 07, 2007 09:41 ]
Betreff des Beitrags: 
so habs nu so gelöst:
Code:
  1.  
  2.   Loadtexture( basispfad + 'textures/DiffuseSpecular.tga' , DiffuseSpecular , false );
  3.   Loadtexture( basispfad + 'textures/NormalHeight.tga' , NormalHeight , false );
  4.  
  5.   glActiveTexture(GL_TEXTURE0);
  6.   glBindTexture(GL_TEXTURE_2D, DiffuseSpecular);
  7.   glUniform1iARB(glGetUniformLocationARB(ProgramObject, PGLCharARB('DiffuseSpecular')), 0);
  8.  
  9.   glActiveTexture(GL_TEXTURE1);
  10.   glBindTexture(GL_TEXTURE_2D, NormalHeight);
  11.   glUniform1iARB(glGetUniformLocationARB(ProgramObject, PGLCharARB('NormalHeight')), 1);
  12.  


und natürlich die MultiTexCoords für beide Texturen gesetzt. Ob jetzt die Befehlreihenfolge, oder die Coords das Problem
waren weiß ich nicht genau, kann ja auch in Kombination gewesen sein.. aufjedenfall läufts im Moment und damit bin ich zufrieden.

Ich habe allerdings noch einige andere Fragen bezüglich der Vektoren, die man für die verschiedenen Lichtmodelle braucht. Ins besondere
meine ich damit Vektoren wie Blickrichtung,CameraPosition und Lichtposition. Wo bekomme ich die her? Bei dem Licht stellt
sich für mich die Frage, ob ich das openGL Licht verwende, oder einfach ein eigenes schreibe und dann die Werte als uniform
an den Shader schicke. Die eigenen wären praktisch, weil ich sie modifizieren kann wie ich möchte, dafür sind die oGL Lichter bereits bestandteil der GLSL.

Ich hatte mal in openGL ein Goroud-Licht geschrieben, das basierte aber komplett auf eigene Objekte und beleuchtete eine Fläche nur
in abhängigkeit zur Flächennormale, nicht nach den Normalen der vertieces, oder sogar Pixel. Außerdem wurde die Färbung per gl_color3f(); angestellt,
was denke ich ebenfalls eine unglückliche Lösung ist.

Aufjedenfall soll es diesmal ewas schöner werden und habe mir dazu einige Tuts von oZone3d.net angesehen zum thema blinn-phong und
ambient occlusion unter Verwendung von Normalmaps und Bumpmaps. Erst wollte ich ne Radiosity schreiben, aber das ist mir für den Anfang zu heftig...

Also wenn mir jemand für diese 3-4 Vektoren ne Quelle geben kann, dann bin ich auch erstmal leise. ^^"

[EDIT1] => Frage in neues Thema gebunkert
Autor:  Lossy eX [ Fr Sep 07, 2007 09:47 ]
Betreff des Beitrags: 
Da das vom Thema her doch ziemlich stark vom Ursprung abweicht würde ich ich dich bitten daraus eine eigene Frage zu machen. Da es sonst nur zu verwirrend ist. Also einfach editieren und in ein neues Thema kopieren.
Autor:  MatReno [ Fr Sep 07, 2007 09:49 ]
Betreff des Beitrags: 
Also für blinn / phong kann ich dir das GLSlang2 Tutorial von LaBoda empfehlen. Da ist auch ein Link zu Delphi3d, wo auch blinn und phong nochmals sehr genau mit Vektorzeichnungen beschrieben sind.
Autor:  damadmax [ Fr Sep 07, 2007 17:03 ]
Betreff des Beitrags: 
Nicht dass ich mich irre...bin ja schliesslich nen noob...

aber wo soll bei
Code:
  1.  
  2. gl_FragColor = texture2D(NormalHeight, vec2(gl_TexCoord[0]));
  3.  

die andere textur herkommen? du liest doch nur eine aus^^
Autor:  Der Zerhackte [ Fr Sep 07, 2007 18:02 ]
Betreff des Beitrags: 
das ging darum, dass wenn ich in der Zeile, die du geschrieben hast das "NormalHeight" durch die ander Textur ersetzt habe und die Texcoords auch angepasst hatte, dass der shader trotzdem noch die "NormalHeight" verwendet, obwohl sie gar nicht mehr benutzt werden sollte.

Aber jetzt geht es ja zum Glück;
Seite 1 von 1 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/