Open GL und VBOs

Übersicht

BlitzMax, BlitzMax NG

Beginners-Corner

	Pokoyo Betreff: Open GL und VBOs	Sa, Jun 02, 2018 7:29 Antworten mit Zitat
Hallo liebe Community, heute habe ich mal eine ganz grundsätzliche Frage, welche eher an die GL Spezis hier im Forum gerichtet ist. Ich fummel ja jetzt auch schon seit einiger Zeit mit Opengl rum wenns die Zeit mal zulässt. Ich habe jetzt ein Partikelsystem bei dem ich die Vertexpositionen der Partikel per CPU berechnen lasse. Sin und cos werden vorberechnet, ebenso die texturkoordinaten welche per index in einem array abgerufen werden. Desweiteren fließen Scalefaktor und transparenz in die berechnungen ein. Das Ganze wird dann über eine Schleife im OGL Immediate Mode mittels GL_Quad dargestellt. Rechenaufwand der CPU pro Partikel also : BlitzMax: [AUSKLAPPEN] [EINKLAPPEN] T.alpha :- T.alphaadd If T.alpha <= 0 Then T.destroy; Continue If T.Flugwinkel = -10000 Then' verlangsamen der fluggeschwindigkeit / Vorgegebener Sin und Cosinus T.precosinus :* t.speed T.presinus :* t.speed EndIf T.x :+ T.precosinus T.y :+ T.presinus T.rotation = Abs((T.rotation + T.rotationadd) Mod 359) T.scale :+ T.scaleadd und dann nochmal beim rendern : BlitzMax: [AUSKLAPPEN] [EINKLAPPEN] If T.x>GLobal_X_Minus And T.x<GLobal_X_Plus And T.y>GLobal_Y_Minus And T.y<GLobal_Y_Plus Then sizeCos = TestBild.WD2 * T.scale * CosinusF[T.rotation] sizeSin = TestBild.WD2 * T.scale * SinusF[T.rotation] x = sizeCos - sizeSin y = sizeCos + sizeSin GLColor4f ( 0.3, 0.3, 0.3, T.alpha)'Transparenz des Flares setzen GLTexCoord2f( TKL64[T.index,0], TKL64[T.index,1] ); GLVertex2f( T.x - x , T.y + y ) GLTexCoord2f( TKL64[T.index,2], TKL64[T.index,3] ); GLVertex2f( T.x + y , T.y + x ) GLTexCoord2f( TKL64[T.index,4], TKL64[T.index,5] ); GLVertex2f( T.x + x , T.y - y ) GLTexCoord2f( TKL64[T.index,6], TKL64[T.index,7] ); GLVertex2f( T.x - y , T.y - x ) EndIf Gerade beim Rendern also doch schon ordentlich trotz Vorberechnung. bei ca. 32000 Partikeln ist auf meiner Grafikkarte Schluß, soll heißen : Das Rendern dauert ca 14-15ms wohingegen die rechnerei auf der cpu nur 1-2 ms ausmacht. Da man die CPU aber auch noch für andere Berechnungen benötigt würde ich das gerne noch drücken. Jetzt dachte ich mir das evtl. VBOs das Mittel der Wahl wären. Hat schon jemand von Euch Erfahrungen damit gesammelt was den Speed angeht ? Immerhin müsste ich beim aktualisieren der Partikel ja jedesmal alle Werte im dynamischen VBO ändern. Also Alpha, Texturkoordinaten, Rotation, Translation. Ich kann mir vorstellen dass das ne ganz schön gefährliche rumpointerei im Grafikspeicher werden kann. Desweiteren ändert sich ja ziemlich oft die Objekt Anzahl was zur Folge hätte dass man das VBO jedesmal neu erstellen müsste oder auf eine feste Partikel Anzahl setzen müsste. Ich hoffe Ihr versteht was ich meine. Meine Frage also, macht das Sinn sich damit zu beschäftigen oder eher nicht ? Gruß Poko
\|Win10 64bit\|FX 8350@4,5 GHz\|Asrock 990FX Killer Fatality\|16GB HyperX\|R9 290X\|Blitz3D\|BlitzMax\|

Pokoyo

Betreff: Open GL und VBOs

Sa, Jun 02, 2018 7:29
Antworten mit Zitat

Hallo liebe Community,
heute habe ich mal eine ganz grundsätzliche Frage, welche eher an die GL Spezis hier im Forum gerichtet ist.
Ich fummel ja jetzt auch schon seit einiger Zeit mit Opengl rum wenns die Zeit mal zulässt.
Ich habe jetzt ein Partikelsystem bei dem ich die Vertexpositionen der Partikel per CPU berechnen lasse.
Sin und cos werden vorberechnet, ebenso die texturkoordinaten welche per index in einem array abgerufen werden.
Desweiteren fließen Scalefaktor und transparenz in die berechnungen ein. Das Ganze wird dann über eine Schleife im
OGL Immediate Mode mittels GL_Quad dargestellt.
Rechenaufwand der CPU pro Partikel also :
BlitzMax: [AUSKLAPPEN]

