Pandora Wiki - User contributions [en]

GLES

2010-01-17T22:18:04Z

Butterman:

== Introduction ==
Unfortunately, the OpenGL ES takes away many of the functions that beginner programmers use. They do this, because a lot of those functions are plain rubbish for any high-end application. We're only covering ES 1.1 here, but the Pandora also supports ES 2.0, which, leaves you with a handful of functions, you have to do all of the matrix math on your own. Which can be really hard if you're not good at maths, I'll cover how to do that in a later tutorial. What you're learning here isn't just for the Pandora, you should use these new methods in your Windows/Linux code. These changes are being made to the core OpenGL too, so you're loosing all of this stuff soon enough. Which is silly, OpenGL is good because beginners can pick it up easily. But whatever, I'm not in charge.

== The Basics ==

glBegin() and glEnd()

<source lang=cpp>

glBegin(GL_TRIANGLES);

glVertex3f(1,0,0);
glVertex3f(0,1,0);
glVertex3f(-1,0,0);

glEnd();

</source>

You know what I just did? Yeah, I drew a triangle! Nope, you can't draw stuff like this in OpenGL ES 1.1, so how would one draw a triangle in ES? Bare with me while you read this if you don't understand it, I'll explain it in depth.

<source lang=cpp>

GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, vertices);

glDrawArrays(GL_TRIANGLES, 0, 3);

glDisableClientState(GL_VERTEX_ARRAY);

</source>

This is called drawing with a vertex array. Eww? Yeah, you would never draw like that in a real program, your vertex array would be stored already, you wouldn't have to define it every time you drew somthing. While it's messy for drawing primitives, it's really cool for drawing models, because your models vertices are generally stored in arrays like that already. I'll show you an example from TINCS after I explain this code.
<source lang=cpp>
GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};
</source>
This ''should'' be obvious, we're simply creating an array that stores the vertices of our triangle. It can be of any size, you can store as many vertices as you want. Note, how I space out every three numbers, this is because a vertex is made of X,Y,Z components. So we have our X, our Y, our Z then a space for the next three. You don't have to space it like this, it's mainly so you can see what's going on.
<source lang=cpp>
glEnableClientState(GL_VERTEX_ARRAY);
</source>
We need to do this before we start drawing, this tells OGL that we're going to feed it a vertex array from the client side (rather than the server, which is the graphics card).
<source lang=cpp>
glVertexPointer(3, GL_FLOAT, 0, vertices);
</source>
Ok, here is where we're telling OGL where to get it's vertices from. The first argument, tells OGL how many components (or floats) there are per vertex. Remember we talked about how we were spacing them out every 3 numbers? Here we're telling OGL that we did that! The next argument tells OpenGL that we're giving it floating point numbers. Now we have a "0". This is called the stride, I could explain it in detail, but you don't need to understand it yet. Just leave it at 0. In the last argument we give OGL our vertex array!
<source lang=cpp>
glDrawArrays(GL_TRIANGLES, 0, 3);
</source>
Here is where the work is done. The first argument is telling OGL that we're drawing in triangles. (This can be GL_QUADS, GL_LINES, whatever!). The second is specifying where we want to start in the array we passed OGL earier. The last one is telling OpenGL how many vertices we want to draw. In this case, it's just the three.
<source lang=cpp>
glDisableClientState(GL_VERTEX_ARRAY);
</source>
Finally, we're disabling the vertex array state. We're done!

So this is one of the ways to draw stuff in OpenGL. It's the next step up from glBegin and glEnd and it works fine in ES 1.1, so it works fine on the Pandora!

== Drawing Textured Quads ==

OpenGL can be great for speeding up your 2D application. One of the ways you do this, is by drawing with OpenGL rather than SDL. 2D games are made up of lots of sprites, which are just images that move about in a 2D world. You can use hardware acceleration to speed this up. If you're only planning on using 3D stuff on the Pandora, read this anyway, it introduces you to texturing with texture arrays and you're probably going to need to use sprites somewhere anyway.

So, we can pick apart my method of sprite drawing in TINCS for this tutorial, I mainly use this function to draw text, once it's been rendered by SDL_ttf and converted into a OpenGL texture, but never mind any of that.

