OpenGL 2.0 ES coordinates

I'm doing my first steps with OpenGL ES 2.0 trying things on my ipod touch. I was wondering how to solve this coordinates issue..

To explain better, I was trying to draw a quad and rotate/translate it using a vertex shader (also because from what I've read it seems the only way to do it).

Since I'm working with a ipod I have a 1.5 : 1 ratio and a viewport set by

glViewport(0, 0, backingWidth, backingHeight);

So 0,0 is the center and bounds for clipping should be at -1.0, -1.0, -1.0, 1.0, etc (right?)

To draw a square I had to use different values for x and y coordinates because of the aspect ratio:

static const GLfloat lineV[] = {
        -0.5f, 0.33f,  0.5f, 0.33f,
         0.5f, 0.33f,  0.5f,-0.33f, 
         0.5f,-0.33f, -0.5f,-0.33f,
        -0.5f,-0.33f, -0.5f, 0.33f,
        -0.5f, 0.33f,  0.5f,-0.33f,
         0.5f, 0.33f, -0.5f,-0.33f,
    };

It's a square with both diagonals (I know that using indexes would be more efficient but that's not the point)..

Then I tried writing a vertex shader to rotate the object while moving it:

void main()
{
    m = mat4( cos(rotation), sin(rotation), 0.0, 0.0,
             -sin(rotation), cos(rotation), 0.0, 0.0,
                        0.0,           0.0, 1.0, 0.0,
                        0.0,           0.0, 0.0, 1.0);

    m2 = mat4(1.0);
    m2[1][3] = sin(rotatio开发者_运维问答n)*0.8;
    gl_Position = position*(m*m2);
}

It works but since coordinates are not the same the quad is distorted while it rotates. How should I prevent that? I thought if it was possible to change the view frustum to have different bounds (not -1.0 to 1.0 on both axis so that enlarging on y-axis would fix the problem).

In addition is there a better way to use matrixes? I mean, I was used to use glRotatef without having to specify the whole matrix.. does convenience functions/constructors exist to accomplish this task?

The first arguments to glViewport() is not the center, it's the bottom left corner's coordinates.

You should probably set up a projection that takes your aspect into account, typically using gluPerspective() (if GLU is available in ES).

No glut or support functions are provided from what I've seen. Basically I solved it by using equal coordinates when building vertices and using a vertex shader to scale on y axis by the right aspect ratio.