Vertex Buffer Object - Versionsgeschichte

SchlurcherBot: Bot: http → https

2025-05-24T21:12:58Z

Bot: http → https

← Nächstältere Version		Version vom 24. Mai 2025, 23:12 Uhr
Zeile 1:		Zeile 1:
	Ein '''Vertex Buffer Object''' ('''VBO''') ist eine [[OpenGL]]-Funktionalität, die Methoden zum Hochladen von [[Vertex]]daten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Bildsynthese\|Rendern]] im [[Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem Rendern im [[Immediate Mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].		Ein '''Vertex Buffer Object''' ('''VBO''') ist eine [[OpenGL]]-Funktionalität, die Methoden zum Hochladen von [[Vertex]]daten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Bildsynthese\|Rendern]] im [[Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem Rendern im [[Immediate Mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].

	Die Spezifikation des Vertex-Puffer-Objekts wurde für OpenGL Version 1.5 (im Jahr 2003) vom OpenGL Architecture Review Board standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung „vertex array range“<ref>{{cite web \|title=GL_NV_vertex_array_range \|accessdate=2020-05-10 \|url=~~http~~://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATIs]] „vertex array object“<ref>{{cite web \|title=ATI_vertex_array_object \|accessdate=2020-05-10 \|url=https://people.freedesktop.org/~marcheu/extensions/ATI/vertex_array_object.html}}</ref> Erweiterungen verfügbar.		Die Spezifikation des Vertex-Puffer-Objekts wurde für OpenGL Version 1.5 (im Jahr 2003) vom OpenGL Architecture Review Board standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung „vertex array range“<ref>{{cite web \|title=GL_NV_vertex_array_range \|accessdate=2020-05-10 \|url=https://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATIs]] „vertex array object“<ref>{{cite web \|title=ATI_vertex_array_object \|accessdate=2020-05-10 \|url=https://people.freedesktop.org/~marcheu/extensions/ATI/vertex_array_object.html}}</ref> Erweiterungen verfügbar.

	== Grundlegende VBO-Funktionen ==		== Grundlegende VBO-Funktionen ==

Lómelinde: Kategorie:Wikipedia:Seite mit Syntaxhervorhebungsfehlern veralteter Parameter source → syntaxhighlight

2020-05-12T07:29:38Z

Kategorie:Wikipedia:Seite mit Syntaxhervorhebungsfehlern veralteter Parameter source → syntaxhighlight

← Nächstältere Version		Version vom 12. Mai 2020, 09:29 Uhr
Zeile 1:		Zeile 1:
	Ein '''Vertex Buffer Object''' ('''VBO''') ist eine [[OpenGL]]-Funktionalität, die Methoden zum Hochladen von [[Vertex]]daten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Bildsynthese\|Rendern]] im [[Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem Rendern im [[Immediate Mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].		Ein '''Vertex Buffer Object''' ('''VBO''') ist eine [[OpenGL]]-Funktionalität, die Methoden zum Hochladen von [[Vertex]]daten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Bildsynthese\|Rendern]] im [[Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem Rendern im [[Immediate Mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].

	Die Spezifikation des Vertex-Puffer-Objekts wurde für OpenGL Version 1.5 (im Jahr 2003) vom OpenGL Architecture Review Board standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung „vertex array range“<ref>{{cite web		Die Spezifikation des Vertex-Puffer-Objekts wurde für OpenGL Version 1.5 (im Jahr 2003) vom OpenGL Architecture Review Board standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung „vertex array range“<ref>{{cite web \|title=GL_NV_vertex_array_range \|accessdate=2020-05-10 \|url=http://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATIs]] „vertex array object“<ref>{{cite web \|title=ATI_vertex_array_object \|accessdate=2020-05-10 \|url=https://people.freedesktop.org/~marcheu/extensions/ATI/vertex_array_object.html}}</ref> Erweiterungen verfügbar.
	\| title=GL_NV_vertex_array_range
	\| accessdate = 2020-05-10
	\| url=http://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATI]]s „vertex array object“<ref>{{cite web
	\| title=ATI_vertex_array_object
	\| accessdate = 2020-05-10
	\| url=https://people.freedesktop.org/~marcheu/extensions/ATI/vertex_array_object.html}}</ref> Erweiterungen verfügbar.

	== Grundlegende VBO-Funktionen ==		== Grundlegende VBO-Funktionen ==
Zeile 26:		Zeile 20:
	::Löscht die angegebene Anzahl von VBOs aus dem übergebenen Array oder der VBO-IDs.		::Löscht die angegebene Anzahl von VBOs aus dem übergebenen Array oder der VBO-IDs.

			:In OpenGL '''2.1''',<ref>{{cite web \|title=OpenGL 2.1 reference pages \|accessdate=2020-05-10 \|url=https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/}}</ref> OpenGL '''3.x'''<ref>{{cite web \|title=OpenGL 3.2 quick reference \|accessdate=2020-05-10 \|format=PDF \|url=https://www.opengl.org/sdk/docs/reference_card/opengl32-quick-reference-card.pdf}}</ref> und OpenGL '''4.x''':<ref>{{cite web \|title=OpenGL 4.x reference pages \|accessdate=2020-05-10 \|url=https://www.khronos.org/registry/OpenGL-Refpages/gl4/}}</ref>
	:In OpenGL '''2.1''',<ref>{{cite web
	\| title=OpenGL 2.1 reference pages
	\| accessdate = 2020-05-10
	\| url=https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/}}</ref> OpenGL '''3.x'''<ref>{{cite web
	\| title=OpenGL 3.2 quick reference
	\| accessdate = 2020-05-10
	\| url=https://www.opengl.org/sdk/docs/reference_card/opengl32-quick-reference-card.pdf}}</ref> und OpenGL '''4.x''':<ref>{{cite web
	\| title=OpenGL 4.x reference pages
	\| accessdate = 2020-05-10
	\| url=https://www.khronos.org/registry/OpenGL-Refpages/gl4/}}</ref>
	::'''glGenBuffers'''(sizei n, uint *buffers)		::'''glGenBuffers'''(sizei n, uint *buffers)
	::Erzeugt ein neues VBO und gibt seine ID-Nummer als vorzeichenlose Ganzzahl zurück. ID 0 ist reserviert.		::Erzeugt ein neues VBO und gibt seine ID-Nummer als vorzeichenlose Ganzzahl zurück. ID 0 ist reserviert.
Zeile 52:		Zeile 37:
	=== In C, für OpenGL 2.1 ===		=== In C, für OpenGL 2.1 ===

	<~~source~~ lang="c">		<syntaxhighlight lang="c">
	//Initialise VBO - do only once, at start of program		//Initialise VBO - do only once, at start of program
	//Create a variable to hold the VBO identifier		//Create a variable to hold the VBO identifier
Zeile 86:		Zeile 71:
	glFlush();		glFlush();

			</syntaxhighlight>
	</source>

	=== In C, für OpenGL 3.x und OpenGL 4.x ===		=== In C, für OpenGL 3.x und OpenGL 4.x ===

	'''Vertex Shader:'''		'''Vertex Shader:'''
	<~~source~~ lang="glsl">		<syntaxhighlight lang="glsl">
	/----------------- "exampleVertexShader.vert" -----------------/		/----------------- "exampleVertexShader.vert" -----------------/

Zeile 104:		Zeile 89:
	}		}
	/--------------------------------------------------------------/		/--------------------------------------------------------------/
			</syntaxhighlight><br />
	</source>
	<br>
	'''Fragment Shader:'''		'''Fragment Shader:'''
	<~~source~~ lang="glsl">		<syntaxhighlight lang="glsl">
	/---------------- "exampleFragmentShader.frag" ----------------/		/---------------- "exampleFragmentShader.frag" ----------------/

Zeile 121:		Zeile 105:
	}		}
	/--------------------------------------------------------------/		/--------------------------------------------------------------/
			</syntaxhighlight><br />
	</source>
	<br>
	'''Main OpenGL Program:'''		'''Main OpenGL Program:'''
	<~~source~~ lang="c">		<syntaxhighlight lang="c">
	/--------------------- Main OpenGL Program ---------------------/		/--------------------- Main OpenGL Program ---------------------/

Zeile 220:		Zeile 203:
	glDrawArrays(GL_TRIANGLES, 0, (sizeof(data) / 3) / sizeof(GLfloat));		glDrawArrays(GL_TRIANGLES, 0, (sizeof(data) / 3) / sizeof(GLfloat));
	/---------------------------------------------------------------/		/---------------------------------------------------------------/
			</syntaxhighlight>
	</source>

⚫	== Einzelnachweise ==
⚫	<references />

	== Weblinks ==		== Weblinks ==

	* [https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt Vertex Buffer Object Whitepaper]		* [https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt Vertex Buffer Object Whitepaper]
	* [http://www.opengl.org/about/arb/ OpenGL Architecture Review Board]		* [http://www.opengl.org/about/arb/ OpenGL Architecture Review Board]

		⚫	== Einzelnachweise ==
		⚫	<references />

	[[Kategorie:Khronos Group]]		[[Kategorie:Khronos Group]]

Trustable: Kleinigkeiten verbessert

2020-05-10T20:47:15Z

Kleinigkeiten verbessert

← Nächstältere Version		Version vom 10. Mai 2020, 22:47 Uhr
Zeile 1:		Zeile 1:
	Ein '''Vertex~~-Puffer-Objekt~~''' ('''VBO''') ist eine [[OpenGL]]-Funktionalität, die Methoden zum Hochladen von ~~Vertexdaten~~ ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[~~Rendern (Design)~~\|Rendern]] im [[~~Retained Mode (Computergrafik)\|~~Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem [[Rendern ~~(Design)\|Rendern]]~~ im [[Immediate ~~mode~~ (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].		Ein '''Vertex Buffer Object''' ('''VBO''') ist eine [[OpenGL]]-Funktionalität, die Methoden zum Hochladen von [[Vertex]]daten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Bildsynthese\|Rendern]] im [[Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem Rendern im [[Immediate Mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].

	Die Spezifikation des Vertex-Puffer-Objekts wurde für OpenGL Version 1.5 (im Jahr 2003) vom OpenGL Architecture Review Board standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung „vertex array range“<ref>{{cite web		Die Spezifikation des Vertex-Puffer-Objekts wurde für OpenGL Version 1.5 (im Jahr 2003) vom OpenGL Architecture Review Board standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung „vertex array range“<ref>{{cite web
	\| title=GL_NV_vertex_array_range		\| title=GL_NV_vertex_array_range
	\| accessdate = 2020-05-10		\| accessdate = 2020-05-10
	\| url=http://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATI]]s „vertex array object“<ref>{{cite web		\| url=http://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATI]]s „vertex array object“<ref>{{cite web
	\| title=ATI_vertex_array_object		\| title=ATI_vertex_array_object
	\| accessdate = 2020-05-10		\| accessdate = 2020-05-10
Zeile 26:		Zeile 26:
	::Löscht die angegebene Anzahl von VBOs aus dem übergebenen Array oder der VBO-IDs.		::Löscht die angegebene Anzahl von VBOs aus dem übergebenen Array oder der VBO-IDs.

	:In OpenGL '''2.1''',<ref>{{cite web		:In OpenGL '''2.1''',<ref>{{cite web
	\| title=OpenGL 2.1 reference pages		\| title=OpenGL 2.1 reference pages
	\| accessdate = 2020-05-10		\| accessdate = 2020-05-10
	\| url=https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/}}</ref> OpenGL '''3.x'''<ref>{{cite web		\| url=https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/}}</ref> OpenGL '''3.x'''<ref>{{cite web
	\| title=OpenGL 3.2 quick reference		\| title=OpenGL 3.2 quick reference
	\| accessdate = 2020-05-10		\| accessdate = 2020-05-10

Blik: /* Einleitung */ Typo, Typograf.

2020-05-10T17:23:44Z

Einleitung: Typo, Typograf.

← Nächstältere Version		Version vom 10. Mai 2020, 19:23 Uhr
Zeile 4:		Zeile 4:
	\| title=GL_NV_vertex_array_range		\| title=GL_NV_vertex_array_range
	\| accessdate = 2020-05-10		\| accessdate = 2020-05-10
	\| url=http://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATI]]'s ~~"vertex~~ array ~~object"~~<ref>{{cite web		\| url=http://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies\|ATI]]s „vertex array object“<ref>{{cite web
	\| title=ATI_vertex_array_object		\| title=ATI_vertex_array_object
	\| accessdate = 2020-05-10		\| accessdate = 2020-05-10

Blik: Typograf.

2020-05-10T17:23:16Z

Typograf.

← Nächstältere Version		Version vom 10. Mai 2020, 19:23 Uhr
Zeile 1:		Zeile 1:
	Ein '''Vertex-Puffer-Objekt''' ('''VBO''') ist eine [[OpenGL]] Funktionalität, die Methoden zum Hochladen von Vertexdaten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Rendern (Design)\|Rendern]] im [[Retained Mode (Computergrafik)\|Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem [[Rendern (Design)\|Rendern]] im [[Immediate mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].		Ein '''Vertex-Puffer-Objekt''' ('''VBO''') ist eine [[OpenGL]]-Funktionalität, die Methoden zum Hochladen von Vertexdaten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Rendern (Design)\|Rendern]] im [[Retained Mode (Computergrafik)\|Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem [[Rendern (Design)\|Rendern]] im [[Immediate mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].

	Die Spezifikation des Vertex-Puffer-Objekts wurde für [[OpenGL]] Version 1.5 (im Jahr 2003) vom ~~[http://www.opengl.org/about/arb/~~ OpenGL Architecture Review Board] standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung ~~"vertex~~ array ~~range"~~<ref>{{cite web		Die Spezifikation des Vertex-Puffer-Objekts wurde für OpenGL Version 1.5 (im Jahr 2003) vom OpenGL Architecture Review Board standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung „vertex array range“<ref>{{cite web
	\| title=GL_NV_vertex_array_range		\| title=GL_NV_vertex_array_range
	\| accessdate = 2020-05-10		\| accessdate = 2020-05-10
Zeile 9:		Zeile 9:
	\| url=https://people.freedesktop.org/~marcheu/extensions/ATI/vertex_array_object.html}}</ref> Erweiterungen verfügbar.		\| url=https://people.freedesktop.org/~marcheu/extensions/ATI/vertex_array_object.html}}</ref> Erweiterungen verfügbar.

	== Grundlegende VBO Funktionen ==		== Grundlegende VBO-Funktionen ==

	Die folgenden Funktionen bilden den Kern des VBO-Zugriffs und der VBO-Manipulation:		Die folgenden Funktionen bilden den Kern des VBO-Zugriffs und der VBO-Manipulation:
Zeile 225:		Zeile 225:
	<references />		<references />

	== ~~Externe Links~~ ==		== Weblinks ==

	*[https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt Vertex Buffer Object Whitepaper]		* [https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt Vertex Buffer Object Whitepaper]
			* [http://www.opengl.org/about/arb/ OpenGL Architecture Review Board]

	[[Kategorie:Khronos Group]]		[[Kategorie:Khronos Group]]

Aka: Halbgeviertstrich, Leerzeichen in Überschrift, Kleinkram

2020-05-10T09:15:27Z

Halbgeviertstrich, Leerzeichen in Überschrift, Kleinkram

← Nächstältere Version		Version vom 10. Mai 2020, 11:15 Uhr
Zeile 1:		Zeile 1:
	Ein '''Vertex-Puffer-Objekt''' ('''VBO''') ist eine [[OpenGL]] Funktionalität, die Methoden zum Hochladen von Vertexdaten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Rendern (Design)\|Rendern]] im [[Retained Mode (Computergrafik)\|Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem [[Rendern (Design)\|Rendern]] im [[Immediate mode (Computergrafik)\|Immediate Mode]] - vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].		Ein '''Vertex-Puffer-Objekt''' ('''VBO''') ist eine [[OpenGL]] Funktionalität, die Methoden zum Hochladen von Vertexdaten ([[Ecke\|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Rendern (Design)\|Rendern]] im [[Retained Mode (Computergrafik)\|Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem [[Rendern (Design)\|Rendern]] im [[Immediate mode (Computergrafik)\|Immediate Mode]] – vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].

	Die Spezifikation des Vertex-Puffer-Objekts wurde für [[OpenGL]] Version 1.5 (im Jahr 2003) vom [http://www.opengl.org/about/arb/ OpenGL Architecture Review Board] standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung "vertex array range"<ref>{{cite web		Die Spezifikation des Vertex-Puffer-Objekts wurde für [[OpenGL]] Version 1.5 (im Jahr 2003) vom [http://www.opengl.org/about/arb/ OpenGL Architecture Review Board] standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung "vertex array range"<ref>{{cite web
Zeile 50:		Zeile 50:
	== Beispiel für die Verwendung ==		== Beispiel für die Verwendung ==

	===In C, für OpenGL 2.1 ===		=== In C, für OpenGL 2.1 ===

	<source lang="c">		<source lang="c">
Zeile 99:		Zeile 99:
	in vec3 in_Position;		in vec3 in_Position;

	void main()		void main()
	{		{
	gl_Position = vec4(in_Position.x, in_Position.y, in_Position.z, 1.0);		gl_Position = vec4(in_Position.x, in_Position.y, in_Position.z, 1.0);
Zeile 116:		Zeile 116:
	out vec4 fragColor;		out vec4 fragColor;

	void main()		void main()
	{		{
	fragColor = vec4(1.0,1.0,1.0,1.0); //Set colour of each fragment to WHITE		fragColor = vec4(1.0,1.0,1.0,1.0); //Set colour of each fragment to WHITE
Zeile 129:		Zeile 129:
	/* Create a variable to hold the VBO identifier */		/* Create a variable to hold the VBO identifier */
	GLuint triangleVBO;		GLuint triangleVBO;


	/* This is a handle to the shader program */		/* This is a handle to the shader program */
	GLuint shaderProgram;		GLuint shaderProgram;
Zeile 216:		Zeile 216:

	/* Actually draw the triangle, giving the number of vertices provided by invoke glDrawArrays		/* Actually draw the triangle, giving the number of vertices provided by invoke glDrawArrays
	while telling that our data is a triangle and we want to draw 0-3 vertexes		while telling that our data is a triangle and we want to draw 0-3 vertexes
	*/		*/
	glDrawArrays(GL_TRIANGLES, 0, (sizeof(data) / 3) / sizeof(GLfloat));		glDrawArrays(GL_TRIANGLES, 0, (sizeof(data) / 3) / sizeof(GLfloat));

PZ0151: /* Externe Links */ Tote Links ersetzt/entfernt.

2020-05-10T07:19:25Z

Externe Links: Tote Links ersetzt/entfernt.

← Nächstältere Version		Version vom 10. Mai 2020, 09:19 Uhr
Zeile 228:		Zeile 228:
	*[https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt Vertex Buffer Object Whitepaper]		*[https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt Vertex Buffer Object Whitepaper]

	[[Kategorie:~~OpenGL~~]]		[[Kategorie:Khronos Group]]
	[[Kategorie:Computergrafik]]		[[Kategorie:Computergrafik]]
	[[Category:3D computer graphics]]

PZ0151: AZ: Die Seite wurde neu angelegt: Ein '''Vertex-Puffer-Objekt''' ('''VBO''') ist eine OpenGL Funktionalität, die Methoden zum Hochl…

2020-05-10T07:14:09Z

AZ: Die Seite wurde neu angelegt: Ein '''Vertex-Puffer-Objekt''' ('''VBO''') ist eine OpenGL Funktionalität, die Methoden zum Hochl…

Neue Seite

Ein '''Vertex-Puffer-Objekt''' ('''VBO''') ist eine [[OpenGL]] Funktionalität, die Methoden zum Hochladen von Vertexdaten ([[Ecke|Position]], [[Normalenvektor]], Farbe usw.) auf das Videogerät für das [[Rendern (Design)|Rendern]] im [[Retained Mode (Computergrafik)|Retained Mode]] bereitstellt. VBOs bieten erhebliche Leistungssteigerungen gegenüber dem [[Rendern (Design)|Rendern]] im [[Immediate mode (Computergrafik)|Immediate Mode]] - vor allem deshalb, weil sich die Daten im Speicher des Videogeräts und nicht im Systemspeicher befinden und daher direkt vom Videogerät gerendert werden können. Die VBOs sind äquivalent zu Vertexpuffern in [[Direct3D]].

Die Spezifikation des Vertex-Puffer-Objekts wurde für [[OpenGL]] Version 1.5 (im Jahr 2003) vom [http://www.opengl.org/about/arb/ OpenGL Architecture Review Board] standardisiert. Eine ähnliche Funktionalität war vor der Standardisierung von VBOs über die von [[Nvidia]] erstellte Erweiterung "vertex array range"<ref>{{cite web
| title=GL_NV_vertex_array_range
| accessdate = 2020-05-10
| url=http://developer.download.nvidia.com/opengl/specs/GL_NV_vertex_array_range.txt}}</ref> oder [[ATI Technologies|ATI]]'s "vertex array object"<ref>{{cite web
| title=ATI_vertex_array_object
| accessdate = 2020-05-10
| url=https://people.freedesktop.org/~marcheu/extensions/ATI/vertex_array_object.html}}</ref> Erweiterungen verfügbar.

== Grundlegende VBO Funktionen ==

Die folgenden Funktionen bilden den Kern des VBO-Zugriffs und der VBO-Manipulation:

:In OpenGL '''1.4''':
::'''glGenBuffersARB'''(sizei n, uint *buffers)
::Erzeugt ein neues VBO und gibt seine ID-Nummer als vorzeichenlose Ganzzahl zurück. ID 0 ist reserviert.

::'''glBindBufferARB'''(enum target, uint buffer)
::Verwendet einen zuvor erstellten Puffer als aktiven VBO.

::'''glBufferDataARB'''(enum target, sizeiptrARB size, const void *data, enum usage)
::Daten in den aktiven VBO hochladen.

::'''glDeleteBuffersARB'''(sizei n, const uint *buffers)
::Löscht die angegebene Anzahl von VBOs aus dem übergebenen Array oder der VBO-IDs.

:In OpenGL '''2.1''',<ref>{{cite web
| title=OpenGL 2.1 reference pages
| accessdate = 2020-05-10
| url=https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/}}</ref> OpenGL '''3.x'''<ref>{{cite web
| title=OpenGL 3.2 quick reference
| accessdate = 2020-05-10
| url=https://www.opengl.org/sdk/docs/reference_card/opengl32-quick-reference-card.pdf}}</ref> und OpenGL '''4.x''':<ref>{{cite web
| title=OpenGL 4.x reference pages
| accessdate = 2020-05-10
| url=https://www.khronos.org/registry/OpenGL-Refpages/gl4/}}</ref>
::'''glGenBuffers'''(sizei n, uint *buffers)
::Erzeugt ein neues VBO und gibt seine ID-Nummer als vorzeichenlose Ganzzahl zurück. ID 0 ist reserviert.

::'''glBindBuffer'''(enum target, uint buffer)
::Verwendet einen zuvor erstellten Puffer als aktiven VBO.

::'''glBufferData'''(enum target, sizeiptrARB size, const void *data, enum usage)
::Daten in den aktiven VBO hochladen.

::'''glDeleteBuffers'''(sizei n, const uint *buffers)
::Löscht die angegebene Anzahl von VBOs aus dem übergebenen Array oder der VBO-IDs.

== Beispiel für die Verwendung ==

===In C, für OpenGL 2.1 ===

<source lang="c">
//Initialise VBO - do only once, at start of program
//Create a variable to hold the VBO identifier
GLuint triangleVBO;

//Vertices of a triangle (counter-clockwise winding)
float data[] = {1.0, 0.0, 1.0, 0.0, 0.0, -1.0, -1.0, 0.0, 1.0};
//try float data[] = {0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0}; if the above doesn't work.

//Create a new VBO and use the variable id to store the VBO id
glGenBuffers(1, &triangleVBO);

//Make the new VBO active
glBindBuffer(GL_ARRAY_BUFFER, triangleVBO);

//Upload vertex data to the video device
glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);

//Make the new VBO active. Repeat here incase changed since initialisation
glBindBuffer(GL_ARRAY_BUFFER, triangleVBO);

//Draw Triangle from VBO - do each time window, view point or data changes
//Establish its 3 coordinates per vertex with zero stride in this array; necessary here
glVertexPointer(3, GL_FLOAT, 0, NULL);

//Establish array contains vertices (not normals, colours, texture coords etc)
glEnableClientState(GL_VERTEX_ARRAY);

//Actually draw the triangle, giving the number of vertices provided
glDrawArrays(GL_TRIANGLES, 0, sizeof(data) / sizeof(float) / 3);

//Force display to be drawn now
glFlush();

</source>

=== In C, für OpenGL 3.x und OpenGL 4.x ===

'''Vertex Shader:'''
<source lang="glsl">
/*----------------- "exampleVertexShader.vert" -----------------*/

#version 150 // Specify which version of GLSL we are using.

// in_Position was bound to attribute index 0("shaderAttribute")
in vec3 in_Position;

void main()
{
gl_Position = vec4(in_Position.x, in_Position.y, in_Position.z, 1.0);
}
/*--------------------------------------------------------------*/
</source>
<br>
'''Fragment Shader:'''
<source lang="glsl">
/*---------------- "exampleFragmentShader.frag" ----------------*/

#version 150 // Specify which version of GLSL we are using.

precision highp float; // Video card drivers require this line to function properly

out vec4 fragColor;

void main()
{
fragColor = vec4(1.0,1.0,1.0,1.0); //Set colour of each fragment to WHITE
}
/*--------------------------------------------------------------*/
</source>
<br>
'''Main OpenGL Program:'''
<source lang="c">
/*--------------------- Main OpenGL Program ---------------------*/

/* Create a variable to hold the VBO identifier */
GLuint triangleVBO;

/* This is a handle to the shader program */
GLuint shaderProgram;

/* These pointers will receive the contents of our shader source code files */
GLchar *vertexSource, *fragmentSource;

/* These are handles used to reference the shaders */
GLuint vertexShader, fragmentShader;

const unsigned int shaderAttribute = 0;

/* Vertices of a triangle (counter-clockwise winding) */
float data[3][3] = {
{ 0.0, 1.0, 0.0 },
{ -1.0, -1.0, 0.0 },
{ 1.0, -1.0, 0.0 }
};

/*---------------------- Initialise VBO - (Note: do only once, at start of program) ---------------------*/
/* Create a new VBO and use the variable "triangleVBO" to store the VBO id */
glGenBuffers(1, &triangleVBO);

/* Make the new VBO active */
glBindBuffer(GL_ARRAY_BUFFER, triangleVBO);

/* Upload vertex data to the video device */
glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);

/* Specify that our coordinate data is going into attribute index 0(shaderAttribute), and contains three floats per vertex */
glVertexAttribPointer(shaderAttribute, 3, GL_FLOAT, GL_FALSE, 0, 0);

/* Enable attribute index 0(shaderAttribute) as being used */
glEnableVertexAttribArray(shaderAttribute);

/* Make the new VBO active. */
glBindBuffer(GL_ARRAY_BUFFER, triangleVBO);
/*-------------------------------------------------------------------------------------------------------*/

/*--------------------- Load Vertex and Fragment shaders from files and compile them --------------------*/
/* Read our shaders into the appropriate buffers */
vertexSource = filetobuf("exampleVertexShader.vert");
fragmentSource = filetobuf("exampleFragmentShader.frag");

/* Assign our handles a "name" to new shader objects */
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

/* Associate the source code buffers with each handle */
glShaderSource(vertexShader, 1, (const GLchar**)&vertexSource, 0);
glShaderSource(fragmentShader, 1, (const GLchar**)&fragmentSource, 0);

/* Free the temporary allocated memory */
free(vertexSource);
free(fragmentSource);

/* Compile our shader objects */
glCompileShader(vertexShader);
glCompileShader(fragmentShader);
/*-------------------------------------------------------------------------------------------------------*/

/*-------------------- Create shader program, attach shaders to it and then link it ---------------------*/
/* Assign our program handle a "name" */
shaderProgram = glCreateProgram();

/* Attach our shaders to our program */
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);

/* Bind attribute index 0 (shaderAttribute) to in_Position*/
/* "in_Position" will represent "data" array's contents in the vertex shader */
glBindAttribLocation(shaderProgram, shaderAttribute, "in_Position");

/* Link shader program*/
glLinkProgram(shaderProgram);
/*-------------------------------------------------------------------------------------------------------*/

/* Set shader program as being actively used */
glUseProgram(shaderProgram);

/* Set background colour to BLACK */
glClearColor(0.0, 0.0, 0.0, 1.0);

/* Clear background with BLACK colour */
glClear(GL_COLOR_BUFFER_BIT);

/* Actually draw the triangle, giving the number of vertices provided by invoke glDrawArrays
while telling that our data is a triangle and we want to draw 0-3 vertexes
*/
glDrawArrays(GL_TRIANGLES, 0, (sizeof(data) / 3) / sizeof(GLfloat));
/*---------------------------------------------------------------*/
</source>

== Einzelnachweise ==
<references />

== Externe Links ==
*[https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt Vertex Buffer Object Whitepaper]

[[Kategorie:OpenGL]]
[[Kategorie:Computergrafik]]
[[Category:3D computer graphics]]