OpenGL ES 2.0 -需要性能/优化？

Question

我画了大约30 - 80个纹理平面(方块)-背景，玩家，敌人，子弹，等等。

所有平面都会移动和缩放，有些+旋转，有些具有动画纹理。

我认为，这对CPU或GPU来说不会太难，但在速度较慢/较老的设备上，它的性能相对较低-例如在Galaxy ACE上。

你能看看我的代码吗，我做错了什么？或者什么是可以优化的？

谢谢。

这是我的onSurfaceCreated，onSurfaceChanged和onDrawFrame：

public void onSurfaceCreated(GL10 glUnused, EGLConfig config) { 
  ..
  // load and prepare all textures 
  ..

  GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);  
  GLES20.glEnable(GLES20.GL_CULL_FACE);             
  GLES20.glDisable(GLES20.GL_DEPTH_TEST);       
  GLES20.glEnable(GLES20.GL_TEXTURE_2D);            

  GLES20.glDisable(GL10.GL_DITHER);
  GLES20.glDisable(GL10.GL_LIGHTING);
  final float eyeX = 0.0f; final float eyeY = 0.0f; final float eyeZ = 1.5f;       
  final float lookX = 0.0f; final float lookY = 0.0f; final float lookZ = -3.0f;
  final float upX = 0.0f; final float upY = 1.0f; final float upZ = 0.0f;
  Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);  

  mProgramHandle = GLES20.glCreateProgram();    

  final String vertexShader =
  "uniform mat4 u_MVPMatrix;         \n"                       
  + "attribute vec4 a_Position;      \n"                            
  + "attribute vec2 a_TexCoordinate; \n"    
  + "attribute float a_AlphaValue;   \n"
  + "varying vec2 v_TexCoordinate;   \n"            
  + "varying float v_AlphaValue;     \n"
  + "void main()                     \n"                                
  + "{                               \n"                          
  + "   v_TexCoordinate = a_TexCoordinate;      \n"  
  + "   v_AlphaValue = a_AlphaValue;            \n"
  + "   gl_Position = u_MVPMatrix * a_Position; \n"
  + "}                                          \n";        

  final String fragmentShader =
  "precision lowp float;                \n"         
  + "uniform sampler2D u_Texture;       \n"     
  + "varying vec2 v_TexCoordinate;      \n"     
  + "varying float v_AlphaValue;        \n"             
  + "void main()                        \n"     
  + "{                                  \n"
  + "   gl_FragColor = texture2D(u_Texture, v_TexCoordinate); \n"             
  + "   gl_FragColor.a *= v_AlphaValue; \n"
  + "}                                  \n";            

  final int vertexShaderHandle = ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, vertexShader);     
  final int fragmentShaderHandle = ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader);       
  mProgramHandle = ShaderHelper.createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, new String[] {"a_Position", "a_TexCoordinate", "a_AlphaValue"});

  GLES20.glUseProgram(mProgramHandle);  
  mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgramHandle, "u_MVPMatrix");
  mMVMatrixHandle = GLES20.glGetUniformLocation(mProgramHandle, "u_MVMatrix");
  mPositionHandle = GLES20.glGetAttribLocation(mProgramHandle, "a_Position");
}   

public void onSurfaceChanged(GL10 glUnused, int width, int height) {    
  GLES20.glViewport(0, 0, width, height);
  float ratio = (float) width / height;
  Matrix.frustumM(mProjectionMatrix, 0, -ratio, ratio, -1, 1, 1, 1000);
}   

public void onDrawFrame(GL10 glUnused) {
  GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
  GLES20.glEnable(GLES20.GL_BLEND); 
  GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
  updateGame();

  // all planes are saved in Vector<Mesh> children          
  int size = children.size();
  for (int i = 0; i < size; i++)
  {
    children.get(i).Draw(renderer);
  }
}

并在'plane‘对象中绘制(渲染器)：

