Vertex Arrays in OpenGL Video Lecture | Open GL: Basics to Expert - Game Development

hey what's up guys my name is eterno and
welcome back to my open GL series so
today when we talking all about vertex
arrays in OpenGL of course so so far
we've been talking about what a vertex
buffer is what a index buffer is or an
element buffer which over we've talked
about shaders we've talked about a lot
of kind of basic concepts of OpenGL and
even graphics programming in general but
OpenGL actually has something called a
vertex array and at first glance you
might be like well vertex array vertex
buffer what is the difference they sound
extremely similar and they are and to
make it even even crazier so does that
mean this isn't particularly crazy but
to make it even crazier this isn't
really something that exists in under in
other rendering API is like DirectX
vertex arrays are a bit of an OpenGL
special or an OpenGL original if you
like and what they basically are are a
way to bind buffers vertex buffers with
a certain kind of specification for the
layout of that actual vertex buffer so
let's take a look at what I mean by that
by just looking at some code real quick
so in our application we have this
buffer that we're creating over here
specifically there's array buffer which
contains all of our vertex data and
actually you may have noticed from
previous episodes that I have 6 written
here as a size so as if we have 6
vertices clearly we have 4 according to
this that's a bug let's fix that by
setting this to 4 but this vertex buffer
contains these vertex positions these
vertically all of this vertex data which
in this case is just vertex positions
for 4 vertices and then after we've
created the buff room we bounded and
we've set the daughter and all of that
we actually enable the vertex a trip
array and then specify the layout of
this actual data here by saying that it
basically every vertex each vertex is
two floats and then that's the stride
vertical of vertex to vertex right and
we also specify like the offset of this
attribute and all of that so we
basically just specify the layout of
this actual vertex buffer now what a
vertex array object actually lets us do
is kind of bind that vertex
specification that we specify by using
the search
vertex a trip pointer to an actual
buffer to an actual vertex buffer or a
series of vertex buffers depending on
how we actually organized this so
instead of us having to actually
explicitly specify the vertex layout
every time before we draw well again so
right now obviously we're not drawing
anything complex so it might be a little
bit difficult for those of you who are
new to OpenGL to actually get what I
mean by this but what we actually need
to do currently to draw this if we have
multiple what if we have multiple
objects on the screen multiple meshes
multiple vertex buffers all of that is
we would basically have to bind our
vertex buffer bind our index buffer and
then draw our actual object but after we
bind the vertex buffer we also need to
actually specify that layout because if
we if we later on if we later down the
road bind another vertex buffer which
has a different layout then we have to
actually have a way of saying that well
this buffer has this layout and this
buffer has the other layout it's not
it's not actually stored in the buffer
you might think that because we actually
in our code we bind a buffer and then we
actually call this vertex a trip pointer
that this state is kind of tied to and
saved with this actual buffer object but
it's not this is something that is
actually technically tied to a vertex
array object and thus we need to call it
every time in fact let's take a look at
what our code would look like if we were
actually kind of binding everything that
we needed to render every time because
right now what we've done is we've bound
all of the kind of objects that we have
because we only have one of each we have
one shader we have one vertex buffer one
index buffer and all of that if we
actually were to have multiple objects
we would have to rebind everything we
need for the current draw every time so
let's take a look at what that will look
like what I'm going to do is when we
actually set everything up over here I'm
actually going to unbind everything so
I'm going to call jail bind buffer in
fact let me just copy everything from
here so we need bind buffer we need bind
win this line buffer which is our index
buffer or our element buffer and then we
have this use program okay so what I'm
going to do is basically call zero for
all of these right so Jill use program
zero and bind buffer zero for array
buffer and index buffer so what I've
done here is I've basically unbound
everything so when it comes time to draw
what we need to do is actually bind
everything that we need for this draw
elements to work so that we render
everything correctly and this will
include you know setting up any kind of
state that we may need in this example
is very very simple so all we would all
we really need to do is just bind these
things right so before we draw this I'm
going to bind this shader right by
calling drill use program and then we
can set the uniform once that's bound
then I'm going to bind my buffer which
is going to be just buffer and then I'm
going to bind my index buffer which I
believe we called IB oh okay cool and
what I actually need to do which might
not be apparent here is I also need to
get this G over taste the trip pointer
and run that again
now you will probably if you end up
disabling vertex attrib arrays you
probably have to do that again so let's
just copy this and this whole block here
because we might need it like that okay
so this is what it kind of ends up
looking like we bind our shader we set
up our uniform so we bind our vertex
buffer we set up the layout of that
vertex buffer and then finally we bind
our index buffer and then we call GL
draw elements let's run this code and
see what happens and you can see we get
the same result as before perfect so the
part that is interesting here is these
two
do we have to do these every time and
the answer is well yes because they may
have changed if we draw another object
with a different layout so vertex array
objects are actually what contained this
stay so if we utilize vertex array of
dress properly and were to for example
make a different vertex array object for
each piece of geometry that we actually
draw or for each draw called basically
then all we would need to do
theoretically is just bind the vertex
array object and that's it we're done
because a vertex array object will
contain a binding between a vertex
buffer or buffers and that actual kind
of vertex specification or that vertex
layout so in other words vertex attrib
pointer actually will bind an actual
vertex buffer and array buffer so
something bound to this PL array buffer
slot it will bind that with that actual
layout with that specification and that
works whether or not you have a single
buffer like we do here or if you have
multiple buffers and we'll definitely
end up talking about kind of a single
buffer and multiple vertex buffer
in the future as well and so the way
that we draw things changes from being
bind our shader bind our vertex buffer
set up the vertex layout bind our
indexed buffer and then actually issue
that draw call it changes from that to
just being bind our shader because
obviously that stays the same then we
bind our vertex array and then we bind
our index buffer and then finally we we
should that drop halt
so basically binding that vertex buffer
and setting up its layout just becomes
binding that vertex array object because
that contains all the state that we
actually need one other thing that I
need to mention here is that technically
speaking vertex array objects are
mandatory and they are actually in use
right now which is why I said that even
without us creating them this state is
still maintained by the vertex array
object the thing is the opengl
compatibility profile which is what
we're actually running here it's like a
mode for and jelled basically running
the compatibility profile actually
creates a vertex array object for us by
default and that's what zero is whereas
the core profile does not so we actually
need to explicitly create an OpenGL
vertex array object by ourselves and
bind it and make sure that's all up and
running manually if we're using the core
profile so to demonstrate this what I'm
going to do I'm just going to hit a 5
draw my code just to see if everything
is running correctly and you can see it
is what I'm going to do now is actually
tell GL FW that I want to create a
context this OpenGL context I actually
want to create this window in this
context with the core profile and the
way I'm going to do this is basically
just by pasting this code in here so
what I'm doing here is I'm setting a gel
W window hint which says that I want my
major version to be OpenGL 3 minor
version 2 B 3 so it's OpenGL 3.3 and
then this is the important code here I'm
setting my opengl profile to be core now
currently I've got compatibility on so
if I actually just set this to compat
profile and hit f5 the only thing that
you'll notice that changes is our actual
version of OpenGL instead of using the
absolute latest one that we have
available in our drivers it's using
three point three which of course is the
one that I specified and you can see
that of course my code still works
perfectly however if I change this
to be the core profile like this and hit
f5 we're actually going to trigger an
assert as you can see when we try and
enable this vertex at rib array and that
is because if we go over here into the
open shell documentation here this
kernel site on vertex specification is
actually really really good and you can
see the lineup highlighted here the
compatibility OpenGL profile makes the
arrow objects zero a default object
whereas core does not it's not an object
at all right that's what's actually
happening here and you can see
specifically if we look at our actual
console here we have an open GL error
1282 which is jail invalid operation on
this line of code enabled vertex the
Trib array so let's again open the
documentation and look at GL vertex the
Trib array and see what 1282 actually
means and you can see over here that one
of the causes of this invalid operation
is if no vertex array object is bound so
that's what's happening we don't have a
vertex array object bound therefore we
cannot specify a vertex at ribbed kind
of specification or enable a vertex the
Trib array so what we need to do now to
fix this in the core profile is actually
create that V arrow that vertex array
object so let's do that it's really easy
to do this all I'm going to do is before
we actually generate this buffer and
created I'm going to type in an unsigned
into the arrow which will hold that
actual vertex array object ID and then
going to GL call a GL gen vertex arrays
I'm going to generate one of them and
then store that ID in that vo variable
so the same as with buffers of course
except which and running vertex arrays
and then finally I'm going to bind it
and GL
bind vertex arrays there's no actual
target so we just specify the idea of
what we want to bind like this so we
don't have a target like gel right
buffer or anything it's just fine vertex
array and then the ID so I've still got
the call profile on which is what
asserted before with an Open GL error
let's try and run this now and see what
happens and you can see I don't get any
errors and I still get the same result
okay so that is us explicitly crediting
a var and that's basically how you use
the errors as well
we just generate one we bind it and then
we have the ability to actually bind a
buffer and specify a layout for it now
what's what's really interesting is that
if we scroll down here we no longer have
to
actually do this enable vertex a trip
array or pointer code okay and we also
don't need to actually bind the buffer
let's add to this GL well twice clearing
all of our GL States GL by and vertex
array well so we will be binding vertex
array 0 just so the we're clearing
everything and then over here I'm just
going to bind vertex array VAR oh so you
can see that I'm not binding my vertex
buffer at all and the currently bound
buffer to gel array buffer is actually 0
right I'm just binding my vertex array
and just binding my index buffer and
that's it okay obviously I'm binding my
shader as well and then issuing that
draw call let's hit f5 check that out I
still get my rectangle rendering
correctly so what's actually happening
is we're linking vaps
vertex buffer to this vertex array
object and the question is what code is
actually doing that and it might be a
little bit confusing if you don't know
how it works
but of course I'm going to tell you how
it works when we bind a vertex array and
we bind a buffer nothing actually links
the two but when we actually specify
this vertex the trip pointer we're
saying index 0 of this vertex array is
going to actually be bound to the
currently bound GL array buffer okay so
this in other words it's a line of code
that actually links this buffer with
this VAR ok if I was then to bind a
different buffer and then called geo
vertex the trip points that with the
index 1 after enabling and of course
using this line then I would actually be
saying that that that inside this array
buffer index 1 is actually pointing to a
different vertex buffer and again we'll
definitely talk about multiple vertex
buffers in the future as well as having
one buffer with everything in one buffer
because that's also an option so that's
how it actually works and because we've
actually specified this vertex a trip
pointer and we have a vertex right bound
and we have an axle buffer bound the two
are basically linked which means that
all we have to do is just bind our
vertex array and then index bottles of
course for a separate thing completely
which is why we still need to bind it
and then we control element so you can
see this code has become quite a bit
cleaner and that's all we have to
actually do so the big question is what
do I do
am I supposed to use vertex array
objects like all the
time do I can I just be setting a vertex
before a new vertex specification what's
optimal like how do i do things all
these questions what happens when we
have multiple meshes that we want to
draw I know that a lot of this is
incredibly kind of simple because we're
destroying one object and it happens to
be really really simple I am going to
start extracting all this code out into
classes and as soon as I do that I think
I want to actually start doing that next
episode as soon as that's done it's
gonna be really easy for us to actually
create a bunch of different vertex
buffers fill them with data and draw
multiple objects on the screen and we'll
probably have to set up some other
things like maths and all of that to
make that happen but the idea is what's
the like what is the deal like should I
be using multiple vertex array objects
can I get away without using them what's
the deal now what I'm about to tell you
is going to be a little bit opinionated
and probably a bit vague but the thing
is there's no better way for me to
actually explain it to you because the
answer is it depends so first of all
let's take a look at what's happening
here if we use the call profile which
I'm currently using we have to create a
vertex array object if we just use the
compatibility profile it doesn't mean
there are no vertex array objects it
just means that we have one default we
have a default one that's bound and set
up for us to use if we're on call we
have to create one ourselves now what
you could do technically is you could
just create one create one vertex array
object like we did it like we did here
and just leave it bound for the duration
of your entire program so you always
have one vertex object bound and then
what you can do is bind a vertex buffer
and specify a vertex layout every time
before you actually end up drawing your
geometry so in other words you're kind
of doing the same thing that we did
before we introduced this vertex array
object so as if we were using that
compare that compatibility profile that
is an option and that's kind of you
that's kind of a way for you to say I'm
ignoring vertex for objects entirely I'm
just finding one kind of default one by
myself because I need to otherwise my
program won't run otherwise I won't be
able to render anything because OpenGL
actually mandates that in the core
profile so that is one option you could
just ignore vertex array objects by
binding one forgetting about it leaving
it bound and then every time you
actually have to draw something you
you bind a vertex buffer you bind
something into the into the GL array
buffer slot then you specify that you
enable any birthday strip arrays you
have to and specify that vertex the trip
point to stop so that you map your
layout and then you find your index
buffer in the new render write and
obviously you have a shader bound in any
other state that you might have to set
up right you could do that that's one
option that's also a option B is for
every piece of geometry that you create
it you basically create a vertex array
object then you specify that
specification once so you enable any
vertex the trip arrays you need to you
specify GL vertex a trip pointer as many
times as you need to to set all of that
stuff up and then your video Z bind a
vertex buffer as well before you do all
that and then when it comes time to draw
you just bind a different vertex array
object basically every time before you
draw your geometry and then your binding
in an index buffer and then you called
field draw elements or whatever draw
function you're using okay
so you basically you either have one
global vieo for the entire program and
then you bind different buffers and
different vertex specifications every
time or you have a separate video for
each piece of geometry or each unique
piece of geometry or whatever right
which one's better again it's hard to
answer so a better an easier question to
answer is which one is more optimal
which one should I use which one is
faster is it faster to just bind a
buffer and specify and specify that
specification every time that layout or
can i or is it faster to bind a
different var every time now in the past
it has been faster to actually just have
one biere
and then bind everything every time I
know that for a fact and NVIDIA actually
has a paper on that I'll link something
in the description it's like I think
slide 67 or something of that I'm really
just talking from memory here of um of a
source engine valves Source engine kind
of presentation where they actually
Nvidia specifically discouraged the use
of the arrows and said just don't use
them that was a while ago I haven't done
any recent benchmarks on this so what I
would recommend for you to do is use the
arrows right just use
OpenGL recommends that you use them so
use them now just because a
specification recommends that you do
something does not mean that it is the
best thing to do okay this is the real
world things work a little bit
differently than the ideal case where
video is just work right and they're
faster so what I recommend you do is
that if you really really care about
performance and you absolutely need to
squeeze every last bit of performance
out of all this you actually run some
tests so in your environment on your
platform on your device whatever it is
that you're actually doing try in your
actual production environment try to
actually use one global v error versus a
V error for each object and see get some
real numbers out of that and see what
works better for you because it is going
to be circumstantial it is going to be
different depending on your environment
so benchmark that profile that in your
environment and see whatever option
works better for you and then stick with
the one that works better for you okay
it's really difficult for me to answer
questions like this because it depends
right again I haven't done any recent
benchmarks on this in the past I have
found using one global var to be faster
but that was years ago
so I cannot talk about this right now
with current drivers so what am i doing
the future is actually benchmark this
this kind of engine or whatever that we
have right now this little sandbox
application is nowhere near mature
enough doesn't have enough it doesn't
have enough stuff going on for me to
actually test it otherwise I would
probably throw a little benchmark
actually yeah drop a comment below if
you want me to benchmark this and I'll
see what I can do if you yourself are on
a stress test and benchmark this and do
all that you can leave your results in
the comments below I'd love to read them
but the idea is again it kind of depends
whether or not you want to use videos I
will from now on be using Fieros just
because I don't particularly care about
performance right now and it is what
OpenGL recommends that you actually do
however do check out that paper or
presentation or whatever that I linked
in the comment section in the
description box below if you're in if
you're interested in that and definitely
test it in your environment for your use
case you know on your platform on your
device whatever to actually see what
you get because that's what actually
matters anyway I hope you guys enjoyed
this video if you did you can hit the
like button if you want to support
everything that I do here on this
channel then head on over to patreon a
composter Cherno you'll get some cool
rewards such as getting videos early
access to all the source code
repositories for every series that I
make on this channel including all the
code that I've written here today as
well as like a diff between each episode
so that you can easily see what I've
added and all that there's some other
pretty cool rewards like for example all
of the partners which is the highest
patron tier all of us we hang out like
once a month and just have like an
hour-long conversation about life and
about programming and about developing
and all that that's a really good this
really great time so definitely check
out those four what's there the biggest
thing you're doing is obviously helping
me to continue making these videos which
is pretty cool and as always a huge
shout out to everyone who supports what
I do because without you not this would
be possible next time I think we're
either going to talk about maths or
we're going to probably start up
stretching all this code out let me know
what you want to think let me know what
you want to see in the comment section
below and we'll see what we actually end
up doing one thing I wanted to mention
was if we talk about maths we'll have to
use a math library as well as probably
talk about you know how things like
projection matrices work and matrices in
general and all of that so that might be
a long thing but it is something we have
to do so the only thing you can then
think I can see it I can say about maths
is you gotta learn to love it because as
a graphics programmer you're gonna be
dealing with mass quite a lot because
that's how pretty much everything works
anyway I hope you guys enjoyed this
video I will see you guys next time
good bye
[Music]