Vertex buffertobjekt

Vertex Buffer Object (VBO) är en funktion i OpenGL som tillhandahåller metoder för att dumpa data ( hörn , normala vektorer , färger och så vidare) till videoenheten för icke-live-rendering. VBO:er gav en betydande prestandaökning jämfört med direktåtergivningsläge, främst för att data finns i videoenhetens minne, inte i RAM, och så att den kan renderas direkt av videoenheten.

Vertex Buffer Object-specifikationen standardiserades av OpenGL Architecture Review Board som OpenGL version 1.5 (2003). Liknande funktionalitet var tillgänglig före standardiseringen av VBO:er genom Nvidias "Vertex Array Range" [1] och ATI :s "Vertex Array Object" [2] tillägg .

Huvudfunktioner för VBO

Följande funktioner utgör grunden för VBO-åtkomst och manipulation:

I OpenGL 1.4 : GenBuffersARB (storlek n, uint *buffertar) Skapar n nya VBO och returnerar deras ID-nummer som ett osignerat heltal. ID 0 är reserverat. BindBufferARB (enum target, uint buffer) Använder den tidigare skapade bufferten som aktiv VBO. BufferDataARB (enum target, sizeiptrARB size, const void *data, enum use) Laddar upp data till den aktiva VBO:n. DeleteBuffersARB (sizei n, const uint *buffers) Tar bort de angivna VBO:erna från arrayen eller VBO-id. I OpenGL 2.1 : [3] , OpenGL 3.x [4] och OpenGL 4.x kan ARB-suffixet utelämnas från funktionerna: [5] Genbuffertar (storlek n, uint *buffrar) Skapar n nya VBO och returnerar deras ID-nummer som ett osignerat heltal. ID 0 är reserverat. BindBuffer (enum target, uint buffer) Använder den tidigare skapade bufferten som aktiv VBO. BufferData (enum target, sizeiptrARB size, const void *data, enum use) Laddar upp data till den aktiva VBO:n. Ta bort buffertar (storlek, konst uint *buffertar) Tar bort de angivna VBO:erna från arrayen eller VBO-id.

Exempel i C och OpenGL 2.1

//VBO-initiering - gjort en gång, vid programstart //Skapar en variabel för att lagra VBO-identifieraren GLuint triangleVBO ; // Triangelhörn (förbikoppling moturs) flytdata [ ] = { 1,0 , 0,0 , 1,0 , 0,0 , 0,0 , -1,0 , -1,0 , 0,0 , 1,0 }; //Skapa en ny VBO och spara VBO ID glGenBuffers ( 1 , & triangleVBO ); //Ställ in VBO-aktivitet glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO ); //Ladda upp vertexdata till videoenheten glBufferData ( GL_ARRAY_BUFFER , sizeof ( data ), data , GL_STATIC_DRAW ); //Rita triangel från VBO - händer varje gång fönstret, synvinkeln eller data ändras //Ange 3 koordinater för varje vertex i 0 steg i denna array; den behöver glVertexPointer ( 3 , GL_FLOAT , 0 , NULL ); //Gör den nya VBO:en aktiv. Upprepa detta om ändrat från initialisering glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO ); //Denna array innehåller hörn (inte normaler, färger, texturer, etc.) glEnableClientState ( GL_VERTEX_ARRAY ); //Rita en triangel genom att ange antalet hörn glDrawArrays ( GL_TRIANGLES , 0 , sizeof ( data ) / sizeof ( float ) / 3 ); //Instruktion att visa ritad omedelbart glFlush ();

Exempel i C och OpenGL 3.x eller OpenGL 4.x

En funktion som kan läsa vilken text eller binär fil som helst i en bytebuffert:

/* Funktion för att läsa en textfil i en allokerad char-buffert */ char * filetobuf ( char * fil ) { FIL * fptr ; lång längd ; char * buf ; fptr = fopen ( fil , "rb" ); /* Öppna fil för läsning */ if ( ! fptr ) /* Returnera NULL vid fel */ returnera NULL ; fseek ( fptr , 0 , SEEK_END ); /* Hitta slutet av filen */ längd = ftell ( fptr ); /* Beräkna filstorlek i byte */ buf = malloc ( längd + 1 ); /* Tilldela ytterligare en buffert för fil och nollpekare */ fseek ( fptr , 0 , SEEK_SET ); /* Hoppa tillbaka till början av filen */ fread ( buf , längd , 1 , fptr ); /* Läs innehållet i filen i bufferten */ fclose ( fptr ); /* Stäng filen */ buf [ längd ] = 0 ; /* Ställ in nollpekare som slutmarkör för buffert */ returnera buff ; /* Returnera den mottagna bufferten */ }


Vertex shader:

/*----------------- "exampleVertexShader.vert" ------------------*/ #version 150 // Ange vilken version av GLSL vi använder. // in_Position har associerats med ett attribut med index 0 ("shaderAttribute") i vec3 in_Position ; void main ( void ) { gl_Position = vec4 ( in_Position . x , in_Position . y , in_Position . z , 1.0 ); } /*------------------------------------------------------- --------------- -------------------/


Fragment Shader:

/*---------------- "exampleFragmentShader.frag" ----------------*/ #version 150 // Ange vilken version av GLSL vi använder. precision högt flytande ; // Drivrutiner för grafikkort kräver detta för att nästa rad ska fungera korrekt ut vec4 fragColor ; void main ( void ) { fragColor = vec4 ( 1.0 , 1.0 , 1.0 , 1.0 ); //Ställ in färgen på varje fragment till vit } /*------------------------------------------------ ----------- --------------------------------*/


