Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Do Mär 28, 2024 22:46

Foren-Übersicht » Programmierung » Einsteiger-Fragen
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 58 Beiträge ]  Gehe zu Seite Vorherige  1, 2, 3, 4  Nächste
Autor Nachricht
BeitragVerfasst: Fr Jan 16, 2015 18:50 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
Hey,

selbes Beispiel mit dem LazOpenGLCore. Die Daten des VBOs werden dynamisch generiert, so könnte man auch das Laden aus einer Datei realisieren, oder das teilweise Updaten eines VBOs. VAOs gibts im Core noch nicht. Die stehen aber als nächstes auch der ToDo-Liste.
Code:
  1. unit uMainForm;
  2.  
  3. {$mode objfpc}{$H+}
  4.  
  5. interface
  6.  
  7. uses
  8.   Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
  9.   uglcContext, uglcShader, uglcArrayBuffer, uglcTypes, uglcCamera;
  10.  
  11. type
  12.   TMainForm = class(TForm)
  13.     ApplicationProperties: TApplicationProperties;
  14.     LogLB: TListBox;
  15.     RenderPanel: TPanel;
  16.     procedure ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
  17.     procedure FormCreate(Sender: TObject);
  18.     procedure FormDestroy(Sender: TObject);
  19.     procedure RenderPanelResize(Sender: TObject);
  20.   private
  21.     fContext: TglcContext;
  22.     fShader: TglcShaderProgram;
  23.     fVBO: TglcArrayBuffer;
  24.     procedure Log(aSender: TObject; const aMsg: String);
  25.     procedure Render;
  26.   public
  27.     { public declarations }
  28.   end;
  29.  
  30. var
  31.   MainForm: TMainForm;
  32.  
  33. implementation
  34.  
  35. {$R *.lfm}
  36.  
  37. uses
  38.   dglOpenGL, ugluVector, ugluMatrix;
  39.  
  40. procedure TMainForm.FormCreate(Sender: TObject);
  41. type
  42.   TVertex = packed record
  43.     pos: TgluVector3f;
  44.   end;
  45.   PVertex = ^TVertex;
  46. var
  47.   pf: TglcContextPixelFormatSettings;
  48.   p: PVertex;
  49. begin
  50.   pf := TglcContext.MakePF();
  51.   fContext := TglcContext.GetPlatformClass.Create(RenderPanel, pf);
  52.   fContext.BuildContext;
  53.  
  54.   fShader := TglcShaderProgram.Create(@Log);
  55.   fShader.LoadFromFile(ExtractFilePath(Application.ExeName) + 'shader.glsl');
  56.   fShader.Compile;
  57.  
  58.   fVBO := TglcArrayBuffer.Create(TglcBufferTarget.btArrayBuffer);
  59.   fVBO.BufferData(4, sizeof(TVertex), TglcBufferUsage.buStaticDraw, nil);
  60.   p := fVBO.MapBuffer(TglcBufferAccess.baWriteOnly);
  61.   try
  62.     p^.pos := gluVector3f(-0.5, -0.5, 0); inc(p);
  63.     p^.pos := gluVector3f( 0.5, -0.5, 0); inc(p);
  64.     p^.pos := gluVector3f( 0.5,  0.5, 0); inc(p);
  65.     p^.pos := gluVector3f(-0.5,  0.5, 0); inc(p);
  66.   finally
  67.     fVBO.UnmapBuffer;
  68.   end;
  69. end;
  70.  
  71. procedure TMainForm.ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
  72. begin
  73.   Render;
  74.   Done := false;
  75. end;
  76.  
  77. procedure TMainForm.FormDestroy(Sender: TObject);
  78. begin
  79.   FreeAndNil(fVBO);
  80.   FreeAndNil(fShader);
  81.   FreeAndNil(fContext);
  82. end;
  83.  
  84. procedure TMainForm.RenderPanelResize(Sender: TObject);
  85. begin
  86.   if Assigned(fContext) then begin
  87.     glViewport(0, 0, RenderPanel.ClientWidth, RenderPanel.ClientHeight);
  88.   end;
  89. end;
  90.  
  91. procedure TMainForm.Log(aSender: TObject; const aMsg: String);
  92. begin
  93.   LogLB.Items.Add(aMsg);
  94. end;
  95.  
  96. procedure TMainForm.Render;
  97. begin
  98.   glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
  99.   fVBO.Bind;
  100.   fShader.Enable;
  101.   glEnableVertexAttribArray(0);
  102.   glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, nil);
  103.   glDrawArrays(GL_QUADS, 0, fVBO.DataCount);
  104.   glDisableClientState(GL_VERTEX_ARRAY);
  105.   fShader.Disable;
  106.   fVBO.Unbind;
  107.   fContext.SwapBuffers;
  108. end;
  109.  
  110. end.


Code:
  1. /* ShaderObject: GL_VERTEX_SHADER */
  2. #version 330
  3. in vec3 inPos;
  4. void main(void)
  5. {
  6.   gl_Position = vec4(inPos, 1.0);
  7. }
  8.  
  9. /* ShaderObject: GL_FRAGMENT_SHADER */
  10. #version 330
  11. out vec4 outColor;
  12. void main(void)
  13. {
  14.   outColor = vec4(1.0, 0.0, 0.0, 1.0);
  15. }


Download

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Fr Jan 16, 2015 22:02 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
mathias hat geschrieben:
Das Problem liegt eindeutig an dglOpenGL, es gibt mehrere Versionen.

Du schreibst waren, somit nehme ich an, du hast den Code zum laufen gebracht ?


