I am doing frame based animation for 300 frames in opengl es 2.0

I want a rectangle to translate by +200 pixels in X axis and also scaled up by double (2 units) in the first 100 frames

Then, the animated rectangle has to stay there for the next 100 frames.

Then, I want the same animated rectangle to translate by +200 pixels in X axis and also scaled down by half (0.5 units) in the last 100 frames.

I am using simple linear interpolation to calculate the delta-animation value for each frame.

Pseudo code:

The below drawFrame() is executed for 300 times (300 frames) in a loop.

float RectMVMatrix[4][4] = {1, 0, 0, 0,
                            0, 1, 0, 0,
                            0, 0, 1, 0,
                            0, 0, 0, 1
                           };   // identity matrix
int totalframes = 300;
float translate-delta;  // interpolated translation value for each frame
float scale-delta;  // interpolated scale value for each frame

// The usual code for draw is:
void drawFrame(int iCurrentFrame)
{
 // mySetIdentity(RectMVMatrix); // comment this line to retain the animated position.
  mytranslate(RectMVMatrix, translate-delta, X_AXIS); // to translate the mv matrix in x axis by translate-delta value
  myscale(RectMVMatrix, scale-delta); // to scale the mv matrix  by scale-delta value
  ... // opengl calls 
  glDrawArrays(...);
  eglswapbuffers(...);
}

The above code will work fine for first 100 frames. in order to retain the animated rectangle during the frames 101 to 200, i removed the "mySetIdentity(RectMVMatrix);" in the above drawFrame().

Now on entering the drawFrame() for the 2nd frame, the RectMVMatrix will have the animated value of first frame

e.g. RectMVMatrix[4][4] = { 1.01, 0, 0, 2,
                            0,    1, 0, 0,
                            0,    0, 1, 0,
                            0,    0, 0, 1
                           };// 2 pixels translation and 1.01 units scaling after first frame

This RectMVMatrix is used for mytranslate() in 2nd frame. The translate function will affect the value of "RectMVMatrix[0][0]". Thus translation affects the scaling values also.

Eventually output is getting wrong.

How to retain the animated position without affecting the current ModelView matrix?

=========================================== I got the solution... Thanks to Sergio.

I created separate matrices for translation and scaling. e.g.CurrentTranslateMatrix[4][4], CurrentScaleMatrix[4][4].

Then for every frame,

I reset 'CurrentTranslateMatrix' to identity and call mytranslate( CurrentTranslateMatrix, translate-delta, X_AXIS) function.

I reset 'CurrentScaleMatrix' to identity and call myscale(CurrentScaleMatrix, scale-delta) function.

Then, I multiplied these 'CurrentTranslateMatrix' and 'CurrentScaleMatrix' to get the final 'RectMVMatrix' Matrix for the frame.

Pseudo Code:

    float RectMVMatrix[4][4] = {0};
    float CurrentTranslateMatrix[4][4] = {0};
    float CurrentScaleMatrix[4][4] = {0};
    int iTotalFrames = 300;
    int iAnimationFrames = 100;

    int iTranslate_X = 200.0f; // in pixels
    float fScale_X = 2.0f;
    float scaleDelta;
    float translateDelta_X;
    void DrawRect(int iTotalFrames)
    {
        mySetIdentity(RectMVMatrix);
        for (int i = 0; i< iTotalFrames; i++)
        {
            DrawFrame(int iCurrentFrame);
        }
    }
    void getInterpolatedValue(int iStartFrame, int iEndFrame, int iTotalFrame, int iCurrentFrame, float *scaleDelta, float *translateDelta_X)
    {
        float fDelta = float ( (iCurrentFrame - iStartFrame) / (iEndFrame - iStartFrame))

        float fStartX = 0.0f;
        float fEndX = ConvertPixelsToOpenGLUnit(iTranslate_X);
        *translateDelta_X = fStartX + fDelta * (fEndX - fStartX);

        float fStartScaleX = 1.0f;
        float fEndScaleX   = fScale_X;
        *scaleDelta  = fStartScaleX + fDelta * (fEndScaleX - fStartScaleX);
    }

    void DrawFrame(int iCurrentFrame)
    {
        getInterpolatedValue(0, iAnimationFrames, iTotalFrames, iCurrentFrame, &scaleDelta, &translateDelta_X)
        mySetIdentity(CurrentTranslateMatrix);
        myTranslate(RectMVMatrix, translateDelta_X, X_AXIS); // to translate the mv matrix in x axis by translate-delta value
        mySetIdentity(CurrentScaleMatrix);
        myScale(RectMVMatrix, scaleDelta); // to scale the mv matrix  by scale-delta value
        myMultiplyMatrix(RectMVMatrix, CurrentTranslateMatrix, CurrentScaleMatrix);// RectMVMatrix = CurrentTranslateMatrix*CurrentScaleMatrix;
        ... // opengl calls 
        glDrawArrays(...);
        eglswapbuffers(...);

}

I maintained this 'RectMVMatrix' value, if there is no animation for the current frame (e.g. 101th frame onwards).

Thanks, Arun AC