Vertex Buffer Objects (VBO), Android 2.3.3 üzerinde çalışmıyor, GLES20 kullanarak

Question

Android'de, bir köşe arabellek nesnesini kullanan basit bir OpenGL ES 2.0 uygulaması çalıştırmaya çalışıyorum, ancak başarısız oldum.

Bu projede başladı: anlatıldığı gibi

http://developer.android.com/resources/tutorials/opengl/opengl-es20.html 

Her şey güzel açıkladı ve eserleri edilir. İnce.

Oluşturma işlemini glDrawArrays yerine glDrawElements komutuyla alternatif olarak yapmak için bir kod ekledim. Başarılı oldum.

Şimdi sıradaki adım: Aynı şeyi yapmak için Vertex Buffer Object kullanmak istiyorum.

1. yeni değişkenler:

   Bu yüzden bu ilave

   özel int [] mVBOid = new int [2]; VBO ve index buffer için gereken // 2 kimlikleri özel ShortBuffer mIndices'i; // endeksleri

2. VBO oluşturmak için kod ilave kullanılır:

   GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVBOid[0]); 
       GLES20.glVertexAttribPointer(maPositionHandle, nc, GLES20.GL_FLOAT, false, stride, 0); 
       GLES20.glEnableVertexAttribArray(maPositionHandle); 
   
       GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mVBOid[1]); 
       GLES20.glDrawElements(GLES20.GL_TRIANGLE_FAN, mNumIndices, GLES20.GL_UNSIGNED_SHORT, 0); 
   

Not:

geometri çizmek için kod ilave

ByteBuffer vbb = ByteBuffer.allocateDirect(
      triangleCoords.length * SIZEOF_FLOAT); 
    vbb.order(ByteOrder.nativeOrder());// use the device hardware's native byte order 
    mTriangleVB = vbb.asFloatBuffer(); // create a floating point buffer from the ByteBuffer 
    mTriangleVB.put(triangleCoords); // add the coordinates to the FloatBuffer 
    mTriangleVB.position(0);   // set the buffer to read the first coordinate 

    ByteBuffer ibb = ByteBuffer.allocateDirect(
      indices.length * SIZEOF_SHORT); 
    ibb.order(ByteOrder.nativeOrder()); // use the device hardware's native byte order 
    mIndices = ibb.asShortBuffer();  // create a short buffer from the ByteBuffer 
    mIndices.put(indices);    // add the indices to the Buffer 
    mIndices.position(0);    // set the buffer to read the first index 

    GLES20.glGenBuffers(2, mVBOid, 0); 

    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVBOid[0]); 
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, 
      numComponentsPerVertex * SIZEOF_FLOAT, 
      mTriangleVB, 
      GLES20.GL_STATIC_DRAW); 

    GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mVBOid[1]); 
    GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, 
      mNumIndices * SIZEOF_SHORT, 
      mIndices, 
      GLES20.GL_STATIC_DRAW); 

ilk olarak uygulanan yeni işlevler de VBO kullanmadan glDrawElements kullanarak geometriyi işliyor, mTriangleVB ve mIndices değişkenlerinin gerekli verilerle doğru şekilde doldurulduğunu biliyorum. Ayrıca maPositionHandle ve muMVPMatrixHandle doğrudur. Benim kodumda GL hatalarını kontrol ederim - none bulundu

Sorunum: VBO tekniği çalışmıyor; Net renk dışında ekranda hiçbir şey görülmez. Bir VBO göre geometri

segmentasyon hatası Zaman zaman bildirilmektedir sokulduğu zaman, doğru bir şekilde işlenen görünmezdir edildi VBOS kullanmadan

• diğer geometriler: daha karmaşık bir uygulamasında daha sorunları olsun. Tam bir neden almaya çalıştım, çok fazla kod açıkladım ve sonunda, geometri hiç oluşturulmasa bile çökme meydana geldiğini gördüm. Çarpmanın sebebi, VBO'nun başlatılması olmalı - kaza anında değil, ancak bir süre sonra gerçekleşir.
  Fakat neden hala çalışmıyor olduğunu anlayamıyorum.

  1. My Çevre::

     • Android 2.3.3
     • Yapı Hedef: 2.3 Android

     İşte bazı fazla bilgi verilmektedir.3

  2. Android SDK Tool:
  3. Android SDK Platformu Araçları Rev. 15: Rev. 9
  4. Cihaz: Huawei Ideos X3 akıllı telefon

SimpleOpenGLES20Renderer sınıf için komple Kaynak.
kod Bu örnek dayanmaktadır:
http://developer.android.com/resources/tutorials/opengl/opengl-es20.html

package com.hugo.simplegles20; 

import java.nio.ByteBuffer; 
import java.nio.ByteOrder; 
import java.nio.FloatBuffer; 
import java.nio.ShortBuffer; 

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

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


public class SimpleOpenGLES20Renderer implements GLSurfaceView.Renderer { 

    public float mAngle; 

    static String TAG = "SimpleTest"; 

    final int SIZEOF_FLOAT = Float.SIZE/8; 
    final int SIZEOF_SHORT = Short.SIZE/8; 


    private int[] mVBOid = new int[2];  // 2 ids needed for VBO and index buffer oject 


    enum TestType { 
     USE_ARRAY,   // (almost) the original code 
     USE_ELEMENTS,  // rendering, using glDrawElements call 
     USE_VBO_ELEMENTS // using a vertex buffer object (VBO) 
    } 
    private TestType mUsage = TestType.USE_VBO_ELEMENTS; 


    private boolean mFourComponents = true; 

    private int mNumIndices = 0; 

    private FloatBuffer mTriangleVB; 
    private ShortBuffer mIndices; 
    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; \n" + 

     "attribute vec4 vPosition; \n" + 
     "void main(){    \n" + 

     // the matrix must be included as a modifier of gl_Position 
     " gl_Position = uMVPMatrix * vPosition; \n" + 

     "} \n"; 

    private final String fragmentShaderCode = 
     "precision mediump float; \n" + 
     "void main(){    \n" + 
     " gl_FragColor = vec4 (0.63671875, 0.76953125, 0.22265625, 1.0); \n" + 
     "}       \n"; 

