Java 未能在OpenGl/Android中使用VBOs

各位程序员

我在网上搜索过，在网上查过一些例子，但还是弄不懂。如果之前有人问我这个问题，我很抱歉，经过一周的调试，我已经很累了。我希望你能帮助我

基本上，问题是我试图画一些四边形（带三角形），但什么也没画。以前，我在没有VBOs的情况下，按照Android官方网站上“三角形示例”中描述的方式绘制。一切正常，但我认为在Renderer.OnDrawFrame（）中更新顶点/索引缓冲区效率不高：）

这是我的代码：

public class FloorPlanRenderer implements GLSurfaceView.Renderer {

public volatile float mAngle;

// mMVPMatrix is an abbreviation for "Model View Projection Matrix"
private final float[] mMVPMatrix = new float[16];
private final float[] mProjectionMatrix = new float[16];
private final float[] mViewMatrix = new float[16];
private final float[] mRotationMatrix = new float[16];

private GLSurfaceView mGlView;
private GlEngine mGlEngine;
private boolean dataSet = false;

@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    // Set the background frame color
    GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    // Initialize the accumulated rotation matrix
    Matrix.setIdentityM(mRotationMatrix, 0);

    // Position the eye in front of the origin.
    final float eyeX = 0.0f;
    final float eyeY = 0.0f;
    final float eyeZ = -3.0f;

    // We are looking toward the distance
    final float lookX = 0.0f;
    final float lookY = 0.0f;
    final float lookZ = 0.0f; //-5.0f;

    // Set our up vector. This is where our head would be pointing were we holding the camera.
    final float upX = 0.0f;
    final float upY = 1.0f;
    final float upZ = 0.0f;

    // Set the view matrix. This matrix can be said to represent the camera position.
    Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
    mGlEngine = new GlEngine(10);
    mGlEngine.registerQuad(new Wall(-0.5f, 0.4f, -0.2f, 0.4f));
    mGlEngine.registerQuad(new Wall(0.5f, 0.4f, 0.2f, 0.4f));
    mGlEngine.registerQuad(new Wall(0.0f, 0.0f, 0.0f, 0.3f, 0.02f));
}

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

    // Create a new perspective projection matrix. The height will stay the same
    // while the width will vary as per aspect ratio.
    final float ratio = (float) width / height;
    final float left = -ratio;
    final float right = ratio;
    final float bottom = -1.0f;
    final float top = 1.0f;
    final float near = 3.0f;
    final float far = 7.0f;

    // this projection matrix is applied to object coordinates
    // in the onDrawFrame() method
    Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);
}

@Override
public void onDrawFrame(GL10 gl) {
    float[] scratch = new float[16];

    // Calculate the projection and view transformation
    Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);

    Matrix.setRotateM(mRotationMatrix, 0, mAngle, 0, 0, 1.0f);

    // Combine the rotation matrix with the projection and camera view
    // Note that the mMVPMatrix factor *must be first* in order
    // for the matrix multiplication product to be correct.
    Matrix.multiplyMM(scratch, 0, mMVPMatrix, 0, mRotationMatrix, 0);

    mGlEngine.render(scratch);
}

}

格伦尼级：

public class GlEngine {
public static final int COORDS_PER_VERTEX = 3;
public static final int ORDER_INDICES_PER_QUAD = 6;
public static final int VERTICES_PER_QUAD = 4;
public static final int SIZE_OF_FLOAT = Float.SIZE/Byte.SIZE;
public static final int SIZE_OF_SHORT = Short.SIZE/Byte.SIZE;

private int mQuadsNum = 0;
private int mLastCoordsIndex = 0;
private int mLastOrderIndex = 0;

private final FloatBuffer vertexBuffer;
private final ShortBuffer indexBuffer;

private final String vertexShaderCode =
        // This matrix member variable provides a hook to manipulate
        // the coordinates of the objects that use this vertex shader
        "uniform mat4 uMVPMatrix;" +
                "attribute vec4 vPosition;" +
                "void main() {" +
                // the matrix must be included as a modifier of gl_Position
                // Note that the uMVPMatrix factor *must be first* in order
                // for the matrix multiplication product to be correct.
                "  gl_Position = uMVPMatrix * vPosition;" +
                "}";

// Use to access and set the view transformation
private int mMVPMatrixHandle;

private final String fragmentShaderCode =
        "precision mediump float;" +
                "uniform vec4 vColor;" +
                "void main() {" +
                "  gl_FragColor = vColor;" +
                "}";

private final int mProgram;

private int mPositionHandle;
private int mColorHandle;

private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex
float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 0.0f };
private boolean mDataInitNeeded = true;