Gut zu wissen.
Ich habe mich nach diesem Hinweis einfach mal getraut, im Code rumzupfuschen, habe Errorstatus als ByteBool definiert und ZACK - alles läuft.
Ganz großes Dankeschön, das gibt mir jetzt wieder Hoffnung. Mit so einem Grundgerüst, das schonmal funktioniert, lässt sich alles viel leichter verstehen und nachvollziehen.

*edit:
Auch allerbesten Dank an Dich, Bergmann89, habs gleich runtergeladen und erfolgreich getestet.
Endlich etwas funktionierendes. Ich werd mich in nächster Zeit mal genauer mit dem TextureLoader glBitmap befassen und auch mal testen ob sich x-beliebiger Shader-Code einfach einbauen lässt - Beispiele für GLSL-Normalmap-Shader gibt es ja zu Hauf im Netz.
Bin sehr begeistert. Tausend Dank!


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Jan 18, 2015 11:41 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Ich wollte mal meine ersten kleinen Erfolgserlebnisse melden.
Habe es tatsächlich geschafft, in Bergmanns Beispiel das Quad mit einem Farbverlauf zu füllen :D
Habe dazu die Ecken des Quads auf die Ecken der Form (minus Listbox) gesetzt und TMainForm.Render folgendermaßen erweitert:

Code:
  1. procedure TMainForm.Render;
  2. var w,h: integer;
  3. begin
  4.   w := MainForm.Width;
  5.   h := MainForm.Height-LogLB.Height;
  6.   glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
  7.   fVBO.Bind;
  8.   fShader.Enable;
  9.   fshader.Uniform2f('windowsize', w, h);
  10.   glEnableVertexAttribArray(0);
  11.   glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, nil);
  12.   glDrawArrays(GL_QUADS, 0, fVBO.DataCount);
  13.   glDisableClientState(GL_VERTEX_ARRAY);
  14.   fShader.Disable;
  15.   fVBO.Unbind;
  16.   fContext.SwapBuffers;
  17. end;    

Dann die Größe des Fensters minus Listbox an den Shader weitergegeben:
Code:
  1. /* ShaderObject: GL_VERTEX_SHADER */
  2. #version 330
  3. uniform mat4 uModelViewProjMat;
  4. in vec3 inPos;
  5.  
  6. void main(void)
  7. {
  8.   gl_Position = vec4(inPos, 1.0);
  9. }
  10.  
  11. /* ShaderObject: GL_FRAGMENT_SHADER */
  12. #version 330
  13.  
  14. uniform vec2 windowsize;
  15. out vec4 outColor; // ausgegebene Farbe
  16.  
  17. void main(void)
  18. {
  19.   float r = gl_FragCoord.x/windowsize.x;
  20.   float g = gl_FragCoord.y/windowsize.y;
  21.   outColor = vec4(r, g, 1.0, 1.0);
  22. }

Und siehe da - ein wunderschöner Farbverlauf in X und Y Richtung, immer relativ zur Fenstergröße :)
Es geht voran! ;)

*edit: Um den Pseudo-Shader des Tools zusammenzubasteln, der momentan auf der CPU läuft, habe ich u.a. viel auf folgender Seite gelernt:
https://github.com/mattdesl/lwjgl-basics/wiki/ShaderLesson6
Das Problem mit dem GLSL Code dort, wie auf den meisten anderen openGL/GLSL Seiten, die man im Netz findet, ist daß die meisten Befehle deprecated sind, was auch nochmal gut für Verwirrung sorgt (bei benutzen von "varying" z.B. kommt direkt eine Warnung).

*edit2: Ich versuche gerade, auf naive Weise eine Textur auf das Quad zu bekommen, bisher ohne Erfolg. Habe dazu die unit uglcBitmap eingebunden und in Form.Create folgende Befehle eingebaut:
Code:
  1.   fTexture := TglBitmap2D.Create('textur.png');
  2.   fTexture.GenTexture;
  3.   fTexture.Bind;    

Den Shader Code habe ich folgendermaßen manipuliert:
Code:
  1. /* ShaderObject: GL_VERTEX_SHADER */
  2. #version 330
  3.  
  4. uniform mat4 uModelViewProjMat;
  5. in vec2 TexCoord;
  6. out vec2 vTexCoord;
  7.  
  8. void main(void)
  9. {
  10.   vTexCoord = TexCoord;
  11. }
  12.  
  13. /* ShaderObject: GL_FRAGMENT_SHADER */
  14. #version 330
  15.  
  16. uniform sampler2D u_texture;
  17. in vec2 vTexCoord;
  18. out vec4 outColor; // ausgegebene Farbe
  19.  
  20. void main(void)
  21. {
  22.   vec4 TextureColor = texture2D(u_texture, vTexCoord);
  23.   outColor = TextureColor;
  24. }


Bisher ist noch alles dunkel. Vermutlich muss die Textur noch irgendwie an den Shader weitergegeben werden?


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Jan 18, 2015 15:06 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
Hey,

MainForm.Height nimmt die gesamte Höhe der Form, auch mit Rahmen, das Ergebnis sollte also nicht 100%tig stimmen. Normalerweiße nimmt man da ClientWidth und ClientHeight. Der Render-Context wird auf "RenderPanel" erstellt, also solltest du von da auch deine Große beziehen (RenderPanel.ClientWidth und RenderPanel.ClientHeight).
Kleine Rand-Info: Uniforms setzten ist teuer, also so wenig wie nötig machen. Für die Fenster-Größe bietet sich das in RenderPanel.OnResize an (da wo auch der Viewport gesetzt wird).
Das gezeichnete Quad geht von -0.5 bis 0.5 der sichtbar Bereich ist immer -1 bis 1. Du könntest im ShaderCode also auch einfach ohne die Fenster-Größe rechnen: (inPos + 1.0) / 2.0 sollte das selbe Ergebnis bringen. Weiterhin ist dein Farbverlauf vom Fenster abhängig und nicht vom Quad. Heißt das Quad fungiert sozusagen nur als Maske, wo Framgmente gezeichnet werden sollen und wo nicht. Lange Rede kurzer Sinn: versuch nicht Vertex abhängige Daten durch irgendwelche Berechnungen zu rekonstuieren, sondern gib sie gleich als Vertex Attribut mit in den Shader (siehe Vertex-Position).

