Un objeto de búfer de vértice ( VBO ) es una función de OpenGL que proporciona métodos para cargar datos de vértice ( posición , vector normal , color, etc.) al dispositivo de video para una representación en modo no inmediato. Los VBO ofrecen ganancias sustanciales de rendimiento sobre el renderizado en modo inmediato principalmente porque los datos residen en la memoria del dispositivo de video en lugar de en la memoria del sistema y, por lo tanto, el dispositivo de video puede procesarlos directamente. Estos son equivalentes a los búferes de vértices en Direct3D .
La especificación del objeto de búfer de vértice ha sido estandarizada por el OpenGL Architecture Review Board a partir de la versión 1.5 de OpenGL (en 2003). Una funcionalidad similar estaba disponible antes de la normalización de OISCIV a través de la Nvidia -creada extensión "rango de matriz vértice" [1] o ATI 's 'array vértice objeto' [2] de extensión.
Funciones básicas de VBO
Las siguientes funciones forman el núcleo del acceso y la manipulación de VBO:
- En OpenGL 1.4 :
- glGenBuffersARB (tamaño, uint * búferes)
- Genera un nuevo VBO y devuelve su número de identificación como un entero sin signo. Id 0 está reservado.
- glBindBufferARB (destino de enumeración, búfer uint)
- Utilice un búfer creado previamente como VBO activo.
- glBufferDataARB (destino de enumeración, tamaño de tamaño de iptrARB, datos const void *, uso de enumeración)
- Sube datos al VBO activo.
- glDeleteBuffersARB (tamaño, const uint * búferes)
- Elimina la cantidad especificada de VBO de la matriz proporcionada o la identificación de VBO.
- En OpenGL 2.1 , [3] OpenGL 3.x [4] y OpenGL 4.x : [5]
- glGenBuffers (sizei n, uint * búferes)
- Genera un nuevo VBO y devuelve su número de identificación como un entero sin signo. Id 0 está reservado.
- glBindBuffer (destino de enumeración, búfer uint)
- Utilice un búfer creado previamente como VBO activo.
- glBufferData (destino de enumeración, tamaño de tamaño de iptrARB, datos const void *, uso de enumeración)
- Sube datos al VBO activo.
- glDeleteBuffers (tamaño, const uint * búferes)
- Elimina la cantidad especificada de VBO de la matriz proporcionada o la identificación de VBO.
Uso de ejemplo
En C, usando OpenGL 2.1
// Inicializar VBO - hacerlo solo una vez, al inicio del programa // Crear una variable para contener el identificador VBO GLuint triangleVBO ;// Vértices de un triángulo (devanado en sentido antihorario) float data [] = { 1.0 , 0.0 , 1.0 , 0.0 , 0.0 , -1.0 , -1.0 , 0.0 , 1.0 }; // probar datos flotantes [] = {0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0}; si lo anterior no funciona.// Cree un nuevo VBO y use la variable id para almacenar el VBO id glGenBuffers ( 1 , & triangleVBO );// Activa el nuevo VBO glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );// Subir datos de vértice al dispositivo de video glBufferData ( GL_ARRAY_BUFFER , sizeof ( data ), data , GL_STATIC_DRAW );// Activa el nuevo VBO. Repita aquí en caso de que haya cambiado desde la inicialización glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );// Dibujar Triángulo de VBO - hacer cada ventana de tiempo, punto de vista o cambios de datos // Establecer sus 3 coordenadas por vértice con paso cero en esta matriz; necesario aquí glVertexPointer ( 3 , GL_FLOAT , 0 , NULL );// Establecer matriz que contiene vértices (no normales, colores, coordenadas de textura, etc.) glEnableClientState ( GL_VERTEX_ARRAY );// Dibuja realmente el triángulo, dando el número de vértices proporcionados glDrawArrays ( GL_TRIANGLES , 0 , sizeof ( data ) / sizeof ( float ) / 3 );// Forzar que la pantalla se dibuje ahora glFlush ();
En C, usando OpenGL 3.xy OpenGL 4.x
Sombreador de vértices:
/ * ----------------- "exampleVertexShader.vert" ----------------- * /#version 150 // Especifica qué versión de GLSL estamos usando.// in_Position estaba vinculado al índice de atributo 0 ("shaderAttribute") en vec3 in_Position ;void main () { gl_Position = vec4 ( in_Position . x , in_Position . y , in_Position . z , 1.0 ); } / * ----------------------------------------------- --------------- * /
Shader de fragmentos:
/ * ---------------- "exampleFragmentShader.frag" ---------------- * /#version 150 // Especifica qué versión de GLSL estamos usando. flotador de alta precisión ; // Los controladores de la tarjeta de video requieren que esta línea funcione correctamente out vec4 fragColor ;void main () { fragColor = vec4 ( 1.0 , 1.0 , 1.0 , 1.0 ); // Establecer el color de cada fragmento en BLANCO } / * -------------------------------------- ------------------------ * /
Programa principal de OpenGL:
/ * --------------------- Programa principal de OpenGL --------------------- * // * Crea una variable para contener el identificador VBO * / GLuint triangleVBO ; / * Este es un identificador del programa de sombreado * / GLuint shaderProgram ;/ * Estos punteros recibirán el contenido de nuestros archivos de código fuente de sombreado * / GLchar * vertexSource , * fragmentSource ;/ * Estos son identificadores que se utilizan para hacer referencia a los sombreadores * / GLuint vertexShader , fragmentShader ;const unsigned int shaderAttribute = 0 ;/ * Vértices de un triángulo (devanado en sentido antihorario) * / datos flotantes [ 3 ] [ 3 ] = { { 0.0 , 1.0 , 0.0 }, { -1.0 , -1.0 , 0.0 }, { 1.0 , -1.0 , 0.0 } }; / * ---------------------- Inicializar VBO - (Nota: hacerlo solo una vez, al inicio del programa) ----------- ---------- * / / * Crea un nuevo VBO y usa la variable "triangleVBO" para almacenar el ID de VBO * / glGenBuffers ( 1 , & triangleVBO );/ * Activa el nuevo VBO * / glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );/ * Subir datos de vértice al dispositivo de video * / glBufferData ( GL_ARRAY_BUFFER , sizeof ( datos ), datos , GL_STATIC_DRAW );/ * Especifica que nuestros datos de coordenadas van al índice de atributo 0 (shaderAttribute) y contiene tres flotantes por vértice * / glVertexAttribPointer ( shaderAttribute , 3 , GL_FLOAT , GL_FALSE , 0 , 0 );/ * Habilitar el índice de atributo 0 (shaderAttribute) como en uso * / glEnableVertexAttribArray ( shaderAttribute );/ * Activa el nuevo VBO. * / glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO ); / * ------------------------------------------------ -------------------------------------------------- ----- * // * --------------------- Cargar sombreadores de vértices y fragmentos desde archivos y compilarlos ----------------- --- * / / * Leer nuestros sombreadores en los búferes apropiados * / vertexSource = filetobuf ( "exampleVertexShader.vert" ); fragmentSource = filetobuf ( "exampleFragmentShader.frag" );/ * Asignar a nuestros identificadores un "nombre" a los nuevos objetos de sombreado * / vertexShader = glCreateShader ( GL_VERTEX_SHADER ); fragmentShader = glCreateShader ( GL_FRAGMENT_SHADER );/ * Asociar los búferes de código fuente con cada identificador * / glShaderSource ( vertexShader , 1 , ( const GLchar ** ) & vertexSource , 0 ); glShaderSource ( fragmentShader , 1 , ( const GLchar ** ) & fragmentSource , 0 );/ * Libera la memoria temporal asignada * / free ( vertexSource ); libre ( fragmentSource );/ * Compila nuestros objetos de sombreado * / glCompileShader ( vertexShader ); glCompileShader ( fragmentShader ); / * ------------------------------------------------ -------------------------------------------------- ----- * // * -------------------- Crear programa de sombreado, adjuntar sombreadores y luego vincularlo ---------------- ----- * / / * Asignarle a nuestro programa un "nombre" * / shaderProgram = glCreateProgram ();/ * Adjuntar nuestros sombreadores a nuestro programa * / glAttachShader ( shaderProgram , vertexShader ); glAttachShader ( shaderProgram , fragmentShader );/ * Vincular el índice de atributo 0 (shaderAttribute) a in_Position * / / * "in_Position" representará el contenido de la matriz de "datos" en el sombreador de vértices * / glBindAttribLocation ( shaderProgram , shaderAttribute , "in_Position" );/ * Programa de sombreado de enlaces * / glLinkProgram ( shaderProgram ); / * ------------------------------------------------ -------------------------------------------------- ----- * // * Establecer el programa de sombreado como en uso activo * / glUseProgram ( shaderProgram );/ * Establecer el color de fondo en NEGRO * / glClearColor ( 0.0 , 0.0 , 0.0 , 1.0 );/ * Fondo claro con color NEGRO * / glClear ( GL_COLOR_BUFFER_BIT );/ * Dibujar realmente el triángulo, dando el número de vértices proporcionado por invocar glDrawArrays mientras decimos que nuestros datos son un triángulo y queremos dibujar 0-3 vértices * / glDrawArrays ( GL_TRIANGLES , 0 , ( sizeof ( data ) / 3 ) / sizeof ( GLfloat )); / * ------------------------------------------------ --------------- * /
Referencias
- ^ "Libro blanco GL_NV_vertex_array_range" .
- ^ "ATI_vertex_array_object" .
- ^ "Referencia de la función OpenGL 2.1" .
- ^ "Referencia de la función OpenGL 3.3" .
- ^ "Referencia de la función OpenGL 4.2" .