public GlEngine(int quadsNum) {
    ByteBuffer bb = ByteBuffer.allocateDirect(quadsNum * VERTICES_PER_QUAD *
            COORDS_PER_VERTEX * SIZE_OF_FLOAT);
    bb.order(ByteOrder.nativeOrder()); // device hardware's native byte order
    vertexBuffer = bb.asFloatBuffer();

    ByteBuffer bb2 = ByteBuffer.allocateDirect(quadsNum *
            ORDER_INDICES_PER_QUAD * SIZE_OF_SHORT);
    bb2.order(ByteOrder.nativeOrder());
    indexBuffer = bb2.asShortBuffer();

    int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER,
            vertexShaderCode);
    int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER,
            fragmentShaderCode);

    mProgram = GLES20.glCreateProgram();
    GLES20.glAttachShader(mProgram, vertexShader);
    GLES20.glAttachShader(mProgram, fragmentShader);
    GLES20.glLinkProgram(mProgram);
}

public static int loadShader(int type, String shaderCode){

    // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
    // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
    int shader = GLES20.glCreateShader(type);

    // add the source code to the shader and compile it
    GLES20.glShaderSource(shader, shaderCode);
    GLES20.glCompileShader(shader);

    return shader;
}

public void registerQuad(Wall quad) {
    quad.putCoords(vertexBuffer);
    quad.putIndices(indexBuffer);
    mQuadsNum++;
}

// This code is dealing with VBO side of things
private final int[] mVerticesBufferId = new int[BUFFERS_COUNT];
private final int[] mIndicesBufferId = new int[BUFFERS_COUNT];
private static final int BUFFERS_COUNT = 1;

public void copyToGpu(FloatBuffer vertices) {
    GLES20.glGenBuffers(BUFFERS_COUNT, mVerticesBufferId, 0);

    // Copy vertices data into GPU memory
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVerticesBufferId[0]);
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vertices.capacity() * SIZE_OF_FLOAT, vertices, GLES20.GL_STATIC_DRAW);

    // Cleanup buffer
    vertices.limit(0);
    vertices = null;
}

public void copyToGpu(ShortBuffer indices) {
    GLES20.glGenBuffers(BUFFERS_COUNT, mIndicesBufferId, 0);

    // Copy vertices data into GPU memory
    GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndicesBufferId[0]);
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, indices.capacity() * SIZE_OF_SHORT, indices, GLES20.GL_STATIC_DRAW);

    // Cleanup buffer
    indices.limit(0);
    indices = null;
}

public void render(float[] mvpMatrix) {
    setData();

    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVerticesBufferId[0]);
    GLES20.glUseProgram(mProgram);

    mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
    GLES20.glEnableVertexAttribArray(mPositionHandle);
    GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, 0);

    mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
    GLES20.glUniform4fv(mColorHandle, 1, color, 0);

    // get handle to shape's transformation matrix
    mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
    // Pass the projection and view transformation to the shader
    GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);

    GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndicesBufferId[0]);

    // Draw quads
    GLES20.glDrawElements(
            GLES20.GL_TRIANGLES, mQuadsNum * ORDER_INDICES_PER_QUAD,
            GLES20.GL_UNSIGNED_SHORT, 0);

    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
    GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
}