Der Sampler müsste noch gesetzt werden. Das ist ein Int und der Wert entspricht der genutzten TexturUnit, in deinem Fall also 0. Der Uniform ist zwar im Normalfall schon mit 0 initialisiert, aber sicher ist sicher. Ich nehm an, dass du die Vertex-Daten um die Textur-Coordinaten erweitert hast, damit dein in vec2 TexCoord entsprechend gefüllt werden kann?

"texture2D" ist auch deprecated, da sollte man "texture" nutzen. Parameter bleiben die selben, also einfach das "2D" weg.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Jan 18, 2015 19:01 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Klar, der Context rendert auf den Panel, keine Ahnung warum ich die Form als Rendertarget im Hinterkopf hatte.
Das setzen der Fenstergröße im Resize Event macht natürlich auch perfekt Sinn.

Die Textur zu intialisieren habe ich jetzt mal mit glActiveTexture(0); direkt nach dem Binden versucht, ich hoffe, das stimmt so.

Allerdings habe ich auch nach längerer Google-Suche keine Ahnung wie man die Vertex Daten um die Texturkoordinaten erweitert, bräuchte also auch hier wieder eine Hilfestellung.

Generell habe ich noch nicht so ganz verstanden woher der Shader die "in" Variablen bekommt, auch bei inPos. Nur bei dem Fenstergrößenexperiment ist mir klar, daß die Variable durch fshader.Uniform2f übermittelt wird.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Jan 18, 2015 19:39 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1276
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Zitat:
Allerdings habe ich auch nach längerer Google-Suche keine Ahnung wie man die Vertex Daten um die Texturkoordinaten erweitert

Genau gleich wie die Vertexdaten.

Code:
  1. const
  2.   Quad: array[0..5] of TVector3f =
  3.     ((-0.8, -0.8, 0.0), (0.8, 0.8, 0.0), (-0.8, 0.8, 0.0),
  4.     (-0.8, -0.8, 0.0), (0.8, -0.8, 0.0), (0.8, 0.8, 0.0));
  5.  
  6.   QuadTextureVertex0: array[0..5] of TVector2f =
  7.     ((0.0, 0.0), (3.0, 3.0), (0.0, 3.0),
  8.     (0.0, 0.0), (3.0, 0.0), (3.0, 3.0));  
  9.  
  10.  
  11.  
  12.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);   // Vertex
  13.   glBufferData(GL_ARRAY_BUFFER, sizeof(Quad), @Quad, GL_STATIC_DRAW);
  14.   glEnableVertexAttribArray(pos_id);
  15.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  16.  
  17.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[1]);   // Texur.Vertex
  18.   glBufferData(GL_ARRAY_BUFFER, sizeof(QuadTextureVertex0), @QuadTextureVertex0, GL_STATIC_DRAW);
  19.   glEnableVertexAttribArray(texture_id0);
  20.   glVertexAttribPointer(texture_id0, 2, GL_FLOAT, False, 0, nil);  


Zitat:
Die Textur zu intialisieren habe ich jetzt mal mit glActiveTexture(0); direkt nach dem Binden versucht, ich hoffe, das stimmt so.

Ich habe es beim Rendern, bevor glDrawArrays kommt.

Code:
  1.   glBindVertexArray(uiVAO[0]);
  2.  
  3.   glUniformMatrix4fv(WorldMatrix_id, 1, False, WorldMatrix.ptr);
  4.  
  5.   glActiveTexture(GL_TEXTURE0);
  6.   glBindTexture(GL_TEXTURE_2D, TexID);
  7.  
  8.   glDrawArrays(GL_Triangles, 0, Length(Quad));


Zitat:
Generell habe ich noch nicht so ganz verstanden woher der Shader die "in" Variablen bekommt, auch bei inPos.

Bei dem Vertex-Shader kommt in von glVertexAttribPointer, beim Fragment-Shader vom Vertex-Shader.
inPos sind der Vertex-Daten.

_________________
OpenGL


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Jan 18, 2015 19:44 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
Hey,

das mit der Textur-Unit hab ich anders gemeint. Du must einen Wert an das Uniform in Shader übergeben. So wie du das mit der WindowSize gemacht hast. Wie gesagt ist der im Normalfall 0, da du aber bei denem Problem sicherlich mehr als eine Textur haben wirst, must du die Uniforms entsprechend setzten (und natrürlich auch die Textur in der richigen Textur Unit binden).
€2: nach dem Binden der Textur bringt glActiveTexture nichts. glactiveTexture legt die Texture Unit fest auf die Texturen gebunden werden. Also muss es vor dem binden gerufen werden.

Zu der Datenübergabe:
Alle Shader-Variablen die mit "in" gekennzeichnet sind, sind sogenannte VertexAttribs. Jedes dieser Attribs hat eine sogenannte Location (GLint). Die Location kann auf verschiedene Wege festgelegt werden:
Diese Location wird dann in glEnableVertexAttribArray und glVertexAttribPointer genutzt um zu sagen auf welche in-Variable die Daten gelegt werden sollen. Da in dem Test-Programm nur eine in-Variable war, steht dort hart eine 0 drin. Richtiger wäre es so:
Code:
  1. procedure TMainForm.Render;
  2. var
  3.   inPosLocation: GLint;
  4. begin
  5.   glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
  6.   fVBO.Bind;
  7.   fShader.Enable;
  8.   inPosLocation := glGetAttribLocation(fShader.ProgramObj, 'inPos');
  9.   glEnableVertexAttribArray(inPosLocation);
  10.   glVertexAttribPointer(inPosLocation, 3, GL_FLOAT, False, 0, Pointer(0));
  11.   glDrawArrays(GL_QUADS, 0, fVBO.DataCount);
  12.   fShader.Disable;
  13.   fVBO.Unbind;
  14.   fContext.SwapBuffers;
  15. end;

