वर्टेक्स बफर ऑब्जेक्ट (VBO) एंड्रॉयड 2.3.3 पर काम नहीं कर, GLES20

Question

एंड्रॉयड पर का उपयोग कर, मैं एक साधारण ओपन ES 2.0 आवेदन चल रहा है, जो एक शीर्ष बफर वस्तु का उपयोग करता है पाने के लिए कोशिश कर रहा हूँ, लेकिन मैं असफल रहा।

मैं इस परियोजना के साथ शुरू किया:

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

सब कुछ अच्छी तरह से समझाया और काम करता है के रूप में वर्णन किया। ठीक।

मैं glDrawElements साथ glDrawArrays के बजाय कमांड वैकल्पिक रूप से प्रतिपादन करने के लिए कुछ कोड जोड़ा,। मैं सफल हुआ।

अब अगले कदम: मैं एक वर्टेक्स बफर वस्तु का उपयोग करने के एक ही बात करना चाहता हूँ।

1. नई वार्स:

   तो मैं इस जोड़ा

   निजी पूर्णांक [] mVBOid = नई int [2]; वीबीओ और इंडेक्स बफर के लिए आवश्यक // 2 आईडी निजी शॉर्टबफर माइंडिस; // सूचकांक

2. VBO बनाने के लिए कोड जोड़ा इस्तेमाल किया:

   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); 
   

3. ज्यामिति आकर्षित करने के लिए कोड कहा:

   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); 
   

नोट: करने के लिए सबसे पहले लागू किया नई कार्यक्षमता के रूप में VBO का उपयोग किए बिना glDrawElements का उपयोग करके ज्यामिति प्रस्तुत करना काम कर रहा है, मुझे पता है कि mTriangleVB और mIndices चर आवश्यक डेटा से सही ढंग से भरे हुए हैं। इसके अलावा maPositionHandle और muMVPMatrixHandle सही हैं। मेरे कोड मैं जीएल त्रुटियों की जांच में - कोई भी

पाए जाते हैं

मेरे समस्या: VBO तकनीक काम नहीं कर रहा है; स्पष्ट रंग को छोड़कर, स्क्रीन पर कुछ भी नहीं देखा जाता है। , VBOs जो सही ढंग से गाया गया अदृश्य हैं का उपयोग करते समय एक VBO आधारित ज्यामिति शुरू की है

विभाजन दोष occasionaly रिपोर्ट कर रहे हैं बिना

• अन्य geometries: एक अधिक जटिल आवेदन में मैं और अधिक समस्याओं मिलता है। सटीक कारण प्राप्त करने का प्रयास करते हुए मैंने बहुत सारे कोड पर टिप्पणी की, और अंततः पाया कि दुर्घटना तब भी होती है जब ज्यामिति बिल्कुल प्रस्तुत नहीं होती है। दुर्घटना का कारण वीबीओ का प्रारंभ होना चाहिए - हालांकि दुर्घटना तुरंत नहीं होती है, लेकिन कुछ समय बाद।
  लेकिन मैं अभी भी यह नहीं समझ सकता कि यह क्यों काम नहीं कर रहा है।

  1. मेरे पर्यावरण::

     • एंड्रॉयड 2.3.3
     • बिल्ड लक्ष्य: एंड्रॉयड 2,3

     यहाँ कुछ अधिक जानकारी है।3

  2. Android SDK Tools: रेव 15
  3. एंड्रॉयड एसडीके मंच उपकरण: रेव 9
  4. डिवाइस: Huawei Ideos X3 स्मार्टफोन