<source lang=cpp>
static void DrawSprite(GLuint sprite, float X, float Y, float Z, float W, float H)
{
glBindTexture(GL_TEXTURE_2D,sprite);

GLfloat box[] = {X,Y + H,Z, X + W,Y + H,Z, X + W, Y, Z, X,Y,Z};
GLfloat tex[] = {0,0, 1,0, 1,1, 0,1};

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);

glVertexPointer(3, GL_FLOAT, 0,box);
glTexCoordPointer(2, GL_FLOAT, 0, tex);

glDrawArrays(GL_QUADS,0,4);

glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
</source>
Give it a good read, make sure you understand all of the stuff we've been over before and how it's applied in this example! Also, I'm not sure how this will fare in the 3D realm, I only use it when I'm in Ortho mode (2D, drawing ma GUI).

Right!
<source lang=cpp>
glBindTexture(GL_TEXTURE_2D,sprite);
</source>
As you can see here, binding the texture that's passed to the function to GL_TEXTURE_2D. You should understand this already. (If not, hit up NeHes tutorials!)
<source lang=cpp>
GLfloat tex[] = {0,0, 1,0, 1,1, 0,1};
</source>
This is new too, what we've done, is got the texture co-ordinates that we would usually pass to OGL per-vertex. (glTexCoord2f() style) Then put them into a little array.
<source lang=cpp>
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</source>
Just like last time, we're enabling a state on the client (not the server), this one tells the GPU we want to pass a texture coordinate array too.
<source lang=cpp>
glTexCoordPointer(2, GL_FLOAT, 0, tex);
</source>
Here we're passing the texture coordinates to OGL. Exactly like the vertex coordinates, except that the first argument (the size) is only two. This is because we only need two values per texture coordinate (a U and a V).
<source lang=cpp>
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
</source>
We disable the texture coordinate array just like we did with the vertex array.

There we go! That's not much harder than SDL blit is it? I guarantee it will make your app run a whole bunch faster too :D

==Conclusion==

This is all you need to know to use OpenGL on the Pandora. Note, you can't open your window like you would in SDL/Linux/Windows, it's a little bit different in OpenGL ES and I'll go over that in my [[Combining OpenGL ES 1.1 and SDL to create a window on the Pandora]] tutorial! Remember, you can and should use this knowledge for regular OpenGL!

''I want to add one last section about drawing models once I've released the source to my model format loader/drawer''

[[Category:Development]]

Combining OpenGL ES 1.1 and SDL to create a window on the Pandora

2009-02-21T19:55:42Z

Butterman: New page: Under Construction

Under Construction

GLES

2009-02-21T19:55:27Z

Butterman:

''Please don't skim over this tutorial, then just email me because you don't understand something. This tutorial has to be read in its entirety or you wont get it. If you're not up for that, then go find some other code you can copy paste, ya lazy bum. If you do have questions, I hang around on #TINCS in "irc.quakenet.org" or you can email me on "jack@sorok.co.uk"''

== Introduction ==
Unfortunately, the OpenGL ES takes away many of the functions that beginner programmers use. They do this, because a lot of those functions are plain rubbish for any high-end application. We're only covering ES 1.1 here, but the Pandora also supports ES 2.0, which, leaves you with a handful of functions, you have to do all of the matrix math on your own. Which can be really hard if you're not good at maths, I'll cover how to do that in a later tutorial. What you're learning here isn't just for the Pandora, you should use these new methods in your Windows/Linux code. These changes are being made to the core OpenGL too, so you're loosing all of this stuff soon enough. Which is silly, OpenGL is good because beginners can pick it up easily. But whatever, I'm not in charge.

== The Basics ==

glBegin() and glEnd()

<source lang=cpp>

glBegin(GL_TRIANGLES);

glVertex3f(1,0,0);
glVertex3f(0,1,0);
glVertex3f(-1,0,0);

glEnd();

</source>

You know what I just did? Yeah, I drew a triangle! Nope, you can't draw stuff like this in OpenGL ES 1.1, so how would one draw a triangle in ES? Bare with me while you read this if you don't understand it, I'll explain it in depth.

<source lang=cpp>

GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, vertices);

glDrawArrays(GL_TRIANGLES, 0, 3);

glDisableClientState(GL_VERTEX_ARRAY);

</source>

