是否可以使用OpenGL ES 2.0繪製多個對象

Question

這是對我最近問的一個問題的更新，但在嘗試了一些東西之後出現新問題。我想要的是在屏幕上繪製多個圈子。我爲圓形對象創建了一個類。在我的渲染器類中，我創建了一個具有不同位置的這些圓圈的數組列表。當被調用來繪製時，它只繪製其中一個。我記錄了正在發生的事情，並且每個對象都被調用來繪製，但似乎只有一個出現在屏幕上。這不僅僅是我的圈子。它在整個個人測試中出現OpenGL ES 2.0只會在屏幕上繪製一個對象。我不知道如何解決這個問題。 OpenGL ES 2.0中有什麼特別的我需要做的嗎？這是我的代碼。現在忽略令人難以置信的馬虎和低效的代碼。我知道它，稍後會修復它。這裏是我的圈子對象類：

GLCircle：

package com.background.gl.objects; 
import static android.opengl.GLES20.GL_TRIANGLE_FAN; 
import static android.opengl.GLES20.glDrawArrays; 
import static android.opengl.Matrix.multiplyMM; 
import static android.opengl.Matrix.setIdentityM; 
import static android.opengl.Matrix.translateM; 
import static com.background.gl.glcirclebackgroundanimation.Constants.BYTES_PER_FLOAT; 

import java.util.Random; 

import android.opengl.Matrix; 
import android.util.Log; 

import com.background.gl.data.VertexArray; 
import com.background.gl.helper.TextureShaderProgram; 

public class GLCircle { 
    private static final int POSITION_COMPONENT_COUNT = 2; 
    private static final int TEXTURE_COORDINATES_COMPONENT_COUNT = 2; 
    private static final int STRIDE = (POSITION_COMPONENT_COUNT 
    + TEXTURE_COORDINATES_COMPONENT_COUNT) * BYTES_PER_FLOAT; 

    public float x; 
    public float y; 
    protected float[] wallBounds; 
    protected boolean positiveX, positiveY; 
    public boolean nullify; 
    protected float xCounter = 0f; 
    protected float yCounter = 0f; 
    public float[] bounds; 
    protected Random ran; 

    private float[] VERTEX_DATA = { 
     // Order of coordinates: X, Y, S, T 
     // Triangle Fan 
     0f, 0f, 0.5f, 0.5f, 
     -0.25f, -0.25f, 0f, 0.9f, 
     0.25f, -0.25f, 1f, 0.9f, 
     0.25f, 0.25f, 1f, 0.1f, 
     -0.25f, 0.25f, 0f, 0.1f, 
     -0.25f, -0.25f, 0f, 0.9f }; 

    private final VertexArray vertexArray; 

    public GLCircle(float x, float y) { 
     vertexArray = new VertexArray(VERTEX_DATA); 
     ran = new Random(); 
     wallBounds = new float[4]; 
     nullify = false; 
     this.x = x; 
     this.y = y; 
    } 

    public void bindData(TextureShaderProgram textureProgram) { 
     //Bind the position data to the shader attribute 
     vertexArray.setVertexAttribPointer(
      0, 
      textureProgram.getPositionAttributeLocation(), 
      POSITION_COMPONENT_COUNT, 
      STRIDE); 
     //Bind the texture coordinate data to the shader attribute 
     vertexArray.setVertexAttribPointer(
       POSITION_COMPONENT_COUNT, 
       textureProgram.getTextureCoordinatesAttributeLocation(), 
       TEXTURE_COORDINATES_COMPONENT_COUNT, 
       STRIDE); 
     } 

    public void drawCircle() { 
     glDrawArrays(GL_TRIANGLE_FAN, 0, 6); 
    } 


    public float getX() { 
     return this.x; 
    } 

    public float getY() { 
     return this.y; 
    } 



    public boolean isPositiveX() { 
     return positiveX; 
    } 



    public boolean isPositiveY() { 
     return positiveY; 
    } 


