Java Code Examples for android.opengl.GLES20#glGenBuffers()

/**
 * instantiate the Points shape object
 * @param aActivity
 * @param positions
 * @param colors
 */
public Points(Context aActivity, float[] positions, float[] colors){

    /** initialize the point program */
    final String pointVS = RawResourceReader.readTextFileFromRawResource(aActivity, R.raw.point_vertex_shader);
    final String pointFS = RawResourceReader.readTextFileFromRawResource(aActivity, R.raw.point_fragment_shader);

    final int pointVSHandle = ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, pointVS);
    final int pointFSHandle = ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, pointFS);

    aPointProgramHandle = ShaderHelper.createAndLinkProgram(pointVSHandle, pointFSHandle,
            new String[]{"a_Position", "a_Color"});

    // Second, copy these buffers into OpenGL's memory. After, we don't need to keep the client-side buffers around.
    GLES20.glGenBuffers(glPointBuffer.length, glPointBuffer, 0);

    createBuffers(positions, colors);
}
 

/**
 * instantiate the Lines shape object
 * @param activity
 * @param positions
 * @param colors
 */
public Lines(Context activity, float[] positions, float[] colors) {

    /** initialize the line program */
    final String lineVS = RawResourceReader.readTextFileFromRawResource(activity, R.raw.line_vertex_shader);
    final String lineFS = RawResourceReader.readTextFileFromRawResource(activity, R.raw.line_fragment_shader);

    final int lineVSHandle = ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, lineVS);
    final int lineFSHandle = ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, lineFS);

    aLineProgramHandle = ShaderHelper.createAndLinkProgram(lineVSHandle, lineFSHandle,
            new String[]{"a_Position", "a_Color"});

    // Second, copy these buffers into OpenGL's memory. After, we don't need to keep the client-side buffers around.
    GLES20.glGenBuffers(glLineBuffer.length, glLineBuffer, 0);

    createBuffers(positions, colors);
}
 

private void initializeGLProgram(Context context) {
    final String vertexShader = RawResourceReader.readTextFileFromRawResource(context,
            R.raw.heightmap_vertex_shader);
    final String fragmentShader = RawResourceReader.readTextFileFromRawResource(context,
            R.raw.heightmap_fragment_shader);

    final int vertexShaderHandle = ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, vertexShader);
    final int fragmentShaderHandle = ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader);

    aProgramHandle = ShaderHelper.createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, new String[] {
            "a_Position", "a_Normal", "a_Color" });

    GLES20.glGenBuffers(1, vbo, 0);
    GLES20.glGenBuffers(1, ibo, 0);

    isActive = true;

}
 

/**
 * instantiate the Quad shape object
 * @param activity
 * @param positions
 * @param widths
 */
public Quad(Context activity, float[] positions, float[] widths) {

    final String vertexShader = RawResourceReader.readTextFileFromRawResource(activity,
            R.raw.quad_vertex_shader);
    final String fragmentShader = RawResourceReader.readTextFileFromRawResource(activity,
            R.raw.quad_fragment_shader);

    final int vertexShaderHandle = ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, vertexShader);
    final int fragmentShaderHandle = ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader);

    aQuadProgramHandle = ShaderHelper.createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, new String[] {
            "a_Position", "a_Color", "a_TexCoordinate" });

    GLES20.glGenBuffers(1, qvbo, 0);
    GLES20.glGenBuffers(1, qibo, 0);

    createBuffers(positions, widths);
}
 

private void createVertexBuffers() {
    cubeBuffer.position(0);
    texBuffer.position(0);
    indexBuffer.position(0);

    GLES20.glGenBuffers(1, texturePointer, 0);
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, texturePointer[0]);
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, tex.length * 4, texBuffer, GLES20.GL_STATIC_DRAW);

    GLES20.glGenBuffers(1, cubePointer, 0);
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, cubePointer[0]);
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, cube.length * 4, cubeBuffer, GLES20.GL_STATIC_DRAW);

    GLES20.glGenBuffers(1, indexPointer, 0);
    GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, indexPointer[0]);
    GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, indeces.length * 4, indexBuffer, GLES20.GL_STATIC_DRAW);

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