SimpleOpenGLES20Renderer वर्ग के लिए पूरा स्रोत।
कोड इस नमूने पर आधारित है:
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. क्रैश डम्प: 12-18 14: 59: ०२.७९०: मैं/डिबग (85): * * * * * * * * * * * * * * * *

   12-18 14: 59: ०२.७९०: मैं/डिबग (85): निर्माण अंगुली की छाप: 'Huawei/U8510/hwu8510: 2.3.3/HuaweiU8510/C169B831: उपयोगकर्ता/ओटा-रिला-चाबियाँ, रिलीज-कीज '

   12-18 14: 59: 02.790: I/DEBUG (85): pid: 1638, tid: 1646 >>> com.gles20.step1 < < < 12 -18 14: 59: 02.7 9 0: I/DEBUG (85): सिग्नल 11 (एसआईजीएसईजीवी), कोड 1 (एसईजीवी_Mएपीईआरआर), गलती योजक 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 एफपी 00000000 12-18 14: 59: 02.7 9 0: आई/डेबग (85): आईपी 00368000 एसपी 443ef9d0 lr 80e02a08 पीसी afd0cd7c cpsr 20000010 12-18 14: 59: 02.790: I/DEBUG (85): d0 c420e36a40000000 d1 3f800000c4a0e36a 12-18 14: 59: ०२.७९०: मैं/डिबग (85): d2 000000003f800000 d3 000000003f800000 12-18 14: 59: ०२.७९०: मैं/डिबग (85): d4 -0000000000000000 d5 -0000000000000000 12-18 14 : 5 9: 02.7 9 0: आई/डेबग (85): डी 6 3 एफ 80000000000000 डी 7 3 एफ 8000003 एफ 800000 12-18 14: 5 9: 02.7 9 0: आई/डेबग (85): डी 8 0000000000000000 डी 9 0000000000000000 12-18 14: 59: 02.800: आई/डेबग (85): डी 10 0000000000000000 डी 11 0000000000000000 12-18 14:59: 02.800: I/DEBUG (85): डी 12 0000000000000000 डी 13 0000000000000000 12-18 14: 59: 02.800: I/DEBUG (85): d14 0000000000000000 d15 0000000000000000 12-18 14: 59: 02.800: I/DEBUG (85) : scr 20000010 12-18 14: 59: 02.860: I/DEBUG (85): # 00 पीसी 0000cd7c /system/lib/libc.so 12-18 14: 59: 02.860: I/DEBUG (85): # 01 पीसी 00002a04 /system/lib/libgsl.so 12-18 14: 59: 02.860: I/DEBUG (85): # 02 पीसी 00089de0 /system/lib/egl/libGLESv2_adreno200.so 12-18 14:59: 02.860: I/DEBUG (85): # 03 पीसी 00091a4a /system/lib/egl/libGLESv2_adreno200.so 12-18 14: 59: 02.860: I/DEBUG (85): # 04 पीसी 000612ca /system/lib/egl/libGLESv2_adreno200.so 12-18 14: 59: 02.860: I/DEBUG (85): # 05 पीसी 0006138a /system/lib/egl/libGLESv2_adreno200.so 12-18 14 : 5 9: 02.860: I/DEBUG (85): # 06 पीसी 00063d94 /system/lib/egl/libGLESv2_adreno200.so 12-18 14:59:02।860: I/DEBUG (85): # 07 पीसी 000836aa /system/lib/egl/libGLESv2_adreno200.so 12-18 14: 59: 02.860: I/DEBUG (85): # 08 पीसी 0003fd66/system/lib/libandroid_runtime .so 12-18 14: 59: 02.860: I/DEBUG (85): # 09 पीसी 00012174 /system/lib/libdvm.so 12-18 14: 59: 02.860: I/DEBUG (85): कोड पीसी: 12-18 14: 59: ०२.८६०: मैं/डिबग (85): afd0cd5c e0422003 e2522020 3a000008 e3c1c01f 12-18 14: 59: ०२.८६०: मैं/डिबग (85): afd0cd6c e28cc040 e8b10ff0 f5dcf040 e2522020 12-18 14: 59: ०२.८६०: मैं/डिबग (85): afd0cd7c 849c3020 e8a00ff0 2afffff9 e2822020 12-18 14: 59: ०२.८६०: मैं/डिबग (85): afd0cd8c e312001f 0a00000c e1b0ce02 28b100f0 12-18 14: 59: ०२.८६०: I/DEBUG (85): afd0cd9c 48b10300 28a000f0 48a00300 e1b0cf02 12-18 14: 59: 02.860: I/DEBUG (85): कोड ar ound एलआर: 12-18 14: 59: ०२.८६०: मैं/डिबग (85): 80e029e8 e5906008 e0831001 e1510006 8a000006 12-18 14: 59: ०२.८६०: मैं/डिबग (85): 80e029f8 e5903000 e1a0100e e0830005 eb000a13 12- 18 14: 59: ०२.८६०: मैं/डिबग (85): 80e02a08 e1a00004 e28dd008 e8bd8070 e59f104c 12-18 14: 59: ०२.८६०: मैं/डिबग (85): 80e02a18 e59fe04c e1a02005 e79c0001 e08f100e 12-18 14: 59: ०२.८६० : I/DEBUG (85): 80e02a28 e58d6000 e28000a8 ebfffef8 e3e00000 12-18 14: 59: 02.860: I/DEBUG (85): ढेर: 12-18 14: 59: 02.860: I/DEBUG (85): 443ef990 0000018c
   12-18 14: 59: ०२.८६०: मैं/डिबग (85): 443ef994 811bd8b0
   12-18 14: 59: ०२.८६०: मैं/डिबग (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: 595 029160: मैं/डीबग (85): 443ef9a4 4360bea0
   12-18 14: 59: ०२.८६०: मैं/डिबग (85): 443ef9a8 428da7b4
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9ac 81089e25/प्रणाली/lib/EGL/libGLESv2_adreno200.so 12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9b0 001e8cc8
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9b4 443efa6c
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9b8 00000001
   12-18 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: ०२.८७०: मैं/डिबग (85): 443ef9c8 df002777
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9cc e3a070ad
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): # 00 443ef9d0 00000000
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9d4 000a3000
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9d8 0018b834
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9dc 443efb68
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9e0 4360beb4
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9e4 4360bea0
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9e8 428da7b4
   12-18 14: 59: ०२.८७० : मैं/डिबग (85): 443ef9ec 44aac000
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9f0 00000000
   12-18 14: 59: ०२.८७०: मैं/डिबग (85): 443ef9f4 80e02a08 /system/lib/libgsl.so 12-18 14: 59: 02.870: I/DEBUG (85): # 01 443ef9f8 001e9320
   12-18 14: 59: 02.870: I/DEBUG (85): 443ef9fc 00000001
   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

