4. Dreiecke Pro Sekunde

Dreiecke Pro Sekunde

  • A

    Hallo, ich stelle eine Landschaft dar. (OpenGL)
    Diese besteht aus 4 Ecken, die ich jeweils durch 2 Dreiecke zeichne.

    Nun kann ich die Landschaft höchstens 200 * 200 Vierecke groß machen.
    Dies entspricht ja 200 * 200 *2 = 80000 Dreiecke.
    Dann schaft mein PC noch 20 Bilder / Sekunde.
    Also 1600000 = 1.6 millionen Dreiecke / Sekunde.

    Min Rechner hat nen Intel Dual Core E6600 und ne Geforce 6800 GT.

    Wenn man nachließt soll diese Grafikkarte einige hundert Millionen Dreiecke / Sekunde berechnen können.

    Warum ist dann bei soviel weniger schon schluß?

    0
  • V

    wie zeichnest du die Dreiecke? sind diese in einem Vertexbuffer? benutzt du einen Trianglestrip... oder...

    0
  • A

    Also ich berechne zuerst für jedes Viereck, ob es überhaupt gesehen werden kann.
    (Indem ich zuerst die ganze landschaft (200 * 200 Felder teste und dann rekursiv dieses für jedes der 4 Teildreiecke wiederhole bis runter zu einzelnen Vierecken. So kann ich schnell große nicht zu zeichnende Bereiche ausschließen)

    Dann stelle ich jedes Viereck bestehend aus 2 Dreiecken als Triangle Strip dar, da ich so nur 4 Ecken übertragen muß anstatt 6 wenn ich beide Dreiecke einzeln zeichnen würde.

    Bei 200*200 Feldern erhalte ich wie vorher erwähnt nur 20 FPS.

    Die zeichenfunktion selbst sieht dann so aus:

    inline void zeiche_Boden(long x, long y) 
	{

		glBindTexture(GL_TEXTURE_2D, textur[kachel[x][y].get_textur()].get_texture());

		glBegin(GL_TRIANGLE_STRIP);

		//Informationen für erste Kante angeben
		glNormal3f(kachel[x][y].get_normale1().x,kachel[x][y].get_normale1().y,kachel[x][y].get_normale1().z);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3d(x,      y,     kachel[x][y].get_hoehe());

		//genauso für 2. Kante
		glNormal3f(kachel[x][y].get_normale2().x,kachel[x][y].get_normale2().y,kachel[x][y].get_normale2().z);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3d(x+1,    y,     kachel[x+1][y].get_hoehe());

		//genauso für 3. Kante
		glNormal3f(kachel[x][y].get_normale3().x,kachel[x][y].get_normale3().y,kachel[x][y].get_normale3().z);								
		glTexCoord2f(0.0f, 1.0f);
		glVertex3d(x,    y+1,     kachel[x][y+1].get_hoehe());

		//genauso für die 4.Kante
		glNormal3f(kachel[x][y].get_normale6().x,kachel[x][y].get_normale6().y,kachel[x][y].get_normale6().z);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3d(x+1,    y+1,   kachel[x+1][y+1].get_hoehe());

		glEnd();
	}
    0
  • M

    deine anwendung muss jeden Frame alle Dreiecke über den AGP-Port auf deine GraKa übertragen, weil du mit glVertex arbeitest.
    Erstell einen Vertexbuffer oder Displaylist oder wie das OpenGL heißt, dass die Daten in der GraKa bleiben. Deine Sichtbarkeitstests kannst du dann mit indizes realisieren.

    0
  • G

    Maxi hat recht,

    und wenn du schon im Immediate-mode rendern willst, dann verwende wenigstens

    glBegin(GL_QUADS);

    Aber besser, verwende Arrays oder Vertex-Buffers. Dein Software-Culling kannst du dir wahrscheinlich auch sparen (Ich denke, dass es schneller wird, wenn du immer alle Quads zeichnest).

    Mit VBOs sollte auf einer 6800 eine Landschaft der Groesse 2000x2000 noch interaktiv laufen, wenn das nicht so ist, hast du was falsch gemacht.

    Gruss, Gast

    0
Anmelden zum Antworten