移动多个对象的 Android OpenGL ES 2.0 性能问题

Question

我正在为一个小型 2D 游戏编写图形。 为此，请使用 OpenGL ES 2.0。 我有一个包含构成矩形的顶点的对象。对于我需要的每一个障碍物，我都会缩放、翻译和绘制这个对象。 我这样做是为了不必为每次绘制和每个障碍上传顶点。 (“水平”一直在移动，就像飞扬的小鸟或喷气背包兜风一样) 但是现在我必须为每一帧中的每个对象上传我的矩阵。 大多数情况下，在我的 lg g2 上绘制一帧需要 5-17 毫秒。但是有每帧 100 毫秒的峰值。

此时我只绘制矩形，所以我真的不知道为什么我会遇到这些性能问题。以下是我的 ObstacleGL 类和我的渲染器的代码。

package com.example.jump;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;

import android.opengl.GLES20;
import android.opengl.Matrix;

public class ObstacleGL {
    static final int COORDS_PER_VERTEX = 3;
    static final int vertexStride = COORDS_PER_VERTEX * 4;
    private static final String vertexShaderCode =
            "uniform mat4 uMVPMatrix;                   \n" +
            "attribute vec4 vPosition;                  \n" +
            "attribute vec4 color;                      \n" +
            "varying vec4   fragColor;                  \n"+
            "void main() {                              \n" +
            "   gl_Position = uMVPMatrix * vPosition;   \n" +
            "   fragColor = color;                      \n"+
            "}";
    private static final String fragmentShaderCode =
            "precision mediump float;   \n" +
            "varying vec4 fragColor;    \n" +
            "void main() {              \n" +
            "  gl_FragColor = fragColor;\n" +
            "}";

    private  float [] coords={
            //x,y,z   z=0
            -1,1,0,         //upper left
            -1,-1,0,                //bottom left
            1,-1,0,         //upper right
            1,1,0  //bottom right
    };
    private  final short[] drawOrder = { 0, 1, 2, 0, 2, 3 };
    private  int fragmentShader;
    private  int vertexShader;
    private  int mProgram;
    private  float[] color={0.33f,1f,0.33f,0.5f};
    private  int colorHandle;
    private  int positionHandle;    
    private  FloatBuffer vertexBuffer;
    private  ShortBuffer drawListBuffer;
    private int matrixHandle;
    private int vertexCount;
    private float[] translationMatrix=new float[16];
    private float[] scaleMatrix=new float[16];


    public void initialize(){

        fragmentShader=GameRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER,fragmentShaderCode);
        vertexShader=GameRenderer.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        ByteBuffer bb;
        ByteBuffer dlb;
        bb= ByteBuffer.allocateDirect(coords.length*4);
        bb.order(ByteOrder.nativeOrder());
        vertexBuffer=bb.asFloatBuffer();
        vertexBuffer.put(coords);
        vertexBuffer.position(0);

        dlb=ByteBuffer.allocateDirect(12); //drawOrder.length*2
        dlb.order(ByteOrder.nativeOrder());
        drawListBuffer=dlb.asShortBuffer();
        drawListBuffer.put(drawOrder);
        drawListBuffer.position(0);

        mProgram=GLES20.glCreateProgram();
        GLES20.glAttachShader(mProgram, vertexShader);
        GLES20.glAttachShader(mProgram, fragmentShader);
        GLES20.glLinkProgram(mProgram);
        colorHandle=GLES20.glGetAttribLocation(mProgram, "color");
        positionHandle=GLES20.glGetAttribLocation(mProgram, "vPosition");
        matrixHandle=GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");


        GLES20.glVertexAttrib4fv(colorHandle, color, 0);

