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

Aktuelle Zeit: Fr Apr 26, 2024 06:19

Foren-Übersicht » Programmierung » OpenGL 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 2
  [ 22 Beiträge ]  Gehe zu Seite 1, 2  Nächste
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
mathias
 Betreff des Beitrags: Texturen
BeitragVerfasst: Mo Jan 20, 2014 20:45 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1278
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Was mach ich falsch.
Eigentlich müsste ja ein zufälliges Muster zu erwarten sein.
Mein Objekt kommt in einer zufälligen Farbe, es ist einfarbig.
Somit kommt beim Shader etwas an.
Code:
  1. var
  2.   textureID: GLuint;  
  3. begin
  4. ....
  5.   textureID := glGetAttribLocation(ProgramID, 'vertexUV');
  6.   glBindVertexArray(uiVAO[0]);
  7.  
  8.   for x := 0 to 127 do for y := 0 to 127 do t[x, y] := Random($100); // Zufällige Farben
  9.   glGenTextures(1, @textureID);
  10.  
  11.   glBindTexture(GL_TEXTURE_2D, textureID);
  12.   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 128, 128, 0, GL_BGR, GL_UNSIGNED_BYTE, @t);
  13.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  14.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  15.   glGenerateMipmap(GL_TEXTURE_2D);
  16.  
  17.  
  18.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);
  19. .....
  20.  

FragmentShader
Code:
  1. #version 330
  2.  
  3. in vec2 UV;
  4.  
  5. out vec3 Color;
  6.  
  7. uniform sampler2D myTextureSampler;
  8.  
  9. void main()
  10. {
  11.     Color = texture( myTextureSampler, UV ).rgb;
  12. }            


VertexShader
Code:
  1. #version 330
  2. in vec3 inPos;
  3.  
  4. in vec2 vertexUV;
  5.  
  6. out vec2 UV;
  7.  
  8. uniform mat4 meinMatrix;
  9. uniform mat4 CameraMatrix;
  10.  
  11. void main(void)
  12. {
  13.  
  14.   gl_Position = CameraMatrix * meinMatrix * vec4(inPos, 1.0);
  15.  
  16.   UV = vertexUV;
  17. }              


Als Quelle habe ich diese Tutorial benutzt: http://www.opengl-tutorial.org/beginner ... ured-cube/

_________________
OpenGL
Nach oben
 Profil  
Mit Zitat antworten  
glAwesome
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Mo Jan 20, 2014 20:59 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 14, 2013 21:17
Beiträge: 588
Programmiersprache: C++
Das Vertexattribut vertexUV hast du auch mit Input versorgt (glVertexAttribPointer)?

Kleine Anmerkung zum Fragmentshader:
outColor deklariert man soweit ich das kenne immer als vec4. Ich will nicht ausschließen, dass das auch anders geht, aber es lohnt sich vielleicht, das zu überprüfen.

Edit: Was du in Zeile 5 in Pascal machst, sieht falsch aus. Der Wert von textureID wird sowieso von glGenTextures wieder überschrieben. Nicht Texturen mit Texturkoordinaten verwechseln!

_________________
So aktivierst du Syntaxhighlighting im Forum: [code=pascal ][/code], [code=cpp ][/code], [code=java ][/code] oder [code=glsl ][/code] (ohne die Leerzeichen)
Nach oben
 Profil  
Mit Zitat antworten  
mathias
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Mo Jan 20, 2014 22:52 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1278
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
wen tx und ty z.B. 3 ist, dann kommt eine Textur, aber da ich jetzt die Daten mit $FF fülle, müsste das Objekt einfarbig kommen.
Wen aber tx und ty zu gross ist, dann kommt eine Schutzverletzung.
Irgendwas ist immer noch falsch.