    public float[] getBounds(float ranX, float ranY) { 
     if(!positiveX) { 
      /*if(ranX >= 0f) { 
       wallBounds[0] = 1.05f + ranX; 
      } else {*/ 
       this.wallBounds[0] = 1.05f + ranX; 
      //} 
     } else { 
      /* 
      if(ranX >= 0f) { 
       wallBounds[0] = 1.05f - ranX; 
      } else {*/ 
       this.wallBounds[1] = 1.05f - ranX; 
      //} 
     } 
     if(!positiveY) { 
      this.wallBounds[2] = 1.75f + ranY; 
     } else { 
      this.wallBounds[3] = 1.75f - ranY; 
     } 

     return this.wallBounds; 
    } 

    public void setPos(float[] modelMatrix, 
      float[] projectionMatrix, TextureShaderProgram textureProgram, 
      int texture, float x, float y, String log) { 
     setIdentityM(modelMatrix, 0); 
     translateM(modelMatrix, 0, 0f, 0.01f, 0f); 
     final float[] temp = new float[16]; 
     multiplyMM(temp, 0, projectionMatrix, 0, modelMatrix, 0); 
     System.arraycopy(temp, 0, projectionMatrix, 0, temp.length); 

     textureProgram.useProgram(); 
     textureProgram.setUniforms(projectionMatrix, texture); 
     bindData(textureProgram); 
     drawCircle(); 
     Log.d("Drawing", "Drawing " + log); 
    } 

    public void scaleCircle(float[] modelMatrix, float x, float y, float z) { 
     Matrix.scaleM(modelMatrix, 0, x, y, z); 
    } 

    public void storeResults(float[] results) { 
     this.x = results[0]; 
     this.y = results[1]; 
    } 

    public void translateCircle(float x, float[] modelMatrix, float[] projectionMatrix) { 
     setIdentityM(modelMatrix, 0); 
     translateM(modelMatrix, 0, /*-0.001f*/ x, -3f, -2f); 
     final float[] temp = new float[16]; 
     multiplyMM(temp, 0, projectionMatrix, 0, modelMatrix, 0); 
     System.arraycopy(temp, 0, projectionMatrix, 0, temp.length); 
    } 
} 

再次，我所知道的大部分事情我做不正確的，但目前我只需要弄清楚爲什麼我不能繪製多個屏幕上的對象。這裏是我的渲染代碼：

package com.background.gl.glcirclebackgroundanimation; 

import static android.opengl.GLES20.GL_COLOR_BUFFER_BIT; 
import static android.opengl.GLES20.glClear; 
import static android.opengl.GLES20.glClearColor; 
import static android.opengl.GLES20.glViewport; 
import static android.opengl.Matrix.multiplyMM; 
import static android.opengl.Matrix.setIdentityM; 
import static android.opengl.Matrix.translateM; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.Random; 

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

import android.content.Context; 
import android.opengl.GLSurfaceView.Renderer; 
import android.util.Log; 

import com.background.gl.helper.TextureShaderProgram; 
import com.background.gl.objects.GLCircle; 
import com.background.gl.objects.Mallet; 
import com.background.gl.objects.Table; 
import com.background.gl.util.MatrixHelper; 
import com.background.gl.util.TextureHelper; 

public class CircleDynamicBackgroundRenderer implements Renderer { 
private final Context context; 

    private final float[] projectionMatrix = new float[16]; 
    private final float[] modelMatrix = new float[16]; 
    protected static float ranX, 
    ranY, ranSignX, ranSignY, ranSignVeloX, ranSignVeloY; 
    public boolean logNums; 
    private Table table; 
    private Mallet mallet; 
    private List<GLCircle> circles; 
    private GLCircle circle2; 
    float xPos, yPos; 
    int x = 1; 
    float[] bounds; 
    Random ran; 
    private TextureShaderProgram textureProgram; 

    private int texture; 


    public CircleDynamicBackgroundRenderer(Context context) { 
     this.context = context; 
     circles = new ArrayList<GLCircle>(); 
     xPos = 0.1f; 
     ran = new Random(); 
     logNums = true; 
    } 

