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

我认为你不想在你的绘制循环中多次调用glGet *，因为它可能是一个缓慢的操作。

您可以在对象内部缓存属性位置吗？或者我想知道为什么你甚至为每个对象设置每个对象的属性位置，因为它们都使用相同的着色器。

Answer 2

如果您使用的是较新版本的Android SDK（例如v16），则可以使用分析器找出问题所在的位置：

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

但乍看之下我可以看到一些事情：

另一位回应者强调，您在抽奖通话中呼叫glGetAttribLocation，每次抽奖时都不需要这样做。一旦设置了“程序”，就可以获得这些引用，只要程序没有改变它们就不会改变（即你不改变着色器）。同样调用glEnableVertexAttribArray
考虑使用纹理图集。每次调用glBindTexture都可能导致VRAM状态发生变化，这是一个缓慢的操作。纹理图集只是一个包含所有（或许多）或纹理（例如精灵）的图像。指定纹理坐标时，只需指定0到1之间的值，表示单个精灵在图集中的位置。如果你想使用这种方法，你必须“装箱”你的地图集，这样你就不会浪费空间。有一些工具可以做到这一点（例如TexturePacker）。这意味着对glBindTexture
你用glUniformMatrix4fv两次传递你的MVP矩阵，这是不必要的。更改发送后发送到着色器的矩阵将无效（即初始设置操作将被覆盖），因为仅在着色器在glDrawArrays
的调用中执行时使用矩阵
我最近发现setRotateM非常缓慢。我还需要在这个地方找到替代品！
您的上一个System.arrayCopy是不必要的。你可以直接链接矩阵乘法而不需要temp。矩阵。 Model * View = MV，然后MV * Projection = MVP

如果您还没有，您还应该查看本教程：

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

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

http://libgdx.badlogicgames.com/

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

Answer 3

你以前看过使用游戏引擎了吗？他们中的很多人能够用相当少的代码处理这种任务，而压力= P

最初学习游戏引擎需要花费更多时间，但数百小时后会为您节省时间。它们专为游戏而设计，通常可以很好地处理大量物体而不会牺牲性能，即使在较旧的设备上也是如此。

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

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

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

3 个答案: