Implement the Fixed function Pipeline efficent in OpenGL ES 2.0?

Question

I want to use fixed function methods like glTranslate(), glRotate(), glScale() in my openGL 2.0 App. I know, that I need to implement an matrix class - and have done this. My question now is about efficiency. To be able to use something like:

glLoadIdentity();
glRotatef(2.0f, 0.0f, 0.0f, 1.0f);
glScalef(2.0f, 2.0f, 2.0f);

I think, I need to do at least 3 matrix multiplications (assuming we have a projection and a modelview matrizes and this is for the modelview). First would be: Identity-Matrix*Rotation-Matrix - Second is: ActualMatrix*ScaleMatrix and the last would be: projectionMatrix*ActualMatrix (and this Im passing as uniform value to my shader).

glUniformMatrix4fv(uniforms[UNIFORM_MODELVIEW_PROJECTION_MATRIX], 1, GL_FALSE, matrix->getProjectionModelviewMatrix());

So my Vertexshader looks like:

attribute vec4 position;
attribute vec4 color;

varying vec4 colorVarying;

uniform mat4 modelViewProjectionMatrix;

void main()
{
    gl_Position = modelViewProjectionMatrix * position;
    colorVarying = color;
}

Is it done the same way in OpenGL ES 1.1? It seems like, I need one matrix multiplication vor every: glRotate, glScale, glTranslate... Call - that seems very much for me. Or is there a better way? (maybe with less matrix multiplications?)

Any help on this topic would be highly appreciated! Thank you for reading

Answer 1

Identity, translation, rotation, and scaling matrices don’t require a full matrix multiplication to apply, because many of the terms are always 0.0 or 1.0. If you write out the element-by-element results of multiplying other matrices by these matrices, you’ll see that many elements may only have a few terms contributing to their final values. Two simple examples:

• Given the identity matrix I and an arbitrary matrix M, I × M = M × I = M.
• The only non-zero elements in a scaling matrix S are the four along the diagonal, which we’ll call S₀, S₁, S₂, and S₃. (S₃ is always 1.0 for something like glScalef.) S × M scales the n^th row of M by S_n. M × S works column-by-column instead. You can also think of the identity matrix as a particularly boring scaling matrix.

The resulting element-by-element expressions for translations and rotations are a bit more complicated than these examples, but still greatly simpler than a full matrix multiplication. (Rotations also get a great deal simpler if the axis of rotation is exactly aligned with the X, Y, or Z axis.) You’ll probably want to look into modifying matrices directly when asked to translate, scale, or rotate, rather than constructing another matrix and multiplying.

Answer 2

Check out this: http://glm.g-truc.net/about.html