Natürlich macht man das nur einmal nach dem Linken und speichert sich die Location dann irgendwo zwischen. Ich hab das der Einfachheit halber jetzt mal so gemacht. glVertexAttribPointer sagt wie die Daten im VBO liegen: 3 Elemente, Typ single/float, nicht normalisiert, mit 0 Byte zwischen den einzellnen Elementen und 0 Byte Offset von Start des VBOs. Der letzte Wert ist zwar ein Zeiger, wird hier aber als Offset interpretiert.
Kleines Bsp:
Code:
  1. TVertex = packed record
  2.   pos: TgluVector3f;
  3.   color: TgluVector4f;
  4. end;
  5.  
  6. inPosLocation := glGetAttribLocation(fShader.ProgramObj, 'inPos');
  7. glEnableVertexAttribArray(inPosLocation);
  8. glVertexAttribPointer(inPosLocation, 3, GL_FLOAT, False, SizeOf(TVertex), Pointer(OffsetOf(TVertex.pos)));
  9.  
  10. inColorLocation := glGetAttribLocation(fShader.ProgramObj, 'inColor');
  11. glEnableVertexAttribArray(inColorLocation);
  12. glVertexAttribPointer(inColorLocation, 4, GL_FLOAT, False, SizeOf(TVertex), Pointer(OffsetOf(TVertex.color)));

Das geht mit so ziemlich allen Daten die ein Vertex haben kann: Position, Farbe, TexturCoords, Normalen, ...

€: so wie mathias das gemacht hat geht das mit den Daten natürlich auch. Allerdings braucht man dann dafür 2 VBOs. Ich hab die Daten lieber alle in einem VBO. Was besser ist kommt auch die Anwendung an. Es gibt Fälle, da sind 2 getrennte VBOs schneller, es gibts aber auch Fälle, da ist es besser alles in einem zu haben. Für deinen Fall würd ich alles in eins packen, weil der Treiber dann nicht so oft im VRAM rumspringen must um an die Daten zu kommen. Denn es liegt ja schon alles vorsortiert im VBO.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mo Jan 19, 2015 15:29 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Leute, ihr seid unglaublich. Vielen Dank für die Klarstellung und Hilfestellung.

Mathias, mit Deinem Beispiel habe ich zuerst herumexperimentiert.
Beim definieren des QuadTextureVertex0 bekam ich erstmal eine Fehlermeldung, weil TVector2f nicht definiert war - evtl. wieder ein Konflikt der unterschiedlichen dglopengl Versionen. Ich habe es dann manuell definiert als
Code:
  1. TVector2f = array[0..1] of GLfloat;

Code:
  1. uiVBO: array[0..1] of GLuint;
habe ich global definiert.
Nach einigem Herumschrauben war allerdings immer noch irgendwo ein SIGSEGV, daher habe ich mich erstmal an Bergmanns Version versucht.

Hier habe ich die Texturkoordinaten auf die gleiche Art wie inPos und WindowSize an den Shader weitergegeben:
Code:
  1.   inColorLocation := glGetAttribLocation(fShader.ProgramObj, 'TexCoord');
  2.   glEnableVertexAttribArray(inColorLocation);
  3.   glVertexAttribPointer(inColorLocation, 3, GL_FLOAT, False, SizeOf(TVertex), Pointer(0));


Nach der Fehlermeldung "Identifier not found "OffsetOf"" habe ich "Pointer(OffsetOf(TVertex.color))" durch "Pointer(0)" ersetzt, auch wenn ich den Offset nicht ganz verstehe. Kann man dadurch eine Verschiebung der Koordinaten innerhalb des VBO festlegen?

Jedenfalls habe ich dann noch "glActiveTexture(0);" VOR "fTexture.Bind;" gesetzt, ich denke mal daß Du das mit "die Textur in der richigen Textur Unit binden" gemeint hast, Bergmann.
Den Wert (die Textur-ID?) an das Uniform im Shader zu übergeben, meinst Du damit etwas wie "fshader.Uniform1f('u_texture', 0);"?

Viele Anfängerfragen, ich weiß.
Trotzdem habe ich es mittlerweile geschafft, daß die Textur angezeigt wird.
Zunächst nur im rechten oberen Viertel des Renderpanels, und auf den Kopf gestellt, was ich dann behoben habe durch "fTexture.FlipVert;" direkt vor "fTexture.GenTexture;" und Umrechnen der TexturKoordinaten im Vertex-Shader:
Code:
  1. vTexCoord = (TexCoord+1)/2;

Falls es bessere Lösungen dafür gibt, bin ich natürlich offen und dankbar.

Nun funktioniert das Rendern der Textur auf volle Fenstergröße schonmal einwandfrei, und ich kann langsam anfangen, mit Pixel-Berechnungen im Shader herumzuspielen.
Dazu muss ich gleich noch fragen wie man am besten das Seitenverhältnis der Originaltextur beibehalten kann. Mein naiver Ansatz würde wohl in etwa so aussehen:
Seitenverhältnis beim laden der Textur ausrechnen und wieder über Windowsize die Breite über die Höhe und das Seitenverhältnis ausrechnen, oder umgekehrt, um diese Werte dann an den Shader weiterzugeben.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mo Jan 19, 2015 17:31 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
Hey,