This is called drawing with a vertex array. Eww? Yeah, you would never draw like that in a real program, your vertex array would be stored already, you wouldn't have to define it every time you drew somthing. While it's messy for drawing primitives, it's really cool for drawing models, because your models vertices are generally stored in arrays like that already. I'll show you an example from TINCS after I explain this code.
<source lang=cpp>
GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};
</source>
This ''should'' be obvious, we're simply creating an array that stores the vertices of our triangle. It can be of any size, you can store as many vertices as you want. Note, how I space out every three numbers, this is because a vertex is made of X,Y,Z components. So we have our X, our Y, our Z then a space for the next three. You don't have to space it like this, it's mainly so you can see what's going on.
<source lang=cpp>
glEnableClientState(GL_VERTEX_ARRAY);
</source>
We need to do this before we start drawing, this tells OGL that we're going to feed it a vertex array from the client side (rather than the server, which is the graphics card).
<source lang=cpp>
glVertexPointer(3, GL_FLOAT, 0, vertices);
</source>
Ok, here is where we're telling OGL where to get it's vertices from. The first argument, tells OGL how many components (or floats) there are per vertex. Remember we talked about how we were spacing them out every 3 numbers? Here we're telling OGL that we did that! The next argument tells OpenGL that we're giving it floating point numbers. Now we have a "0". This is called the stride, I could explain it in detail, but you don't need to understand it yet. Just leave it at 0. In the last argument we give OGL our vertex array!
<source lang=cpp>
glDrawArrays(GL_TRIANGLES, 0, 3);
</source>
Here is where the work is done. The first argument is telling OGL that we're drawing in triangles. (This can be GL_QUADS, GL_LINES, whatever!). The second is specifying where we want to start in the array we passed OGL earier. The last one is telling OpenGL how many vertices we want to draw. In this case, it's just the three.
<source lang=cpp>
glDisableClientState(GL_VERTEX_ARRAY);
</source>
Finally, we're disabling the vertex array state. We're done!

So this is one of the ways to draw stuff in OpenGL. It's the next step up from glBegin and glEnd and it works fine in ES 1.1, so it works fine on the Pandora!

== Drawing Textured Quads ==

OpenGL can be great for speeding up your 2D application. One of the ways you do this, is by drawing with OpenGL rather than SDL. 2D games are made up of lots of sprites, which are just images that move about in a 2D world. You can use hardware acceleration to speed this up. If you're only planning on using 3D stuff on the Pandora, read this anyway, it introduces you to texturing with texture arrays and you're probably going to need to use sprites somewhere anyway.

So, we can pick apart my method of sprite drawing in TINCS for this tutorial, I mainly use this function to draw text, once it's been rendered by SDL_ttf and converted into a OpenGL texture, but never mind any of that.

<source lang=cpp>
static void DrawSprite(GLuint sprite, float X, float Y, float Z, float W, float H)
{
glBindTexture(GL_TEXTURE_2D,sprite);

GLfloat box[] = {X,Y + H,Z, X + W,Y + H,Z, X + W, Y, Z, X,Y,Z};
GLfloat tex[] = {0,0, 1,0, 1,1, 0,1};

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);

glVertexPointer(3, GL_FLOAT, 0,box);
glTexCoordPointer(2, GL_FLOAT, 0, tex);

glDrawArrays(GL_QUADS,0,4);

glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
</source>
Give it a good read, make sure you understand all of the stuff we've been over before and how it's applied in this example! Also, I'm not sure how this will fare in the 3D realm, I only use it when I'm in Ortho mode (2D, drawing ma GUI).

Right!
<source lang=cpp>
glBindTexture(GL_TEXTURE_2D,sprite);
</source>
As you can see here, binding the texture that's passed to the function to GL_TEXTURE_2D. You should understand this already. (If not, hit up NeHes tutorials!)
<source lang=cpp>
GLfloat tex[] = {0,0, 1,0, 1,1, 0,1};
</source>
This is new too, what we've done, is got the texture co-ordinates that we would usually pass to OGL per-vertex. (glTexCoord2f() style) Then put them into a little array.
<source lang=cpp>
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
</source>
Just like last time, we're enabling a state on the client (not the server), this one tells the GPU we want to pass a texture coordinate array too.
<source lang=cpp>
glTexCoordPointer(2, GL_FLOAT, 0, tex);
</source>
Here we're passing the texture coordinates to OGL. Exactly like the vertex coordinates, except that the first argument (the size) is only two. This is because we only need two values per texture coordinate (a U and a V).
<source lang=cpp>
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
</source>
We disable the texture coordinate array just like we did with the vertex array.

