DGL • Thema anzeigen - VBO langsamer als glBegin/glEnd?

VBO langsamer als glBegin/glEnd?

Moderator: DGL-Team

Seite 1 von 1

[ 2 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Kyro

Betreff des Beitrags: VBO langsamer als glBegin/glEnd?

Verfasst: Di Sep 11, 2007 16:43

DGL Member

Registriert: So Okt 26, 2003 20:07
Beiträge: 249

Hi,

Mir ist es kürzlich schonmal aufgefallen, jetzt hat es sich bestätigt: Meine VBO Implementierung scheint langsamer zu sein als die selbe Szene mit einfachem glBegin/glEnd. Gerendert werden 1000 Partikel - es sind so wenig, da sonst das Durchlaufen der Liste die Performance drückt, und nicht das Rendern selbst. Das VBO leistet ~845FPS, GL_QUADS leistet ~935FPS. Bei höherer Partikelanzahl mindert sich der Abstand zwischen den Zahlen, aber das VBO wird davon nicht schneller. Die Daten des VBO werden in jedem Durchlauf upgedated. Die Berechnungen sind bei beiden Methoden die gleichen. Hier der relevante Code:

Code:

 
    //*********** VBO ************
 
     if FCalcNormals then
     begin
      vMode := GL_T2F_C4F_N3F_V3F;
      vSize := SizeOf(T_T2F_C4F_N3F_V3F_Vertex);
     end else
     begin
      vSize := SizeOf(T_T2F_C4UB_V3F_Vertex);
      vMode := GL_T2F_C4UB_V3F;
     end;
      
     vSize := SizeOf(vMode);
 
     // Calculate the amount of data that will be mapped
     VBOLength := Length(FParticlePointers)*vSize*4;
     
     glBindBufferARB(GL_ARRAY_BUFFER_ARB, FVBO);
     glEnableClientState(GL_VERTEX_ARRAY);
     if (FCurrentVBOLength <= VBOLength) or (FCurrentVBOLength-100*vSize*4 > VBOLength) then
     begin
       WriteLn('Resize');
       // Add some free space to avoid resize all the time
       ResizeVBO(VBOLength+50*vSize*4);
     end;
     //glBufferDataARB(GL_ARRAY_BUFFER_ARB, VBOLength, nil, GL_DYNAMIC_DRAW_ARB);
     VBOPointer := glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB); //nil
     
     DataLength := 0;
 
     while NodeIterator <> nil do // Die Initialisierung hab ich rausgelassen,  nicht wundern
     begin
        For k := 0 to 3 do
        begin
          if FCalcNormals then
          begin
            VNPointer := VBOPointer;
            VNPointer^.X := Particle.Position.X + Vectors[k].X;
            VNPointer^.Y := Particle.Position.Y + Vectors[k].Y;
            VNPointer^.Z := Particle.Position.Z + Vectors[k].Z;
            VNPointer^.S := FTextures[Particle.Texture, k, 0];
            VNPointer^.T := FTextures[Particle.Texture, k, 1];
            VNPointer^.R := Particle.Color.X;
            VNPointer^.G := Particle.Color.Y;
            VNPointer^.B := Particle.Color.Z;
            VNPointer^.A := Particle.Opacity;
            VNPointer^.NX:= Normals[k].X;
            VNPointer^.NY:= Normals[k].Y;
            VNPointer^.NZ:= Normals[k].Z;
          end else
          begin
            VPointer := VBOPointer;
            VPointer^.X := Particle.Position.X + Vectors[k].X;
            VPointer^.Y := Particle.Position.Y + Vectors[k].Y;
            VPointer^.Z := Particle.Position.Z + Vectors[k].Z;
            VPointer^.S := FTextures[Particle.Texture, k, 0];
            VPointer^.T := FTextures[Particle.Texture, k, 1];
            VPointer^.R := Round(Particle.Color.X*255);
            VPointer^.G := Round(Particle.Color.Y*255);
            VPointer^.B := Round(Particle.Color.Z*255);
            VPointer^.A := Round(Particle.Opacity*255);
          end;
      {$IFDEF cpux86_64}
          VBOPointer := Pointer(Int64(VBOPointer)+vSize);
      {$ELSE}
      VBOPointer := Pointer(Integer(VBOPointer)+vSize);
          {$ENDIF}
      inc(DataLength);
        end;
 
        if NodeIterator^.Right <> -1 then
          NodeIterator := @FParticleStack[NodeIterator^.Right]
        else
          NodeIterator := nil;
     end;
 
     glUnmapBuffer(GL_ARRAY_BUFFER_ARB);
     glInterleavedArrays(vMode, vSize, nil);
     glDrawArrays(GL_QUADS, 0, DataLength);
     glDisableClientState(GL_VERTEX_ARRAY);
     glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
    
  //*********** glBegin/glEnd ************
 
  glBegin(GL_QUADS);
  while NodeIterator <> nil do
  begin
         if FCalcNormals then
           glNormal3fv(@Normals[k]);
         glColor4f(Color.X, Color.Y, Color.Z, Opacity);
         glTexCoord2fv(@FTextures[Texture, k]);
         glVertex3fv(@Vectors[k]);
  
       NodeIterator^.Value := Particle;
       if NodeIterator^.Right <> -1 then
         NodeIterator := @FParticleStack[NodeIterator^.Right]
       else
         NodeIterator := nil;
  end;
  glEnd;
 

Mach ich was falsch? oder lohnt sich ein VBO erst, wenn man nicht in jedem Zyklus updated?

_________________
I'm not the signature, I'm just cleaning the floor...

Derzeitiges Projekt:
FireBlade Particle Engine (Release R2 2009.06.29)

Nach oben

Kyro

Betreff des Beitrags:

Verfasst: Di Sep 11, 2007 20:08

DGL Member

Registriert: So Okt 26, 2003 20:07
Beiträge: 249

Hat sich scheinbar bestätigt:

Habe Berechnung und Rendering entkoppelt, und siehe da: aus 845FPS werden, mit der entsprechenden Anzahl an Berechnungen pro Frame, 4600FPS

Im Vergleich dazu erreicht das entkoppelte Rendern über Displaylisten ca. 4200FPS, ich bin zufrieden

_________________
I'm not the signature, I'm just cleaning the floor...

Derzeitiges Projekt:
FireBlade Particle Engine (Release R2 2009.06.29)

Nach oben

Seite 1 von 1

[ 2 Beiträge ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 4 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.