public Vector2f[] getFrameBufferSamplePositions(FrameBuffer fb) {
    if (fb.getSamples() <= 1) {
        throw new IllegalArgumentException("Framebuffer must be multisampled");
    }

    setFrameBuffer(fb);

    Vector2f[] samplePositions = new Vector2f[fb.getSamples()];
    FloatBuffer samplePos = BufferUtils.createFloatBuffer(2);
    for (int i = 0; i < samplePositions.length; i++) {
        glGetMultisample(GL_SAMPLE_POSITION, i, samplePos);
        samplePos.clear();
        samplePositions[i] = new Vector2f(samplePos.get(0) - 0.5f,
                samplePos.get(1) - 0.5f);
    }
    return samplePositions;
}
 

/**
 * Creates a new FloatBuffer with the same contents as the given FloatBuffer. The new FloatBuffer is seperate from the old one and changes are not reflected across. If you want to reflect changes,
 * consider using Buffer.duplicate().
 *
 * @param buf
 *            the FloatBuffer to copy
 * @return the copy
 */
public static FloatBuffer clone(FloatBuffer buf) {
	if (buf == null) {
		return null;
	}
	buf.rewind();

	FloatBuffer copy;
	if (buf.isDirect()) {
		copy = createFloatBuffer(buf.limit());
	}
	else {
		copy = FloatBuffer.allocate(buf.limit());
	}
	copy.put(buf);

	return copy;
}
 

private boolean initBuffer(GL3 gl3) {

        FloatBuffer positionBuffer = GLBuffers.newDirectFloatBuffer(positionData);
        IntBuffer uniformBufferOffset = GLBuffers.newDirectIntBuffer(1);

        gl3.glGenBuffers(Buffer.MAX, bufferName);

        gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
        gl3.glBufferData(GL_ARRAY_BUFFER, positionSize, positionBuffer, GL_STATIC_DRAW);
        gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

        gl3.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, uniformBufferOffset);
        int uniformBlockSize = Math.max(Mat4.SIZE, uniformBufferOffset.get(0));

        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        gl3.glBufferData(GL_UNIFORM_BUFFER, uniformBlockSize, null, GL_DYNAMIC_DRAW);
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, 0);

        BufferUtils.destroyDirectBuffer(positionBuffer);
        BufferUtils.destroyDirectBuffer(uniformBufferOffset);

        return checkError(gl3, "initBuffer");
    }
 

private boolean initBuffer(GL4 gl4) {

        // Generate a buffer object
        gl4.glGenBuffers(Buffer.MAX, bufferName);

        gl4.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
        FloatBuffer vertexBuffer = GLBuffers.newDirectFloatBuffer(vertexData);
        gl4.glBufferStorage(GL_ARRAY_BUFFER, vertexSize, vertexBuffer, 0);
        BufferUtils.destroyDirectBuffer(vertexBuffer);
        gl4.glBindBuffer(GL_ARRAY_BUFFER, 0);

        int[] uniformBufferOffset = {0};
        gl4.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, uniformBufferOffset, 0);
        int uniformBlockSize = Math.max(Mat4.SIZE, uniformBufferOffset[0]);

        gl4.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        gl4.glBufferStorage(GL_UNIFORM_BUFFER, uniformBlockSize, null, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT
                | GL_MAP_COHERENT_BIT);
        gl4.glBindBuffer(GL_UNIFORM_BUFFER, 0);

        return checkError(gl4, "initBuffer");
    }
 

@Override
public void init() {
	glClearColor(0, 0, 0, 0);
	
	program = new ShaderProgram(readFromFile("example3.3.vert"), readFromFile("example3.3.frag"));
	timeLocation = program.getUniformLocation("time");
	
	int loopDurationLocation = program.getUniformLocation("loopDuration");
	program.begin();
	glUniform1f(loopDurationLocation, 5);
	program.end();
	
	vbo = glGenBuffers();
	
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, (FloatBuffer)BufferUtils.createFloatBuffer(12).put(new float[] { 0.25f, 0.25f, 0.0f, 1.0f,
			0.25f, -0.25f, 0.0f, 1.0f,
			-0.25f, -0.25f, 0.0f, 1.0f }).flip(), GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	
	// In core OpenGL, Vertex Array Objects (VAOs) are required for all draw calls. VAOs will be explained in Chapter 5.
	glBindVertexArray(glGenVertexArrays());
}
 