Dee hat geschrieben:
Hier habe ich die Texturkoordinaten auf die gleiche Art wie inPos und WindowSize an den Shader weitergegeben:
Code:
  1.   inColorLocation := glGetAttribLocation(fShader.ProgramObj, 'TexCoord');
  2.   glEnableVertexAttribArray(inColorLocation);
  3.   glVertexAttribPointer(inColorLocation, 3, GL_FLOAT, False, SizeOf(TVertex), Pointer(0));


Nach der Fehlermeldung "Identifier not found "OffsetOf"" habe ich "Pointer(OffsetOf(TVertex.color))" durch "Pointer(0)" ersetzt, auch wenn ich den Offset nicht ganz verstehe. Kann man dadurch eine Verschiebung der Koordinaten innerhalb des VBO festlegen?
Das geht jetzt zwar, aber du übergibts die Vertex-Position als TexturCoord (weil Offset 0). Das OffsetOf war Pseudo-Code (hätt ich vlt ran schreiben sollen). Das berechnet den Byte Offset der Daten in TVertex. Könnte man in Lazarus so machen: PtrUInt(@PVertex(nil)^.color); oder du schreibst den Wert einfach hart in den Code.
Nochmal zu dem Offset. Du hast folgende Daten in deinem VBO
Px, Py, Pz, Cr, Cg, Cb, Ca, Px, Py, Pz, Cr, Cg, Cb, Ca, ... usw.
Das Offset gibt an, wo die Daten im VBO anfangen, bei Color wäre das dann 3 * SizeOf(Single). Weil Px, Py und Pz vor den Color-Daten im VBO liegen. Du hast Offset 0 angegeben, also ließt er beginnend ab Px.

Dee hat geschrieben:
Jedenfalls habe ich dann noch "glActiveTexture(0);" VOR "fTexture.Bind;" gesetzt, ich denke mal daß Du das mit "die Textur in der richigen Textur Unit binden" gemeint hast, Bergmann.
Den Wert (die Textur-ID?) an das Uniform im Shader zu übergeben, meinst Du damit etwas wie "fshader.Uniform1f('u_texture', 0);"?
Genau, Textur-Unit aktivieren, Textur binden und deinem Sampler2D Uniform eine Textur-Unit geben. Achtung! nicht Textur-ID mit Textur-Unit verwechseln. Textur-ID ist der "Name" des OpenGL Textur Objects (GLint). Textur-Unit ist eine der parallel verfügbaren Textur-Einheiten (bei aktuellen Grafik Karten 8 oder mehr, siehe GL_MAX_TEXTURE_UNITS). Man kann unterschiedliche IDs an die einzellnen Units binden und diese dann gemeinsam im Shader nutzen.

Dee hat geschrieben:
Zunächst nur im rechten oberen Viertel des Renderpanels, und auf den Kopf gestellt, was ich dann behoben habe durch "fTexture.FlipVert;" direkt vor "fTexture.GenTexture;" und Umrechnen der TexturKoordinaten im Vertex-Shader:
Code:
  1. vTexCoord = (TexCoord+1)/2;

Falls es bessere Lösungen dafür gibt, bin ich natürlich offen und dankbar.
Normalerweiße macht man das Spiegeln und Drehen gleich über die TextCoords oder eine Matrix im Shader, da das berechnen/umwandeln der Textur-Daten auf der CPU viel Zeit kostet. Auf der Graka wird einfach die Textur anders auf die Geometrie gelegt, da muss nichts extra gerechnet werden, nur mit anderen Werten.
Wie oben schon gesagt hast du die Vertex-Position an dein "in TexCoord" übergeben. Deshalb musstest du auch die Umrechnung machen, die das Problem umgeht, aber nicht wirklich gelöst hat.

Dee hat geschrieben:
Dazu muss ich gleich noch fragen wie man am besten das Seitenverhältnis der Originaltextur beibehalten kann. Mein naiver Ansatz würde wohl in etwa so aussehen:
Seitenverhältnis beim laden der Textur ausrechnen und wieder über Windowsize die Breite über die Höhe und das Seitenverhältnis ausrechnen, oder umgekehrt, um diese Werte dann an den Shader weiterzugeben.
Im Shader ist das Fehl am Platz. Das solltest du über entsprechende Matrix-Transformationen über das gezeichnete Quad regeln, sodass das Quad nicht Bildschirm füllend ist, sondern sozusagen Best-Fit. Im "alten" OpenGL gab es dafür eingebaute Uniform-Variablen, die dir deine ModelView- und Projektions-Matrix gegeben haben. Das musst du jetzt selber machen. Zu ModelView und Projektions-Matrix sollte man im Netz genug Lektüre finden. Die TglcCamera aus dem LazOpenGLCore unterstützt dich bei den Matrixen und feslegen der Matrizen, aber dennoch benötigst du erstmal das Verständnis, was die beiden machen.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mo Jan 19, 2015 18:41 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1276
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Zitat:
Beim definieren des QuadTextureVertex0 bekam ich erstmal eine Fehlermeldung, weil TVector2f nicht definiert war

TVector2f hatte ich selbst definiert.
Code:
  1.   TVector2f = array[0..1] of GLfloat;


@Dee

Ich habe da ein Code für dich, welcher Multitexturing demonstriert.
Ich habe bei der Uniform-Übergabe WorldMatrix ausgeklammert, weil sich diese in einer Classe von mir befindet.
Wen du diese entfernst, läuft der Code trotzdem auf einem stehenden Rechteck.

TShader ist auch eine Classe, aber du weist jetzt ja, wie man einen Shader initialisiert.