// This method is called on gl thread GlSurfaceView.queueEvent(...)
public void setData() {
    if (mDataInitNeeded) {
        // Reset positions of buffers for consuming in GL
        vertexBuffer.position(0);
        indexBuffer.position(0);

        copyToGpu(vertexBuffer);
        copyToGpu(indexBuffer);

        mDataInitNeeded = false;
    }
}

public void deallocateGlBuffers() {
    if (mVerticesBufferId[0] > 0) {
        GLES20.glDeleteBuffers(mVerticesBufferId.length, mVerticesBufferId, 0);
        mVerticesBufferId[0] = 0;
    }
    if (mIndicesBufferId[0] > 0) {
         GLES20.glDeleteBuffers(mIndicesBufferId.length, mIndicesBufferId, 0);
        mIndicesBufferId[0] = 0;
    }
}
}

表示矩形的墙类：

public class Wall {
// number of coordinates per vertex in this array
private static final int COORDS_PER_VERTEX = 3;
private static final int VERTICES_NUM = 4; // it's a rect after all
private static final float DEFAULT_WIDTH = 0.05f;
private static final float DEFAULT_COORDS_SOURCE = 0.5f;

private final float mCoords[] = new float[COORDS_PER_VERTEX * VERTICES_NUM];

private final short mDrawOrder[] = { 0, 1, 2,   // first triangle
                                     1, 2, 3 }; // second triangle

private int mVertexBufferPosition;
private int mIndexBufferPosition;

private final PointF mA = new PointF(0, 0);
private final PointF mB = new PointF(0, 0);
private float mWidth;

public Wall() {
    init(-DEFAULT_COORDS_SOURCE, DEFAULT_COORDS_SOURCE, DEFAULT_COORDS_SOURCE,
            -DEFAULT_COORDS_SOURCE, DEFAULT_WIDTH);
}

public Wall(float x1, float y1, float x2, float y2)
{
    init(x1, y1, x2, y2, DEFAULT_WIDTH);
}

public Wall(float x1, float y1, float x2, float y2, float width) {
    init(x1, y1, x2, y2, width);
}

private void init(float x1, float y1, float x2, float y2, float width) {
    mA.x = x1;
    mA.y = y1;
    mB.x = x2;
    mB.y = y2;
    mWidth = width;
    calcCoords();
}

private void calcCoords() {
    float[] vector = {mA.x - mB.x, mA.y - mB.y};
    float magnitude = (float) Math.sqrt(vector[0]*vector[0] + vector[1]*vector[1]);
    float[] identityVector = {vector[0]/magnitude, vector[1]/magnitude};
    float[] orthogonalIdentityVector = {identityVector[1], -identityVector[0]};

    mCoords[0] = mA.x + mWidth * orthogonalIdentityVector[0];
    mCoords[1] = mA.y + mWidth * orthogonalIdentityVector[1];

    mCoords[3] = mA.x - mWidth * orthogonalIdentityVector[0];
    mCoords[4] = mA.y - mWidth * orthogonalIdentityVector[1];

    mCoords[6] = mB.x + mWidth * orthogonalIdentityVector[0];
    mCoords[7] = mB.y + mWidth * orthogonalIdentityVector[1];

    mCoords[9] = mB.x - mWidth * orthogonalIdentityVector[0];
    mCoords[10] = mB.y - mWidth * orthogonalIdentityVector[1];
}

public void putCoords(FloatBuffer vertexBuffer) {
    mVertexBufferPosition = vertexBuffer.position();
    for (int i = 0; i < mDrawOrder.length; i++) {
        mDrawOrder[i] += mVertexBufferPosition/GlEngine.COORDS_PER_VERTEX;
    }
    vertexBuffer.put(mCoords);
}

public void putIndices(ShortBuffer indexBuffer) {
    mIndexBufferPosition = indexBuffer.position();
    indexBuffer.put(mDrawOrder);
}

public float getWidth() {
    return mWidth;
}

public void setWidth(float mWidth) {
    this.mWidth = mWidth;
}

public PointF getA() {
    return mA;
}

public void setA(float x, float y) {
    this.mA.x = x;
    this.mA.y = y;
}

public PointF getB() {
    return mB;
}

public void setB(float x, float y) {
    this.mB.x = x;
    this.mB.y = y;
}
}