@Override
public FloatBuffer filter(float sx, float sy, float base, FloatBuffer buffer, int size) {
	float[] data = buffer.array();
	float[] retval = new float[data.length];

	for (int y = this.radius; y < size - this.radius; y++) {
		for (int x = this.radius; x < size - this.radius; x++) {
			int idx = y * size + x;
			float n = 0;
			for (int i = -this.radius; i < this.radius + 1; i++) {
				for (int j = -this.radius; j < this.radius + 1; j++) {
					n += data[(y + i) * size + x + j];
				}
			}
			retval[idx] = this.effect * n / (4 * this.radius * (this.radius + 1) + 1) + (1 - this.effect) * data[idx];
		}
	}

	return FloatBuffer.wrap(retval);
}
 

private boolean initSampler(GL4 gl4) {

        FloatBuffer borderColor = GLBuffers.newDirectFloatBuffer(new float[]{0.0f, 0.0f, 0.0f, 0.0f});

        gl4.glGenSamplers(1, samplerName);
        gl4.glSamplerParameteri(samplerName.get(0), GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
        gl4.glSamplerParameteri(samplerName.get(0), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        gl4.glSamplerParameteri(samplerName.get(0), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        gl4.glSamplerParameteri(samplerName.get(0), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        gl4.glSamplerParameteri(samplerName.get(0), GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
        gl4.glSamplerParameterfv(samplerName.get(0), GL_TEXTURE_BORDER_COLOR, borderColor);
        gl4.glSamplerParameterf(samplerName.get(0), GL_TEXTURE_MIN_LOD, -1000.f);
        gl4.glSamplerParameterf(samplerName.get(0), GL_TEXTURE_MAX_LOD, 1000.f);
        gl4.glSamplerParameterf(samplerName.get(0), GL_TEXTURE_LOD_BIAS, 0.0f);
        gl4.glSamplerParameteri(samplerName.get(0), GL_TEXTURE_COMPARE_MODE, GL_NONE);
        gl4.glSamplerParameteri(samplerName.get(0), GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);

        BufferUtils.destroyDirectBuffer(borderColor);

        return true;
    }
 

void ensureCapacity(int size)
{
	while (buffer.remaining() < size)
	{
		FloatBuffer newB = allocateDirect(buffer.capacity() * 2);
		buffer.flip();
		newB.put(buffer);
		buffer = newB;
	}
}
 

@Override
public <T> T convert(NDArray from, Class<T> to) {
    Preconditions.checkState(canConvert(from, to));
    SerializedNDArray s = (SerializedNDArray)from.get();
    FloatBuffer fb = s.getBuffer().asFloatBuffer();
    int len = fb.capacity();
    float[] out = new float[len];
    fb.get(out);
    return (T) new TestNDArrayObject(out);
}
 

private boolean initBuffer(GL3 gl3) {

        ShortBuffer elementBuffer = GLBuffers.newDirectShortBuffer(elementData);
        FloatBuffer vertexBuffer = GLBuffers.newDirectFloatBuffer(vertexData);
        IntBuffer uniformBufferOffset = GLBuffers.newDirectIntBuffer(1);

        gl3.glGenBuffers(Buffer.MAX, bufferName);

        gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
        gl3.glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementSize, elementBuffer, GL_STATIC_DRAW);
        gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

        gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
        gl3.glBufferData(GL_ARRAY_BUFFER, vertexSize, vertexBuffer, GL_STATIC_DRAW);
        gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

        gl3.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, uniformBufferOffset);
        int uniformBlockSize = Math.max(Mat4.SIZE, uniformBufferOffset.get(0));

        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        gl3.glBufferData(GL_UNIFORM_BUFFER, uniformBlockSize, null, GL_DYNAMIC_DRAW);
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, 0);

        BufferUtils.destroyDirectBuffer(elementBuffer);
        BufferUtils.destroyDirectBuffer(vertexBuffer);
        BufferUtils.destroyDirectBuffer(uniformBufferOffset);

        return checkError(gl3, "initBuffer");
    }
 

private static void writeColorBuffer(List<VertexData> vertices, ColorRGBA[] cols, Mesh mesh) {
    FloatBuffer colors = BufferUtils.createFloatBuffer(vertices.size() * 4);
    colors.rewind();
    for (ColorRGBA color : cols) {
        colors.put(color.r);
        colors.put(color.g);
        colors.put(color.b);
        colors.put(color.a);
    }
    mesh.clearBuffer(Type.Color);
    mesh.setBuffer(Type.Color, 4, colors);
}
 

/**
 * Ensures there is at least the <code>required</code> number of entries left after the current position of the
 * buffer. If the buffer is too small a larger one is created and the old one copied to the new buffer.
 * @param buffer buffer that should be checked/copied (may be null)
 * @param required minimum number of elements that should be remaining in the returned buffer
 * @return a buffer large enough to receive at least the <code>required</code> number of entries, same position as
 * the input buffer, not null
 */
public static FloatBuffer ensureLargeEnough(FloatBuffer buffer, int required) {
    if (buffer == null || (buffer.remaining() < required)) {
        int position = (buffer != null ? buffer.position() : 0);
        FloatBuffer newVerts = createFloatBuffer(position + required);
        if (buffer != null) {
            buffer.rewind();
            newVerts.put(buffer);
            newVerts.position(position);
        }
        buffer = newVerts;
    }
    return buffer;
}
 

public FloatBuffer toBuffer() {
	buffer.clear();
	buffer.put(cameraSpaceLightPos.toBuffer());
	buffer.put(lightIntensity.toBuffer());
	buffer.flip();
	return buffer;
}
 

private boolean initBuffers(GL4 gl4) {

        command = new DrawElementsIndirectCommand(elementCount, 1, 0, 0, 0);
        IntBuffer commandBuffer = GLBuffers.newDirectIntBuffer(command.toIa_());
        FloatBuffer positionBuffer = GLBuffers.newDirectFloatBuffer(positionData);
        IntBuffer elementBuffer = GLBuffers.newDirectIntBuffer(elementData);

        gl4.glGenBuffers(Buffer.MAX, bufferName);

        gl4.glBindBuffer(GL_DRAW_INDIRECT_BUFFER, bufferName.get(Buffer.INDIRECT));
        gl4.glBufferData(GL_DRAW_INDIRECT_BUFFER, command.SIZE, commandBuffer, GL_STATIC_READ);
        gl4.glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);

        gl4.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.ARRAY));
        gl4.glBufferData(GL_ARRAY_BUFFER, positionSize, positionBuffer, GL_STATIC_DRAW);
        gl4.glBindBuffer(GL_ARRAY_BUFFER, 0);

        gl4.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
        gl4.glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementSize, elementBuffer, GL_STATIC_DRAW);
        gl4.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

        BufferUtils.destroyDirectBuffer(positionBuffer);
        BufferUtils.destroyDirectBuffer(elementBuffer);
        BufferUtils.destroyDirectBuffer(commandBuffer);

        return checkError(gl4, "initBuffers");
    }
 