        GLES20.glEnableVertexAttribArray(positionHandle);
        GLES20.glVertexAttribPointer(positionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false,vertexStride , vertexBuffer);
        GLES20.glDisableVertexAttribArray(positionHandle);



    }

    public ObstacleGL()
    {
        vertexCount=coords.length/COORDS_PER_VERTEX;
        Matrix.setIdentityM(translationMatrix, 0);
        Matrix.setIdentityM(scaleMatrix, 0);
        initialize();
    }
    public void prepare(){
            //prepare Obstacle Drawing
        GLES20.glUseProgram(mProgram);
        GLES20.glEnableVertexAttribArray(positionHandle);
    }
    public void finish(){
        GLES20.glDisableVertexAttribArray(positionHandle);
    }
    public void draw(float posx, float posy, float height, float width)
    {
        //new position and scale
        float[] matrix= new float[16];
        Matrix.setIdentityM(translationMatrix, 0);
        Matrix.setIdentityM(scaleMatrix, 0);
        Matrix.scaleM(scaleMatrix, 0, width, height, 1);
        Matrix.translateM(translationMatrix, 0, 2*posx-1,2*posy-1+height, 0);
        Matrix.multiplyMM(matrix, 0,translationMatrix , 0,scaleMatrix , 0);


        //here I give the new position
        GLES20.glUniformMatrix4fv(matrixHandle, 1,false, matrix, 0);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_FAN, 0, vertexCount);
    }
}

下面是我的 GameRenderer。覆盖的方法由我们在另一个线程上运行的游戏模拟使用。

package com.example.jump;

import java.util.LinkedList;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.util.Log;

public class GameRenderer implements GLSurfaceView.Renderer,GameVisualisation {


    private ObstacleGL obstacle;
    private LinkedList<Obstacle> obstacleList= new LinkedList<Obstacle>();
    Obstacle o;

    //Renderer Methoden
    @Override
    public void onDrawFrame(GL10 gl) {
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
        obstacle.prepare();

        for (int i = 0; i < obstacleList.size(); i++) {
            if(i==obstacleList.size())
                break;
            o=obstacleList.get(i);
            obstacle.draw(o.xPosition, o.yPosition, o.height, o.width);
        }


        obstacle.finish();
    }

    public static int loadShader(int type, String shadercode)
    {
        int shader=GLES20.glCreateShader(type);
        GLES20.glShaderSource(shader, shadercode);
        GLES20.glCompileShader(shader);
        return shader;
    }



    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
        GLES20.glViewport(0, 0, width, height);
    }

    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
        initialize();

    }

    private void initialize() {
        obstacle=new ObstacleGL();      
    }

    //GameVisualisationInterfaceMethoden
    @Override
    public void changePunktestand(int punkte) {
        // TODO Auto-generated method stub
    }

    @Override
    public void moveCharacter(double height) {
        // TODO Auto-generated method stub
    }

    @Override
    public void changeCharacterAnimation(int animation) {
        // TODO Auto-generated method stub
    }

    @Override
    public void addObstacle(int id, float xpos, float ypos, float width, float height) {
        obstacleList.add(new Obstacle(id, height, width, xpos, ypos));  
        if(o==null)
            o=new Obstacle(id, height, width, xpos, ypos);
    }

    @Override
    public void moveObstacle(int id, double xPos, double yPos) {
        // TODO 
    }

    @Override
    public void moveObstaclesX(float x) {
        for (int i = 0; i < obstacleList.size(); i++) {
            Obstacle o=obstacleList.get(i);
            o.xPosition+=-x;
        }

    }


    @Override
    public void deleteObstacle(int id) {
        for (int i = 0; i < obstacleList.size(); i++) {
            if(obstacleList.get(i).id==id){
                obstacleList.remove(i);
                return;
            }   
        }
    }

    @Override
    public void gameOver() {
        // TODO Auto-generated method stub
    }
}

Answer 1

所以我找到了一个目前效果很好的解决方案: 首先，我将矩阵外包给了 Obstacle 类，因此不需要每次抽奖都计算它们。 这有 3 个效果:

1. 当障碍物不动时，不需要修改矩阵。
2. 矩阵不需要在 opengl 线程中计算。
3. 我不需要每次都计算比例，因为我对每个障碍物都有一个比例矩阵