(GLES20) Как правильно использовать VBO?

Question

Я действительно новичок в программировании OpenGL (в частности, GLES20), поэтому, пожалуйста, терпите меня. Я пытаюсь сделать простой квадрат без использования VBO в GLES20, и он отлично работает, он рисует цветной квадрат, но почему-то, когда я использую VBO (который я предпочитаю), квадрат не рисовал. Я все еще изучаю программирование OpenGL, поэтому я не совсем понимаю большую часть этого. Может ли кто-нибудь объяснить и предоставить мне несколько кодов, как правильно использовать VBO? Заранее спасибо!

вот квадратный класс для справки:

      public class Square2
{
        private float[] vertexArray = {
                //Vertices                                  //Color
                0.5f, -0.5f, 0.0f,                  1.0f, 0.0f, 0.0f, 1.0f, //Bottom right 0
                -0.5f, 0.5f, 0.0f,                  0.0f, 1.0f, 0.0f, 1.0f, //top left       1
                0.5f, 0.5f, 0.0f,                       0.0f, 0.0f, 1.0f, 1.0f, //top right      2
                -0.5f, -0.5f, 0.0f,                 1.0f, 1.0f, 0.0f, 1.0f //bottom left     3
        };
    
        private short[] elementArray = {
                2,1,0, //top right triangle
                0,1,3  //bottom left triangle
        };

        private int shaderProgram;
    
        FloatBuffer vertexBuffer;
    
        ShortBuffer elementBufer;

        private int[] vboID = new int[2];

        private int positionSize;

        private int colorSize;

        private int floatBytes;

        private int vertexSizeBytes;

        private int mMVPMatrixHandle;

        private int mPositionHandle;

        private int mColorHandle;

        public Square2() {
            
                final String vertexShaderSrc =
                        "uniform mat4 u_MVPMatrix;      \n"

                        + "attribute vec4 a_Position;     \n"
                        + "attribute vec4 a_Color;        \n"

                        + "varying vec4 v_Color;          \n"

                        + "void main()                    \n"
                        + "{                              \n"
                        + "   v_Color = a_Color;          \n"
                        + "   gl_Position = u_MVPMatrix   \n"
                        + "               * a_Position;   \n"
                        + "}";
                    
                final String fragmentShaderSrc =
                        "precision mediump float;       \n"                                                 
                        + "varying vec4 v_Color;          \n"
                        + "void main()                    \n"
                        + "{                              \n"
                        + "   gl_FragColor = v_Color;     \n"
                        + "}";
            
                //Create float buffer           
                vertexBuffer = ByteBuffer.allocateDirect(vertexArray.length * 4)
                        .order(ByteOrder.nativeOrder()).asFloatBuffer();
        vertexBuffer.put(vertexArray).position(0);
            
                GLES20.glGenBuffers(2, vboID, 0);
                GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboID[0]);
                GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vertexArray.length * 4, vertexBuffer, GLES20.GL_STATIC_DRAW);

                //Create ShortBuffer
                elementBufer = ByteBuffer.allocateDirect(elementArray.length * 2)
                        .order(ByteOrder.nativeOrder()).asShortBuffer();
        elementBufer.put(elementArray).position(0);
            
                GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, vboID[1]);
                GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, elementArray.length * 2, elementBufer, GLES20.GL_STATIC_DRAW);
        
                int vertexID = openGLRenderer.loadShader(
                        GLES20.GL_VERTEX_SHADER,
                        vertexShaderSrc);
        int fragmentID = openGLRenderer.loadShader(
                        GLES20.GL_FRAGMENT_SHADER,
                        fragmentShaderSrc);

                shaderProgram = GLES20.glCreateProgram();
                GLES20.glAttachShader(shaderProgram, vertexID);   // add the vertex shader to program
        GLES20.glAttachShader(shaderProgram, fragmentID); // add the fragment shader to program
                GLES20.glBindAttribLocation(shaderProgram, 0, "a_Position");
                GLES20.glBindAttribLocation(shaderProgram, 1, "a_Color");
        GLES20.glLinkProgram(shaderProgram);
            
                // Get the link status.
                final int[] linkStatus = new int[1];
                GLES20.glGetProgramiv(shaderProgram, GLES20.GL_LINK_STATUS, linkStatus, 0);

                // If the link failed, delete the program.
                if (linkStatus[0] == 0) 
                {               
                        GLES20.glDeleteProgram(shaderProgram);
                        shaderProgram = 0;
                }
                    
                mMVPMatrixHandle = GLES20.glGetUniformLocation(shaderProgram, "u_MVPMatrix");
                mPositionHandle = GLES20.glGetAttribLocation(shaderProgram, "a_Position");
                mColorHandle = GLES20.glGetAttribLocation(shaderProgram, "a_Color");
    
                positionSize = 3; colorSize = 4; floatBytes = 4;
                vertexSizeBytes = (positionSize + colorSize) * floatBytes;
            
                GLES20.glUseProgram(shaderProgram);
        }
    
        public void draw(float[] mvpMatrix) {
            
                //vertexBuffer.position(0);
                GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboID[0]);
                GLES20.glVertexAttribPointer(mPositionHandle,  positionSize, GLES20.GL_FLOAT, false,
                                                                         vertexSizeBytes, 0);
                GLES20.glEnableVertexAttribArray(mPositionHandle);
            
                //vertexBuffer.position(3);
                GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, vboID[1]);
                /*GLES20.glVertexAttribPointer(mColorHandle, colorSize, GLES20.GL_FLOAT, false,
                                                                         vertexSizeBytes, 3);*/
                GLES20.glEnableVertexAttribArray(mColorHandle);
                
                GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
            
                GLES20.glDrawElements(GLES20.GL_TRIANGLES, elementArray.length, GLES20.GL_UNSIGNED_SHORT, 0);
                GLES20.glDisableVertexAttribArray(mPositionHandle);
                GLES20.glDisableVertexAttribArray(mColorHandle);
                GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
                GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
        }
}