There we go! That's not much harder than SDL blit is it? I guarantee it will make your app run a whole bunch faster too :D

==Conclusion==

This is all you need to know to use OpenGL on the Pandora. Note, you can't open your window like you would in SDL/Linux/Windows, it's a little bit different in OpenGL ES and I'll go over that in my [[Combining OpenGL ES 1.1 and SDL to create a window on the Pandora]] tutorial! Remember, you can and should use this knowledge for regular OpenGL!

''I want to add one last section about drawing models once I've released the source to my model format loader/drawer''

[[Category:Development]]

GLES

2009-02-21T19:51:13Z

Butterman:

GLES

2009-02-21T19:44:26Z

Butterman:

''Please don't skim over this tutorial, then just email me because you don't understand something. This tutorial has to be read in its entirety or you wont get it. If you're not up for that, then go find some other code you can copy paste, ya lazy bum. If you do have questions, I hang around on #TINCS in "irc.quakenet.org" or you can email me on "jack@sorok.co.uk"''

== Introduction ==
Unfortunately, the OpenGL ES takes away many of the functions that beginner programmers use. They do this, because a lot of those functions are plain rubbish for any high-end application. We're only covering ES 1.1 here, but the Pandora also supports ES 2.0, which, leaves you with a handful of functions, you have to do all of the matrix math on your own. Which can be really hard if you're not good at maths, I'll cover how to do that in a later tutorial. What you're learning here isn't just for the Pandora, you should use these new methods in your Windows/Linux code. These changes are being made to the core OpenGL too, so you're loosing all of this stuff soon enough. Which is silly, OpenGL is good because beginners can pick it up easily. But whatever, I'm not in charge.

== The Basics ==

glBegin() and glEnd()

<source lang=cpp>

glBegin(GL_TRIANGLES);

glVertex3f(1,0,0);
glVertex3f(0,1,0);
glVertex3f(-1,0,0);

glEnd();

</source>

You know what I just did? Yeah, I drew a triangle! Nope, you can't draw stuff like this in OpenGL ES 1.1, so how would one draw a triangle in ES? Bare with me while you read this if you don't understand it, I'll explain it in depth.

<source lang=cpp>

GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, vertices);

glDrawArrays(GL_TRIANGLES, 0, 3);

glDisableClientState(GL_VERTEX_ARRAY);

</source>

This is called drawing with a vertex array. Eww? Yeah, you would never draw like that in a real program, your vertex array would be stored already, you wouldn't have to define it every time you drew somthing. While it's messy for drawing primitives, it's really cool for drawing models, because your models vertices are generally stored in arrays like that already. I'll show you an example from TINCS after I explain this code.
<source lang=cpp>
GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};
</source>
This ''should'' be obvious, we're simply creating an array that stores the vertices of our triangle. It can be of any size, you can store as many vertices as you want. Note, how I space out every three numbers, this is because a vertex is made of X,Y,Z components. So we have our X, our Y, our Z then a space for the next three. You don't have to space it like this, it's mainly so you can see what's going on.
<source lang=cpp>
glEnableClientState(GL_VERTEX_ARRAY);
</source>
We need to do this before we start drawing, this tells OGL that we're going to feed it a vertex array from the client side (rather than the server, which is the graphics card).
<source lang=cpp>
glVertexPointer(3, GL_FLOAT, 0, vertices);
</source>
Ok, here is where we're telling OGL where to get it's vertices from. The first argument, tells OGL how many components (or floats) there are per vertex. Remember we talked about how we were spacing them out every 3 numbers? Here we're telling OGL that we did that! The next argument tells OpenGL that we're giving it floating point numbers. Now we have a "0". This is called the stride, I could explain it in detail, but you don't need to understand it yet. Just leave it at 0. In the last argument we give OGL our vertex array!
<source lang=cpp>
glDrawArrays(GL_TRIANGLES, 0, 3);
</source>
Here is where the work is done. The first argument is telling OGL that we're drawing in triangles. (This can be GL_QUADS, GL_LINES, whatever!). The second is specifying where we want to start in the array we passed OGL earier. The last one is telling OpenGL how many vertices we want to draw. In this case, it's just the three.
<source lang=cpp>
glDisableClientState(GL_VERTEX_ARRAY);
</source>
Finally, we're disabling the vertex array state. We're done!

So this is one of the ways to draw stuff in OpenGL. It's the next step up from glBegin and glEnd and it works fine in ES 1.1, so it works fine on the Pandora!

