OpenGl ES 2.0. Некорректный поворот объекта

package com.contedevel.easygame.render;
 
import android.content.Context;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
import android.util.Log;
 
import com.contedevel.easygame.core.EasySceneManager;
import com.contedevel.easygame.objects.EasyRealObject;
import com.contedevel.easygame.objects.EasySquare;
import com.contedevel.easygame.utils.EasyColor;
import com.contedevel.easygame.utils.EasySettings;
import com.contedevel.easygame.utils.IEasyEnumerator;
 
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
 
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
 
/**
 * Created by ConteDevel on 11.11.2014. Author Sologub D.S.
 */
public class EasyRenderer implements GLSurfaceView.Renderer {
    public static final String TAG = EasyRenderer.class.getSimpleName();
    private Context context;
    static final int COORDS_PER_VERTEX = 3;
    private EasySettings settings;
    private EasySceneManager sceneManager;
    private FPSCounter counter;
    private EasyCache cache = null;
    private ShortBuffer drawListBuffer;
    private final short drawOrder[] = { 0, 1, 2, 0, 2, 3 };
 
    // mMVPMatrix is an abbreviation for "Model View Projection Matrix"
    private final float[] mvpMatrix = new float[16];
    private final float[] projectionMatrix = new float[16];
    private final float[] viewMatrix = new float[16];
    private final float[] rotationMatrix = new float[16];
    private int programHandle;
 
    public EasyRenderer(Context context, EasySettings settings, final EasySceneManager sceneManager) {
        if(settings == null)
            throw new NullPointerException("EasySettings cannot be null!");
        this.settings = settings;
 
        if(context == null)
            throw new NullPointerException("Context cannot be null!");
        this.context = context;
 
        if(sceneManager == null)
            throw new NullPointerException("EasySceneManager cannot be null!");
        this.sceneManager = sceneManager;
        if(this.sceneManager.count() > 0)
            cache = new EasyCache(sceneManager.top());
        this.sceneManager.setListener(new EasySceneManager.IEasySceneManagerListener() {
            @Override
            public void onSceneChange() {
                cache = new EasyCache(sceneManager.top());
            }
        });
    }
 
    @Override
    public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig) {
        // Set the background frame color
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        // initialize byte buffer for the draw list
        ByteBuffer dlb = ByteBuffer.allocateDirect(12);
        dlb.order(ByteOrder.nativeOrder());
        drawListBuffer = dlb.asShortBuffer();
        drawListBuffer.put(drawOrder);
        drawListBuffer.position(0);
        // prepare shaders and OpenGL program
        String vertexShader =
                EasyShader.loadShader(EasyShader.VERTEX_SHADER, context);
        String fragmentShader =
                EasyShader.loadShader(EasyShader.FRAGMENT_SHADER, context);
        programHandle = EasyShader.compileProgram(vertexShader, fragmentShader);
        counter = new FPSCounter();
    }
 
    @Override
    public void onSurfaceChanged(GL10 gl10, int width, int height) {
        // Adjust the viewport based on geometry changes,
        // such as screen rotation
        GLES20.glViewport(0, 0, width, height);
 
        float ratio = (float) width / height;
 
        // this projection matrix is applied to object coordinates
        // in the onDrawFrame() method
        Matrix.frustumM(projectionMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
    }
 
    @Override
    public void onDrawFrame(GL10 gl10) {
        float[] scratch = new float[16];
        // Draw background color
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
        // Set the camera position (View matrix)
        Matrix.setLookAtM(viewMatrix, 0, 0, 0, -3.0f, 0, 0, 0, 0.0f, 1.0f, 0.0f);
        if(cache != null) {
            cache.update();
            IEasyEnumerator<EasyCache.EasyCacheItem> i = cache.getCacheEnumerator();
            i.moveToFirst();
            do {
                EasyRealObject object = i.get().object;
                Matrix.translateM(viewMatrix, 0, -object.getX(), object.getY(), 0);
                Matrix.scaleM(viewMatrix, 0, object.getScaleX(), object.getScaleY(), 0);
                Matrix.rotateM(viewMatrix, 0, object.getAngle(), 0, 0, 1.0f);
                // Calculate the projection and view transformation
                Matrix.multiplyMM(mvpMatrix, 0, projectionMatrix, 0, viewMatrix, 0);
                draw(((EasySquare)object).getColor(), i.get().buffer, drawListBuffer);
            } while (i.moveToNext());
        }
        counter.logFrame();
    }
 
    public static void checkGlError(String glOperation) {
        int error;
        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
            Log.e(TAG, glOperation + ": glError " + error);
            throw new RuntimeException(glOperation + ": glError " + error);
        }
    }
 
    private void draw(EasyColor color, FloatBuffer vertexBuffer, ShortBuffer drawListBuffer) {
        final int vertexStride = COORDS_PER_VERTEX * 4;
        // Add program to OpenGL environment
        GLES20.glUseProgram(programHandle);
 
        // get handle to vertex shader's vPosition member
        int positionHandle = GLES20.glGetAttribLocation(programHandle, "vPosition");
 
        // Enable a handle to the triangle vertices
        GLES20.glEnableVertexAttribArray(positionHandle);
 
        // Prepare the triangle coordinate data
        GLES20.glVertexAttribPointer(
                positionHandle, COORDS_PER_VERTEX,
                GLES20.GL_FLOAT, false,
                vertexStride, vertexBuffer);
 
        // get handle to fragment shader's vColor member
        int colorHandle = GLES20.glGetUniformLocation(programHandle, "vColor");
 
        // Set color for drawing the triangle
        GLES20.glUniform4fv(colorHandle, 1, color.getColor(), 0);
 
        // get handle to shape's transformation matrix
        int mvpMatrixHandle = GLES20.glGetUniformLocation(programHandle, "uMVPMatrix");
        EasyRenderer.checkGlError("glGetUniformLocation");
 
        // Apply the projection and view transformation
        GLES20.glUniformMatrix4fv(mvpMatrixHandle, 1, false, mvpMatrix, 0);
        EasyRenderer.checkGlError("glUniformMatrix4fv");
 
        // Draw the square
        GLES20.glDrawElements(
                GLES20.GL_TRIANGLES, drawOrder.length,
                GLES20.GL_UNSIGNED_SHORT, drawListBuffer);
 
        // Disable vertex array
        GLES20.glDisableVertexAttribArray(positionHandle);
    }
 
    public static class FPSCounter {
        long startTime = System.nanoTime();
        int frames = 0;
 
        public void logFrame() {
            frames++;
            if(System.nanoTime() - startTime >= 1000000000) {
                Log.d("FPSCounter", "fps: " + frames);
                frames = 0;
                startTime = System.nanoTime();
            }
        }
    }
}