Ok, so I am missing the connection between getting an abstract object translated to an on-screen rendering.

I am working on a 2d test game. I want to have a little helicopter point to the screen where I touch and fly there.

I can get a rectangle with the helicopter projected onto it. I can translate and rotate this square. I can also keep track of a point that is "the helicopter" but I am having trouble figuring out how to sync the 'helicopter point' and the image of the helicopter on the screen.

When the helicopter moves, should I be using the glTranslate function to also move the helicopter drawing? Or should I just update the coordinates of the vertices of the helicopter?

Likewise, how should I handle the rotation of the square to keep it facing my finger? Is the best way to do this to draw it on the origin, rotate it, then translate it to the proper location?

This seems to be a missing step in a lot of the opengl tutorials and advice or links to good information would really be appreciated.

Thanks
Justin

There are four coordinate spaces you are dealing with. To make this easy, think of it this way.

First you have your helecopter, which consists of vertices for the quad and texture vertices for how to put your helicopter texture onto the quad. Both of these sets of coordinates are created ONCE at initialization of your application. They are relative to zero, with zero being the center of your quad whereever it eventually ends up in the scene.

Next you have what I call world coordinates. This the relative location of your helicopter object in the world. Basically, it is the x,y,z location of your object relative to world space.

Finally you have screen coordinates. These are the coordinates of your touch event relative to the screen size.

Generally, I like to have two objects for stuff in my game. A Mesh object that has the information in (1) above in it (vertices, texture vertices, and indices) and an GameObj that has the position of the actual object in it as in (2) above (world coordinates, velocity, acceleration, etc). The stuff in the Mesh Object never changes. You modify the GameObj to move your thing around.

To move your helicopter to the point of the screen touch you do this:

1) Convert your screen coordinates to world coordinates. This you have to do yourself by creating your own translation.
2) Set your helicopter coordinates to the world coordinates that you calculated in step 1 if you just want to jump it to there. Or you can use a velocity vector to slowly move it there if you want.
3) Tell GL to translate based on the world coordinates of your GameObj. Position in the code below is the position of your helicopter GameObj in world coordinates. Mesh is the object that you are storing your quad vertices and texture vertices in.

Code: Select all

public class Obj {
   public void draw(GL10 gl)
   {
      gl.glPushMatrix();
      gl.glTranslatef(position.x,position.y,position.z);
      mesh.draw(gl);
      gl.glPopMatrix();
   }

4) Render your helicopter. All vertices should be translated properly because you have pushed a translation matrix onto the model stack to do these translations in step 3 above.

Code: Select all

public class Mesh {
   public void draw(GL10 gl) {
      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, verticesBuffer);
      gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, tverticesBuffer);
      gl.glDrawElements(GL10.GL_TRIANGLES, numOfIndices,
            GL10.GL_UNSIGNED_SHORT, indicesBuffer);

   }

Note that there are also view matrix that you have to set up to give the proper view into your world coordinates, but from your description, you have that figured out already. For a 2D game, you don't have to move your view generally.

If you have a scrolling game, you probably shouldn't scroll by moving your view. Rather, you should scroll by having a higher level model matrix translation for the scroll and then rendering your GameObjs making sure you properly push and pop the matrixes as in the code above.

Hope this helps.

Thank you, this is the type of thing I am looking for. I just have a couple follow up question.

For these functions is GL_MODELVIEW or is GL_PROJECTION set?

In the Obj.draw function, wont the glTranslatef move the helicopter to a position relative to its current location rather than to the absolute world coordinates?

Then, if I were to want to rotate the helicopter, I assume I would do that in the Obj.draw immediately before the Translatef call?

Thanks again!

Resilient wrote:Thank you, this is the type of thing I am looking for. I just have a couple follow up question.

For these functions is GL_MODELVIEW or is GL_PROJECTION set?

In the Obj.draw function, wont the glTranslatef move the helicopter to a position relative to its current location rather than to the absolute world coordinates?

Then, if I were to want to rotate the helicopter, I assume I would do that in the Obj.draw immediately before the Translatef call?

Thanks again!

GL_MODELVIEW is set.

I am suggesting that you don't move your viewport at all. So, in your init routine, you set up your GL_PROJECTION and then leave it. You don't need to touch it again for a 2D game, and generally don't need to for a 3D game either.

Then you set GL_MODELVIEW and leave it set from that point forward. You don't need to reset it each frame generally.

Regarding Obj.Draw, no it should move it relative to the world coordinates. That is what the glPushMatrix and glPopMatrix are doing for you. GL works with a matrix stack. You can push the current modelview matrix onto the stack and pop it off later. So, assuming that the modelview matrix is the identity matrix initially (no translation) then when you call draw, the routine pushes the current matrix (identity) onto the stack, performs a translation, renders your object, and then pops the last stored matrix off of the stack (back to identity). Each time you call draw you are temporarily translating for the particular object and then restoring the matrix back to what it was when the call was made. So, no you don't get any accumulation.

Regarding where to rotate. This is an interesting question. In 3D stuff, you almost always want to rotate before you translate. This is the equivelent of spinning the object around its own center of gravity (origin) and then moving it to where it should be. If you did it in the other order, then you are moving it first and then rotating it in a big arc around the origin which is probably not what you are going for. So, conceptually, you want to rotate first.

That said, in GL this means that you translate first and then rotate, because gl does the matrix multiplications in reverse.

Code: Select all

   public void draw(GL10 gl)
   {
      gl.glPushMatrix();
      gl.glTranslatef(position.x,position.y,position.z);
      rotate(gl);
      mesh.draw(gl);
      gl.glPopMatrix();
   }

Got it?

Great, I got it working. Thanks so much for the help, this is just what I needed!

I'd love to see the code, as I too am following along with pretty much exactly these questions ..

To be clear, this is not good code, it is barely functional code that was written just to see if I could get stuff to work. I am sure you will be sorry if you copy it and expect it to do anything


Two helicopters just follow your finger around.


Here is the main activity


Here is the renderer
I make a couple helicopters in this code


Here is what is essentially the helicopter abstraction


And here is the visual representation of the helicopter


Again, not good code, but hopefully you can get something from it.

Again, not good code, but hopefully you can get something from it.

Hey, it works fine and demonstrates what we're talking about, so in my opinion its good code!

Thank you for making my afternoon hacking on Android interesting .. you've definitely given me a leg-up on understanding the issues with doing 3D on Android, so thanks!