== Drawing Textured Quads ==

OpenGL can be great for speeding up your 2D application. One of the ways you do this, is by drawing with OpenGL rather than SDL. 2D games are made up of lots of sprites, which are just images that move about in a 2D world. You can use hardware acceleration to speed this up. If you're only planning on using 3D stuff on the Pandora, read this anyway, it introduces you to texturing with texture arrays and you're probably going to need to use sprites somewhere anyway.

So, we can pick apart my method of sprite drawing in TINCS for this tutorial, I mainly use this function to draw text, once it's been rendered by SDL_ttf and converted into a OpenGL texture, but never mind any of that.

<source lang=cpp>
static void DrawSprite(GLuint sprite, float X, float Y, float Z, float W, float H)
{
glLoadIdentity();

glBindTexture(GL_TEXTURE_2D,sprite);

GLfloat box[] = {X,Y + H,Z, X + W,Y + H,Z, X + W, Y, Z, X,Y,Z};
GLfloat tex[] = {0,0, 1,0, 1,1, 0,1};

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);

glVertexPointer(3, GL_FLOAT, 0,box);
glTexCoordPointer(2, GL_FLOAT, 0, tex);

glDrawArrays(GL_QUADS,0,4);

glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
</source>
Give it a good read, make sure you understand all of the stuff we've been over before and how it's applied in this example!

[[Category:Development]]

GLES

2009-02-21T19:43:57Z

Butterman:

''Please don't skim over this tutorial, then just email me because you don't understand something. This tutorial has to be read in its entirety or you wont get it. If you're not up for that, then go find some other code you can copy paste, ya lazy bum. If you do have questions, I hang around on #TINCS in "irc.quakenet.org" or you can email me on "jack@sorok.co.uk"''

== Introduction ==
Unfortunately, the OpenGL ES takes away many of the functions that beginner programmers use. They do this, because a lot of those functions are plain rubbish for any high-end application. We're only covering ES 1.1 here, but the Pandora also supports ES 2.0, which, leaves you with a handful of functions, you have to do all of the matrix math on your own. Which can be really hard if you're not good at maths, I'll cover how to do that in a later tutorial. What you're learning here isn't just for the Pandora, you should use these new methods in your Windows/Linux code. These changes are being made to the core OpenGL too, so you're loosing all of this stuff soon enough. Which is silly, OpenGL is good because beginners can pick it up easily. But whatever, I'm not in charge.

== The Basics ==

glBegin() and glEnd()

<source lang=cpp>

glBegin(GL_TRIANGLES);

glVertex3f(1,0,0);
glVertex3f(0,1,0);
glVertex3f(-1,0,0);

glEnd();

</source>

You know what I just did? Yeah, I drew a triangle! Nope, you can't draw stuff like this in OpenGL ES 1.1, so how would one draw a triangle in ES? Bare with me while you read this if you don't understand it, I'll explain it in depth.

<source lang=cpp>

GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, vertices);

glDrawArrays(GL_TRIANGLES, 0, 3);

glDisableClientState(GL_VERTEX_ARRAY);

</source>

This is called drawing with a vertex array. Eww? Yeah, you would never draw like that in a real program, your vertex array would be stored already, you wouldn't have to define it every time you drew somthing. While it's messy for drawing primitives, it's really cool for drawing models, because your models vertices are generally stored in arrays like that already. I'll show you an example from TINCS after I explain this code.
<source lang=cpp>
GLfloat vertices[] = {1,0,0, 0,1,0, -1,0,0};
</source>
This ''should'' be obvious, we're simply creating an array that stores the vertices of our triangle. It can be of any size, you can store as many vertices as you want. Note, how I space out every three numbers, this is because a vertex is made of X,Y,Z components. So we have our X, our Y, our Z then a space for the next three. You don't have to space it like this, it's mainly so you can see what's going on.
<source lang=cpp>
glEnableClientState(GL_VERTEX_ARRAY);
</source>
We need to do this before we start drawing, this tells OGL that we're going to feed it a vertex array from the client side (rather than the server, which is the graphics card).
<source lang=cpp>
glVertexPointer(3, GL_FLOAT, 0, vertices);
</source>
Ok, here is where we're telling OGL where to get it's vertices from. The first argument, tells OGL how many components (or floats) there are per vertex. Remember we talked about how we were spacing them out every 3 numbers? Here we're telling OGL that we did that! The next argument tells OpenGL that we're giving it floating point numbers. Now we have a "0". This is called the stride, I could explain it in detail, but you don't need to understand it yet. Just leave it at 0. In the last argument we give OGL our vertex array!
<source lang=cpp>
glDrawArrays(GL_TRIANGLES, 0, 3);
</source>
Here is where the work is done. The first argument is telling OGL that we're drawing in triangles. (This can be GL_QUADS, GL_LINES, whatever!). The second is specifying where we want to start in the array we passed OGL earier. The last one is telling OpenGL how many vertices we want to draw. In this case, it's just the three.
<source lang=cpp>
glDisableClientState(GL_VERTEX_ARRAY);
</source>
Finally, we're disabling the vertex array state. We're done!