    private int mProgram; 

    private int maPositionHandle; 

    private int muMVPMatrixHandle; 

    private float[] mMVPMatrix = new float[16]; 
    private float[] mMMatrix = new float[16]; 
    private float[] mVMatrix = new float[16]; 
    private float[] mProjMatrix = new float[16]; 

    public static void checkGLError(String msg) { 
     int e = GLES20.glGetError(); 
     if (e != GLES20.GL_NO_ERROR) { 
      Log.d(TAG, "GLES20 ERROR: " + msg + " " + e); 
      Log.d(TAG, errString(e)); 
     } 
    } 
    public static String errString(int ec) { 
     switch (ec) { 
     case GLES20.GL_NO_ERROR: 
      return "No error has been recorded."; 
     case GLES20.GL_INVALID_ENUM: 
      return "An unacceptable value is specified for an enumerated argument."; 
     case GLES20.GL_INVALID_VALUE: 
      return "A numeric argument is out of range."; 
     case GLES20.GL_INVALID_OPERATION: 
      return "The specified operation is not allowed in the current state."; 
     case GLES20.GL_INVALID_FRAMEBUFFER_OPERATION: 
      return "The command is trying to render to or read from the framebuffer" + 
      " while the currently bound framebuffer is not framebuffer complete (i.e." + 
      " the return value from glCheckFramebufferStatus is not" + 
      " GL_FRAMEBUFFER_COMPLETE)."; 
     case GLES20.GL_OUT_OF_MEMORY: 
      return "There is not enough memory left to execute the command." + 
        " The state of the GL is undefined, except for the state" + 
        " of the error flags, after this error is recorded."; 
     default : 
      return "UNKNOW ERROR"; 
     } 
    } 

    @Override 
    public void onSurfaceCreated(GL10 uu, EGLConfig config) { 
     // Set the background frame color 
     GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1.0f); 
     checkGLError("onSurfaceCreated 1"); 

     initShapes(); 

