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

Aktuelle Zeit: Fr Jul 11, 2025 07:17

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



Ein neues Thema erstellen Auf das Thema antworten  [ 3 Beiträge ] 
Autor Nachricht
 Betreff des Beitrags: Beginner Problem mit VBOs
BeitragVerfasst: So Mai 08, 2011 21:55 
Offline
DGL Member

Registriert: So Mai 08, 2011 20:42
Beiträge: 2
Hi.

Ich bin neu bei opengl und versuche gerade mich an einer fraktalen Szene (wie dem Sierpinski Dreieck http://en.wikipedia.org/wiki/Sierpinski_triangle). Grundlegend hat das schonmal geklappt wenn ich jedes der Dreiecke einzelnd erstelle und rendere. Jetzt möchte ich das Ganze auf VBOs umstellen und das funktioniert leider nicht richtig.

Ich hab eine Struktur für farbige Vertizes:

Code:
  1.  
  2. struct ColoredVertex
  3. {
  4.     M3DVector3f m_Position;
  5.     M3DVector3f m_Color;
  6. };


Dann erstell ich die Dreiecke rekursiv:

Code:
  1.  
  2. ColoredVertex frontTriangle[3];
  3. // draw front triangle
  4. m3dLoadVector3(frontTriangle[0].m_Position, xB, yB, zB);
  5. m3dLoadVector3(frontTriangle[1].m_Position, xA, yA, zA);
  6. m3dLoadVector3(frontTriangle[2].m_Position, xD, yD, zD);
  7. m3dLoadVector3(frontTriangle[0].m_Color, 0.0f, 1.0f, 0.0f); // green
  8. m3dLoadVector3(frontTriangle[1].m_Color, 0.0f, 1.0f, 0.0f); // green
  9. m3dLoadVector3(frontTriangle[2].m_Color, 0.0f, 1.0f, 0.0f); // green


Und erstell dann das VBO array:

Code:
  1.  
  2. // Erzeuge das VBO
  3. glGenBuffers(m_Depth, &m_FrontTriangle);
  4. glBindBuffer(GL_ARRAY_BUFFER, m_FrontTriangle);
  5. //Kopiere die 3 * m_Depth + 1 vertices ins VBO
  6. glBufferData(GL_ARRAY_BUFFER, sizeof(ColoredVertex) * (3 * m_Depth), frontTriangle, GL_STATIC_DRAW);
  7.  
  8. glGenVertexArrays(m_Depth,&m_vaoFrontTriangle);
  9. glBindVertexArray(m_vaoFrontTriangle);
  10.  
  11. // erstes Shader-Attribut aktivieren (Vertex-Position)
  12. glEnableVertexAttribArray(0);  
  13. glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,  sizeof(ColoredVertex), NULL);
  14.  
  15. // Zweites Shader-Attribut aktivieren (Farbe).
  16. //Farbdaten stehen immer nach der Position, daher ein offset der Größe von M3DVector3f notwendig
  17. glEnableVertexAttribArray(1);
  18. glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,  sizeof(ColoredVertex), (const GLvoid *)(sizeof(M3DVector3f)));
  19.  
  20. //VAO wieder unbinden
  21. glBindVertexArray(0);
  22.  


... und in der Renderloop will ich dann die Dreiecke zeichnen.

Code:
  1.  
  2. //VBO aktivieren
  3. glBindVertexArray(m_vaoFrontTriangle);
  4. glBindBuffer(GL_ARRAY_BUFFER, m_FrontTriangle);
  5. // Zeiche einen Triangle
  6.  
  7. glDrawArrays(GL_TRIANGLES, 0,3 * m_Depth));
  8.    
  9. //Aufräumen
  10. glBindVertexArray(0);
  11.  


Tja... leider wird nur ein einziges Dreieck gezeichnet, egal wie groß ich den Buffer mache. Ich vermute ich überschreibe vielleicht irgenwelche Vertizes wieder im Vertexbuffer, aber ich kann irgendwie noch nicht so richtig erkennen woran es nun genau hapert.

Hat jemand n Tipp oder sieht was ich falsch mache?

Jede Hilfe ist gern gesehen :)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Beginner Problem mit VBOs
BeitragVerfasst: So Mai 08, 2011 22:36 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Möchtest du VertexbufferObjects (VBO) oder VertexArrays benutzen? Letztere sind Teil von OpenGL 3.0. Du scheinst irgendwie beides zu benutzen. Du füllst den VBO und versuchst dann aber das VertexArray zu rendern. Absicht? (ich habe von VertexArrays leider keine Ahnung)