So this is one of the ways to draw stuff in OpenGL. It's the next step up from glBegin and glEnd and it works fine in ES 1.1, so it works fine on the Pandora!

== Drawing Textured Quads ==

OpenGL can be great for speeding up your 2D application. One of the ways you do this, is by drawing with OpenGL rather than SDL. 2D games are made up of lots of sprites, which are just images that move about in a 2D world. You can use hardware acceleration to speed this up. If you're only planning on using 3D stuff on the Pandora, read this anyway, it introduces you to texturing with texture arrays and you're probably going to need to use sprites somewhere anyway.

So, we can pick apart my method of sprite drawing in TINCS for this tutorial, I mainly use this function to draw text, once it's been rendered by SDL_ttf and converted into a OpenGL texture, but never mind any of that.

<source lang=cpp>
static void DrawSprite(GLuint sprite, float X, float Y, float Z, float W, float H)
{
glLoadIdentity();

glBindTexture(GL_TEXTURE_2D,sprite);

GLfloat box[] = {X,Y + H,Z, X + W,Y + H,Z, X + W, Y, Z, X,Y,Z};
GLfloat tex[] = {0,0, 1,0, 1,1, 0,1};

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);

glVertexPointer(3, GL_FLOAT, 0,box);
glTexCoordPointer(2, GL_FLOAT, 0, tex);

glDrawArrays(GL_QUADS,0,4);

glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
</source>
Give it a good read, make sure you understand all of the stuff we've been over before and how it's applied in this example!

[[Category:Development]]

GLES

2009-02-20T19:04:19Z

Butterman:

GLES

2009-02-17T20:38:52Z

Butterman:

GLES

2009-02-17T18:46:26Z

Butterman:

GLES

2009-02-17T14:48:49Z

Butterman:

Development

2009-02-17T13:49:36Z

Butterman:

==Getting your code onto the Pandora==

*[[Setting up a cross-compiler]]

==Other==

*[[PXML|PXML file structure guide]]

[[Category:Development]]

Development

2009-02-17T13:49:25Z

Butterman:

==Getting your code onto the Pandora==

*[[Setting up a cross-compiler]]

==Other==

[[PXML|PXML file structure guide]]

*[[Category:Development]]

Development tutorials

2009-02-17T13:49:07Z

Butterman:

== SDL Tutorials ==

These tutorials assume you know the basics of C++ programming, and know your way around a C++ compiler.