     Log.d(TAG, "load vertex shader"); 
     int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); 
     Log.d(TAG, "load fragment shader"); 
     int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); 

     mProgram = GLES20.glCreateProgram();    // create empty OpenGL Program 
     checkGLError("onSurfaceCreated 2"); 
     GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program 
     checkGLError("onSurfaceCreated 3"); 
     GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program 
     checkGLError("onSurfaceCreated 4"); 
     GLES20.glLinkProgram(mProgram);     // creates OpenGL program executables 
     checkGLError("onSurfaceCreated 5"); 

     // get handle to the vertex shader's vPosition member 
     maPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition"); 
     checkGLError("onSurfaceCreated 6"); 
     muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix"); 
     checkGLError("onSurfaceCreated 7"); 
    } 

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

     float ratio = (float) width/height; 

     // this projection matrix is applied to object coordinates 
     // in the onDrawFrame() method 
     Matrix.frustumM(mProjMatrix, 0, -ratio, ratio, -1, 1, 3, 7); 
     Matrix.setLookAtM(mVMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f); 
    } 
    @Override 
    public void onDrawFrame(GL10 uu) { 
     GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT); 
     checkGLError("onDrawFrame 1"); 

     // Add program to OpenGL environment 
     GLES20.glUseProgram(mProgram); 
     checkGLError("onDrawFrame 2"); 

     // Use the mAngle member as the rotation value 
     Matrix.setRotateM(mMMatrix, 0, mAngle, 0, 0, 1.0f); 

     // Apply a ModelView Projection transformation 
     Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, mMMatrix, 0); 
     Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0); 

     GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0); 
     checkGLError("onDrawFrame 3"); 

     int nc = mFourComponents ? 4 : 3; 
     int stride = nc * SIZEOF_FLOAT; 

     switch (mUsage) { 
     case USE_ARRAY: 
      // Prepare the triangle data 
      GLES20.glVertexAttribPointer(maPositionHandle, nc, GLES20.GL_FLOAT, false, stride, mTriangleVB); 
      checkGLError("onDrawFrame 4"); 
      GLES20.glEnableVertexAttribArray(maPositionHandle); 
      checkGLError("onDrawFrame 5"); 

      // Draw the triangle 
      GLES20.glDrawArrays(GLES20.GL_TRIANGLE_FAN, 0, mNumIndices); 
      checkGLError("onDrawFrame 6"); 
      break; 
     case USE_ELEMENTS: 
      // Prepare the triangle data 
      GLES20.glVertexAttribPointer(maPositionHandle, nc, GLES20.GL_FLOAT, false, stride, mTriangleVB); 
      checkGLError("onDrawFrame 7"); 
      GLES20.glEnableVertexAttribArray(maPositionHandle); 
      checkGLError("onDrawFrame 8"); 

      // Draw the triangle 
      // int indicesSizeInBytes = SIZEOF_SHORT * mNumIndices; 
      GLES20.glDrawElements(GLES20.GL_TRIANGLE_FAN, mNumIndices, GLES20.GL_UNSIGNED_SHORT, mIndices); 
      checkGLError("onDrawFrame 9"); 
      break; 
     case USE_VBO_ELEMENTS: 
      GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVBOid[0]); 
      checkGLError("onDrawFrame 14"); 
      GLES20.glVertexAttribPointer(maPositionHandle, nc, GLES20.GL_FLOAT, false, stride, 0); 
      checkGLError("onDrawFrame 15"); 
      GLES20.glEnableVertexAttribArray(maPositionHandle); 
      checkGLError("onDrawFrame 16"); 

      GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mVBOid[1]); 
      checkGLError("onDrawFrame 17"); 
      GLES20.glDrawElements(GLES20.GL_TRIANGLE_FAN, mNumIndices, GLES20.GL_UNSIGNED_SHORT, 0); 
      checkGLError("onDrawFrame 18"); 
      break; 
     } 
    } 

    private void initShapes(){ 

     float triangleCoords3[] = { 
       // X, Y, Z 
       -0.5f, -0.5f, 0, 
       -0.5f, 0.5f, 0, 
       -0.2f, -0.2f, 0, 
       0.5f, -0.5f, 0 
      }; 
     float triangleCoords4[] = { 
       // X, Y, Z, W 
       -0.5f, -0.5f, 0, 1, 
       -0.5f, 0.5f, 0, 1, 
       -0.2f, -0.2f, 0, 1, 
       0.5f, -0.5f, 0, 1 
      }; 

     short[] indices = {0,1,2,3}; 

     float[] triangleCoords; 

     int numComponentsPerVertex; 
     if (mFourComponents) { 
      triangleCoords = triangleCoords4; 
      numComponentsPerVertex = 4; 
     } else { 
      triangleCoords = triangleCoords3; 
      numComponentsPerVertex = 3; 
     } 

     mNumIndices = triangleCoords.length/numComponentsPerVertex; 

     Log.d(TAG, "Components per Vertex: " + numComponentsPerVertex); 
     Log.d(TAG, "Number of Indices : " + mNumIndices); 

     switch (mUsage) { 
     case USE_ARRAY: 
     { 
      Log.d(TAG, "using array"); 
      // initialize vertex Buffer for triangle 
      ByteBuffer vbb = ByteBuffer.allocateDirect(
        // (# of coordinate values * 4 bytes per float) 
        triangleCoords.length * SIZEOF_FLOAT); 
      vbb.order(ByteOrder.nativeOrder());// use the device hardware's native byte order 
      mTriangleVB = vbb.asFloatBuffer(); // create a floating point buffer from the ByteBuffer 
      mTriangleVB.put(triangleCoords); // add the coordinates to the FloatBuffer 
      mTriangleVB.position(0);   // set the buffer to read the first coordinate 
      break; 
     } 
     case USE_ELEMENTS: 
     { 
      Log.d(TAG, "using VBO elements"); 
      // initialize vertex Buffer for triangle 
      ByteBuffer vbb = ByteBuffer.allocateDirect(
        // (# of coordinate values * 4 bytes per float) 
        triangleCoords.length * SIZEOF_FLOAT); 
      vbb.order(ByteOrder.nativeOrder());// use the device hardware's native byte order 
      mTriangleVB = vbb.asFloatBuffer(); // create a floating point buffer from the ByteBuffer 
      mTriangleVB.put(triangleCoords); // add the coordinates to the FloatBuffer 
      mTriangleVB.position(0);   // set the buffer to read the first coordinate 

      vbb = ByteBuffer.allocateDirect(
        // (# of coordinate values * 2 bytes per short) 
        indices.length * SIZEOF_SHORT); 
      vbb.order(ByteOrder.nativeOrder()); // use the device hardware's native byte order 
      mIndices = vbb.asShortBuffer();  // create a short buffer from the ByteBuffer 
      mIndices.put(indices);    // add the indices to the Buffer 
      mIndices.position(0);    // set the buffer to read the first index 
      break; 
     } 
     case USE_VBO_ELEMENTS: 
     { 
      Log.d(TAG, "using VBO elements"); 
      ByteBuffer vbb = ByteBuffer.allocateDirect(
        // (# of coordinate values * 4 bytes per float) 
        triangleCoords.length * SIZEOF_FLOAT); 
      vbb.order(ByteOrder.nativeOrder());// use the device hardware's native byte order 
      mTriangleVB = vbb.asFloatBuffer(); // create a floating point buffer from the ByteBuffer 
      mTriangleVB.put(triangleCoords); // add the coordinates to the FloatBuffer 
      mTriangleVB.position(0);   // set the buffer to read the first coordinate 

      ByteBuffer ibb = ByteBuffer.allocateDirect(
        indices.length * SIZEOF_SHORT); 
      ibb.order(ByteOrder.nativeOrder()); // use the device hardware's native byte order 
      mIndices = ibb.asShortBuffer();  // create a short buffer from the ByteBuffer 
      mIndices.put(indices);    // add the indices to the Buffer 
      mIndices.position(0);    // set the buffer to read the first index 

      GLES20.glGenBuffers(2, mVBOid, 0); 
      checkGLError("initShapes 4"); 

      GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVBOid[0]); 
      checkGLError("initShapes 5"); 
      GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, 
        numComponentsPerVertex * SIZEOF_FLOAT, 
        mTriangleVB, 
        GLES20.GL_STATIC_DRAW); 
      checkGLError("initShapes 6"); 

      GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mVBOid[1]); 
      checkGLError("initShapes 7"); 
      GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, 
        mNumIndices * SIZEOF_SHORT, 
        mIndices, 
        GLES20.GL_STATIC_DRAW); 
      checkGLError("initShapes 8"); 
      break; 
     } 
     } 
    } 

    private 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); 
     checkGLError("loadShader 1"); 

     // add the source code to the shader and compile it 
     GLES20.glShaderSource(shader, shaderCode); 
     checkGLError("loadShader 2"); 
     GLES20.glCompileShader(shader); 
     checkGLError("loadShader 3"); 

     // Get the compilation status. 
     final int[] compileStatus = new int[1]; 
     GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compileStatus, 0); 
     checkGLError("loadShader 4"); 

     // If the compilation failed, delete the shader. 
     if (compileStatus[0] == 0) 
     { 
      Log.e(TAG, "Error compiling shader: " + GLES20.glGetShaderInfoLog(shader)); 
      GLES20.glDeleteShader(shader); 
      checkGLError("loadShader 5"); 
      shader = 0; 
     } 

     return shader; 
    } 
} 

