OpenGL zeichnen Kreis, seltsame Bugs

Question

Ich bin kein Mathematiker, aber ich muss einen ausgefüllten Kreis zeichnen.

Mein Ansatz war, jemandes Mathematik zu verwenden, um alle Punkte auf dem Umfang eines Kreises zu erhalten und sie in einen Dreiecksfächer zu verwandeln.

Ich brauche die Vertices in einem Vertex-Array, keine unmittelbare Modus.

Der Kreis erscheint. Wenn ich jedoch versuche, Kreise zu überlagern, passieren seltsame Dinge. Sie erscheinen nur eine Sekunde und verschwinden dann. Wenn ich meine Maus aus dem Fenster ziehe, ragt ein Dreieck aus dem Nichts hervor.

Hier ist die Klasse:

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

Answer 1

, dass einige hässliche Code ist, würde ich sagen - viele magische Zahlen und so weiter.

Versuchen Sie so etwas wie:

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

Es liegt an Ihnen, dies als eine Klasse neu zu schreiben, wie Sie bevorzugen. Die Mathematik dahinter ist wirklich einfach, habe keine Angst, es zu versuchen und zu verstehen.