Code:
  1. const
  2.   Triangle: array[0..2] of TVector3f =
  3.     ((-0.4, 0.1, 0.0), (0.4, 0.1, 0.0), (0.0, 0.7, 0.0));
  4.   TriangleTextureVertex: array[0..2] of TVector2f =
  5.     ((-1.0, -1.0), (1.0, -1.0), (1.0, 1.0));  
  6. const
  7.   tx = 1023;
  8.   ty = 1023;
  9. var
  10.   t: array[0..tx, 0..ty] of byte;
  11.  
  12. begin
  13.   pos_id := glGetAttribLocation(ProgramID, 'inPos');
  14.   col_id := glGetAttribLocation(ProgramID, 'inColor');
  15.   Normale_id := glGetAttribLocation(ProgramID, 'inNormal');
  16.   textureID := glGetAttribLocation(ProgramID, 'vertexUV');
  17.  
  18.   glGenVertexArrays(3, uiVAO); // Generate two VAOs, one for triangle and one for quad
  19.  
  20.   glGenBuffers(8, uiVBO); // And four VBOs
  21.  
  22.   // Setup whole triangle
  23.   glBindVertexArray(uiVAO[0]);
  24.  
  25.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);
  26.   glBufferData(GL_ARRAY_BUFFER, sizeof(Triangle), @Triangle, GL_STATIC_DRAW);
  27.   glEnableVertexAttribArray(pos_id);
  28.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  29.  
  30.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[1]);
  31.   glBufferData(GL_ARRAY_BUFFER, sizeof(TriangleTextureVertex), @TriangleTextureVertex, GL_STATIC_DRAW);
  32.   glEnableVertexAttribArray(textureID);
  33.   glVertexAttribPointer(textureID, 3, GL_FLOAT, False, 0, nil);
  34.  
  35.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[2]);
  36.   glBufferData(GL_ARRAY_BUFFER, sizeof(fTriangleNormale), @fTriangleNormale, GL_STATIC_DRAW);
  37.   glEnableVertexAttribArray(Normale_id);
  38.   glVertexAttribPointer(Normale_id, 3, GL_FLOAT, False, 0, nil);
  39.  
  40.   for x := 0 to tx do for y := 0 to ty do t[x, y] := $FF; // Zufällige Farben
  41. //  for x := 0 to tx do for y := 0 to ty do t[x, y] := Random($1); // Zufällige Farben
  42.   glGenTextures(1, @textureID);
  43.  
  44.   glBindTexture(GL_TEXTURE_2D, textureID);
  45.   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tx, ty, 0, GL_BGR, GL_UNSIGNED_BYTE, @t);
  46.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  47.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  48.   glGenerateMipmap(GL_TEXTURE_2D);


Zitat:
outColor deklariert man soweit ich das kenne immer als vec4.

Habe ich wieder auf vec 4 zurückgesetzt.

_________________
OpenGL
Nach oben
 Profil  
Mit Zitat antworten  
OpenglerF
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Mo Jan 20, 2014 23:18 
Offline
DGL Member

Registriert: Do Dez 29, 2011 19:40
Beiträge: 421
Wohnort: Deutschland, Bayern
Programmiersprache: C++, C, D, C# VB.Net
In Zeile 45 lässt du die Adresse eines Array übergeben.
Ich weiß nicht wie es in Delphi genau funktioniert, aber in den meisten C Sprachen mit Zeigern hätte man dann einen Doppelpointer. Also ein Zeiger auf den Zeiger, der das erste Element des Arrays markiert.

Zitat:
one for triangle and one for quad

Ich weiß nicht, ob Quad in dem Sinn gemeint ist, aber als Hinweis: In OpenGL 3 wurden Quads gestrichen.
Nativ unterstützt OpenGL keine Quads mehr. Du musst also an Stelle eines Quads zwei Dreiecke erzeugen. Mit Indices ist das kein großer Nachteil.
Nach oben
 Profil  
Mit Zitat antworten  
glAwesome
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Di Jan 21, 2014 11:00 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 14, 2013 21:17
Beiträge: 588
Programmiersprache: C++
In Zeile 33 tust du so, als wenn du 3D-Vektoren als Texturkoordinaten hättest. Ersetze die 3 mal mit einer 2.

_________________
So aktivierst du Syntaxhighlighting im Forum: [code=pascal ][/code], [code=cpp ][/code], [code=java ][/code] oder [code=glsl ][/code] (ohne die Leerzeichen)
Nach oben
 Profil  
Mit Zitat antworten  
damadmax
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Di Jan 21, 2014 12:35 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java
Du solltest dir mal über die Benennung/Verwendung der Variablen Gedanken machen. Es mag ja platzsparend sein textureID für 2 verschiedene Zwecke zu verwenden, aber es ist keineswegs übersichtlich.

Soweit ich mich an Delphi erinnere ist es keine gute Idee 2-dimensionale Arrays für Texturdaten zu nutzen.
Nimm einfach ein einfaches Array und indiziere es mit
Code:
  1. t[x+height*y]
.

Soweit ich weiss, muss man auch nicht
Code:
  1. glEnableVertexAttribArray(xxx);
beim zusammenbauen des VAOs/VBOs benutzen. Geht auch ohne.

Wenn man seine Shader relativ konform hält kann man sich auch das Holen der AttribLocation mittels
Code:
  1. pos_id := glGetAttribLocation(ProgramID, 'inPos');