public void Draw(Renderer renderer)
{                       
  if (!Visible) return; // no visible object, no need draw
  mTextureCoordinateHandle = GLES20.glGetAttribLocation(renderer.mProgramHandle, "a_TexCoordinate");
  GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mBrickDataHandle); 
  mAlphaHandle = GLES20.glGetAttribLocation(renderer.mProgramHandle, "a_AlphaValue");       
  GLES20.glVertexAttrib1f(mAlphaHandle, alpha);

  // texture animation
  renderer.mPlaneTextureCoords[(byte)indexAnim].position(0); 
  GLES20.glVertexAttribPointer(mTextureCoordinateHandle, mTextureCoordinateDataSize, GLES20.GL_FLOAT, false, 0, renderer.mPlaneTextureCoords[(byte)indexAnim]);
  indexAnim++;

  renderer.mPlanePositions.position(0); 
  GLES20.glVertexAttribPointer(Renderer.mPositionHandle, renderer.mPositionDataSize, GLES20.GL_FLOAT, false, 0, renderer.mPlanePositions);        
  GLES20.glEnableVertexAttribArray(Renderer.mPositionHandle);                       

  if (angleZ == 0) // no rotating plane -> no need setRotateM
  {
    Matrix.setIdentityM(renderer.mModelMatrix, 0);
    Matrix.translateM(renderer.mModelMatrix, 0, x, y, z);
    Matrix.scaleM(renderer.mModelMatrix, 0, scaleX, scaleY, 1);
  }
  else // rotating plane
  {
    float[] mt = new float[16];
    Matrix.setIdentityM(mt, 0);
    Matrix.translateM(mt, 0, x, y, z);
    Matrix.scaleM(mt, 0, scaleX, scaleY, 1);
    Matrix.setRotateM(mRotZMatrix, 0, angleZ, 0, 0, 1);
    Matrix.multiplyMM(renderer.mModelMatrix, 0, mt, 0, mRotZMatrix, 0);
  }

  Matrix.multiplyMM(renderer.mMVPMatrix, 0, renderer.mViewMatrix, 0, renderer.mModelMatrix, 0);   
  GLES20.glUniformMatrix4fv(renderer.mMVMatrixHandle, 1, false, renderer.mMVPMatrix, 0);                

  //Matrix.multiplyMM(renderer.mMVPMatrix, 0, renderer.mProjectionMatrix, 0, renderer.mMVPMatrix, 0);
  Matrix.multiplyMM(renderer.mTemporaryMatrix, 0, renderer.mProjectionMatrix, 0, renderer.mMVPMatrix, 0); // little bit faster (?)
  System.arraycopy(renderer.mTemporaryMatrix, 0, renderer.mMVPMatrix, 0, 16);

  GLES20.glUniformMatrix4fv(renderer.mMVPMatrixHandle, 1, false, renderer.mMVPMatrix, 0); // pass in the combined matrix
  GLES20.glEnableVertexAttribArray(mTextureCoordinateHandle);        
  GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 6);  
}   

Answer 1

如果你运行的是较新版本的Android SDK (例如v16)，你可以使用分析器找出问题所在：

http://developer.android.com/tools/debugging/debugging-tracing.html

但乍一看，我可以看到几件事：

1. 另一个响应者强调，你在你的绘图调用中调用glGetAttribLocation，你不需要在每次绘图时都这样做。一旦设置了“程序”，这些引用就可以获得，只要程序不改变(即你不改变着色器)，它们就不会改变。使用纹理图集对glEnableVertexAttribArray
2. Consider的调用也是如此。每次对glBindTexture的调用都可能导致VRAM中的状态改变，这是一个缓慢的操作。纹理图集只是包含所有(或多个)或您的纹理(例如精灵)的单个图像。指定纹理坐标时，只需指定一个介于0和1之间的值，表示单个精灵在贴图集中的位置。如果你想使用这种方法，你将不得不“打包”你的地图集，这样你就不会浪费空间。有一些工具可以做到这一点(例如TexturePacker)。这意味着更少(可能只有一次)通过glUniformMatrix4fv传递两次MVP矩阵的glBindTexture
3. You're调用，这是不必要的。更改在发送后发送到着色器的矩阵将没有任何效果(即，初始设置操作将被覆盖)，因为仅当着色器在调用glDrawArrays
4. I时执行时才使用矩阵最近发现setRotateM非常慢。有周围的替代方案，我也需要找到！
5. 你的最后一个System.arrayCopy是不必要的。你可以直接链接矩阵乘法，而不需要temp。矩阵。模型*视图= MV，然后MV * Projection = MVP

如果你还没有，你也应该看看这个教程：

http://www.learnopengles.com/android-lesson-one-getting-started/

如果你决定走第三方游戏引擎的路线，IMO libgdx是最好的：

http://libgdx.badlogicgames.com/

它是免费的，开源的，并且非常注重性能。话虽如此，我也决定构建我自己的，因为我不需要libgdx提供的广泛功能，但我必须说，我写的每一行代码都让我停下来质疑这个决定;)

祝好运。

Answer 2

我不认为你想在你的draw循环中调用glGet*这么多次，因为这可能是一个很慢的操作。

你能只在对象内部本地缓存属性的位置吗？或者我想知道，当每个对象都使用相同的着色器时，为什么还要为每个对象设置每个对象的属性位置。

Answer 3

你以前有没有考虑过使用游戏引擎？其中相当多的人能够用相当少的代码来处理这种任务，并且stress =P

最初学习游戏引擎会花费你更多的时间，但之后会为你节省数百个小时。由于是为游戏而设计的，它们通常可以很好地处理大量对象，而不会牺牲性能，即使是在较老的设备上也是如此。

这不是你问题的直接解决方案，但也许它可以在以后帮助你^。^这里有大量的Android http://mobilegameengines.com/android/game_engines游戏引擎列表

如果你喜欢开源游戏引擎，你可能会喜欢它们，我只有几次使用这些引擎的经验，但我发现AndEngine是最简单的入门，它绝对足够强大，可以处理30-80个对象。http://ntt.cc/2011/05/08/8-open-source-android-game-engines.html