公共类墙{
//此数组中每个顶点的坐标数
私有静态最终整数坐标每顶点=3；
private static final int VERTICES_NUM=4；//它毕竟是一个rect
专用静态最终浮动默认宽度=0.05f；
专用静态最终浮点默认坐标源=0.5f；
私有最终浮点mCoords[]=新浮点[COORDS_PER_VERTEX*Vertexts_NUM]；
private final short mDrawOrder[]={0,1,2，//第一个三角形
1,2,3}；//第二个三角形
私有int mVertexBufferPosition；
私人职位；
私有最终点F mA=新点F（0,0）；
私有最终点F mB=新点F（0，0）；
私人浮动宽度；
公共墙（）{
init（-DEFAULT\u COORDS\u SOURCE，DEFAULT\u COORDS\u SOURCE，DEFAULT\u COORDS\u SOURCE，
-默认坐标（源、默认宽度）；
}
公共墙（浮子x1、浮子y1、浮子x2、浮子y2）
{
初始值（x1，y1，x2，y2，默认宽度）；
}
公共墙（浮子x1、浮子y1、浮子x2、浮子y2、浮子宽度）{
初始值（x1，y1，x2，y2，宽度）；
}
专用void init（浮动x1、浮动y1、浮动x2、浮动y2、浮动宽度）{
mA.x=x1；
mA.y=y1；
mB.x=x2；
mB.y=y2；
mWidth=宽度；
calccoods（）；
}
私有无效calcCoords（）{
float[]vector={mA.x-mB.x，mA.y-mB.y}；
浮点幅值=（浮点）数学sqrt（向量[0]*向量[0]+向量[1]*向量[1]）；
float[]identityVector={vector[0]/幅度，vector[1]/幅度}；
float[]正交dentityvector={identityVector[1]，-identityVector[0]}；
mCoords[0]=mA.x+mWidth*正交向量[0]；
mCoords[1]=mA.y+mWidth*正交向量[1]；
mCoords[3]=mA.x-mWidth*正交向量[0]；
mCoords[4]=mA.y-mWidth*正交向量[1]；
mCoords[6]=mB.x+mWidth*正交向量[0]；
mCoords[7]=mB.y+mWidth*正交向量[1]；
mCoords[9]=mB.x-mWidth*正交向量[0]；
mCoords[10]=mB.y-mWidth*正交向量[1]；
}
公共void putCoords（FloatBuffer vertexBuffer）{
mVertexBufferPosition=vertexBuffer.position（）；
for（int i=0；i

在Wall类中，我保存偏移量，将其顶点和索引放置在该类中，因为该类将在将来更改，并打算在主缓冲区中更新其顶点（不会为每个OnDrawFrame重新编译缓冲区）

---

多谢各位。我希望在你的帮助下，我能在通往OpenGl ES的路上克服这个（另一个）障碍。

真为我感到羞耻！我无意中将索引放入了错误的数组。与此相反：

// Copy vertices data into GPU memory
GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndicesBufferId[0]);
GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, indices.capacity() * SIZE_OF_SHORT, indices, GLES20.GL_STATIC_DRAW);

应该有：

// Copy vertices data into GPU memory
GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndicesBufferId[0]);
GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, indices.capacity() * SIZE_OF_SHORT, indices, GLES20.GL_STATIC_DRAW);

为什么羞耻？因为在日志中我看到：

07-23 16:20:05.442 5170-5264/com.example.neutrino.maze W/Adreno-ES20:：GL_无效操作

---

在第二次调用glBufferData之后，我将

GL\u ARRAY\u BUFFER

而不是

GL\u ELEMENT\u ARRAY\u BUFFER

。在许多情况下，这肯定是由于复制粘贴造成的。

我会尝试将“near”值设置得小一点。现在，您的几何体正好位于近剪裁平面上。您能告诉我代码中的精确线吗？

final float near=3.0f