sparen. Das kann man fest in den Shader einbauen:
Code:
  1. layout(location = 0) in vec3 in_Position;
Zumindest wenn man sich an seine eigenen Konventionen hält :) Aber das muss man sowieso, weil man ja den richtigen Namen angeben müsste.

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next
Nach oben
 Profil  
Mit Zitat antworten  
yunharla
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Di Jan 21, 2014 18:37 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern
ich kürz mal den Code ein wenig damit hier nicht noch mehr wilde Gerüchte aufkommen:
mathias hat geschrieben:
Code:
  1.  
  2.   t: array[0..tx, 0..ty] of byte;
  3. ...
  4.   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tx, ty, 0, GL_BGR, GL_UNSIGNED_BYTE, @t);


_________________
Meine Homepage
Nach oben
 Profil  
Mit Zitat antworten  
mathias
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Di Jan 21, 2014 19:00 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1278
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
So wie es aussieht funktioniert es.
Jetzt kann ich jeden Pixel der Textur einzeln ansprechen.

Code:
  1. const
  2.   Triangle: array[0..5] of TVector3f =     // Ein Quadrat aus 2 Dreiecken
  3.     ((-0.4, 0.7, 0.0), (0.4, 0.1, 0.0), (-0.4, 0.1, 0.0),
  4.     (-0.4, 0.7, 0.0), (0.4, 0.7, 0.0), (0.4, 0.1, 0.0));
  5.   TriangleTextureVertex: array[0..5] of TVector2f =
  6.     ((0.0, 1.0), (1.0, 0.0), (0.0, 0.0),
  7.     (0.0, 1.0), (1.0, 1.0), (1.0, 0.0));
  8.  
  9. procedure TForm1.InitScene;
  10. const
  11.   tx = 3;
  12.   ty = 3;
  13. var
  14.   t: array[0..tx, 0..ty] of LongWord;  //7 ein Pixel hat 4 Byte
  15.   x, y: integer;
  16. begin
  17.   ProgramID := InitShader('VertexShader.txt', 'FragmentShader.txt');
  18.   glUseProgram(programID);
  19.  
  20.   VertexModif.Normale(fCube, FCubeNormale);
  21.   VertexModif.Normale(Triangle, fTriangleNormale);
  22.  
  23.   glClearColor(0.0, 0.5, 1.0, 1.0);
  24.  
  25.   glEnable(GL_DEPTH_TEST);
  26.   glDepthFunc(GL_LESS);
  27.  
  28.   pos_id := glGetAttribLocation(ProgramID, 'inPos');
  29.   col_id := glGetAttribLocation(ProgramID, 'inColor');
  30.   Normale_id := glGetAttribLocation(ProgramID, 'inNormal');
  31.   texture_id := glGetAttribLocation(ProgramID, 'vertexUV');
  32.  
  33.   glGenVertexArrays(3, uiVAO);
  34.  
  35.   glGenBuffers(8, uiVBO); // And four VBOs
  36.  
  37.   // Setup whole triangle
  38.   glBindVertexArray(uiVAO[0]);
  39.  
  40.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);
  41.   glBufferData(GL_ARRAY_BUFFER, sizeof(Triangle), @Triangle, GL_STATIC_DRAW);
  42.   glEnableVertexAttribArray(pos_id);
  43.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  44.  
  45.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[1]);
  46.   glBufferData(GL_ARRAY_BUFFER, sizeof(TriangleTextureVertex), @TriangleTextureVertex, GL_STATIC_DRAW);
  47.   glEnableVertexAttribArray(texture_id);
  48.   glVertexAttribPointer(texture_id, 2, GL_FLOAT, False, 0, nil); // da war es die 2/3
  49.  
  50.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[2]);
  51.   glBufferData(GL_ARRAY_BUFFER, sizeof(fTriangleNormale), @fTriangleNormale, GL_STATIC_DRAW);
  52.   glEnableVertexAttribArray(Normale_id);
  53.   glVertexAttribPointer(Normale_id, 3, GL_FLOAT, False, 0, nil);
  54.  
  55.   for x := 0 to tx do for y := 0 to ty do t[x, y] := $00; // löschen
  56.   t[0, 0] := $ff;        // rot
  57.   t[0, 1] := $Ff0000;    // blau
  58.   t[0, 2] := $Ff00;      // grün
  59.   t[0, 3] := $FFFF;      // gelb
  60.   t[tx, ty] := $FFFFFF;    // weiss   letzter Pixel
  61.   glGenTextures(1, @textureID);
  62.  
  63.   glBindTexture(GL_TEXTURE_2D, textureID);
  64.   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tx + 1, ty + 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, @t);
  65.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  66.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  67.   glGenerateMipmap(GL_TEXTURE_2D);
  68.  
  69.   glBindVertexArray(uiVAO[1]);  // nächste Object  

