rotation cercle OpenGL

Question

J'utilise le code suivant pour dessiner mes cercles:

double theta = 2 * 3.1415926/num_segments; 
double c = Math.Cos(theta);//precalculate the sine and cosine 
double s = Math.Sin(theta); 
double t; 
double x = r;//we start at angle = 0 
double y = 0; 

GL.glBegin(GL.GL_LINE_LOOP); 
for(int ii = 0; ii < num_segments; ii++) 
{ 
    float first = (float)(x * scaleX + cx)/xyFactor; 
    float second = (float)(y * scaleY + cy)/xyFactor; 

    GL.glVertex2f(first, second); // output Vertex 

    //apply the rotation matrix 
t = x; 
x = c * x - s * y; 
y = s * t + c * y; 
} 
GL.glEnd(); 

Le problème est que lorsque scaleX est différent de scaleY alors les cercles sont transformés dans le droit chemin, sauf pour la rotation. Dans ma séquence de code ressemble à ceci:

circle.Scale(tmp_p.scaleX, tmp_p.scaleY); 
circle.Rotate(tmp_p.rotateAngle); 

Ma question est ce que les autres calculs dois-je effectuer pour le cercle de tourner correctement lorsque scaleX et scaleY ne sont pas égaux?

alt text http://www.freeimagehosting.net/uploads/c0cfc89146.gif

Le cercle est streched comme ligne rouge indique quand acctually je veux qu'il soit par streched ligne verte.

fonction Rotation:

double cosFi = Math.Cos(angle*Math.PI/180.0); 
double sinFi = Math.Sin(angle * Math.PI/180.0); 
double x, y; 
double newX = 0, newY = 0; 
DVector center = objectSize.CenterPoint; 
y = ((MCircleCmd)cmdList[i]).m_Y; 
x = ((MCircleCmd)cmdList[i]).m_X; 
newX = (x - center.shiftX) * cosFi - (y - center.shiftY) * sinFi + center.shiftX; 
newY = (x - center.shiftX) * sinFi + (y - center.shiftY) * cosFi + center.shiftY; 
((MCircleCmd)cmdList[i]).m_X = newX; 
((MCircleCmd)cmdList[i]).m_Y = newY; 
UpdateSize(ref firstMove, newX, newY); 

fonction Echelle:

public void Scale(double scale) // scale > 1 - increase; scale < 1 decrease 
{ 
    if (!isPrepared) return; 
    objectSize.x1 *= scale; 
    objectSize.x2 *= scale; 
    objectSize.y1 *= scale; 
    objectSize.y2 *= scale; 
    ((MCircleCmd)cmdList[i]).m_X *= scale; 
    ((MCircleCmd)cmdList[i]).m_Y *= scale; 
    ((MCircleCmd)cmdList[i]).m_R *= scale; 
    ((MCircleCmd)cmdList[i]).scaleX = scale; 
    ((MCircleCmd)cmdList[i]).scaleY = scale; 
} 

Answer 1

Je pense que vous abordez ce dans le mauvais sens - vous ne prenez pas l'utilisation complète du GPU si l'on est présent. Personnellement, je l'aborde comme ceci:

class Ellipse 
{ 
public: 
    Ellipse() 
    { 
    // build an array of precalculated vertices for a unit circle 
    // optionally, create a display list 
    } 

    void Draw() 
    { 
     glBegin (...); 
     // create and push a translation, rotation matrix from the m_* value 
     // setup all vertices from array (or use display list) 
     // pop matrix 
     glEnd(); 
    } 

    // setters to define position, rotation and scale 

private: 
    float m_rotation, m_scale_x, m_scale_y, m_x, m_y; 
    glVertex2f m_vertices [...]; 
}; 

Cela met le travail de traduction et mise à l'échelle dans le pipeline de rendu (la poussée de la matrice) et permet de faire le matériel le travail.