1. çökme dökümü: 12-18 14: 59: 02,790: I/DEBUG (85): * * * * Şablon: * * * * * * * * * * *

   12-18 14: 59: 02,790: I/DEBUG (85): Yapı parmak izi: 'Huawei/U8510/hwu8510: 2.3.3/HuaweiU8510/C169B831: kullanıcı/ota-rel-anahtarları, serbest bırakma tuşları '

   12-18 14: 59: 02.790: I/DEBUG (85): pid: 1638, tid: 1646 >>> com.gles20.step1 < < < 12 -18 14: 59: 02.790: I/DEBUG (85): sinyal 11 (SIGSEGV), kod 1 (SEGV_MAPERR), hata adresi 00368000 12-18 14: 59: 02.790: I/DEBUG (85): r0 44affc80 r1 00367ff0 r2 0004f03c r3 00000000 12-18 14: 59: 02.790: I/DEBUG (85): r4 00000000 r5 00000000 r6 00000000 r7 00000028 12-18 14: 59: 02.790: I/DEBUG (85): r8 00000000 r9 00000000 10 00000000 fp 00000000 12-18 14: 59: 02.790: I/DEBUG (85): ip 00368000 sp 443ef9d0 lr 80e02a08 pc afd0cd7c cpsr 20000010 12-18 14: 59: 02.790: I/DEBUG (85): d0 c420e36a40000000 d1 3f800000c4a0e36a 12-18 14: 59: 02,790: I/DEBUG (85): d2 000000003f800000 d3 000000003f800000 12-18 14: 59: 02,790: I/DEBUG (85): D4 0000000000000000 d5 0000000000000000 12-18 14 : 59: 02.790: I/DEBUG (85): d6 3f80000000000000 d7 3f8000003f800000 12-18 14: 59: 02.790: I/DEBUG (85): d8 000000000000000000 d9 0000000000000000 12-18 14: 59: 02.800: I/DEBUG (85): d10 000000000000000000 d11 0000000000000000 12-18 14:59: 02.800: I/DEBUG (85): d12 0000000000000000 d13 000000000000000000 12-18 14: 59: 02.800: I/DEBUG (85): d14 000000000000000000 d15 000000000000000000 12-18 14: 59: 02.800: I/DEBUG (85) : scr 20000010 12-18 14: 59: 02.860: I/DEBUG (85): # 00 pc 0000cd7c /system/lib/libc.so 12-18 14: 59: 02.860: I/DEBUG (85): # 01.0 00002a04 /system/lib/libgsl.so 12-18 14: 59: 02.860: I/DEBUG (85): # 02 pc 00089de0 /system/lib/egl/libGLESv2_adreno200.so 12-18 14:59: 02.860: I/DEBUG (85): # 03 pc 00091a4a /system/lib/egl/libGLESv2_adreno200.so 12-18 14: 59: 02.860: I/DEBUG (85): 12-18 14: 59: 02.860: I/DEBUG (85): # 05 pc 0006138a /system/lib/egl/libGLESv2_adreno200.so 12-18 14 : 59: 02.860: I/DEBUG (85): # 06 pc 00063d94 /system/lib/egl/libGLESv2_adreno200.so 12-18 14:59:02.860: I/DEBUG (85): # 07 pc 000836aa /system/lib/egl/libGLESv2_adreno200.so 12-18 14: 59: 02.860: I/DEBUG (85): # 08 pc 0003fd66/sistem/lib/libandroid_runtime .0 12-18 14: 59: 02.860: I/DEBUG (85): # 09 pc 00012174 /system/lib/libdvm.so 12-18 14: 59: 02.860: I/DEBUG (85): pc: 12-18 14: 59: 02,860: I/DEBUG (85): afd0cd5c e0422003 e2522020 3a000008 e3c1c01f 12-18 14: 59: 02,860: I/DEBUG (85): afd0cd6c e28cc040 e8b10ff0 f5dcf040 e2522020 12-18 14: 59: 02.860: I/DEBUG (85): afd0cd7c 849c3020 e8a00ff0 2afffff9 e2822020 12-18 14: 59: 02.860: I/DEBUG (85): afd0cd8c e312001f 0a00000c e1b0ce02 28b100f0 12-18 14: 59: 02.860: I/DEBUG (85): afd0cd9c 48b10300 28a000f0 48a00300 e1b0cf02 12-18 14: 59: 02.860: I/DEBUG (85): kod ar ound lr: 12-18 14: 59: 02,860: I/DEBUG (85): 80e029e8 e5906008 e0831001 e1510006 8a000006 12-18 14: 59: 02,860: I/DEBUG (85): 80e029f8 e5903000 e1a0100e e0830005 eb000a13 12- 18 14: 59: 02.860: I/DEBUG (85): 80e02a08 e1a00004 e28dd008 e8bd8070 e59f104c 12-18 14: 59: 02.860: I/DEBUG (85): 80e02a18 e59fe04c e1a02005 e79c0001 e08f100e 12-18 14: 59: 02.860 : I/DEBUG (85): 80e02a28 e58d6000 e28000a8 ebfffef8 e3e00000 12-18 14: 59: 02.860: I/DEBUG (85): yığın: 12-18 14: 59: 02.860: I/DEBUG (85): 443ef990 0000018c
   12-18 14: 59: 02,860: I/DEBUG (85): 59: 443ef994 811bd8b0
   12-18 14 02,860: I/DEBUG (85): 443ef998 000000c6
   12-18 14: 59: 02.860: I/DEBUG (85): 443ef99c 443efb68 12-18 14: 59: 02.860: I/DEBUG (85): 443ef9a0 4360beb4
   12-18 14: 59: 02.860: G/DEBUG (85): 59: 443ef9a4 4360bea0
   12-18 14 02.860: I/DEBUG (85): 59: 443ef9a8 428da7b4
   12-18 14 02.870: I/DEBUG (85): 443ef9ac 81089e25/sistem/lib/egl/libGLESv2_adreno200.so 12-18 14: 59: 02,870: I/DEBUG (85): 59: 443ef9b0 001e8cc8
   12-18 14 02,870: I/DEBUG (85): 443ef9b4 443efa6c
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9b8 00000001
   1212 14: 59: 02.870: I/DEBUG (85): 443ef9bc 00000001
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9c0 0000018c
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9c4 afd10f08 /system/lib/libc.so 12- 18 14: 59: 02,870: I/DEBUG (85): 443ef9c8 df002777
   12-18 14: 59: 02,870: I/DEBUG (85): 59: 02,870: 443ef9cc
   12-18 14 e3a070ad I/DEBUG (85): # 00 443ef9d0 00000000
   12-18 14: 59: 02,870: I/DEBUG (85): 59: 443ef9d4 000a3000
   12-18 14 02,870: I/DEBUG (85): 443ef9d8 0018b834
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9dc 443efb68
   1212 14: 59: 02.870: I/DEBUG (85): 443ef9e0 4360beb4
   12-18 14: 59: 02,870: I/DEBUG (85): 443ef9e4 4360bea0
   12-18 14: 59: 02,870: I/DEBUG (85): 59: 443ef9e8 428da7b4
   12-18 14 02,870 : I/DEBUG (85): 443ef9ec 44aac000
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9f0 00000000
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9f4 80e02a08 /system/lib/libgsl.so 12-18 14: 59: 02.870: I/DEBUG (85): # 01 443ef9f8 001e9320
   1212 14: 59: 02.870: I/DEBUG (85): 443ef9fc 12-18 14: 59: 02.870: I/DEBUG (85): 443efa00 001e9320
   12-18 14:59:02.870: I/DEBUG (85): 443efa04 00000001
   12-18 14: 59: 02.870: I/DEBUG (85): 443efa08 001e9328
   12-18 14: 59: 02.870: I/DEBUG (85): 443efa0c 81089de3 /system/lib/egl/libGLESv2_adreno200.so soruşturmanın başka bir gün sonra