_________________
OpenGL
Nach oben
 Profil  
Mit Zitat antworten  
glAwesome
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Di Jan 21, 2014 23:43 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 14, 2013 21:17
Beiträge: 588
Programmiersprache: C++
damadmax hat geschrieben:
Soweit ich weiss, muss man auch nicht
Code:
  1. glEnableVertexAttribArray(xxx);
beim zusammenbauen des VAOs/VBOs benutzen. Geht auch ohne.

Dass es (bei dir) ohne geht, heißt ja nicht, dass es korrekt ist. Das hier
https://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml hat geschrieben:
Each generic vertex attribute array is initially disabled and isn't accessed when glDrawElements, [...] is called.
verstehe ich jedenfalls so, dass glEnableVertexAttribArray keinesfalls unnötig ist - wenn es das wäre hätte man es wahrscheinlich auch aus neueren OpenGL-Versionen gestrichen.

_________________
So aktivierst du Syntaxhighlighting im Forum: [code=pascal ][/code], [code=cpp ][/code], [code=java ][/code] oder [code=glsl ][/code] (ohne die Leerzeichen)
Nach oben
 Profil  
Mit Zitat antworten  
damadmax
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Mi Jan 22, 2014 22:12 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java
Wer lesen kann ist klar im Vorteil....
Im Wiki steht (leicht zu überlesen, zumindest bei mir), dass ein VAO auch die Einstellungen der VertexAttribArrays speichert. Da ich das beim ersten mal überlesen hatte bzw. nichts im 2. Absatz darunter darüber gelesen hatte (da ist nur die Rede von "alles, was ihr mit glVertexAttribPointer einstellen könnt.") habe ich meine VBO Klasse danach gebaut und eben beim Rendern die Attribs aktiviert.
Vielleicht überlege ich mir mal ob/wie man das im Wiki Artikel etwas deutlich machen kann.

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next
Nach oben
 Profil  
Mit Zitat antworten  
mathias
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Mi Jan 22, 2014 22:58 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1278
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
So wie es aussieht merkt sich der VAO alles, man kann nachträglich z.B. Texturen binden.
Der Code funktioniert, obwohl ich VBO gemischt habe.
Code:
  1.  // Setup whole triangle
  2.   glBindVertexArray(uiVAO[0]);
  3.  
  4.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]);
  5.   glBufferData(GL_ARRAY_BUFFER, sizeof(Triangle), @Triangle, GL_STATIC_DRAW);
  6.   glEnableVertexAttribArray(pos_id);
  7.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  8.  
  9.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[2]);
  10.   glBufferData(GL_ARRAY_BUFFER, sizeof(fTriangleNormale), @fTriangleNormale, GL_STATIC_DRAW);
  11.   glEnableVertexAttribArray(Normale_id);
  12.   glVertexAttribPointer(Normale_id, 3, GL_FLOAT, False, 0, nil);
  13.  
  14.  
  15.  
  16.   // Setup whole Quad
  17.   glBindVertexArray(uiVAO[1]);
  18.  
  19.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[3]);
  20.   glBufferData(GL_ARRAY_BUFFER, sizeof(fquad), @fQuad, GL_STATIC_DRAW);
  21.   glEnableVertexAttribArray(pos_id);
  22.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  23.  
  24.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[4]);
  25.   glBufferData(GL_ARRAY_BUFFER, sizeof(fQuadColor), @fQuadColor, GL_STATIC_DRAW);
  26.   glEnableVertexAttribArray(col_id);
  27.   glVertexAttribPointer(col_id, 3, GL_FLOAT, False, 0, nil);
  28.  
  29.   glBindVertexArray(uiVAO[0]);  // Hier wieder VAO 0
  30.  
  31.   glGenTextures(1, @textureID);
  32.  
  33.   glBindTexture(GL_TEXTURE_2D, textureID);
  34.   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tx, ty, 0, GL_RGBA, GL_UNSIGNED_BYTE, Pointer(t));
  35.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  36.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  37.   glGenerateMipmap(GL_TEXTURE_2D);
  38.  
  39.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[1]);
  40.   glBufferData(GL_ARRAY_BUFFER, sizeof(TriangleTextureVertex), @TriangleTextureVertex, GL_STATIC_DRAW);
  41.   glEnableVertexAttribArray(texture_id);
  42.   glVertexAttribPointer(texture_id, 2, GL_FLOAT, False, 0, nil);   // Setup whole Cube
  43.  
  44.  
  45.   glBindVertexArray(uiVAO[2]);
  46.  
  47.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[5]);
  48.   glBufferData(GL_ARRAY_BUFFER, sizeof(fCube), @fCube, GL_STATIC_DRAW);
  49.   glEnableVertexAttribArray(pos_id);
  50.   glVertexAttribPointer(pos_id, 3, GL_FLOAT, False, 0, nil);
  51.  
  52.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[6]);
  53.   glBufferData(GL_ARRAY_BUFFER, sizeof(fCubeColor), @fCubeColor, GL_STATIC_DRAW);
  54.   glEnableVertexAttribArray(col_id);
  55.   glVertexAttribPointer(col_id, 3, GL_FLOAT, False, 0, nil);
  56.  
  57.   glBindBuffer(GL_ARRAY_BUFFER, uiVBO[7]);
  58.   glBufferData(GL_ARRAY_BUFFER, sizeof(fCubeNormale), @fCubeNormale, GL_STATIC_DRAW);
  59.   glEnableVertexAttribArray(Normale_id);
  60.   glVertexAttribPointer(Normale_id, 3, GL_FLOAT, False, 0, nil);        