private boolean initBuffer(GL3 gl3) {

        FloatBuffer vertexBuffer = GLBuffers.newDirectFloatBuffer(vertexSize);
        for (Vertex_v4fc4f vertex : vertexData) {
            vertexBuffer.put(vertex.toFa_());
        }
        vertexBuffer.rewind();
        IntBuffer uniformBufferOffset = GLBuffers.newDirectIntBuffer(1);

        gl3.glGenBuffers(Buffer.MAX, bufferName);

        gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
        gl3.glBufferData(GL_ARRAY_BUFFER, vertexSize, vertexBuffer, GL_STATIC_DRAW);
        gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

        gl3.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, uniformBufferOffset);
        int uniformBlockSize = Math.max(Mat4.SIZE, uniformBufferOffset.get(0));

        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        gl3.glBufferData(GL_UNIFORM_BUFFER, uniformBlockSize, null, GL_DYNAMIC_DRAW);
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, 0);

        BufferUtils.destroyDirectBuffer(vertexBuffer);
        BufferUtils.destroyDirectBuffer(uniformBufferOffset);

        return true;
    }
 

public FloatBuffer toBuffer() {
	buffer.clear();
	buffer.put(ambientIntensity.toBuffer());
	buffer.put(lightAttenuation);
	buffer.put(maxIntensity);
	buffer.put(padding);
	
	for(PerLight light : lights)
		if(light != null)
			buffer.put(light.toBuffer());
	
	buffer.flip();
	
	return buffer;
}
 

/**
 * Get Point Cloud Color Positions as a FloatBuffer, transform to a float array with .array(), or get values with get(index)
 * @return FloatBuffer
 */