* [http://www.lazyfoo.net/SDL_tutorials/index.php Lazy Foo's Tutorials]. Not Pandora specific, but a good guide to getting your programming environment set up, along with many SDL tutorials.
* [http://iki.fi/sol/gp/ Sol's Graphics for beginners]. Not Pandora specific, but a good place to get started with SDL graphics coding.

==OpenGL on the Pandora==

*[[OpenGL ES 1.1 Tutorial]]

*[[OpenGL ES 2.0 Tutorial]]

*[[Combining OpenGL ES 1.1 and SDL to create a window on the Pandora]]

== The Kernel ==
* [[Kernel build instructions|Compiling the Kernel from Git]]
* [[Kernel interface|Kernel Interface]]

== Matchbox Window Manager ==

* [[Matchbox|Matchbox version]]
* [[xoo on ubuntu|Setting up xoo on Ubuntu 8.04/8.10]] (Theme Testing and Development)

== See Also ==

* [[Development Tools]]

[[Category:Development]]

Development

2009-02-17T13:48:45Z

Butterman:

==Getting your code onto the Pandora==

[[Setting up a cross-compiler]]

==Other==

[[PXML|PXML file structure guide]]

[[Category:Development]]

Cross-compiler

2009-02-17T13:47:53Z

Butterman:

''I'm still sorting this out myself, I'm going to give a short tutorial about compiling something from the Windows command line, the rest will be explained when the Pandora is released''

What you need:

- Patience

To compile your applications to the ARM architecture you're going to need a cross-compiler. Luckily, Code-Sourcery hosts a bunch of cross-compiling suites for various platforms on their site, some editions have to be paid for, but they do have "lite" editions without support that are completely free.

Head up onto here, http://www.codesourcery.com/sgpp/lite/arm/releases/2007q3

You want the "ARM GNU/Linux" option, then choose whichever operating system you're running bellow.

Development

2009-02-17T13:45:43Z

Butterman: /* OpenGL on the Pandora */

==Getting your code onto the Pandora==

[[Setting up a cross-compiler]]

==OpenGL on the Pandora==

[[OpenGL ES 1.1 Tutorial]]

[[OpenGL ES 2.0 Tutorial]]

[[Combining OpenGL ES 1.1 and SDL to create a window on the Pandora]]

==Other==

[[PXML|PXML file structure guide]]

[[Category:Development]]

Development

2009-02-17T13:45:29Z

Butterman:

==Getting your code onto the Pandora==

[[Setting up a cross-compiler]]

==OpenGL on the Pandora==

[[OpenGL ES 1.1 Tutorial]]
[[OpenGL ES 2.0 Tutorial]]
[[Combining OpenGL ES 1.1 and SDL to create a window on the Pandora]]

[[PXML|PXML file structure guide]]

[[Category:Development]]

Development

2009-02-17T13:44:43Z

Butterman:

==Getting your code onto the Pandora==

[[Setting up a cross-compiler]]

==OpenGL on the Pandora==

[[OpenGL ES 1.1 Tutorial]]

[[PXML|PXML file structure guide]]

[[Category:Development]]

GLES

2009-02-17T13:42:38Z

Butterman:

GLES

2009-02-17T13:41:05Z

Butterman: New page: ''Please don't skim over this tutorial, then just email me because you don't understand something. This tutorial has to be read in its entirety or you wont get it. If you're not up for tha...

Development

2009-02-17T12:55:53Z

Butterman:

[[Setting up a cross-compiler]]

[[OpenGL ES 1.1 Tutorial]]

[[PXML|PXML file structure guide]]

[[Category:Development]]

Cross-compiler

2009-02-17T12:50:57Z

Butterman:

What you need:

- Patience

To compile your applications to the ARM architecture you're going to need a cross-compiler. Luckily, Code-Sourcery hosts a bunch of cross-compiling suites for various platforms on their site, some editions have to be paid for, but they do have "lite" editions without support that are completely free.

Head up onto here, http://www.codesourcery.com/sgpp/lite/arm/releases/2007q3

You want the "ARM GNU/Linux" option, then choose whichever operating system you're running bellow.

Cross-compiler

2009-02-17T12:50:26Z

Butterman: /* Setting up a cross compiler */

<nowiki>What you need:
- Patience
</nowiki>

To compile your applications to the ARM architecture you're going to need a cross-compiler. Luckily, Code-Sourcery hosts a bunch of cross-compiling suites for various platforms on their site, some editions have to be paid for, but they do have "lite" editions without support that are completely free.

Head up onto here, http://www.codesourcery.com/sgpp/lite/arm/releases/2007q3

You want the "ARM GNU/Linux" option, then choose whichever operating system you're running bellow.

Cross-compiler

2009-02-17T12:50:08Z

Butterman: New page: == Setting up a cross compiler == What you need: - Patience To compile your applications to the ARM architecture you're going to need a cross-compiler. Luckily, Code-Sourcery hosts a bu...

== Setting up a cross compiler ==

What you need:
- Patience

To compile your applications to the ARM architecture you're going to need a cross-compiler. Luckily, Code-Sourcery hosts a bunch of cross-compiling suites for various platforms on their site, some editions have to be paid for, but they do have "lite" editions without support that are completely free.

Head up onto here, http://www.codesourcery.com/sgpp/lite/arm/releases/2007q3

You want the "ARM GNU/Linux" option, then choose whichever operating system you're running bellow.

Development

2009-02-17T12:41:16Z

Butterman:

[[Setting up a cross-compiler]]

[[PXML|PXML file structure guide]]

[[Category:Development]]