Code:
  1. unit Unit1;
  2.  
  3. {$mode objfpc}{$H+}
  4.  
  5. interface
  6.  
  7. uses
  8.   Classes,
  9.   SysUtils,
  10.   FileUtil,
  11.   OpenGLContext,
  12.   Forms,
  13.   Controls,
  14.   Graphics,
  15.   Dialogs,
  16.   ExtCtrls,
  17.   StdCtrls,
  18.   dglOpenGL,
  19.   Shader,
  20.   Matrix;
  21.  
  22. type
  23.  
  24.   { TForm1 }
  25.  
  26.   TForm1 = class(TForm)
  27.     Image1: TImage;
  28.     Image2: TImage;
  29.     Timer1: TTimer;
  30.     procedure FormCreate(Sender: TObject);
  31.     procedure FormDestroy(Sender: TObject);
  32.     procedure Timer1Timer(Sender: TObject);
  33.   private   { private declarations }
  34.     OpenGLControl: TOpenGLControl;
  35.     procedure InitScene;
  36.     procedure RenderScene;
  37.   public        { public declarations }
  38.     Shader: TShader;
  39.   end;
  40.  
  41. var
  42.   Form1: TForm1;
  43.  
  44. implementation
  45.  
  46. {$R *.lfm}
  47.  
  48. { TForm1 }
  49.  
  50. type
  51.   TQuad = array[0..1] of Tmat3x3;
  52.  
  53. const
  54.   Quad: TQuad =
  55.     (((-0.8, -0.8, 0.0), (0.8, 0.8, 0.0), (-0.8, 0.8, 0.0)),
  56.     ((-0.8, -0.8, 0.0), (0.8, -0.8, 0.0), (0.8, 0.8, 0.0)));
  57.  
  58.   QuadTextureVertex0: array[0..5] of TVector2f =
  59.     ((0.0, 0.0), (7.0, 7.0), (0.0, 7.0),
  60.     (0.0, 0.0), (7.0, 0.0), (7.0, 7.0));
  61.  
  62.  
  63. var
  64.   uiVBO: array[0..10] of glUINT;
  65.   uiVAO: array[0..2] of glUINT;
  66.  
  67.   WorldMatrix_id, TexMatrix_id: GLint;
  68.  
  69.   textureID0: GLuint;
  70.   textureID1: GLuint;
  71.  
  72.   WorldMatrix: TMatrix;
  73.  
  74.   mat2x2: TMat2x2 = ((1, 0), (0, 1));
  75.  
  76.  
  77. procedure TForm1.InitScene;
  78. const
  79.   ia: array[0..1] of integer = (0, 1);
  80. begin
  81.   glClearColor(0.0, 0.5, 1.0, 1.0); //Hintergrundfarbe: Hier ein leichtes Blau
  82.  
  83.   glEnable(GL_DEPTH_TEST);
  84.   glDepthFunc(GL_LESS);
  85.  
  86.   glEnable(GL_BLEND);
  87.   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  88.  
  89.   Shader := TShader.Create('VertexShader.txt', 'FragmentShader.txt');
  90.   with Shader do begin
  91.     WorldMatrix_id := UniformLocation('Matrix');
  92.     TexMatrix_id := UniformLocation('Matrix2x2');
  93.   end;
  94.   glUniform1iv(Shader.UniformLocation('Sampler0'), 2, ia);
  95.  
  96.  
  97.   glGenVertexArrays(1, uiVAO);
  98.   glGenBuffers(3, uiVBO);
  99.  
  100.   glBindVertexArray(uiVAO[0]);
  101.  
  102.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);
  103.   glBufferData(GL_ARRAY_BUFFER, sizeof(Quad), @Quad, GL_STATIC_DRAW);
  104.   glEnableVertexAttribArray(0);
  105.   glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, nil);
  106.  
  107.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[1]);
  108.   glBufferData(GL_ARRAY_BUFFER, sizeof(QuadTextureVertex0), @QuadTextureVertex0, GL_STATIC_DRAW);
  109.   glEnableVertexAttribArray(10);
  110.   glVertexAttribPointer(10, 2, GL_FLOAT, False, 0, nil);
  111.  
  112.   // ------------ Texturen laden --------------
  113.  
  114.   // Achtung !   Image müssen 32Bit BMP mit Alpha-Kanal sein.
  115.  
  116.   with Image1.Picture.Bitmap.RawImage do begin   // Textur 0
  117.     glGenTextures(1, @textureID0);
  118.     glBindTexture(GL_TEXTURE_2D, textureID0);
  119.  
  120.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Description.Width, Description.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, Data);
  121.  
  122.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
  123.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
  124.  
  125.     glGenerateMipmap(GL_TEXTURE_2D);
  126.   end;
  127.  
  128.  
  129.   with Image2.Picture.Bitmap.RawImage do begin   // Textur 1
  130.     glGenTextures(1, @textureID1);
  131.     glBindTexture(GL_TEXTURE_2D, textureID1);
  132.  
  133.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Description.Width, Description.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, Data);
  134.  
  135.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  136.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  137.  
  138.     glGenerateMipmap(GL_TEXTURE_2D);
  139.   end;
  140.  
  141. end;
  142.  
  143. procedure TForm1.RenderScene;
  144. begin
  145.   glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
  146.  
  147.   glEnable(GL_CULL_FACE);
  148.   glCullface(GL_BACK);
  149.  
  150.   glActiveTexture(GL_TEXTURE0);
  151.   glBindTexture(GL_TEXTURE_2D, textureID0);
  152.  
  153.   glActiveTexture(GL_TEXTURE1);
  154.   glBindTexture(GL_TEXTURE_2D, textureID1);
  155.  
  156.   glBindVertexArray(uiVAO[0]);
  157.  
  158.   //  glUniformMatrix4fv(WorldMatrix_id, 1, False, WorldMatrix.ptr);
  159.   glUniformMatrix2fv(TexMatrix_id, 1, False, @mat2x2);
  160.   glDrawArrays(GL_Triangles, 0, Length(Quad) * 3);
  161.  
  162.   OpenGLControl.SwapBuffers;
  163. end;
  164.  
  165.  
  166. procedure TForm1.FormCreate(Sender: TObject);
  167. begin
  168.   WorldMatrix := TMatrix.Create;
  169.  
  170.   OpenGLControl := TOpenGLControl.Create(Self);
  171.   OpenGLControl.Parent := Self;
  172.   OpenGLControl.Align := alClient;
  173.   OpenGLControl.AutoResizeViewport:=True; // Ersetzt, glViewport(0, 0, ClientWidth, ClientHeight);
  174.  
  175.   InitOpenGL;
  176.   OpenGLControl.MakeCurrent;
  177.   ReadExtensions;
  178.   ReadImplementationProperties;
  179.  
  180.   InitScene;
  181. end;
  182.  
  183. procedure TForm1.FormDestroy(Sender: TObject);
  184. begin
  185.   glDeleteBuffers(1, @uiVBO);
  186.   glDeleteBuffers(1, @uiVAO);
  187.  
  188.   glDeleteTextures(1, @textureID0);
  189.   glDeleteTextures(1, @textureID1);
  190.  
  191.   OpenGLControl.Free;
  192.   Shader.Free;
  193.   WorldMatrix.Free;
  194. end;
  195.  
  196.  
  197. procedure MatrixRotate(var Matrix: Tmat2x2; Winkel: GLfloat);
  198. var
  199.   i: integer;
  200.   x, y: GLfloat;
  201. begin
  202.   for i := 0 to 1 do begin
  203.     x := Matrix[i, 0];
  204.     y := Matrix[i, 1];
  205.     Matrix[i, 0] := x * cos(Winkel) - y * sin(Winkel);
  206.     Matrix[i, 1] := x * sin(Winkel) + y * cos(Winkel);
  207.   end;
  208. end;
  209.  
  210. procedure TForm1.Timer1Timer(Sender: TObject);
  211. begin
  212.   WorldMatrix.RotateC(Pi / 200);
  213.  
  214.   MatrixRotate(mat2x2, Pi / 2000);
  215.   RenderScene;
  216. end;
  217.  
  218. end.


