Hispanopedia Wiki‹ Se está considerando la posibilidad de fusionar la plantilla Manual .›
Un objeto de búfer de vértices ( VBO ) es una función de OpenGL que proporciona métodos para cargar datos de vértices ( posición , vector normal , color, etc.) al dispositivo de video para 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 video en lugar de en la memoria del sistema y, por lo tanto, pueden ser renderizados directamente por el dispositivo de video. Estos son equivalentes a los búferes de vértices en Direct3D .
La especificación del objeto de búfer de vértices ha sido estandarizada por la OpenGL Architecture Review Board Archivado el 24 de noviembre de 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 a través de 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 forman 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. El identificador 0 está reservado.
- glBindBufferARB (objetivo de enumeración, búfer uint)
- Utilice un búfer creado previamente como VBO activo.
- glBufferDataARB (enumeración destino, tamaño de iptrARB, const void *data, enumeración uso)
- Subir datos al VBO activo.
- glDeleteBuffersARB (tamaño n, constante *buffers)
- Elimina la cantidad especificada de VBO de la matriz o el ID de VBO suministrado.
- 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. El identificador 0 está reservado.
- glBindBuffer (objetivo de enumeración, búfer uint)
- Utilice un búfer creado previamente como VBO activo.
- glBufferData (enumeración objetivo, tamaño de iptrARB, const void *data, enumeración uso)
- Subir datos al VBO activo.
- glDeleteBuffers (tamaño n, constante *buffers)
- Elimina la cantidad especificada de VBO de la matriz o el ID de VBO suministrado.
Ejemplo de uso
En C, utilizando OpenGL 2.1
//Inicializa VBO - hazlo solo una vez, al inicio del programa
//Crea una variable para guardar el identificador VBO
GLuint triangleVBO ;
//Vértices de un triángulo (enrollado en sentido antihorario)
float data [] = { 1.0 , 0.0 , 1.0 , 0.0 , 0.0 , -1.0 , -1.0 , 0.0 , 1.0 }; //Intente 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.
//Cree un nuevo VBO y use la variable id para almacenar el id del VBO
glGenBuffers ( 1 , & triangleVBO );
//Hacer que el nuevo VBO sea activo
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 );
//Active el nuevo VBO. Repita aquí en caso de que haya cambiado desde la inicialización
glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );
//Dibujar un triángulo desde VBO - hacer cada cambio de ventana, punto de vista o 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 contenga 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 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:
/*----------------- "ejemploVertexShader.vert" -----------------*/
#version 150 // Especifica qué versión de GLSL estamos usando.
// in_Position se vinculó al índice de atributo 0 ("shaderAttribute")
en vec3 in_Position ;
void main () { gl_Posición = vec4 ( en_Posición . x , en_Posición . y , en_Posición . z , 1.0 ); } /*--------------------------------------------------------------*/
Sombreador de fragmentos:
/*---------------- "ejemploFragmentShader.frag" ----------------*/
#version 150 // Especifica qué versión de GLSL estamos usando.
precision highp float ; // Los controladores de la tarjeta de video requieren que esta línea funcione correctamente
fuera 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 OpenGL ---------------------*/
/* Crea una variable para almacenar el identificador VBO */
GLuint triangleVBO ; /* Este es un identificador para el programa sombreador */ GLuint shaderProgram ;
/* Estos punteros recibirán el contenido de nuestros archivos de código fuente del sombreador */
GLchar * vertexSource , * fragmentSource ;
/* Estos son controladores utilizados para hacer referencia a los sombreadores */
GLuint vertexShader , fragmentShader ;
constante int sin signo shaderAttribute = 0 ;
/* Vértices de un triángulo (enrollado 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: hacerlo 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 );
/* Hacer que el nuevo VBO esté activo */
glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO );
/* Cargar datos de vértices al dispositivo de video */
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 flotantes por vértice */
glVertexAttribPointer ( shaderAttribute , 3 , GL_FLOAT , GL_FALSE , 0 , 0 );
/* Habilitar el índice de atributo 0(shaderAttribute) como utilizado */
glEnableVertexAttribArray ( shaderAttribute );
/* Activa el nuevo VBO. */
glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO ); /*---------------------------------------------------------------------------------------------------*/
/*--------------------- Carga los shaders Vertex y Fragment desde los archivos y compílalos --------------------*/
/* Lee nuestros shaders en los buffers apropiados */
vertexSource = filetobuf ( "exampleVertexShader.vert" ); fragmentSource = filetobuf ( "exampleFragmentShader.frag" );
/* Asignar a nuestros manejadores un "nombre" a los nuevos objetos shader */
vertexShader = glCreateShader ( GL_VERTEX_SHADER ); fragmentShader = glCreateShader ( GL_FRAGMENT_SHADER );
/* Asociar los buffers 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 shader */
glCompileShader ( vertexShader );
glCompileShader ( fragmentShader ) ;
/*---------------------------------------------------------------------------------------------------*/
/*-------------------- Crea un programa sombreador, adjunta sombreadores a él y luego vincúlalo ---------------------*/
/* Asigna un "nombre" a nuestro controlador de programa */
shaderProgram = glCreateProgram ();
/* Adjuntamos 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 "data" en el sombreador de vértices */
glBindAttribLocation ( shaderProgram , shaderAttribute , "in_Position" );
/* Programa de sombreado de enlaces*/
glLinkProgram ( shaderProgram );
/*---------------------------------------------------------------------------------------------------*/
/* Establecer el programa sombreador 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 );
/* En realidad, dibuja el triángulo, dando el número de vértices proporcionados por la invocación glDrawArrays
mientras indicamos que nuestros datos son un triángulo y queremos dibujar entre 0 y 3 vértices
*/
glDrawArrays ( GL_TRIANGLES , 0 , ( sizeof ( data ) / 3 ) / sizeof ( GLfloat )); /*---------------------------------------------------------------*/
Referencias
- ^ "Libro blanco sobre GL_NV_vertex_array_range". Archivado desde el original el 17 de agosto de 2004. Consultado el 24 de junio de 2024 .
{{cite web}}: CS1 maint: bot: estado de URL original desconocido ( enlace ) - ^ "ATI_vertex_array_object". Archivado desde el original el 4 de julio de 2012. Consultado el 12 de agosto de 2011 .
- ^ "Referencia de funciones de OpenGL 2.1".
- ^ "Referencia de funciones de OpenGL 3.3".
- ^ "Referencia de funciones de OpenGL 4.2".
Enlaces externos
- Documento técnico sobre el objeto Vertex Buffer