Answer 1

benim koduyla bazı sorunlar bulundu:

• kullanılan tampon unbind unuttum; Bu çağrılar verilerle tampon doldurulduktan sonra ve ilkel çizim için bunları kullandıktan sonra eksikti:

  GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mArray); 
  GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndices); 
  // fill or draw 
  // ... 
  // unbind: 
  GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0); 
  GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0); 
  

• glBindAttribLocation doğru zamanda gerçekleşmelidir çağırarak: gölgelendiricileri derleme sonra ancak programı

  // load and compile shaders ... 
  mProgramId = loadProgram(vertexShaderSource, fragmentShaderSource); 
  
  // Bind the locations 
  GLES20.glBindAttribLocation(mProgramId, Shader.VERTEX_POS, "position"); 
  GLES20.glBindAttribLocation(mProgramId, Shader.NORMAL_POS, "normal"); 
  
  // finally link program 
  GLES20.glLinkProgram(mProgramId); 
  

  bağlama ÖNCE

  GLES20.glBindAttribLocation 
  GLES20.glEnableVertexAttribArray 
  GLES20.glVertexAttribPointer 
  

  aramalar endeks parametresinin

• yanlış yorumlama. Spekülasyonda daha derin bir bakış bana yardımcı olur. Bu her zaman iyi bir fikir gibi görünüyor.

Bir başlangıç ​​noktası olarak basit, ama tam OpenGL ES 2.0 uygulaması var VBO kurulum ve kullanımı ile bazı sorunlar var diğerleri için yararlı olabilir, bu yüzden burada kod yayınlayacağız. Burada bulduğu uygulamayı modifiye ettik

: https://code.google.com/p/gdc2011-android-opengl, işlevsellik encapsule için bazı sınıfları kurmak VBO ilgili kod, ama her şeyi kaldırıldı ve Android/VBO marş kiti yapmayı başardı.
Bu paket, etkinlik, bazı yardımcı sınıflar, temel bir gölgelendirici ve bir kamera sınıfı ve en önemli - temel bir VBO sınıfını içeren tek bir dosyadır; bu, köşe arabelleklerini oluşturmak, kullanmak ve yok etmek için tüm işlevleri sarar.
uygulama yapar:

• sabit bir kamera oluşturmak/lit işlemek sönük geometriler yeteneğine sahip bir gölgelendirici oluşturmak OpenGL ES 2.0 ortamı
• kurmak
• örneğini 3 VBO göre geometriler biri u için

renkli geometriler işlemek bir tel kafes ızgara

olduğu Sadece yeni bir Android projesi oluşturun, 'GLES20VBOTest' etkinliği oluşturun ve aşağıdaki dosyayı kullanın.

package com.example.vbo; 

/* 
Note: these not exist or not work before Android 2.3 

GLES20.glVertexAttribPointer 
GLES20.glDrawElements 
*/ 

import java.nio.Buffer; 
import java.nio.ByteBuffer; 
import java.nio.ByteOrder; 
import java.nio.FloatBuffer; 
import java.nio.ShortBuffer; 

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

import android.app.Activity; 
import android.opengl.GLES20; 
import android.opengl.GLSurfaceView; 
import android.opengl.Matrix; 
import android.os.Bundle; 
import android.util.Log; 


public class GLES20VBOTest extends Activity { 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 

     GLSurfaceView view = new GLSurfaceView(this); 
     view.setEGLContextClientVersion(2); 
     view.setRenderer(new GDC11Renderer()); 

     setContentView(view); 
    } 

} 

// Helper class to create some different geometries 
class GeoData { 

    public float[] mVertices; 
    public short[] mIndices; 

    private GeoData() {} 

    static public GeoData halfpipe() { 
     GeoData creator = new GeoData(); 
     creator.mVertices = createVertices1(44); 
     creator.mIndices = createIndices1(44); 
     return creator; 
    } 

    static public GeoData circle() { 
     GeoData creator = new GeoData(); 
     creator.mVertices = createVertices2(32); 
     creator.mIndices = createIndices2(32); 
     return creator; 
    } 

    static public GeoData grid() { 
     GeoData creator = new GeoData(); 
     creator.mVertices = createGridVertices(30,30); 
     creator.mIndices = createGridIndices(30,30); 
     return creator; 
    } 

    static float[] createGridVertices(int m, int n) { 
     float[] vertices = new float[3*(2*m + 2*n + 4)]; 

     float y = 0.1f; 
     float S = 2.8f; 
     for (int i=0; i<=m; i++) { 
      float x = S*(float) (-0.5 + (1.0*i)/m); 
      float z = S*0.5f; 
      vertices[6*i + 0] = x; 
      vertices[6*i + 1] = y; 
      vertices[6*i + 2] = z; 
      vertices[6*i + 3] = x; 
      vertices[6*i + 4] = y; 
      vertices[6*i + 5] = -z; 
     } 

     int start = 3*(2*m + 2); 
     // start = 0; 
     for (int i=0; i<=n; i++) { 
      float z = S*(float) (-0.5 + (1.0*i)/n); 
      float x = S*0.5f; 
      vertices[start + 6*i + 0] = x; 
      vertices[start + 6*i + 1] = y; 
      vertices[start + 6*i + 2] = z; 
      vertices[start + 6*i + 3] = -x; 
      vertices[start + 6*i + 4] = y; 
      vertices[start + 6*i + 5] = z; 
     } 

     float[] M = new float[16]; 
     Matrix.setIdentityM(M, 0); 
     Matrix.rotateM(M, 0, 27, 0.76f, -0.9f, 1.5f); 
     int count = (2*m + 2*n + 4); 
     Log.d("MKZ", "A: " + count); 
     Log.d("MKZ", "B: " + vertices.length/3); 
     for (int i=0; i<count-1; i++) { 
      int offset = 3*i; 
      Log.d("MKZ", "offset: " + offset); 
      Matrix.multiplyMV(vertices, offset, M, 0, vertices, offset); 
     } 

     return vertices; 
    } 

