4

I'm writing my first 2D app for Android using OpenGL. I'm writing it on my Desire, so my screen coords should be 0,0 to 799,479 in landscape mode. I'm trying to get OpenGL to use this range in world coordinates.

The app, such as it is, is working fine so far, but I've had to tweak numbers to get stuff to appear on the screen and I'm frustrated by my inability to understand the relationship between the projection matrix, and the rendering of textures in this regard.

Setting the projection matrix:

gl.glViewport(0, 0, width, height); float ratio = (float) width / height; float size = .01f * (float) Math.tan(Math.toRadians(45.0) / 2); gl.glMatrixMode(GL10.GL_PROJECTION); gl.glLoadIdentity(); gl.glFrustumf(-size, size, -size / ratio, size / ratio, 0.01f, 100.0f); // GLU.gluOrtho2D(gl, 0,width, 0, height);

I want to understand 0.01f and 100.0f here. What do I use to describe a 2D world of 0,0 -> 799,479 with a z value of zero?

Also, I'm not sure what is 'best' - using glFrustumF or GLU.gluOrtho2D The latter has simpler parameters - just the dimensions of the viewport - but I've not got anywhere with that. (Some sites have height and 0 the other way around but that makes no difference.) But shouldn't this be the natural choice for 2D usage of OpenGL? Do I have to set something somewhere to say to OpenGL "I'm doing this in 2D - please disregard the third dimension everywhere, in the interests of speed"?

Drawing my textures:

I'm drawing stuff using 2 textured triangles. The relevant parts of my init (let me know if I need to edit my question with more detail) are:

gl.glMatrixMode(GL10.GL_MODELVIEW); gl.glLoadIdentity(); gl.glTranslatex(nXpos, nYpos, nZoomin); gl.glRotatef(nRotZ, 0, 0, 1); gl.glScalef((float)nScaleup,(float)nScaleup, 0.0f); ... ... gl.glVertexPointer(2, GL10.GL_FIXED, 0, mVertexBuffer); gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, mTextureBuffer); gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4); mVertexBuffer is an IntBuffer and contains: int vertices[] = { -1, -1, 1, -1, -1, 1, 1, 1 };

I don't intend, ultimately, to have to pass in nZoomin - I've done it this way because it was how I found the 'magic numbers' needed to actually see anything! Currently I need to use -1000 there, with smaller numbers resulting in smaller images. Am I right in thinking there must be some way of having a value of zero for nZoomin when the projection matrix is set correctly?

My textures are currently 128x128 (but may end up being different sizes, perhaps always square though). I have no way of knowing when they're being displayed at actual size currently. I'd like to be able to pass in a value of, say, 128 for nScaleup to have it plotted at actual size. Is this related to the projection matrix, or do I have two separate issues?

Improve this question
1
  • For pure 2D, you might be better off using Canvas instead of OpenGL. It's a lot easier to use, and (apparently) not much slower. Commented Feb 6, 2011 at 18:06

2 Answers 2

Reset to default
8

If you're working in 2D, you don't need glFrustum, just use glOrtho. Something like this:

void glOrthof(0, 800, 0, 480, -1, 1);

That'll put the origin at the bottom left. If you want it at the top left, use:

void glOrthof(0, 800, 480, 0, -1, 1);

For 480 and 800, you should obviously substitute the actual size of your view, so your app will be portable to different screen sizes and configurations.

I'm passing -1 and 1 for the z range, but these don't really matter, because the orthogonal projection puts (x, y, z) on the same place on the screen, no matter the value of z. (near and far must not be equal, though.) This is the only way to tell OpenGL to ignore the z coordinate; there is no specific "2D" mode, your matrices are still 4x4, and 2-dimensional vertices will receive a z coordinate of 0.

Note that your coordinates do not range from 0 to 799, but really from 0 to 800. The reason is that OpenGL interprets coordinates as lying between pixels, not on them. Think of it like a ruler of 30 cm: there are 30 intervals of a centimetre on it, and the ticks are numbered 0-30.

The vertex buffer you're using doesn't work, because you're using GL_FIXED format. That means 16 bits before the decimal point, and 16 bits after it, so to specify a 2x2 square around the origin, you need to multiply each value by 0x10000:

int vertices[] = { -0x10000, -0x10000, 0x10000, -0x10000, -0x10000, 0x10000, 0x10000, 0x10000 };

This is probably the reason why you need to scale it so much. If you use this array, without the scaling, you should get a 2x2 pixel square. Turning this into a 1x1 square, so the size can be controlled directly by the scale factor, is left as an exercise to the reader ;)

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

This is great - I'm almost there.
Oddly, the parameters to glTranslatex now need to be fixed-point; for example 300<<16, as opposed to 300 as before. I guess this is because of the change to vertices[], not the projection matrix.
It should've been like that all along. Any OpenGL call ending in x expects fixed-point arguments.
I started using fixed for everything, because I assumed it would be faster. Then I used float in a few places as part of fixing problems. Now it's working better I might revert back. But yes, I was scaling up to compensate for too-small numbers. Incidentally, is the 800 in your second glOrthof example correct, or should it be zero? (I'm using the first, because I like the origin in the lower left). Thanks for all your help, by the way!
I have tried the second example and it just flips everything upside down
2

Do I have to set something somewhere to say to OpenGL "I'm doing this in 2D

I think the problem is that you're using a projection matrix for perspective projection. Instead you should use parallel projection. To get this matrix you can use the glOrtho() function. 

gl.glMatrixMode(GL10.GL_PROJECTION); ... gl.glOrtho(0, width, 0, height, 0, 128);

Now the z-value have no influence over an object's size anymore.

I want to understand 0.01f and 100.0f here. What do I use to describe a 2D world of 0,0 -> 799,479 with a z value of zero?

It's right that in a 2D world, you don't really have about z-values. But you have to decide which of your objects you want to draw at first. There are two ways to decide that:

  1. Deactivate GL_DEPTH_TEST and everything is drawn in the order you choose
  2. Activate GL_DEPTH_TEST and let OpenGL decide
Improve this answer

Comments