/**
 * 创建vbo
 */
private void createVBO() {
    //1. 创建VBO
    int[] vbos = new int[1];
    GLES20.glGenBuffers(vbos.length, vbos, 0);
    vboId = vbos[0];
    //2. 绑定VBO
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboId);
    //3. 分配VBO需要的缓存大小
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vertexPoint.length * 4 + texturePoint.length * 4, null, GLES20.GL_STATIC_DRAW);
    //4. 为VBO设置顶点数据的值
    GLES20.glBufferSubData(GLES20.GL_ARRAY_BUFFER, 0, vertexPoint.length * 4, vertexBuffer);
    GLES20.glBufferSubData(GLES20.GL_ARRAY_BUFFER, vertexPoint.length * 4, texturePoint.length * 4, textureBuffer);
    //5. 解绑VBO
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
}
 

private boolean initGLBuffers() {
    //Fill vertices
    setQuad(mVertexBuffer, 0, 0, mDisplayWidth, mDisplayHeight);

    // Setup GL Textures
    GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mTexNames[0]);
    GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER,
            GLES20.GL_NEAREST);
    GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER,
            GLES20.GL_NEAREST);
    GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S,
            GLES20.GL_CLAMP_TO_EDGE);
    GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T,
            GLES20.GL_CLAMP_TO_EDGE);
    GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, 0);

    // Setup GL Buffers
    GLES20.glGenBuffers(2, mGLBuffers, 0);

    // fill vertex buffer
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mGLBuffers[0]);
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, mVertexBuffer.capacity() * 4,
                        mVertexBuffer, GLES20.GL_STATIC_DRAW);

    // fill tex buffer
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mGLBuffers[1]);
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, mTexCoordBuffer.capacity() * 4,
                        mTexCoordBuffer, GLES20.GL_STATIC_DRAW);

    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);

    return true;
}
 

private static int loadGeometry(final FloatBuffer buffer)
{
  ResultRunnable<Integer> runnable = new ResultRunnable<Integer>()
  {
    @Override
    protected Integer onRun()
    {
      int error;
      int[] buffers = new int[1];

      GLES20.glGenBuffers(1, buffers, 0);
      if ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR)
        throw new GLException(error, Integer.toString(error));

      GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, buffers[0]);
      if ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR)
        throw new GLException(error, Integer.toString(error));

      GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, buffer.capacity() * 4, buffer, GLES20.GL_STATIC_DRAW);
      if ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR)
        throw new GLException(error, Integer.toString(error));

      return buffers[0];
    }
  };

  GameContext.glThread.sendEvent(runnable);
  return runnable.getResult();
}
 

/**
 * Allocates and initializes OpenGL resources needed by the plane renderer.  Must be
 * called on the OpenGL thread, typically in
 * {@link GLSurfaceView.Renderer#onSurfaceCreated(GL10, EGLConfig)}.
 *
 * @param context Needed to access shader source.
 */
public void createOnGlThread(Context context) {
    ShaderUtil.checkGLError(TAG, "before create");

    int[] buffers = new int[1];
    GLES20.glGenBuffers(1, buffers, 0);
    mVbo = buffers[0];
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVbo);

    mVboSize = INITIAL_BUFFER_POINTS * BYTES_PER_POINT;
    GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, mVboSize, null, GLES20.GL_DYNAMIC_DRAW);
    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);

    ShaderUtil.checkGLError(TAG, "buffer alloc");

    int vertexShader = ShaderUtil.loadGLShader(TAG, context,
        GLES20.GL_VERTEX_SHADER, R.raw.point_cloud_vertex);
    int passthroughShader = ShaderUtil.loadGLShader(TAG, context,
        GLES20.GL_FRAGMENT_SHADER, R.raw.passthrough_fragment);

    mProgramName = GLES20.glCreateProgram();
    GLES20.glAttachShader(mProgramName, vertexShader);
    GLES20.glAttachShader(mProgramName, passthroughShader);
    GLES20.glLinkProgram(mProgramName);
    GLES20.glUseProgram(mProgramName);

    ShaderUtil.checkGLError(TAG, "program");

    mPositionAttribute = GLES20.glGetAttribLocation(mProgramName, "a_Position");
    mColorUniform = GLES20.glGetUniformLocation(mProgramName, "u_Color");
    mModelViewProjectionUniform = GLES20.glGetUniformLocation(
        mProgramName, "u_ModelViewProjection");
    mPointSizeUniform = GLES20.glGetUniformLocation(mProgramName, "u_PointSize");

    ShaderUtil.checkGLError(TAG, "program  params");
}
 