    static short[] createGridIndices(int m, int n) { 
     int N = 2*(m+n+2); 
     short[] indices = new short[N]; 
     for (int i=0; i<N; i++) { 
      indices[i] = (short)i; 
     } 
     return indices; 
    } 

    static float[] createVertices1(int n) { 
     int NUM_COMPONENTS = 6; 
     float S = 0.75f; 
     float X = 1f; 
     float z0 = 1.3f; 
     float z1 = 1.1f; 
     float dx = 2*X/n; 
     float[] vertices = new float[NUM_COMPONENTS*(n+1)*2]; 
     for (int i=0; i<(n+1); i++) { 
      int I0 = 2*NUM_COMPONENTS*i; 
      int I1 = 2*NUM_COMPONENTS*i + NUM_COMPONENTS; 
      float x = -X + dx*i; 
      float y = -(float) Math.sqrt(1.0 - x*x); 
      vertices[I0 + 0] = S*x; 
      vertices[I0 + 1] = S*y; 
      vertices[I0 + 2] = S*z0; 
      vertices[I0 + 3] = x; 
      vertices[I0 + 4] = y; 
      vertices[I0 + 5] = 0; 

      vertices[I1 + 0] = S*x; 
      vertices[I1 + 1] = S*y; 
      vertices[I1 + 2] = S*z1; 
      vertices[I1 + 3] = x; 
      vertices[I1 + 4] = y; 
      vertices[I1 + 5] = 0; 
     } 
     return vertices; 
    } 
    static short[] createIndices1(int n) { 
     short[] indices = new short[(n+1)*2]; 
     for (short i=0; i<(n+1)*2; i++) { 
      indices[i] = i; 
     } 
     return indices; 
    } 

    static float[] createVertices2(int n) { 
     int NUM_COMPONENTS = 6; 
     float[] vertices = new float[NUM_COMPONENTS*(n+2)]; 
     final float S = 0.9f; 
     final float Y = -0.0f; 
     vertices[0] = 0; 
     vertices[1] = Y; 
     vertices[2] = 0; 
     vertices[3] = 0; 
     vertices[4] =-1; 
     vertices[5] = 0; 
     for (int i=0; i<=n; i++) { 
      int I = 6 + 6*i; 
      float a = (float) (0.75*2*Math.PI*i/n); 
      float x = (float) (S*Math.cos(a)); 
      float z = (float) (S*Math.sin(a)); 
      vertices[I+0] = x; 
      vertices[I+1] = Y; 
      vertices[I+2] = z; 
      vertices[I+3] = 0; 
      vertices[I+4] =-1; 
      vertices[I+5] = 0; 
     } 
     return vertices; 
    } 
    static short[] createIndices2(int n) { 
     short[] indices = new short[(n+2)]; 
     for (short i=0; i<(n+2); i++) { 
      indices[i] = i; 
     } 
     return indices; 
    } 
} 

// all GLES20 calls are made here 
class Shader { 
    // THESE ARE ARBITRARY VALUES, the only constraints are 
    // - must be different 
    // - must be less than a maximum value 
    static final int VERTEX_POS = 3; 
    static final int NORMAL_POS = 4; 
    static final int TEX_POS = 5; 
    static final String TAG = "VBOTest"; 

    private int mProgramId; 
    private int mViewProjectionLoc; 
    private int mLightVectorLoc; 
    private int mColorLoc; 
    private int mEnableLightLoc; 


    Shader() { 
     mProgramId = loadProgram(kVertexShader, kFragmentShader); 
     GLES20.glBindAttribLocation(mProgramId, Shader.VERTEX_POS, "position"); 
     GLES20.glBindAttribLocation(mProgramId, Shader.NORMAL_POS, "normal"); 
     GLES20.glLinkProgram(mProgramId); 
     mViewProjectionLoc = 
      GLES20.glGetUniformLocation(mProgramId, "worldViewProjection"); 
     mLightVectorLoc = 
      GLES20.glGetUniformLocation(mProgramId, "lightVector"); 
     mColorLoc = 
      GLES20.glGetUniformLocation(mProgramId, "color"); 
     mEnableLightLoc = 
      GLES20.glGetUniformLocation(mProgramId, "enableLight"); 

     // Other state. 
     GLES20.glClearColor(0.7f, 0.7f, 0.7f, 1.0f); 
     GLES20.glEnable(GLES20.GL_CULL_FACE); 
     GLES20.glEnable(GLES20.GL_DEPTH_TEST); 
    } 

    public void use() { 
     GLES20.glUseProgram(mProgramId); 
    } 
    public void setCamera(float[] viewProjectionMatrix) { 
     GLES20.glUniformMatrix4fv(mViewProjectionLoc, 
       1, 
       false, // transpose isn't supported 
       viewProjectionMatrix, 0); 
    } 
    public void setLight(float[] transformedLightVector) { 
     GLES20.glUniform3fv(mLightVectorLoc, 1, transformedLightVector, 0); 
    } 
    public void setColor(float[] color) { 
     GLES20.glUniform3fv(mColorLoc, 1, color, 0); 
    } 
    public void enableLight(boolean val) { 
     GLES20.glUniform1i(mEnableLightLoc, val ? 1 : 0); 
    } 

    static public void setViewPort(int width, int height) { 
     GLES20.glViewport(0, 0, width, height); 
    } 



    private static String kLogTag = "GDC11"; 

