Vertex buffer object

A vertex buffer object (VBO) is an OpenGL feature that provides methods for uploading vertex data (position, normal vector, color, etc.) to the video device for non-immediate-mode rendering. VBOs offer substantial performance gains over immediate mode rendering primarily because the data reside in video device memory rather than system memory and so it can be rendered directly by the video device. These are equivalent to vertex buffers in Direct3D.

The vertex buffer object specification has been standardized by the OpenGL Architecture Review Board Archived 2011-11-24 at the Wayback Machine as of OpenGL Version 1.5 (in 2003). Similar functionality was available before the standardization of VBOs via the Nvidia-created extension "vertex array range" ^[1] or ATI's "vertex array object" ^[2] extension.

Basic VBO functions

The following functions form the core of VBO access and manipulation:

In OpenGL 1.4:

glGenBuffersARB(sizei n, uint *buffers)

Generates a new VBO and returns its ID number as an unsigned integer. Id 0 is reserved.

glBindBufferARB(enum target, uint buffer)

Use a previously created buffer as the active VBO.

glBufferDataARB(enum target, sizeiptrARB size, const void *data, enum usage)

Upload data to the active VBO.

glDeleteBuffersARB(sizei n, const uint *buffers)

Deletes the specified number of VBOs from the supplied array or VBO id.

In OpenGL 2.1, ^[3] OpenGL 3.x ^[4] and OpenGL 4.x: ^[5]

glGenBuffers(sizei n, uint *buffers)

Generates a new VBO and returns its ID number as an unsigned integer. Id 0 is reserved.

glBindBuffer(enum target, uint buffer)

Use a previously created buffer as the active VBO.

glBufferData(enum target, sizeiptrARB size, const void *data, enum usage)

Upload data to the active VBO.

glDeleteBuffers(sizei n, const uint *buffers)

Deletes the specified number of VBOs from the supplied array or VBO id.

Example usage

In C, using OpenGL 2.1

//Initialise VBO - do only once, at start of program//Create a variable to hold the VBO identifierGLuinttriangleVBO;//Vertices of a triangle (counter-clockwise winding)floatdata[]={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 idglGenBuffers(1,&triangleVBO);//Make the new VBO activeglBindBuffer(GL_ARRAY_BUFFER,triangleVBO);//Upload vertex data to the video deviceglBufferData(GL_ARRAY_BUFFER,sizeof(data),data,GL_STATIC_DRAW);//Make the new VBO active. Repeat here in case it has changed since initialisationglBindBuffer(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 hereglVertexPointer(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 providedglDrawArrays(GL_TRIANGLES,0,sizeof(data)/sizeof(float)/3);//Force display to be drawn nowglFlush();

In C, using OpenGL 3.x and OpenGL 4.x

Vertex Shader:

/*----------------- "exampleVertexShader.vert" -----------------*/#version 150 // Specify which version of GLSL we are using.// in_Position was bound to attribute index 0("shaderAttribute")invec3in_Position;voidmain(){gl_Position=vec4(in_Position.x,in_Position.y,in_Position.z,1.0);}/*--------------------------------------------------------------*/

Fragment Shader:

/*---------------- "exampleFragmentShader.frag" ----------------*/#version 150 // Specify which version of GLSL we are using.precisionhighpfloat;// Video card drivers require this line to function properlyoutvec4fragColor;voidmain(){fragColor=vec4(1.0,1.0,1.0,1.0);//Set colour of each fragment to WHITE}/*--------------------------------------------------------------*/

Main OpenGL Program:

/*--------------------- Main OpenGL Program ---------------------*//* Create a variable to hold the VBO identifier */GLuinttriangleVBO;/* This is a handle to the shader program */GLuintshaderProgram;/* These pointers will receive the contents of our shader source code files */GLchar*vertexSource,*fragmentSource;/* These are handles used to reference the shaders */GLuintvertexShader,fragmentShader;constunsignedintshaderAttribute=0;/* Vertices of a triangle (counter-clockwise winding) */floatdata[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,(constGLchar**)&vertexSource,0);glShaderSource(fragmentShader,1,(constGLchar**)&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));/*---------------------------------------------------------------*/

References

1. "GL_NV_vertex_array_range Whitepaper". Archived from the original on 2004-08-17. Retrieved 2024-06-24.
2. "ATI_vertex_array_object". Archived from the original on 2012-07-04. Retrieved 2011-08-12.
3. "OpenGL 2.1 function reference".
4. "OpenGL 3.3 function reference".
5. "OpenGL 4.2 function reference".

External links

• Vertex Buffer Object Whitepaper