Vertex:

Code:
  1. #version 330
  2.  
  3. layout (location = 0) in vec3 inPos;
  4. layout (location = 10) in vec2 vertexUV0;
  5.  
  6. uniform mat4 Matrix = mat4(1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0); // Ist wegen der WorldMatrix
  7. uniform mat2 Matrix2x2;
  8.  
  9. out vec2 UV0;
  10.  
  11. void main(void)
  12. {
  13.   gl_Position = Matrix * vec4(inPos, 1.0);
  14.   UV0 = Matrix2x2 * vertexUV0;
  15. }                                            



Fragment:
Code:
  1. #version 330
  2.  
  3. in vec2 UV0;
  4.  
  5. uniform sampler2D Sampler0[2];
  6.  
  7. out vec4 FragColor;
  8.  
  9. void main()
  10. {
  11.   FragColor = (texture( Sampler0[0], UV0 ) + texture( Sampler0[1], UV0 )) / 2.0;
  12. }          



Ich hoffe mit dem Code hast wieder etwas zum probieren. :wink:

_________________
OpenGL


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Di Jan 27, 2015 12:55 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Ich danke euch beiden erstmal ganz herzlich.
Momentan bin ich ziemlich eingespannt mit den Problemen der aktuellen Beta Version, habe allerdings schon etwas mit den Anregungen herumgespielt (Multitexturing klingt richtig vielversprechend, allerdings konnte ich damit noch nicht experimentieren).

Ich werde mir das alles in den nächsten Tagen erst nochmal vernünftig durchlesen und mich nochmal intensiver mit den VBO beschäftigen, um nicht wegen jedem Kram nachzufragen (habe den Inhalt des VBO und die Offset-Geschichte von Vertex- und Textur-Koordinaten z.B. immer noch nicht wirklich verstanden, weil mir dabei einfach auch das grundlegende Wissen fehlt).
Allerdings scheint das ganze Vorhaben doch durchaus im Bereich des Möglichen zu liegen. Wenn die Textur z.B. erstmal richtig projiziert wird und ich es doch irgendwann hinbekomme, die richtigen Koordinaten an den Shader weiterzugeben, und dann noch eine zweite Textur (Normal Map) an den Shader übergeben kann, dürfte der Rest relativ einfach werden, zumal die Berechnungen im Shader selbst nur übersetzt werden müssen, auf Grundlage der Formeln, die ich im Tool eh schon benutze.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mi Jan 28, 2015 13:47 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Also, ich denke, ich habe den Offset inzwischen verstanden.
Das Attribut inColor scheint in diesem Fall nicht gebraucht zu werden, daher habe ich stattdessen als zweites Attribut in TVertex für die Texturkoordinaten ein TgluVector3f "texco" hinzugefügt.

In der Render-Prozedur sieht das nun folgendermaßen aus:

Code:
  1.   inPosLocation := glGetAttribLocation(fShader.ProgramObj, 'inPos');
  2.   glEnableVertexAttribArray(inPosLocation);
  3.   glVertexAttribPointer(inPosLocation, 3, GL_FLOAT, False, SizeOf(TVertex), Pointer(PtrUInt(@PVertex(nil)^.pos))) ;
  4.  
  5.   intexco := glGetAttribLocation(fShader.ProgramObj, 'TexCoord');
  6.   glEnableVertexAttribArray(intexco);
  7.   glVertexAttribPointer(intexco, 3, GL_FLOAT, False, SizeOf(TVertex),  Pointer(PtrUInt(@PVertex(nil)^.texco)));