public FloatBuffer getPointCloudColorPos() {
	float[] pcRawData = jniGetPointCloudColorMap();
	pointCloudColorPos.put(pcRawData, 0, WIDTHColor * HEIGHTColor * 3);
	pointCloudColorPos.rewind();

	return pointCloudColorPos;
}
 

@Test
public void testIdentity() {
	Assert.assertTrue(Mat3.MAT3_IDENTITY.isIdentity());
	Assert.assertFalse(Mat3.MAT3_IDENTITY.isZero());
	
	Assert.assertEquals(Mat3.MAT3_IDENTITY, new Mat3(1f));
	Assert.assertTrue(new Mat3(1f).isIdentity());
	
	FloatBuffer buffer = Mat3.MAT3_IDENTITY.getBuffer();
	JglmTesting.assertFloatsEqualDefaultTol(1f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(1f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(1f, buffer.get());
	
	// Should be able to get a "fresh" buffer.
	buffer = Mat3.MAT3_IDENTITY.getBuffer();
	JglmTesting.assertFloatsEqualDefaultTol(1f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(1f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(0f, buffer.get());
	JglmTesting.assertFloatsEqualDefaultTol(1f, buffer.get());
}
 

public void updateData(FloatBuffer data, int trianglesCount, Vector3 position, Vector3 angles)
{
  if (mode != MeshMode.Dynamic)
    throw new IllegalStateException("not right mode");

  this.data = data;
  this.pointsCount = trianglesCount;
  this.position = position == null ? null : new Vector3(position);
  this.angles = angles == null ? null : new Vector3(angles);
}
 

public void setUniform(String uniformName, Matrix4f[] matrices) {
    try (MemoryStack stack = MemoryStack.stackPush()) {
        int length = matrices != null ? matrices.length : 0;
        FloatBuffer fb = stack.mallocFloat(16 * length);
        for (int i = 0; i < length; i++) {
            matrices[i].get(16 * i, fb);
        }
        glUniformMatrix4fv(uniforms.get(uniformName), false, fb);
    }
}
 

@Override
protected void onRenderAudioData(
        GL10 gl, int width, int height,
        Object workObj, CapturedDataHolder data) {
    final RenderThreadWork work = (RenderThreadWork) workObj;

    // NOTE:
    // Increase the SKIP value if the visualization is too heavy
    // on your device

    final int SKIP = 1;
    final byte[] waveform = data.mByteData;
    final int N = waveform.length / SKIP;

    // 2: (x, 2)
    final int workBufferSize = N * 2;
    boolean needToUpdateX = false;

    // prepare working buffer
    if (work.mWorkFloatBuffer == null || work.mWorkFloatBuffer.length < workBufferSize) {
        work.mWorkFloatBuffer = new float[workBufferSize];
        work.mNativeFloatBuffer = allocateNativeFloatBuffer(workBufferSize);
        needToUpdateX |= true;
    }

    final float[] points = work.mWorkFloatBuffer;
    final FloatBuffer pointsBuffer = work.mNativeFloatBuffer;

    needToUpdateX |= (width != work.prevCanvasWidth);
    work.prevCanvasWidth = width;

    if (needToUpdateX) {
        makeXPointPositionData(N, points);
    }

    makeYPointPositionData(waveform, N, SKIP, 0, points);
    converToFloatBuffer(pointsBuffer, points, (2 * N));
    drawWaveForm(gl, width, height, pointsBuffer, N, (0.0f - 1.0f), (255.0f + 1.0f),
            work.mColor);
}
 

private static final FloatBuffer asFloatBuffer(ArrayBuffer buffer, int byteOffset, int length) {
    ByteBuffer data = byteBuffer(buffer);
    int byteLength = Float.BYTES * length;

    data.limit(byteOffset + byteLength).position(byteOffset);
    FloatBuffer view = data.asFloatBuffer();
    data.clear();
    return view;
}
 

protected void setFloatVec4(final int location, final float[] arrayValue) {
    runOnDraw(
            new Runnable() {
                @Override
                public void run() {
                    GLES20.glUniform4fv(location, 1, FloatBuffer.wrap(arrayValue));
                }
            });
}
 

public static FloatBuffer createFlippedBufferSOA(Vertex[] vertices)
{
	FloatBuffer buffer = createFloatBuffer(vertices.length * Vertex.FLOATS);
	
	for(int i = 0; i < vertices.length; i++)
	{
		buffer.put(vertices[i].getPos().getX());
		buffer.put(vertices[i].getPos().getY());
		buffer.put(vertices[i].getPos().getZ());
	}
	
	for(int i = 0; i < vertices.length; i++)
	{
		buffer.put(vertices[i].getNormal().getX());
		buffer.put(vertices[i].getNormal().getY());
		buffer.put(vertices[i].getNormal().getZ());
	}
		
	for(int i = 0; i < vertices.length; i++)
	{
		buffer.put(vertices[i].getTextureCoord().getX());
		buffer.put(vertices[i].getTextureCoord().getY());
	}	
	
	buffer.flip();
	
	return buffer;
}
 

public void glLoadMatrixf(FloatBuffer m) {
    int position = m.position();
    mCurrent.glLoadMatrixf(m);
    m.position(position);
    mgl.glLoadMatrixf(m);
    if ( _check) check();
}
 

public void setVector4InArray(float x, float y, float z, float w, int index){
    if (location == -1)
        return;

    if (varType != null && varType != VarType.Vector4Array)
        throw new IllegalArgumentException("Expected a "+varType.name()+" value!");

    FloatBuffer fb = (FloatBuffer) value;
    fb.position(index * 4);
    fb.put(x).put(y).put(z).put(w);
    fb.rewind();
    updateNeeded = true;
    setByCurrentMaterial = true;
}
 

public FloatBuffer toDfb(FloatBuffer fb, int index) {
    return fb
            .put(index + 0, x)
            .put(index + 1, y)
            .put(index + 2, z)
            .put(index + 3, w);
}
 

@Override
public MDHitPoint hit(MDRay ray) {
    if (object3D == null || object3D.getVerticesBuffer(0) == null){
        return MDHitPoint.notHit();
    }

    MDPosition position = getModelPosition();
    float[] model = position.getMatrix();

    List<MDVector3D> points = new LinkedList<>();

    FloatBuffer buffer = object3D.getVerticesBuffer(0);
    int numPoints = buffer.capacity() / 3;

    for (int i = 0; i < numPoints; i++){
        MDVector3D v = new MDVector3D();
        v.setX(buffer.get(i * 3)).setY(buffer.get(i * 3 + 1)).setZ(buffer.get(i * 3 + 2));
        v.multiplyMV(model);
        points.add(v);
    }
    MDHitPoint hit1 = hitPoint1;
    MDHitPoint hit2 = hitPoint2;
    if (points.size() == 4){
        VRUtil.intersectTriangle(ray, points.get(0), points.get(1), points.get(2), hitPoint1);
        VRUtil.intersectTriangle(ray, points.get(3), points.get(2), points.get(1), hitPoint2);
    }

    return MDHitPoint.min(hit1, hit2);
}
 

/**
 * Get Point Cloud Color Positions as a FloatBuffer, transform to a float array with .array(), or get values with get(index)
 * @return FloatBuffer
 */
public FloatBuffer getPointCloudColorPos() {
	float[] pcRawData = jniGetPointCloudColorMap();
	pointCloudColorPos.put(pcRawData, 0, WIDTHColor * HEIGHTColor * 3);
	pointCloudColorPos.rewind();

	return pointCloudColorPos;
}
 

public int onDrawFrame(final int textureId, final FloatBuffer cubeBuffer,
                   final FloatBuffer textureBuffer) {
    GLES20.glUseProgram(mGLProgId);
    runPendingOnDrawTasks();
    if (!mIsInitialized) {
        return OpenGlUtils.NOT_INIT;
    }

    cubeBuffer.position(0);
    GLES20.glVertexAttribPointer(mGLAttribPosition, 2, GLES20.GL_FLOAT, false, 0, cubeBuffer);
    GLES20.glEnableVertexAttribArray(mGLAttribPosition);
    textureBuffer.position(0);
    GLES20.glVertexAttribPointer(mGLAttribTextureCoordinate, 2, GLES20.GL_FLOAT, false, 0,
            textureBuffer);
    GLES20.glEnableVertexAttribArray(mGLAttribTextureCoordinate);
    if (textureId != OpenGlUtils.NO_TEXTURE) {
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId);
        GLES20.glUniform1i(mGLUniformTexture, 0);
    }
    onDrawArraysPre();
    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
    GLES20.glDisableVertexAttribArray(mGLAttribPosition);
    GLES20.glDisableVertexAttribArray(mGLAttribTextureCoordinate);
    onDrawArraysAfter();
    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
    return OpenGlUtils.ON_DRAWN;
}