OpenGL draw circle, weird bugs

I'm no mathematician, but I need to draw a filled in circle.

My approach was to use someone else's math to get all the points on the circumference of a circle, and turn them into a triangle fan.

I need the vertices in a vertex array, no immediate mode.

The circle does appear. However, when I try and overlay circles strange things happen. They appear only a second and then disappear. When I move my mouse out of the window a triangle sticks out from nowhere.

Here's the class:

class circle
{
    //every coordinate with have an X and Y
    private:
    GLfloat *_vertices;
    static const float DEG2RAD = 3.14159/180;

    GLfloat _scalex, _scaley, _scalez;
    int _cachearraysize;

    public:

    circle(float scalex, float scaley, float scalez, float radius, int numdegrees)
    {
       //360 degrees, 2 per coordinate, 2 coordinates for center and end of triangle fan
        _cachearraysize = (numdegrees * 2) + 4;

        _vertices = new GLfloat[_cachearraysize];
        for(int x= 2; x < (_cachearraysize-2); x = x + 2)
        {
            float degreeinRadians = x*DEG2RAD;
     开发者_如何学Go       _vertices[x] = cos(degreeinRadians)*radius;
            _vertices[x + 1] = sin(degreeinRadians)*radius;
        }


       //get the X as X of 0 and X of 180 degrees, subtract to get diameter.  divide
       //by 2 for radius and add back to X of 180
        _vertices[0]= ((_vertices[2] - _vertices[362])/2) + _vertices[362];

        //same idea for Y
        _vertices[1]= ((_vertices[183] - _vertices[543])/2) + _vertices[543];

        //close off the triangle fan at the same point as start
        _vertices[_cachearraysize -1] = _vertices[0];
        _vertices[_cachearraysize] = _vertices[1];

        _scalex = scalex;
        _scaley = scaley;
        _scalez = scalez;

    }
    ~circle()
    {
        delete[] _vertices;
    }

    void draw()
    {
        glScalef(_scalex, _scaley, _scalez);
        glVertexPointer(2,GL_FLOAT, 0, _vertices);
        glDrawArrays(GL_TRIANGLE_FAN, 0, _cachearraysize);
    }
};

---

That's some ugly code, I'd say - lots of magic numbers et cetera.

Try something like:

struct Point {
   Point(float x, float y) : x(x), y(y) {}
   float x, y;
};
std::vector<Point> points;
const float step = 0.1;
const float radius = 2;

points.push_back(Point(0,0));
// iterate over the angle array
for (float a=0; a<2*M_PI; a+=step) {
   points.push_back(cos(a)*radius,sin(a)*radius);
}
// duplicate the first vertex after the centre
points.push_back(points.at(1));

// rendering:

glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2,GL_FLOAT,0, &points[0]);
glDrawArrays(GL_TRIANGLE_FAN,0,points.size());

It's up to you to rewrite this as a class, as you prefer. The math behind is really simple, don't fear to try and understand it.