Code:
  1. glGenBuffers(m_Depth, &m_FrontTriangle);

Damit erzeugst du m_Depth VBO's! Ich glaube nicht das dies die Idee war, du willst wahrscheinlich nur einen einzigen VBO.

Code:
  1. glBufferData(GL_ARRAY_BUFFER, sizeof(ColoredVertex) * (3 * m_Depth), frontTriangle, GL_STATIC_DRAW);

Bei Tiefe 1 hast du drei Dreiecke, richtig? Das wären dann 9 Vertices...nicht nur drei. Das Array frontTriangle besteht ebenfalls nur aus drei Vertices...also einem Dreieck.

Ich sehe keinerlei rekursive Aufrufe in deinem Code.


Edit: Habe mich gerade mal informiert was VertexArrays (die OpenGL 3 Variante) machen. Die speichern alles was mit glVertexAttribPointer & Co zusammenhängt, richtig? In dem Fall sieht die Nutzung richtig aus. Sorry.

_________________
Yeah! :mrgreen:


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Beginner Problem mit VBOs
BeitragVerfasst: So Mai 08, 2011 23:14 
Offline
DGL Member

Registriert: So Mai 08, 2011 20:42
Beiträge: 2
Hm.

Ich poste mal meinen momentanen Code. Wie gesagt versuche ich es gerade erstmal mit dem Frontdreieck, aber später soll es eben zu einem Tetraeder werden:

