SDL wypełnianie wielokątów

0

Próbuje napisać funkcję która będzie wypełniać wielokąty. Mój projekt jest pisany przy pomocy biblioteki SDL
algorytm jest tak pomyślany że rysuje co drugą linię między ixami
Oto fragmenty kodu:
z pliku polygon.cpp funkcja getxfory która ma zwracać strukturę ze wszystkimi wartościami x dla danej linii y :

 
xxx polygon::getxfory(int yy)
{
    double a,b;
    int dp,dk;
    int temp;
    int x1,x2,y1,y2;
    int m;
    int t;
    xxx xprz;
    vector<pix> tx;
    for(int i=0;i<points.size();i++)
    {
        m=i+1;
        if(i==points.size()-1)m=0;
        x1=points[i].x;
        y1=points[i].y;
        x2=points[m].x;
        y2=points[m].y;

        if(y1==y2)continue;
        if(x1>x2){
            temp=x2;
            x2=x1;
            x1=temp;
            temp=y2;
            y2=y1;
            y1=temp;
            }
        dp=x1;
        dk=x2;
        a=((double)y1-(double)y2)/((double)x1-(double)x2);
        b=(double)y1 - ((double)x1 * a);
        t=(int)((yy-b)/a);
        if(t>dp&&t<dk)
        {
            tx.push_back(t);
            //xprz.pr.push_back(t);
        }
      
    }

    for(int i=0;i<points.size();i++)
    {
        if(yy==points[i].y)
        {
            bool a,b;
            int poprz,nast;
            int pozx = points[i].x;

            if(i==0){
                poprz=points.size()-1;
            }else{
                poprz=i-1;
            }

            if(i==points.size()-1){
                nast=0;
            }else{
                nast=i+1;
            }

            a=((points[poprz].y - yy)>0);
            b=((points[nast].y - yy)>0);
            tx.push_back(pozx);
           // xprz.pr.push_back(t);
            if(a==b){
                tx.push_back(pozx);
               // xprz.pr.push_back(t);
            }
        }
    }

  
    bool zn=0;//czy znalazl
    int ai=0;//index znalezionego
    pix tempsort=1000000;//celem oznaczenia
    //\/algorytm sortujacy\/
    for(int i=0;i<tx.size();i++)
    {
        for(int j=0;j<tx.size();j++)
        {
            if(tx[j]<tempsort)
            {
                tempsort=tx[j];
                ai=j;
                zn=1;
            }
        }
        if(zn)
        {
            xprz.pr.push_back(tx[ai]);
            zn=0;
            tx[ai]=tempsort=1000000;
        }
    }
    bool pok=0;
    for(int i=0;i<xprz.pr.size();i++)
       {
        cout<<xprz.pr[i]<<" , ";
        pok=1;
    }
    if(pok){
        cout<<endl;
        pok=0;
    }
    return xprz;
}


i funkcja wirtualna która rysuje wielokąt oznaczyłem ważny kod komentarzem:

void polygon::draw()
{
    if(owner){
     pix xt=owner->totalx;
     pix yt=owner->totaly;
     pix xp,xk,yp,yk;
     xk=yk=0;
     xp=yp=0xfffffff;
        if(brama)
        {
            for(int i=0;i<points.size()-1;i++)
            {
                rysline(points[i].x+xt+x,points[i].y+yt+y,points[i+1].x+xt+x,points[i+1].y+yt+y,color);
            }
            rysline(points[points.size()-1].x+xt+x,points[points.size()-1].y+yt+y,points[0].x+xt+x,points[0].y+yt+y,color);
        }else{
            for(int i=0;i<points.size();i++)
            {
                if(points[i].x>xk)xk=points[i].x;
                if(points[i].y>yk)yk=points[i].y;
                if(points[i].x<xp)xp=points[i].x;
                if(points[i].y<yp)yp=points[i].y;
            }
            int w=xk-xp;
            int h=yk-yp;
            ny=yk;


            xxx przec;
            cout<<"poczatek"<<endl;
        /*TU SIĘ ZACZYNA WAŻNY KOD*/
            for(int wy=yp-1;wy<yp+h;wy++)
            {
                przec=getxfory(wy);
                for(int i=0;i<przec.pr.size();i+=2)
                {

                    rysline(przec.pr[i]+xt+x,wy+yt+y,przec.pr[i+1]+xt+x,wy+yt+y,color);
                }
            }
            cout<<"koniec"<<endl;
        }
        if(!bbuff&&!bdrawout)odswierz();
    }
} 
0

Czy w SDL nie ma normalnego sposobu na coś takiego? Jestem pewien, że jest.

1
int filledTrigonRGBA(SDL_Surface* dst,
                     Sint16 x1, Sint16 y1, 
                     Sint16 x2, Sint16 y2, 
                     Sint16 x3, Sint16 y3, 
                     Uint8 r, Uint8 g, Uint8 b, Uint8 a);

Lub za pomocą OpenGL. Wydaje mi się lepsze od... tego czegoś.

1 użytkowników online, w tym zalogowanych: 0, gości: 1