Huvudprogram för OpenGL:

/*--------------------- Huvud OpenGL-program ---------------------*/ /* Skapa en variabel för att lagra VBO-identifieraren */ GLuint triangel VBO ; /* Detta är namnet på shader-programmet */ GLuint shaderProgram ; /* Dessa pekare kommer att få adresser i shaderns källkodsminne */ GLchar * vertexSource , * fragmentSource ; /* Dessa variabler används för shaders */ GLuint vertexShader , fragmentShader ; const unsigned int shaderAttribute = 0 ; const float NUM_OF_VERTICES_IN_DATA = 3 ; /* Triangelhörn (traverseringsriktning: moturs) */ flytdata [ 3 ] [ 3 ] = { { 0,0 , 1,0 , 0,0 }, { -1,0 , -1,0 , 0,0 }, { 1,0 , -1,0 , 0,0 } }; /*--------------------- VBO-initiering - (gjord en gång, vid programstart) --------------- - -----*/ /* Skapa en ny VBO och använd variabeln "triangleVBO" för att lagra VBO-id */ glGenBuffers ( 1 , & triangleVBO ); /* Gör den nya VBO aktiv */ glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO ); /* Ladda upp data till videoenhet */ glBufferData ( GL_ARRAY_BUFFER , NUM_OF_VERTICES_IN_DATA * 3 * storlek på ( flytande ), data , GL_STATIC_DRAW ); /* Ange att vår koordinatdata i attributindex är 0 (shaderAttribute) och innehåller 3 flytningar per vertex */ glVertexAttribPointer ( shaderAttribute , 3 , GL_FLOAT , GL_FALSE , 0 , 0 ); /* Inkludera attributindex lika med 0 (shaderAttribute) som används */ glEnableVertexAttribArray ( shaderAttribute ); /* Gör den nya VBO aktiv */ glBindBuffer ( GL_ARRAY_BUFFER , triangleVBO ); /*------------------------------------------------ -------------------------------------------------- -----*/ /*--------------------- Ladda Vertex och Fragment från filer och kompilera dem ------------------ --*/ /* Läs skuggningskod i lämpliga dynamiskt allokerade buffertar */ vertexSource = filetobuf ( "exampleVertexShader.vert" ); fragmentSource = filetobuf ( "exampleFragmentShader.frag" ); /* Tilldela "namn" till våra hanterare för de nya shader-objekten */ vertexShader = glCreateShader ( GL_VERTEX_SHADER ); fragmentShader = glCreateShader ( GL_FRAGMENT_SHADER ); /* Slå ihop skuggkällbuffertarna med deras respektive hanterare */ glShaderSource ( vertexShader , 1 , ( const GLchar ** ) & vertexSource , 0 ); glShaderSource ( fragmentShader , 1 , ( const GLchar ** ) & fragmentSource , 0 ); /* Frigör det tidigare tilldelade minnet */ gratis ( vertexSource ); gratis ( fragmentkälla ); /* Sammanställ våra shader-koder */ glCompileShader ( vertexShader ); glCompileShader ( fragmentShader ); /*------------------------------------------------ -------------------------------------------------- -----*/ /*-------------------- Skapa ett skuggningsprogram, fästa skuggningen till det och länka ---------------- ----*/ /* Tilldela ett namn till vårt hanterarprogram */ shaderProgram = glCreateProgram (); /* Fäst våra shaders till shaderprogrammet */ glAttachShader ( shaderProgram , vertexShader ); glAttachShader ( shaderProgram , fragmentShader ); /* Associera ett attributindex på 0 (shaderAttribute) med in_Position */ /* "in_Position" kommer att representera datamatrisen i vertex shader */ glBindAttribLocation ( shaderProgram , shaderAttribute , "in_Position" ); /* Länka shader-programmet */ glLinkProgram ( shaderProgram ); /*------------------------------------------------ -------------------------------------------------- -----*/ /* Aktivera vårt shader-program */ glUseProgram ( shaderProgram ); /* Ställ in bakgrunden till svart */ glClearColor ( 0,0 , 0,0 , 0,0 , 1,0 ); /* Rensa bakgrundsfärg */ glClear ( GL_COLOR_BUFFER_BIT ); /* Rita en triangel, vertexnummer passeras genom att anropa glDrawArrays och säger att våra givna trianglar och vi vill rita hörn 0-3 */ glDrawArrays ( GL_TRIANGLES , 0 , 3 ); /*------------------------------------------------ ---------------*/

Se även

Anteckningar

  1. ↑ GL_NV_vertex_array_range Whitepaper . Arkiverad från originalet den 22 maj 2013.
  2. ↑ ATI_vertex_array_object . Arkiverad från originalet den 22 maj 2013.
  3. ↑ Funktionsreferens för OpenGL 2.1 . Arkiverad från originalet den 22 maj 2013.
  4. ↑ Funktionsreferens för OpenGL 3.3 . Arkiverad från originalet den 22 maj 2013.
  5. ↑ Funktionsreferens för OpenGL 4.2 (inte tillgänglig länk) . Hämtad 5 maj 2013. Arkiverad från originalet 22 maj 2013. 

Länkar