    private static int getShader(String source, int type) { 
     int shader = GLES20.glCreateShader(type); 
     if (shader == 0) return 0; 

     GLES20.glShaderSource(shader, source); 
     GLES20.glCompileShader(shader); 
     int[] compiled = { 0 }; 
     GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0); 
     if (compiled[0] == 0) { 
      Log.e(kLogTag, GLES20.glGetShaderInfoLog(shader)); 
     } 
     return shader; 
    } 

    public static int loadProgram(String vertexShader, 
      String fragmentShader) { 
     int vs = getShader(vertexShader, GLES20.GL_VERTEX_SHADER); 
     int fs = getShader(fragmentShader, GLES20.GL_FRAGMENT_SHADER); 
     if (vs == 0 || fs == 0) return 0; 

     int program = GLES20.glCreateProgram(); 
     GLES20.glAttachShader(program, vs); 
     GLES20.glAttachShader(program, fs); 
     GLES20.glLinkProgram(program); 

     int[] linked = { 0 }; 
     GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linked, 0); 
     if (linked[0] == 0) { 
      Log.e(kLogTag, GLES20.glGetProgramInfoLog(program)); 
      return 0; 
     } 
     return program; 
    } 


    private static final String kVertexShader = 
     "precision mediump float;         \n" + 
     "uniform mat4 worldViewProjection;       \n" + 
     "uniform vec3 lightVector;         \n" + 
     "attribute vec3 position;         \n" + 
     "attribute vec3 normal;          \n" + 
     "varying float light;          \n" + 
     "void main() {            \n" + 
     // |lightVector| is in the model space, so the model 
     // doesn't have to be transformed. 
     " light = max(dot(normal, lightVector), 0.0) + 0.2;  \n" + 
     " gl_Position = worldViewProjection * vec4(position, 1.0); \n" + 
     "}"; 

    private static final String kFragmentShader = 
     "precision mediump float;         \n" + 
     "uniform sampler2D textureSampler;       \n" + 
     "uniform vec3 color;          \n" + 
     "uniform int enableLight;         \n" + 
     "varying float light;          \n" + 
     "void main() {            \n" + 
     " if (1 == enableLight) {         \n" + 
     " gl_FragColor = light * vec4(color,1);     \n" + 
     " } else {             \n" + 
     " gl_FragColor = vec4(color,1);       \n" + 
     " }              \n" + 
     // " gl_FragColor = light * vec4(0.1,0.7,0.0,1);    \n" + 
     "}"; 


    public void clearView() { 
     int clearMask = GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT; 
     GLES20.glClear(clearMask); 
    } 
} 

// view matrices 
class Camera { 
    private float mPhi, mZ = 3.5f; 
    private float[] mProjectionMatrix = new float[16]; 
    private float[] mViewMatrix = new float[16]; 
    private float[] mViewProjectionMatrix = new float[16]; 


    // Updates mViewProjectionMatrix with the current camera position. 
    public void updateMatrices() { 
     Matrix.setIdentityM(mViewMatrix, 0); 
     Matrix.translateM(mViewMatrix, 0, 0, 0, -mZ); 
     Matrix.rotateM(mViewMatrix, 0, mPhi, 0, 1, 0); 
     Matrix.rotateM(mViewMatrix, 0, -90, 1, 0, 0); 
     Matrix.multiplyMM(
       mViewProjectionMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0); 
    } 

    public float[] viewMatrix() { 
     return mViewMatrix; 
    } 

    public void perspective(int width, int height) { 
     float aspect = width/(float)height; 
     perspectiveM(
       mProjectionMatrix, 
       (float)Math.toRadians(45), 
       aspect, 0.1f, 15.f); 
     // aspect, 0.5f, 5.f); 
     updateMatrices(); 
    } 

    // Like gluPerspective(), but writes the output to a Matrix. 
    static private void perspectiveM(
      float[] m, float angle, float aspect, float near, float far) { 
     float f = (float)Math.tan(0.5 * (Math.PI - angle)); 
     float range = near - far; 

     m[0] = f/aspect; 
     m[1] = 0; 
     m[2] = 0; 
     m[3] = 0; 

     m[4] = 0; 
     m[5] = f; 
     m[6] = 0; 
     m[7] = 0; 

     m[8] = 0; 
     m[9] = 0; 
     m[10] = far/range; 
     m[11] = -1; 

     m[12] = 0; 
     m[13] = 0; 
     m[14] = near * far/range; 
     m[15] = 0; 
    } 

    public void use(Shader shader) { 
     shader.setCamera(mViewProjectionMatrix); 
    } 
} 

// The renderer object. 
// Manages the graphic view/content 
class GDC11Renderer implements GLSurfaceView.Renderer { 

    // OpenGL state stuff. 
    private Shader mShader; 
    private Camera mCamera; 

    VBO mVBO1, mVBO2, mVBO3; 

    private float[] mLightVector = { 2/3.f, 1/3.f, 2/3.f }; // Needs to be normalized 
    private float[] mTransformedLightVector = new float[3]; 

    private void updateLightVector() { 

     // Transform the light vector into model space. Since mViewMatrix 
     // is orthogonal, the reverse transform can be done by multiplying 
     // with the transpose. 

     float[] viewMatrix = mCamera.viewMatrix(); 

     mTransformedLightVector[0] = 
      viewMatrix[0] * mLightVector[0] + 
      viewMatrix[1] * mLightVector[1] + 
      viewMatrix[2] * mLightVector[2]; 
     mTransformedLightVector[1] = 
      viewMatrix[4] * mLightVector[0] + 
      viewMatrix[5] * mLightVector[1] + 
      viewMatrix[6] * mLightVector[2]; 
     mTransformedLightVector[2] = 
      viewMatrix[8] * mLightVector[0] + 
      viewMatrix[9] * mLightVector[1] + 
      viewMatrix[10] * mLightVector[2];    
    } 

