Drawing a circle with a sector cut out in OpenGL ES 1.1

I'm trying to draw the following shape using OpenGL ES 1.1. And well, I'm stuck, I don't really know how to go about it.

My game currently uses Android's Canvas API, which isn't hardware accelerated, so I'm rewriting it with OpenGL ES. The开发者_JAVA技巧 Canvas class has a method called drawArc which makes drawing this shape very very easy; Canvas.drawArc

Any advice/hints on doing the same with OpenGL ES?

Thank you for reading.

---

void gltDrawArc(unsigned int const segments, float angle_start, float angle_stop)
{
    int i;
    float const angle_step = (angle_stop - angle_start)/segments;

    GLfloat *arc_vertices;
    arc_vertices = malloc(2*sizeof(GLfloat) * (segments+2));

    arc_vertices[0] = arc_vertices[1] = 0.

    for(i=0; i<segments+1; i++) {
        arc_vertices[2 + 2*i    ] = cos(angle_start + i*angle_step);
        arc_vertices[2 + 2*i + 1] = sin(angle_start + i*angle_step);
    }
    glVertexPointer(2, GL_FLOAT, 0, arc_vertices);
    glEnableClientState(GL_VERTEX_ARRAY);
    glDrawArrays(GL_TRIANGLE_FAN, 0, segments+2);
    free(arc_vertices);
}

---

What about just sampling the circle at discrete angles and drawing a GL_TRIANGLE_FAN?

EDIT: Something like this will just draw a sector of a unit circle around the origin in 2D:

glBegin(GL_TRIANGLE_FAN);
    glVertex2f(0.0f, 0.0f);
    for(angle=startAngle; angle<=endAngle; ++angle)
        glVertex2f(cos(angle), sin(angle));
glEnd();

Actually take this more as pseudocode, as sin and cos usually work on radians and I'm using degrees, but you should get the point.

---

I am new to

android programming so I am sure there is probably a better way to do this. But I was following the OpenGL ES 1.0 tutorial on the android developers site http://developer.android.com/resources/tutorials/opengl/opengl-es10.html which walks you through drawing a green triangle. You can follow the link and you will see most of the code I used there. I wanted to draw a circle on the triangle. The code I added is based on the above example posted by datenwolf. And is shown in snippets below:

public class HelloOpenGLES10Renderer implements GLSurfaceView.Renderer {

    // the number small triangles used to make a circle
    public int segments = 100;
    public float mAngle;
    private FloatBuffer triangleVB;
            // array to hold the FloatBuffer for the small triangles
    private FloatBuffer [] segmentsArray = new FloatBuffer[segments];


    private void initShapes(){

                   .
                   .
                   .

        // stuff to draw holes in the board      
        int i = 0;
        float angle_start = 0.0f;
        float angle_stop = 2.0f * (float) java.lang.Math.PI;
        float angle_step = (angle_stop - angle_start)/segments;

        for(i=0; i<segments; i++) {
            float[] holeCoords;
            FloatBuffer holeVB;
            holeCoords = new float [ 9 ];
            // initialize vertex Buffer for triangle  
            // (# of coordinate values * 4 bytes per float)
            ByteBuffer vbb2 = ByteBuffer.allocateDirect(holeCoords.length * 4); 
            vbb2.order(ByteOrder.nativeOrder());// use the device hardware's native byte order
            holeVB = vbb2.asFloatBuffer();  // create a floating point buffer from the ByteBuffer

            float x1 = 0.05f * (float) java.lang.Math.cos(angle_start + i*angle_step);
            float y1 = 0.05f * (float) java.lang.Math.sin(angle_start + i*angle_step);
            float z1 = 0.1f;
            float x2 = 0.05f * (float) java.lang.Math.cos(angle_start + i+1*angle_step);
            float y2 = 0.05f * (float) java.lang.Math.sin(angle_start + i+1*angle_step);
            float z2 = 0.1f;
            holeCoords[0] = 0.0f;
            holeCoords[1] = 0.0f;
            holeCoords[2] = 0.1f;
            holeCoords[3] = x1;
            holeCoords[4] = y1;
            holeCoords[5] = z1;
            holeCoords[6] = x2;
            holeCoords[7] = y2;
            holeCoords[8] = z2;
            holeVB.put(holeCoords);    // add the coordinates to the FloatBuffer
            holeVB.position(0);            // set the buffer to read the first coordinate
            segmentsArray[i] = holeVB;
        }            
    }

    .
    .
    .


public void onDrawFrame(GL10 gl) {

        .
        .
        .
        // Draw hole
        gl.glColor4f( 1.0f - 0.63671875f, 1.0f - 0.76953125f, 1.0f - 0.22265625f, 0.0f);
        for ( int i=0; i<segments; i++ ) {
            gl.glVertexPointer(3, GL10.GL_FLOAT, 0, segmentsArray[i]);
            gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3);
        }

}