Android Application Development Tutorial - 173 - ShortBuffer to handle Indices Video Lecture | Android Application Development (Mobile App) - Software Development

what's up guys welcome to 170 third
Android tutorial for the new Boston
and what we're gonna do in this tutorial
is kind of the same thing that we did in
last tutorial except instead of working
with vertices we're gonna be working
with indexes so what we're gonna do is
we're going to set up a private instead
of a float array we're going to set up a
private short array that's gonna
basically hold our indexes or our
specific points so we're just gonna call
this point index array or list
we're going to set this equal to is
basically we have three points so we're
just going to say 0 1 & 2 now we have to
set up a buffer for our index points and
again I know right now you guys might be
lost about what we're doing but it will
wrap together and tie together and
you'll see it what we are what we have
done and everything will for the most
part makes sense but what we're gonna do
is we're going to set up a private short
buffer instead of a float buffer since
we're working with a short list so we're
gonna say private short buffer we're
gonna call this our point buffer
something like that and then again we're
just gonna add our imports and now again
within our triangle constructor we're
gonna set up our short buffer for the
most part to relate to our indexes so
just give us a couple spaces here and
we're again set up a byte buffer call
this our point byte buffer or point B
for byte and buff something like that
and we're gonna say again relate to the
byte buffer class and we just gotta you
know tell the buffer how much how big
the capacity needs to be what it can
handle how many bytes were working with
and when we're working with shorts a
short is two bytes so as a float was
four bytes all we're gonna do is relate
to our list of our index our index lists
get the length that and then times it by
two so it's pretty much the same concept
we're just gonna say P index dot length
times that by two for two bytes per
short and then we're gonna again say our
point
or we're gonna see our point byte buffer
set it to native order again just just
by referring to the byte order and
saying dot native order and again all
this line is doing we're gonna be
calling a GL point pointer function on
these buffers and we in order to do that
we need to say it needs to be in native
order so basically the garbage collector
won't be able to access this or move it
or you know dump it so that's what we
need to set up this native order code
and that's all that's doing is relating
to again the byte buffer that we set up
and now what we're gonna do is we're
gonna relate to our index buffer which
we called point buffer or P buff and
we're just gonna say P buff is equal to
our PB buff or a point byte buffer and
we're just gonna say dot as short buffer
because again we aren't working with a
float buffer working with shorts now so
we're just gonna say we need a short
buffer and so there we go now what we're
gonna do is again we're just going to
say our we're gonna relate to our short
buffer and called P buff and all we're
gonna do is say dot put and then we have
to tell it you know what we want to put
in there and we're going to relate to
our point index list and then all we're
gonna say is move the position to 0 as
well and that's pretty much it and we're
gonna do one more thing kind of like
this for our textures relating textures
to a triangle something like that but
we'll get to that and again probably a
few tutorials so you guys actually can
see what these are doing when we get
into the code and then we'll come back
and maybe do like a texture one if we
have we have time and then you'll you
guys can the next time I go through this
type of thing you'll understand
everything that's going on why we you
know set up these buffers and all that
good stuff but again as for now that's
pretty much all we're going to do in
this tutorial pretty simple as well all
we did is set up a new byte buffer
that's going to be a short buffer and
and handle our index or our points like
point zero point one point two instead
of handling actual you know our actual
all of our X and y values of those
points and all that stuff which we did
in the previous tutorial with our vert
buffer you know I'll show you guys how
we're going to use these you know as we
go through this OpenGL series but as for
now that's probably it
I know it's kind of boring tutorial but
thanks again for watching guys I'll
catch you in the next one have a good
night