Hispanopedia Wiki
Articulo de referencia

objeto de búfer de vértices

Un objeto de búfer de vértices ( VBO ) es una característica de OpenGL que proporciona métodos para cargar datos de vértices ( posición , vector normal , color, etc.) al disposi...

Hispanopedia WikiContenido en espanolLectura gratuita

Un objeto de búfer de vértices ( VBO ) es una característica de OpenGL que proporciona métodos para cargar datos de vértices ( posición , vector normal , color, etc.) al dispositivo de vídeo para la renderización en modo no inmediato. Los VBO ofrecen mejoras de rendimiento sustanciales con respecto a la renderización en modo inmediato, principalmente porque los datos residen en la memoria del dispositivo de vídeo en lugar de la memoria del sistema, por lo que el dispositivo de vídeo puede renderizarlos directamente. Estos son equivalentes a los búferes de vértices en Direct3D .

La especificación del objeto de búfer de vértices fue estandarizada por la Junta de Revisión de Arquitectura de OpenGL ( archivada el 24/11/2011 en Wayback Machine) a partir de la versión 1.5 de OpenGL (en 2003). Una funcionalidad similar estaba disponible antes de la estandarización de los VBO mediante la extensión "vertex array range" [ 1 ] creada por Nvidia o la extensión "vertex array object" [ 2 ] de ATI .

Funciones básicas de VBO

Las siguientes funciones constituyen el núcleo del acceso y la manipulación de VBO:

En OpenGL 1.4 :
glGenBuffersARB (tamaño n, uint *buffers)
Genera un nuevo VBO y devuelve su número de identificación como un entero sin signo. La identificación 0 está reservada.
glBindBufferARB (enumeración objetivo, búfer uint)
Utilice un búfer creado previamente como VBO activo.
glBufferDataARB (enumeración objetivo, sizeiptrARB tamaño, constante void *datos, enumeración uso)
Cargue los datos en el VBO activo.
glDeleteBuffersARB (sizei n, const uint *buffers)
Elimina el número especificado de VBO de la matriz o ID de VBO proporcionada.
En OpenGL 2.1 , [ 3 ] OpenGL 3.x [ 4 ] y OpenGL 4.x : [ 5 ]
glGenBuffers (tamaño n, uint *buffers)
Genera un nuevo VBO y devuelve su número de identificación como un entero sin signo. La identificación 0 está reservada.
glBindBuffer (enumeración objetivo, búfer uint)
Utilice un búfer creado previamente como VBO activo.
glBufferData (enumeración objetivo, sizeiptrARB tamaño, constante void *datos, enumeración uso)
Cargue los datos en el VBO activo.
glDeleteBuffers (sizei n, const uint *buffers)
Elimina el número especificado de VBO de la matriz o ID de VBO proporcionada.

Ejemplo de uso

En C, usando OpenGL 2.1

//Inicializar VBO: hacerlo solo una vez, al inicio del programa //Crear una variable para almacenar el identificador de VBO GLuint triangleVBO ;//Vértices de un triángulo (enrollamiento en sentido contrario a las agujas del reloj) float data [] = { 1.0 , 0.0 , 1.0 , 0.0 , 0.0 , -1.0 , -1.0 , 0.0 , 1.0 }; //Intenta con float data[] = {0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0}; si lo anterior no funciona.//Crea un nuevo VBO y usa la variable id para almacenar el ID del VBO glGenBuffers ( 1 , & triangleVBO );//Activar el nuevo VBO glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );//Cargar datos de vértices al dispositivo de vídeo glBufferData ( GL_ARRAY_BUFFER , sizeof ( data ), data , GL_STATIC_DRAW );//Activar el nuevo VBO. Repetir aquí en caso de que haya cambiado desde la inicialización glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );//Dibujar triángulo desde VBO: hacerlo en cada ventana de tiempo, punto de vista o cambios de datos //Establecer sus 3 coordenadas por vértice con paso cero en este array; necesario aquí glVertexPointer ( 3 , GL_FLOAT , 0 , NULL );//Establecer que el array contiene vértices (no normales, colores, coordenadas de textura, etc.) glEnableClientState ( GL_VERTEX_ARRAY );//Realmente dibuja el triángulo, dando el número de vértices proporcionado glDrawArrays ( GL_TRIANGLES , 0 , sizeof ( data ) / sizeof ( float ) / 3 );//Forzar que la pantalla se dibuje ahora glFlush ();

En C, utilizando OpenGL 3.x y OpenGL 4.x

Sombreador de vértices:

/*----------------- "exampleVertexShader.vert" -----------------*/#versión 150 // Especifica qué versión de GLSL estamos utilizando.// 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 ); } /*--------------------------------------------------------------*/

Fragment Shader:

/*---------------- "exampleFragmentShader.frag" ----------------*/#versión 150 // Especifica qué versión de GLSL estamos utilizando.precisión alta flotante ; // Los controladores de la tarjeta de video requieren esta línea para funcionar correctamentevec4 fragColor ;​void main () { fragColor = vec4 ( 1.0 , 1.0 , 1.0 , 1.0 ); //Establece el color de cada fragmento a BLANCO } /*--------------------------------------------------------------*/

Programa principal de OpenGL:

/*--------------------- Programa principal de OpenGL ---------------------*//* Crea una variable para almacenar el identificador VBO */ GLuint triangleVBO ; /* Este es un identificador para el 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 utilizados para hacer referencia a los sombreadores */ GLuint vertexShader , fragmentShader ;const unsigned int shaderAttribute = 0 ;/* Vértices de un triángulo (enrollamiento en sentido antihorario) */ float data [ 3 ][ 3 ] = { { 0.0 , 1.0 , 0.0 }, { -1.0 , -1.0 , 0.0 }, { 1.0 , -1.0 , 0.0 } };/*---------------------- Inicializar VBO - (Nota: hacer solo una vez, al inicio del programa) ---------------------*/ /* Crear un nuevo VBO y usar la variable "triangleVBO" para almacenar el ID del VBO */ glGenBuffers ( 1 , & triangleVBO );/* Activar el nuevo VBO */ glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );/* Cargar datos de vértices al dispositivo de vídeo */ glBufferData ( GL_ARRAY_BUFFER , sizeof ( data ), data , GL_STATIC_DRAW );/* Especifica que nuestros datos de coordenadas van al índice de atributo 0 (shaderAttribute) y contienen tres números flotantes por vértice */ glVertexAttribPointer ( shaderAttribute , 3 , GL_FLOAT , GL_FALSE , 0 , 0 );/* Habilitar el índice de atributo 0 (shaderAttribute) para que se utilice */ 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" );/* Asignamos un "nombre" a nuestros manejadores para 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 asignada temporalmente */ free ( vertexSource ); free ( fragmentSource );/* Compila nuestros objetos de sombreado */ glCompileShader ( vertexShader ); glCompileShader ( fragmentShader ); /*-------------------------------------------------------------------------------------------------------*//*-------------------- Crea un programa de sombreado, adjunta los sombreadores y luego enlaza. ---------------------*/ /* Asigna un "nombre" a nuestro identificador de programa */ shaderProgram = glCreateProgram ();/* Adjuntar nuestros sombreadores a nuestro programa */ glAttachShader ( shaderProgram , vertexShader ); glAttachShader ( shaderProgram , fragmentShader );/* Vincula el índice de atributo 0 (shaderAttribute) a in_Position */ /* "in_Position" representará el contenido del array "data" en el sombreador de vértices */ glBindAttribLocation ( shaderProgram , shaderAttribute , "in_Position" );/* Enlazar programa de sombreado */ 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 );/* Borrar el fondo con color NEGRO */ glClear ( GL_COLOR_BUFFER_BIT );/* Dibuja el triángulo, indicando el número de vértices proporcionado por la llamada a glDrawArrays,  mientras le indicamos que nuestros datos son un triángulo y que queremos dibujar de 0 a 3 vértices */ glDrawArrays ( GL_TRIANGLES , 0 , ( sizeof ( data ) / 3 ) / sizeof ( GLfloat )); /*---------------------------------------------------------------*/

Referencias

  1. ↑ "Documento técnico GL_NV_vertex_array_range" . Archivado del original el 17 de agosto de 2004. Consultado el 24 de junio de 2024 .{{cite web}}: CS1 maint: bot: estado de la URL original desconocido ( enlace )
  2. ↑ "ATI_vertex_array_object" . Archivado del original el 4 de julio de 2012. Consultado el 12 de agosto de 2011 .
  3. ↑ "Referencia de funciones de OpenGL 2.1" . Archivado del original el 17 de febrero de 2008. Consultado el 11 de febrero de 2008 .
  4. ↑ "Referencia de funciones de OpenGL 3.3" .
  5. ↑ "Referencia de funciones de OpenGL 4.2" . Archivado del original el 15/07/2013 . Consultado el 06/04/2012 .
  • Documento técnico sobre el objeto de búfer de vértices