Natürlich funktioniert es noch nicht wie gewünscht, denn die Texturkoordinaten selbst werden ja nirgendwo festgelegt.
Wenn ich es richtig verstanden habe, wird das Attribut inPos im Shader durch gl_Position = vec4(inPos, 1.0); definiert, also bräuchte man wohl für die Texturkoordinaten einen entsprechenden Befehl.
Die Google-Suche hat den Befehl gl_TexCoord ausgespuckt, der aber nicht mehr aktuell ist.
Die Frage ist nun: Wie kann ich anstatt der Vertex-Position die Texturkoordinaten an "in TexCoord" übergeben, bzw. vorher richtig definieren, denn das Übergeben sollte ja so wie beschrieben funktionieren?


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mi Jan 28, 2015 14:10 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1276
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Wen du mein Beispiel oben anguckst, dann siehst du es, wie ich die texcoords übergebe. :wink:

_________________
OpenGL


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mi Jan 28, 2015 14:53 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Dankeschön, Mathias.
Ich hab mir Deinen Code auch schon angeschaut, allerdings weiß ich überhaupt nicht wie man die Klasse TShader selbst erstellen kann.
Das ist alles eine Menge Material zum Studieren, und ich bin ehrlich gesagt noch sehr überfordert damit.

Der funktionierende Code von Bergmann war schonmal eine super Grundlage, ich brauche einfach immer erstmal was, das funktioniert, um daraus zu lernen, weil ich eben blutiger Anfänger bin.
Für euch ist das alles selbstverständlich, aber mich überfordern die meisten Dinge, besonders weil es so viele unterschiedliche Möglichkeiten gibt, und dann noch so viele Befehle, die man gar nicht mehr benutzt.

Mir ist aufgefallen daß Du (Mathias) als Offset vom Start des VBO in glVertexAttribPointer 'nil' angegeben hast, überhaupt ist bei Dir wieder alles komplett anders (auch das Zuweisen der Texturen), was die Dinge für mich nicht leichter verständlich macht, und Nachbauen kann ich Dein Beispiel nicht, um es Stück für Stück zu studieren, weil mir dazu die einfachsten Grundlagen fehlen, um die Fehlermeldungen zu beseitigen (z.B. durch die fehlende Shader-Klasse).

OpenGL komplett zu lernen, werde ich sicherlich nicht hinbekommen, bzw. verschiedene Herangehensweisen um ein Problem zu lösen.
Wenn das Codegerüst, was die Textur erstmal sauber auf das Quad projiziert, entsprechend läuft, und dazu vielleicht noch Multitexturing funktioniert, um die NormalMap im Shader ebenfalls benutzen zu können, werde ich sowieso erst mal weiter schauen müssen, wie/ob das Ganze auf Windows, Linux und Mac läuft, und wenn nicht, kann ich den OpenGL Versuch sowieso abhaken. Wenn ja, kommen noch die Lizenzprobleme. Auf jeden Fall gilt in diesem Stadium noch: "Je einfach desto besser" (was vielleicht etwas faul klingt, allerdings kann ich es mir nicht leisten, erstmal monatelang in eine neue Wissenschaft einzutauchen, mit dem Risiko, daß am Ende nichts dabei herauskommt).
Vielen Dank für eure Hilfe und für die Geduld mit einem extremen Greenhorn wie mir :)


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mi Jan 28, 2015 16:04 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
Hey,

Dee hat geschrieben:
Wenn ich es richtig verstanden habe, wird das Attribut inPos im Shader durch gl_Position = vec4(inPos, 1.0); definiert, also bräuchte man wohl für die Texturkoordinaten einen entsprechenden Befehl.
In der Zeile wird inPos genutzt. Deklariert/Definiert wird es weiter oben durch "in vec3 inPos;" und genau da müssen auch die TexturCoord analog zu inPos deklariert werden "in vec2 inTexCoord".

mathias hat geschrieben:
Mir ist aufgefallen daß Du (Mathias) als Offset vom Start des VBO in glVertexAttribPointer 'nil' angegeben hast
Das Offset bezieht sich immer auf das gebundene VBO. Mathias hat für seine Vertex- und TexCoord-Daten jeweils ein VBO. Also ist der Daten-Offset im jeweiligen VBO auch 0 (bzw. nil). Bei meiner Variante liegen Vertex- und TexCoord-Daten im _selben_ VBO (aus Performance- und Management-Gründen) und deshalb muss da entsprechend das Offset der Daten angegeben werden.

noch ein kleiner Hinweis zu glGetAttribLocation: Der Name der übergebenen Variable muss genau so wie im Shader heißen, sonst kann die Atrib-Location nicht bestimmt werden. Bei deinem TextCoord-Bsp. steht dort "TexCoord". Heißen die im Shader auch so? Normalerweise kennzeichnet man sich die eingehenden Daten irgendwie, z.B. wie gehabt durch ein vorgeschobenes "in", also wäre "inTexCoord" die bessere Wahl.

€: hast du dir eig schonmal die Shader-Tutorials angesehen? Die sind zwar nicht mehr ganz Up-To-Date, was die Datenübergabe angeht, aber für ein grundlegendes Verständnis und um ein Gefühl für die ganzen eingebauten Variablen zu bekommen sind sie top.

MfG Bergmann

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 58 Beiträge ]  Gehe zu Seite Vorherige  1, 2, 3, 4  Nächste
Foren-Übersicht » Programmierung » Einsteiger-Fragen


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.127s | 17 Queries | GZIP : On ]