    // This is called continuously to render. 
    @Override 
    public void onDrawFrame(GL10 unused) { 

     mShader.use(); 
     mShader.clearView(); 
     mCamera.use(mShader); 
     mShader.setLight(mTransformedLightVector); 

     // VBO 
     mShader.enableLight(true); 

     mShader.setColor(red); 
     mVBO1.draw(); 

     mShader.setColor(gold); 
     mVBO2.draw(); 

     mShader.enableLight(false); 
     mShader.setColor(brown); 
     mVBO3.draw(); 

    } 
    static float[] green = {0.2f,1,0.2f}; 
    static float[] brown = {0.7f,0.4f,0.2f}; 
    static float[] red = {0.9f,0,0}; 
    static float[] gold = {0.9f,0.8f,0.1f}; 
    static float[] black = {0,0,0}; 


    @Override 
    public void onSurfaceCreated(GL10 unused, EGLConfig config) { 
     // CREATE GEOMETRY 
     // NEVER load stuff on the render thread in real life! 
     // You'd call fc.map() and b.load() on a loader thread, and 
     // only then upload that to GL once it's done. 

     mShader = new Shader(); 
     mCamera = new Camera(); 

     GeoData data = GeoData.halfpipe(); 
     mVBO1 = new VBO(data.mVertices, data.mIndices, GLES20.GL_TRIANGLE_STRIP, true, false, -1); 

     data = GeoData.circle(); 
     mVBO2 = new VBO(data.mVertices, data.mIndices, GLES20.GL_TRIANGLE_FAN, true, false, -1); 

     data = GeoData.grid(); 
     mVBO3 = new VBO(data.mVertices, data.mIndices, GLES20.GL_LINES, false, false, -1); 
    } 

    // This is called when the surface changes, e.g. after screen rotation. 
    @Override 
    public void onSurfaceChanged(GL10 unused, int width, int height) { 
     mCamera.perspective(width, height); 

     updateLightVector(); 

     // Necessary if the manifest contains |android:configChanges="orientation"|. 
     Shader.setViewPort(width, height); 
    } 
} 


class VBO { 
    int mNumIndices; 

    int mIndexBufferId; 
    int mVertexBufferId; 
    boolean mUseNormals; 
    boolean mUseTexCoords; 

    int mType; 
    int mNumComponents; 
    int mStride; 

    VBO(float[] vertices,    // array of vertex data 
      short[] indices,   // indices 
      int type,     // GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, 
      // GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, and GL_TRIANGLES 
      boolean vertexNormals,  // normals used ? 
      boolean vertexTexCoords, // texCoords used ? 
      int stride) {    // struct size in bytes; if stride <= 0 -> stride will be calculated 


     mType = type; 
     mUseNormals = vertexNormals; 
     mUseTexCoords = vertexTexCoords; 

     mNumComponents = 3; 
     if (mUseNormals) { 
      mNumComponents += 3; 
     } 
     if (mUseTexCoords) { 
      mNumComponents += 2; 
     } 

     if (stride <= 0) { 
      mStride = 4 * mNumComponents; 
     } else { 
      mStride = stride; 
     } 

     int[] buffers = {0,0}; 
     GLES20.glGenBuffers(2, buffers, 0); 

     mVertexBufferId = buffers[0]; 
     mIndexBufferId = buffers[1]; 

     createVertexBuffer(GLES20.GL_ARRAY_BUFFER, vertices, mVertexBufferId); 
     createIndexBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, indices, mIndexBufferId); 
     mNumIndices = indices.length; 
    } 

    void deleteBuffers() { 
     int[] buffers = {mVertexBufferId, mIndexBufferId}; 
     GLES20.glDeleteBuffers(2, buffers, 0); 
     mVertexBufferId = 0; 
     mIndexBufferId = 0; 
    } 

    void draw() { 
     if (0 == mVertexBufferId) { 
      return; 
     } 
     GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVertexBufferId); 

     GLES20.glEnableVertexAttribArray(Shader.VERTEX_POS); 
     if (mUseNormals) { 
      GLES20.glEnableVertexAttribArray(Shader.NORMAL_POS); 
     } 
     if (mUseTexCoords) { 
      GLES20.glEnableVertexAttribArray(Shader.TEX_POS); 
     } 

     int offset = 0; 

     GLES20.glVertexAttribPointer(
       Shader.VERTEX_POS,  // generic id 
       3,      // vertex has 3 components 
       GLES20.GL_FLOAT,  // data type 
       false,     // no normalizing 
       mStride,    // stride: sizeof(float) * number of components 
       offset);    // offset 0; vertex starts at zero 
     offset += 4 * 3; 

     if (mUseNormals) { 

      GLES20.glVertexAttribPointer(
        Shader.NORMAL_POS, 
        3, 
        GLES20.GL_FLOAT, 
        false, 
        mStride, 
        offset); 
      offset += 4 * 3; 
     } 

     if (mUseTexCoords) { 

      GLES20.glVertexAttribPointer(
        Shader.TEX_POS, 
        2,      // texCoord has 2 components 
        GLES20.GL_FLOAT, 
        false, 
        mStride, 
        offset); 
      offset += 4 * 3; 
     } 

     GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndexBufferId); 
     GLES20.glDrawElements(mType, mNumIndices, GLES20.GL_UNSIGNED_SHORT, 0); 

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

     GLES20.glDisableVertexAttribArray(Shader.VERTEX_POS); 
     GLES20.glDisableVertexAttribArray(Shader.NORMAL_POS); 
     GLES20.glDisableVertexAttribArray(Shader.TEX_POS); 
    } 
    static void createVertexBuffer(int target, float[] vertices, int bufferId) { 
     int size = vertices.length * 4; 
     FloatBuffer fb = ByteBuffer.allocateDirect(4*vertices.length).order(ByteOrder.nativeOrder()).asFloatBuffer(); 
     fb.put(vertices); 
     fb.position(0); 

     createBuffer(target, fb, size, bufferId); 
    } 
    static void createIndexBuffer(int target, short[] indices, int bufferId) { 
     int size = indices.length * 2; 
     ShortBuffer sb = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder()).asShortBuffer(); 
     sb.put(indices); 
     sb.position(0); 

     createBuffer(target, sb, size, bufferId); 
    } 
    static void createBuffer(int target, Buffer buf, int size, int bufferId) { 
     GLES20.glBindBuffer(target, bufferId); 
     GLES20.glBufferData(target, size, buf, GLES20.GL_STATIC_DRAW); 
     GLES20.glBindBuffer(target, 0); 
    } 
}