Answer 1

जांच का एक और दिन के बाद मैं अपने कोड के साथ कुछ समस्याओं का सामना:

• इस्तेमाल किया बफ़र्स निकल करना भूल गया; इन कॉल डेटा के साथ बफर भरने के बाद और उन्हें आदिम बैठक के लिए उपयोग करने के बाद लापता गया:

  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 सही समय पर होने चाहिए: shaders संकलन के बाद, लेकिन कार्यक्रम

  // 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); 
  

  लिंक करने से पहले

  GLES20.glBindAttribLocation 
  GLES20.glEnableVertexAttribArray 
  GLES20.glVertexAttribPointer 
  

  कॉल में सूचकांक पैरामीटर का

• अशुद्ध अर्थ। Spec में एक गहरी देखो मुझे मदद करता है। यह हमेशा एक अच्छा विचार प्रतीत होता है।

यह जो दूसरों VBO सेटअप और उपयोग के साथ कुछ समस्याएं हैं एक सरल है, लेकिन पूरा ओपन ES 2.0 एक प्रारंभिक बिंदु के रूप में एप्लिकेशन होना के लिए उपयोगी हो सकता है, तो मैं कोड यहाँ पोस्ट करेंगे।

मैं एप्लिकेशन यहां पाया संशोधित कर लिया है: https://code.google.com/p/gdc2011-android-opengl, सब कुछ लेकिन VBO प्रासंगिक कोड, कार्यक्षमता encapsule करने के लिए कुछ वर्गों की स्थापना हटा दिया और एक एंड्रॉयड/VBO स्टार्टर किट बनाने में सफल रहा।
यह पैकेज एक एकल फ़ाइल है, जिसमें गतिविधि, कुछ सहायक वर्ग, एक मूल शेडर और कैमरा वर्ग और सबसे महत्वपूर्ण - एक मूल वीबीओ वर्ग है, जो वर्टेक्स बफर ऑब्जेक्ट्स बनाने, उपयोग करने और नष्ट करने के लिए सभी कार्यक्षमताओं को लपेटता है।
एप्लिकेशन करता है:

• एक ओपन ES 2.0 वातावरण
• की स्थापना की एक शेडर, जो प्रस्तुत करना जलाया/तिमिराच्छन्न ज्यामिति में सक्षम है बनाने
• एक निश्चित कैमरा बनाने
• इन्स्तांत 3 VBO आधारित ज्यामिति , जिनमें से एक एक wireframe ग्रिड
• है प्रस्तुत करना रंग का geometries

यू करने के लिए

इसे से, बस एक नया एंड्रॉइड प्रोजेक्ट बनाएं, एक गतिविधि 'GLES20VBOTest' बनाएं और निम्न फ़ाइल का उपयोग करें।

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); 
    } 
}