    @Override 
    public void onSurfaceChanged(GL10 glUnused, int width, int height) { 
     glViewport(0, 0, width, height); 
     Log.w("Width and height", Integer.toString(width) + ", " + Integer.toString(height)); 
     MatrixHelper.perspectiveM(projectionMatrix, 90, (float) width 
       /(float) height, 1f, 10f); 

     for(int i = 0; i < circles.size(); i++) { 
      circles.get(i).translateCircle(circles.get(i).x, modelMatrix, projectionMatrix); 
     } 
//  /circle2.translateCircle(circle2.x, modelMatrix); 
     /*final float[] temp = new float[16]; 
     multiplyMM(temp, 0, projectionMatrix, 0, modelMatrix, 0); 
     System.arraycopy(temp, 0, projectionMatrix, 0, temp.length);*/ 
    } 

    @Override 
    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) { 
     glClearColor(0.0f, 0.0f, 1.0f, 0.0f); 

     table = new Table(); 
     mallet = new Mallet(); 

     textureProgram = new TextureShaderProgram(context); 

     texture = TextureHelper.loadTexture(context, R.drawable.air_hockey_surface); 
     //texture2 = TextureHelper.loadTexture(context, R.drawable.air_hockey_surface_2); 
     for(int i = 0; i < 3; i++) { 
      GLCircle circle = new GLCircle(generateRanFloats()[0], generateRanFloats()[1]); 
      circles.add(circle); 
      /*circle[i].x = circle[i].getX(); 
      circle[i].y = circle[i].getY(); 
      circle[i].bounds = circle[i].getBounds();*/ 
     } 
      //circle2 = new GLCircle(generateRanFloats()[0], generateRanFloats()[1]); 
     Log.d("Circles size", Integer.toString(circles.size())); 
     Log.d("circles", Float.toString(circles.get(1).getX()) + " " + Float.toString(circles.get(2).getX())); 
    } 

    @Override 
    public void onDrawFrame(GL10 glUnused) { 
     //Clear the rendering surface 
     glClear(GL_COLOR_BUFFER_BIT); 
     for(int i = 0; i < circles.size(); i++) { 
     circles.get(i).setPos(modelMatrix, projectionMatrix, textureProgram, texture, circles.get(i).x, circles.get(i).y, "1");   if(logNums) { 
      Log.d("Circle1, c2", Float.toString(circles.get(i).x) + ", " + Float.toString(circles.get(i).x)); 
      logNums = false; 
     } 
     //Log.d("Circles", Float.toString(circles.get(i).x)); 
     } 
    } 

    public float[] generateRanFloats() { 
     ranSignX = ran.nextFloat(); 
     ranSignY = ran.nextFloat(); 
     ranSignX = ranSignX > 0.5f? -1:1; 
     ranSignY = ranSignY > 0.5f? -1:1; 
     ranSignVeloX = ran.nextFloat(); 
     ranSignVeloY = ran.nextFloat(); 
     ranX = ran.nextFloat() * 1.05f; 
     ranY = ran.nextFloat() * 1.75f; 
     ranX = ranSignX > 0.5? -ranX:ranX; 
     ranY = ranSignY > 0.5? -ranY:ranY; 
     Log.d("Generated", Float.toString(ranX)); 
     return new float[] {ranX, ranY}; 
    } 

} 

它已經現在兩天，我不能爲我的生活弄清楚什麼是錯的，如何解決這一問題。我真的需要找出解決這個問題的方法。任何援助將不勝感激。如果您需要查看更多代碼，請告訴我。

Answer 1

根據最後一次討論 - 您是否從事視角矩陣？我建議首先從正投影開始，讓你的代碼工作，然後轉向使用透視投影。您可以將以下內容作爲正投影的起點。

mat4.ortho（-1.0,1.0，-1,1.0,10.0,100.0，projectionMatrix）;

還刪除代碼中的所有z翻譯，使您的代碼在xy上工作，然後添加z翻譯。

PS：是不是更好繼續在（OpenGL ES 2.0 only draws the object once）相同的線程？