OpenGL-ES 1.0 2D Rectangle arrondi

Un peu d'une bosse, mais j'étais coincé sur le même problème aujourd'hui, c'est ce que je sortit, c'est créé avec le bureau GL, mais doit être très facile à convertir en gle, tout est une bande. Ce n'est probablement pas aussi optimisé que possible, mais si quelqu'un veut avoir un coup de poignard, s'il vous plaît être mon invité;) XXX

Pour dessiner le rectangle arrondi, appelez simplement quelque chose comme à l'intérieur d'une vue orthographique : xxx

Je devais dessiner un rectangle similaire, mais transparent - et le code ci-dessus dessine certains des triangles se chevauchent. Correction de cela, également supprimé MALLOC, juste pour simplifier la solution. Voici ma version:

typedef struct
{
    float x;
    float y;
} Vector2f;

//
//  Draws rounded rectangle.
//
//  Slightly tuned version of http://stackoverflow.com/questions/5369507/opengles-1-0-2d-rounded-rectangle
//
#define ROUNDING_POINT_COUNT 8      // Larger values makes circle smoother.
void DrawRoundRect( float x, float y, float width, float height, float* color = 0, float radius = 0.0 )
{
    Vector2f top_left[ROUNDING_POINT_COUNT];
    Vector2f bottom_left[ROUNDING_POINT_COUNT];
    Vector2f top_right[ROUNDING_POINT_COUNT];
    Vector2f bottom_right[ROUNDING_POINT_COUNT];

    if( radius == 0.0 )
    {
        radius = min(width, height);
        radius *= 0.10; // 10%
    }

    int i = 0;
    float x_offset, y_offset;
    float step = ( 2.0f * pi ) / (ROUNDING_POINT_COUNT * 4),
          angle = 0.0f;

    unsigned int index = 0, segment_count = ROUNDING_POINT_COUNT;
    Vector2f bottom_left_corner = { x + radius, y - height + radius }; 


    while( i != segment_count )
    {
        x_offset = cosf( angle );
        y_offset = sinf( angle );


        top_left[ index ].x = bottom_left_corner.x - 
                              ( x_offset * radius );
        top_left[ index ].y = ( height - ( radius * 2.0f ) ) + 
                                bottom_left_corner.y - 
                              ( y_offset * radius );


        top_right[ index ].x = ( width - ( radius * 2.0f ) ) + 
                                 bottom_left_corner.x + 
                               ( x_offset * radius );
        top_right[ index ].y = ( height - ( radius * 2.0f ) ) + 
                                 bottom_left_corner.y -
                               ( y_offset * radius );


        bottom_right[ index ].x = ( width - ( radius * 2.0f ) ) +
                                    bottom_left_corner.x + 
                                  ( x_offset * radius );
        bottom_right[ index ].y = bottom_left_corner.y + 
                                  ( y_offset * radius );


        bottom_left[ index ].x = bottom_left_corner.x - 
                                 ( x_offset * radius );
        bottom_left[ index ].y = bottom_left_corner.y +
                                 ( y_offset * radius );


        top_left[ index ].x = top_left[ index ].x;
        top_left[ index ].y = top_left[ index ].y;


        top_right[ index ].x = top_right[ index ].x;
        top_right[ index ].y = top_right[ index ].y;


        bottom_right[ index ].x = bottom_right[ index ].x ;
        bottom_right[ index ].y = bottom_right[ index ].y;


        bottom_left[ index ].x =  bottom_left[ index ].x ;
        bottom_left[ index ].y =  bottom_left[ index ].y ;

        angle -= step;

        ++index;

        ++i;
    }

    static GLubyte clr[] = { 156, 207, 255, 128 };   // Light blue, 50% transparent.

    if( color )
        glColor4fv(color);
    else
        glColor4ubv(clr);

    glBegin( GL_TRIANGLE_STRIP );
    {
        // Top
        for( i = segment_count - 1 ; i >= 0 ; i--)
        {
            glVertex2f( top_left[ i ].x, top_left[ i ].y );
            glVertex2f( top_right[ i ].x, top_right[ i ].y );
        }

        // In order to stop and restart the strip.
        glVertex2f( top_right[ 0 ].x, top_right[ 0 ].y );
        glVertex2f( top_right[ 0 ].x, top_right[ 0 ].y );

        // Center
        glVertex2f( top_right[ 0 ].x, top_right[ 0 ].y );
        glVertex2f( top_left[ 0 ].x, top_left[ 0 ].y );
        glVertex2f( bottom_right[ 0 ].x, bottom_right[ 0 ].y );
        glVertex2f( bottom_left[ 0 ].x, bottom_left[ 0 ].y );

        // Bottom
        for( i = 0; i != segment_count ; i++ )
        {
            glVertex2f( bottom_right[ i ].x, bottom_right[ i ].y );    
            glVertex2f( bottom_left[ i ].x, bottom_left[ i ].y );                                    
        }    
    }
    glEnd();
} //DrawRoundRect

#define PI_2   1.57079632679490f

#define SIN(x) SDL_sinf (x)
#define COS(x) SDL_cosf (x)

typedef struct _g2d_vertex_t g2d_vertex_t;

struct _g2d_vertex_t {

    float x, y;
};

// pVertices - destination buffer
// nVertices - buffer size
// dx - width
// dy - height
// r - radius
// returnes the number of used vertices
int
__cdecl buildRoundedRect (g2d_vertex_t * pVertices, int nVertices, float dx, float dy, float r) {

    float a, da;
    int i1, i2, i3, i4, n;

    if (nVertices < 4) { return 0; }

    if (nVertices == 4) {

        pVertices [0].x = 0.f; pVertices [0].y = 0.f;
        pVertices [1].x = dx;  pVertices [1].y = 0.f;
        pVertices [2].x = dx;  pVertices [2].y = dy;
        pVertices [3].x = 0.f; pVertices [3].y = dy;

        return nVertices;
    }

    n = nVertices >> 2;

    if (r > dx / 2.f) { r = dx / 2.f; }
    if (r > dy / 2.f) { r = dy / 2.f; }

    a = 0.f;
    da = PI_2 / (float) (n - 1);

    for (i1 = 0, i2 = (n << 1) - 1, i3 = n << 1, i4 = (n << 2) - 1; i1 < n; i1++, i2--, i3++, i4--, a += da) {

        float cosA = COS (a), sinA = SIN (a);

        pVertices [i1].x = (dx - r) + r * cosA; pVertices [i1].y = (dy - r) + r * sinA;
        pVertices [i2].x =     r    - r * cosA; pVertices [i2].y = (dy - r) + r * sinA;
        pVertices [i3].x =     r    - r * cosA; pVertices [i3].y =     r    - r * sinA;
        pVertices [i4].x = (dx - r) + r * cosA; pVertices [i4].y =     r    - r * sinA;
    }

    return n << 2;
}

void drawRoundedRect () {

    g2d_vertex_t vertices [50];

    glColor3f (0.3f, 0.5f, 0.2f);

    glVertexPointer (2, GL_FLOAT, 0, vertices);
    glEnableClientState (GL_VERTEX_ARRAY);

    glDrawArrays (GL_LINE_LOOP, 0, buildRoundedRect (vertices, 50 /* max count of vertices to use: 4 - 50 */, 150.f, 80.f, 20.f));
}