T.alpha		:-	T.alphaadd
If T.alpha	<=	0 Then T.destroy; Continue
If T.Flugwinkel = -10000 Then' verlangsamen der fluggeschwindigkeit      / Vorgegebener Sin und Cosinus
T.precosinus	:*	t.speed
T.presinus		:*	t.speed
EndIf
T.x			:+	T.precosinus
T.y			:+	T.presinus
T.rotation	=	Abs((T.rotation +	T.rotationadd) Mod 359)
T.scale		:+	T.scaleadd

und dann nochmal beim rendern :
BlitzMax: [AUSKLAPPEN]

If T.x>GLobal_X_Minus And T.x<GLobal_X_Plus And T.y>GLobal_Y_Minus And T.y<GLobal_Y_Plus Then
	sizeCos		=	TestBild.WD2	*	T.scale	*	CosinusF[T.rotation]
	sizeSin		=	TestBild.WD2	*	T.scale	*	SinusF[T.rotation]
	x			=	sizeCos		-	sizeSin
	y			=	sizeCos		+	sizeSin	
	GLColor4f 	(	0.3,	0.3,	0.3,	T.alpha)'Transparenz des Flares setzen
	GLTexCoord2f(	TKL64[T.index,0],	TKL64[T.index,1]	);	GLVertex2f(	T.x	-	x	,	T.y	+	y	)
	GLTexCoord2f(	TKL64[T.index,2],	TKL64[T.index,3]	);	GLVertex2f(	T.x	+	y	,	T.y	+	x	)
	GLTexCoord2f(	TKL64[T.index,4],	TKL64[T.index,5]	);	GLVertex2f(	T.x	+	x	,	T.y	-	y	)
	GLTexCoord2f(	TKL64[T.index,6],	TKL64[T.index,7]	);	GLVertex2f(	T.x	-	y	,	T.y	-	x	)
EndIf

Gerade beim Rendern also doch schon ordentlich trotz Vorberechnung.

bei ca. 32000 Partikeln ist auf meiner Grafikkarte Schluß, soll heißen : Das Rendern dauert ca 14-15ms wohingegen die rechnerei auf der cpu nur 1-2 ms ausmacht.

Da man die CPU aber auch noch für andere Berechnungen benötigt würde ich das gerne noch drücken.
Jetzt dachte ich mir das evtl. VBOs das Mittel der Wahl wären. Hat schon jemand von Euch Erfahrungen damit
gesammelt was den Speed angeht ?
Immerhin müsste ich beim aktualisieren der Partikel ja jedesmal alle Werte im dynamischen VBO ändern.
Also Alpha, Texturkoordinaten, Rotation, Translation. Ich kann mir vorstellen dass das ne ganz schön gefährliche
rumpointerei im Grafikspeicher werden kann. Desweiteren ändert sich ja ziemlich oft die Objekt Anzahl was zur Folge hätte dass man das VBO jedesmal neu erstellen müsste oder auf eine feste Partikel Anzahl setzen müsste.
Ich hoffe Ihr versteht was ich meine.
Meine Frage also, macht das Sinn sich damit zu beschäftigen oder eher nicht ?

Gruß Poko

	Lobby	Mo, Aug 20, 2018 12:09 Antworten mit Zitat
Ja, sollte sich definitiv lohnen. Das Hauptproblem bei deinem bisherigen Programm ist ja die Verwendung einzelner OpenGL Aufrufe wie GLTexCoord2f um Daten an die GPU zu übermitteln (das wird auch als immediate mode bezeichnet und wird in neueren OpenGL Versionen gar nicht mehr unterstützt). Mit einem VBO würdest du alle benötigten Daten in einem Rutsch (Stichwort Batch-Verarbeitung) in den VRAM schieben. Das ist auf jedem Fall effizienter. Unter Anderem gibt es hier eine tiefer gehende Diskussion über die Vor- und Nachteile. Sieh dir evtl. mal dieses Tutorial zum Thema Instancing an. Das Ganze wird schnell etwas komplexer, aber aus eigener Erfahrung weiß ich, dass der Performancezuwachs durchaus enorm sein kann.
TheoTown - Eine Stadtaufbausimulation für Android, iOS, Windows, Mac OS und Linux

Lobby

Mo, Aug 20, 2018 12:09
Antworten mit Zitat

Ja, sollte sich definitiv lohnen. Das Hauptproblem bei deinem bisherigen Programm ist ja die Verwendung einzelner OpenGL Aufrufe wie GLTexCoord2f um Daten an die GPU zu übermitteln (das wird auch als immediate mode bezeichnet und wird in neueren OpenGL Versionen gar nicht mehr unterstützt). Mit einem VBO würdest du alle benötigten Daten in einem Rutsch (Stichwort Batch-Verarbeitung) in den VRAM schieben. Das ist auf jedem Fall effizienter. Unter Anderem gibt es hier eine tiefer gehende Diskussion über die Vor- und Nachteile.

Sieh dir evtl. mal dieses Tutorial zum Thema Instancing an. Das Ganze wird schnell etwas komplexer, aber aus eigener Erfahrung weiß ich, dass der Performancezuwachs durchaus enorm sein kann.

TheoTown - Eine Stadtaufbausimulation für Android, iOS, Windows, Mac OS und Linux