public int generateArrayBuffer(final int pSize, final int pUsage) {
	GLES20.glGenBuffers(1, this.mHardwareIDContainer, 0);
	final int hardwareBufferID = this.mHardwareIDContainer[0];

	this.bindArrayBuffer(hardwareBufferID);
	GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, pSize, null, pUsage);
	this.bindArrayBuffer(0);

	return hardwareBufferID;
}
 

public int generateIndexBuffer(final int pSize, final int pUsage) {
	GLES20.glGenBuffers(1, this.mHardwareIDContainer, 0);
	final int hardwareBufferID = this.mHardwareIDContainer[0];
	
	this.bindIndexBuffer(hardwareBufferID);
	GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, pSize, null, pUsage);
	this.bindIndexBuffer(0);
	
	return hardwareBufferID;
}
 

@Override
public void glGenBuffers(int n, int[] buffers, int offset) {
    GLES20.glGenBuffers(n, buffers, offset);
    GLES20Canvas.checkError();
}
 

public int generateBuffer() {
	GLES20.glGenBuffers(1, this.mHardwareIDContainer, 0);
	return this.mHardwareIDContainer[0];
}
 

private void checkAndInitGL()
{
    if(mIsModelGenerated == false) {
        // Add dummy surface for debug

        FloatBuffer vertexBuffer;
        FloatBuffer textureCoordinateBuffer;

        // VBO
        GLES20.glGenBuffers(1, mPositionVBO, 0);
        GLUtility.checkGlError("glGenBuffers");

        GLES20.glGenBuffers(1, mTextureCoordinateVBO, 0);
        GLUtility.checkGlError("glGenBuffers");

        // Initialize vertex byte buffer for shape coordinates
        ByteBuffer bb = ByteBuffer.allocateDirect(mPosition.length * 4);
        bb.order(ByteOrder.nativeOrder());
        vertexBuffer = bb.asFloatBuffer();
        vertexBuffer.put(mPosition);
        vertexBuffer.position(0);

        // VBO buffer vertex data
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mPositionVBO[0]);
        GLUtility.checkGlError("glBindBuffer");

        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, mPosition.length * 4, vertexBuffer, GLES20.GL_STATIC_DRAW);
        GLUtility.checkGlError("glBufferData");

        // VBO buffer texture coord data
        bb = ByteBuffer.allocateDirect(mTextureCoordinate.length * 4);
        bb.order(ByteOrder.nativeOrder());
        textureCoordinateBuffer = bb.asFloatBuffer();
        textureCoordinateBuffer.put(mTextureCoordinate);
        textureCoordinateBuffer.position(0);

        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mTextureCoordinateVBO[0]);
        GLUtility.checkGlError("glBindBuffer");

        GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, mTextureCoordinate.length * 4, textureCoordinateBuffer, GLES20.GL_STATIC_DRAW);
        GLUtility.checkGlError("glBufferData");


        // prepare shaders and OpenGL program
        int vertexShader = GLUtility.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = GLUtility.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);
        int fragmentShader_Luminance = GLUtility.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode_Luminance);

        mProgram = GLES20.glCreateProgram();
        GLUtility.checkGlError("glCreateProgram");
        GLES20.glAttachShader(mProgram, vertexShader);
        GLUtility.checkGlError("glAttachShader");
        GLES20.glAttachShader(mProgram, fragmentShader);
        GLUtility.checkGlError("glAttachShader");
        GLES20.glLinkProgram(mProgram);
        GLUtility.checkGlError("glLinkProgram");

        mProgram_Luminance = GLES20.glCreateProgram();
        GLUtility.checkGlError("glCreateProgram");
        GLES20.glAttachShader(mProgram_Luminance, vertexShader);
        GLUtility.checkGlError("glAttachShader");
        GLES20.glAttachShader(mProgram_Luminance, fragmentShader_Luminance);
        GLUtility.checkGlError("glAttachShader");
        GLES20.glLinkProgram(mProgram_Luminance);
        GLUtility.checkGlError("glLinkProgram");

        mIsModelGenerated = true;
    }
}
 