_________________
OpenGL
Nach oben
 Profil  
Mit Zitat antworten  
glAwesome
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Do Jan 23, 2014 00:01 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 14, 2013 21:17
Beiträge: 588
Programmiersprache: C++
Bevor hier Missverständnisse entstehen:
Ein Vertex Array Object merkt sich nur Sachen, die Vertices betreffen. Texturen gehören nicht dazu (falls du das im letzten Post feststellen wolltest). Texturkoordinaten natürlich schon.

_________________
So aktivierst du Syntaxhighlighting im Forum: [code=pascal ][/code], [code=cpp ][/code], [code=java ][/code] oder [code=glsl ][/code] (ohne die Leerzeichen)
Nach oben
 Profil  
Mit Zitat antworten  
mathias
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Do Jan 23, 2014 18:05 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1278
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
glAwesome hat geschrieben:
Bevor hier Missverständnisse entstehen:
Ein Vertex Array Object merkt sich nur Sachen, die Vertices betreffen. Texturen gehören nicht dazu (falls du das im letzten Post feststellen wolltest). Texturkoordinaten natürlich schon.


Wen man für jedes Objekt eine eigene Textur will, muss man den ganzen Code-Block in RenderScene verschieben, dort wo auch glDrawArrays(....) steht ?

Oder gibt es eine elegantere Lösung, so wie mit den Vertex ?

Code:
  1.   glGenTextures(1, @textureID);
  2.   glBindTexture(GL_TEXTURE_2D, textureID);
  3.   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tx, ty, 0, GL_RGBA, GL_UNSIGNED_BYTE, Pointer(t));
  4.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  5.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  6.   glGenerateMipmap(GL_TEXTURE_2D);

_________________
OpenGL
Nach oben
 Profil  
Mit Zitat antworten  
glAwesome
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Do Jan 23, 2014 18:30 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 14, 2013 21:17
Beiträge: 588
Programmiersprache: C++
Initialisieren brauchst du die Textur nur einmal. Code dafür hast du ja schon gepostet. Danach rufst du beim Rendern nur noch
Code:
  1. glBindTexture(GL_TEXTURE_2D, textureID);
auf.

_________________
So aktivierst du Syntaxhighlighting im Forum: [code=pascal ][/code], [code=cpp ][/code], [code=java ][/code] oder [code=glsl ][/code] (ohne die Leerzeichen)
Nach oben
 Profil  
Mit Zitat antworten  
mathias
 Betreff des Beitrags: Re: Texturen
BeitragVerfasst: Do Jan 23, 2014 19:05 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1278
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Danke, hat geklappt.

Anscheinend ist dies vergleichbar mit glBindVertexArray.

Somit steht mir nichts mehr in Weg, Texturen in meine Objekt-Classen einzubauen.

Jetzt muss ich noch folgendes in den Shader einbauen.
Geht natürlich nicht so in C, aber dies werde ich im glsl-Wiki schon noch finden.. :wink:

Code:
  1. void main()
  2. {
  3. if Texturen then
  4.   FragColor = texture( myTextureSampler, UV ) * diffuse();
  5. else
  6.   FragColor = Color * diffuse();
  7. }

_________________
OpenGL
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 2
  [ 22 Beiträge ]  Gehe zu Seite 1, 2  Nächste
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 103 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.123s | 17 Queries | GZIP : On ]