Code:
  1.  
  2. void Sierpinski(float xA, float yA, float zA, float xB, float yB, float zB, float xC, float yC, float zC, float xD, float yD, float zD, int deep)
  3. {
  4.     if (deep > 0)
  5.     {
  6.         deep--;
  7.  
  8. // ... lots of vertices calculation....
  9.         ...
  10. //
  11.        
  12.         Sierpinski(xLL, yLL, zLL, // lower left
  13.             xLR, yLR, zLR, // lower right
  14.             xBP, yBP, zBP, // back
  15.             xTP, yTP, zTP, // top
  16.             deep);
  17.     }
  18.     else
  19.     {
  20.         ColoredVertex frontTriangle[3];
  21.         // draw front triangle
  22.         m3dLoadVector3(frontTriangle[0].m_Position, xB, yB, zB);
  23.         m3dLoadVector3(frontTriangle[1].m_Position, xA, yA, zA);
  24.         m3dLoadVector3(frontTriangle[2].m_Position, xD, yD, zD);
  25.         m3dLoadVector3(frontTriangle[0].m_Color, 0.0f, 1.0f, 0.0f); // green
  26.         m3dLoadVector3(frontTriangle[1].m_Color, 0.0f, 1.0f, 0.0f); // green
  27.         m3dLoadVector3(frontTriangle[2].m_Color, 0.0f, 1.0f, 0.0f); // gree
  28.  
  29.         // same for draw left back triangle
  30. ...
  31.  
  32.         //// same for draw right back triangle
  33. ....
  34.        
  35.         // front triangle
  36.  
  37.         // Erzeuge das VBO
  38.         glGenBuffers((m_Depth+1), &m_FrontTriangle);
  39.         glBindBuffer(GL_ARRAY_BUFFER, m_FrontTriangle);
  40.         //Kopiere die 3 * m_Depth + 1 vertices ins VBO
  41.         glBufferData(GL_ARRAY_BUFFER, sizeof(ColoredVertex) * (3 * (m_Depth+1)), frontTriangle, GL_STATIC_DRAW);
  42.  
  43.         glGenVertexArrays((m_Depth+1),&m_vaoFrontTriangle);
  44.         glBindVertexArray(m_vaoFrontTriangle);
  45.         // erstes Shader-Attribut aktivieren (Vertex-Position)
  46.         glEnableVertexAttribArray(0);  
  47.         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,  sizeof(ColoredVertex), NULL);
  48.  
  49.         // Zweites Shader-Attribut aktivieren (Farbe).
  50.         //Farbdaten stehen immer nach der Position, daher ein offset der Größe von M3DVector3f notwendig
  51.         glEnableVertexAttribArray(1);
  52.         glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,  sizeof(ColoredVertex), (const GLvoid *)(sizeof(M3DVector3f)));
  53.  
  54.         //VAO wieder unbinden
  55.         glBindVertexArray(0);
  56.  
  57.         // same for left back triangle
  58.  
  59.         // Erzeuge das VBO
  60.         glGenBuffers((m_Depth+1), &m_LeftBackTriangle);
  61.         glBindBuffer(GL_ARRAY_BUFFER, m_LeftBackTriangle);
  62.         //Kopiere die 3 * m_Depth + 1 vertices ins VBO
  63.         glBufferData(GL_ARRAY_BUFFER, sizeof(ColoredVertex)*(3 * (m_Depth+1)), leftbackTriangle, GL_STATIC_DRAW);
  64.  
  65.         glGenVertexArrays((m_Depth+1),&m_vaoLeftBackTriangle);
  66.         glBindVertexArray(m_vaoLeftBackTriangle);
  67.         // erstes Shader-Attribut aktivieren (Vertex-Position)
  68.         glEnableVertexAttribArray(0);  
  69.         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,  sizeof(ColoredVertex), NULL);
  70.  
  71.         // Zweites Shader-Attribut aktivieren (Farbe).
  72.         //Farbdaten stehen immer nach der Position, daher ein offset der Größe von M3DVector3f notwendig
  73.         glEnableVertexAttribArray(1);
  74.         glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,  sizeof(ColoredVertex), (const GLvoid *)(sizeof(M3DVector3f)));
  75.         //VAO wieder unbinden
  76.         glBindVertexArray(0);
  77.  
  78.  
  79.         // same for right back triangle
  80.  ...
  81.     }
  82. }
  83.  
  84. void SetupSierpinski(float width, int x, int y, int z, int deep)
  85. {
  86.     float height = (float)(sqrt(3.0)) / 2.0f * width;          // Höhe im gleichseitigen Dreieck
  87.  
  88.     //  unten links
  89.     int xA = x;          
  90.     int yA = y;
  91.     int zA = z;
  92.     // unten rechts
  93.     int xB = (int) (x + width);
  94.     int yB = y;
  95.     int zB = z;
  96.     // hinten Mitte
  97.     int xC = (int)(x + width / 2.0f);
  98.     int yC = y;
  99.     int zC = (int)(z + width); // event breite durch 2
  100.     //  oben Mitte
  101.     int xD= (int) (x + width / 2.0f);
  102.     int yD= (int) (y + height);
  103.     int zD = (int) (z + width / 2.0f); // NOTE: this maybe wrong. height of a tetraeder is a * sqrt(2/3)
  104.     //int zD = (int) (width * sqrt(2.0f / 3.0f));
  105.  
  106.     Sierpinski(xA, yA, zA, xB, yB, zB, xC, yC, zC, xD, yD, zD, deep);
  107. }
  108.  
  109.  
  110.  
  111.  
  112. // Aufruf draw scene
  113. void RenderScene(void)
  114. {
  115.     std::cout << "render" << std::endl;
  116.  
  117. // some init render stuff...
  118. ...
  119. //
  120.  
  121.     //VBO aktivieren
  122.     glBindVertexArray(m_vaoFrontTriangle);
  123.     glBindBuffer(GL_ARRAY_BUFFER, m_FrontTriangle);
  124.     // Zeiche einen Triangle
  125.  
  126.     glDrawArrays(GL_TRIANGLES, 0,3 * m_Depth);
  127.    
  128.     //Aufräumen
  129.     glBindVertexArray(0);
  130.  
  131.     // das selbe nochmal für links hinten
  132.     ...
  133.     //
  134.  
  135.     //Das selbe nochmal für rechts hinten...
  136.     ....
  137.     ///
  138.  
  139.     // Hole die im Stack gespeicherten Transformationsmatrizen wieder zurück
  140.     modelViewMatrix.PopMatrix();
  141.  
  142.     // Vertausche Front- und Backbuffer
  143.     glutSwapBuffers();
  144. }
  145.  
  146.  
  147.  
  148.  
  149. // Initialisierung des Rendering Kontextes
  150. void SetupRC()
  151. {
  152.     // create the sierpinski geometry
  153.     SetupSierpinski(600, 1, 1, 1, 3);
  154. }
  155.  
  156.  


Zuletzt geändert von Lord Horazont am Mo Mai 09, 2011 07:52, insgesamt 1-mal geändert.
Codetags zu C++ geändert


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 3 Beiträge ] 
Foren-Übersicht » Programmierung » Einsteiger-Fragen


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 24 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:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.009s | 17 Queries | GZIP : On ]