public static int createBuffer(final FloatBuffer data) {
    final int[] buffers = new int[1];
    GLES20.glGenBuffers(buffers.length, buffers, 0);
    updateBufferData(buffers[0], data);
    return buffers[0];
}
 

private void checkAndInitGL()
{
    if(mIsModelGenerated == false) {
        FloatBuffer vertexBuffer;
        FloatBuffer textureCoordinateBuffer;

        // VBO
        GLES20.glGenBuffers(1, mPositionVBO, 0);
        GLUtility.checkGlError("glGenBuffers");

        // Initialize vertex byte buffer for shape coordinates
        ByteBuffer bb = ByteBuffer.allocateDirect(mPosition.length * 4);
        bb.order(ByteOrder.nativeOrder());
        vertexBuffer = bb.asFloatBuffer();
        vertexBuffer.put(mPosition);
        vertexBuffer.position(0);

        // VBO buffer vertex data
        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mPositionVBO[0]);
        GLUtility.checkGlError("glBindBuffer");

        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, mPosition.length * 4, vertexBuffer, GLES20.GL_STATIC_DRAW);
        GLUtility.checkGlError("glBufferData");



        // VBO buffer texture coord data
        bb = ByteBuffer.allocateDirect(mTextureCoordinate.length * 4);
        bb.order(ByteOrder.nativeOrder());
        textureCoordinateBuffer = bb.asFloatBuffer();
        textureCoordinateBuffer.put(mTextureCoordinate);
        textureCoordinateBuffer.position(0);

        GLES20.glGenBuffers(1, mTextureCoordinateVBO, 0);
        GLUtility.checkGlError("glGenBuffers");

        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mTextureCoordinateVBO[0]);
        GLUtility.checkGlError("glBindBuffer");

        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, mTextureCoordinate.length * 4, textureCoordinateBuffer, GLES20.GL_STATIC_DRAW);
        GLUtility.checkGlError("glBufferData");


        // VBO buffer index
        GLES20.glGenBuffers(1, mIndexVBO, 0);
        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndexVBO[0]);
        GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, mIndex.length * 2, mIndexBuffer, GLES20.GL_STATIC_DRAW);
        GLUtility.checkGlError("glBufferData");



        // prepare shaders and OpenGL program
        int vertexShader = GLUtility.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = GLUtility.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

        mProgram = GLES20.glCreateProgram();
        GLUtility.checkGlError("glCreateProgram");
        GLES20.glAttachShader(mProgram, vertexShader);
        GLUtility.checkGlError("glAttachShader");
        GLES20.glAttachShader(mProgram, fragmentShader);
        GLUtility.checkGlError("glAttachShader");
        GLES20.glLinkProgram(mProgram);
        GLUtility.checkGlError("glLinkProgram");

        mIsModelGenerated = true;
    }
}
 

public static int createBuffer(final FloatBuffer data) {
    final int[] buffers = new int[1];
    GLES20.glGenBuffers(buffers.length, buffers, 0);
    updateBufferData(buffers[0], data);
    return buffers[0];
}
 

public Framebuffer() {
	int[] buffers = new int[1];
	GLES20.glGenBuffers( 1, buffers, 0 );
	id = buffers[0];
}
 

public int generateBuffer() {
	GLES20.glGenBuffers(1, this.mHardwareIDContainer, 0);
	return this.mHardwareIDContainer[0];
}
 

@Override
public void glGenBuffers(int n, int[] buffers, int offset) {
    GLES20.glGenBuffers(n, buffers, offset);
    GLES20Canvas.checkError();
}