Bresenham triangle

typedef struct { int x, y; } Vei2;

// WARNING : VERTICES MUST BE SORTED BEFORE CALLING THIS, USE VXDrawTriangleNoClip(Vei2,Vei2,Vei2,c)
void VXDrawTriangleNoClip(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, Uint32 c)
{
    int ledx =  abs(x2-x0), lesx = (x0 < x2 ? 1 : -1);
    int ledy = -abs(y2-y0), lesy = (y0 < y2 ? 1 : -1);
    int leerr = ledx+ledy, lee2;
    bool rasterisation = true;
    int lelx = x0;
    int lely = y0;

    int setdx =  abs(x1-x0), setsx = (x0 < x1 ? 1 : -1);
    int setdy = -abs(y1-y0), setsy = (y0 < y1 ? 1 : -1);
    int seterr = setdx+setdy, sete2;
    int setlx = x0;
    int setly = y0;

    int sebdx =  abs(x2-x1), sebsx = (x1 < x2 ? 1 : -1);
    int sebdy = -abs(y2-y1), sebsy = (y1 < y2 ? 1 : -1);
    int seberr = sebdx+sebdy, sebe2;
    int seblx = x1;
    int sebly = y1;

    int selx = x0;
    int rx = x0;
    while (rasterisation)
    {
        for (;;)
        {
            VXSetPixelNoClip(lelx, lely, c);
            if (lelx==x2&&lely==y2) rasterisation = false;
            lee2 = 2*leerr;
            if (lee2 >= ledy) { leerr += ledy; lelx += lesx; }
            if (lee2 <= ledx) { leerr += ledx; lely += lesy; break; }
        }

        if (lely <= y1)
        {
            for (;;)
            {
                VXSetPixelNoClip(setlx, setly, c);
                sete2 = 2*seterr;
                if (sete2 >= setdy) { seterr += setdy; setlx += setsx; }
                if (sete2 <= setdx) { seterr += setdx; setly += setsy; break; }
            }
            selx = setlx;
        }
        if (lely >= y1)
        {
            for (;;)
            {
                VXSetPixelNoClip(seblx, sebly, c);
                sebe2 = 2*seberr;
                if (sebe2 >= sebdy) { seberr += sebdy; seblx += sebsx; }
                if (sebe2 <= sebdx) { seberr += sebdx; sebly += sebsy; break; }
            }
            selx = seblx;
        }

        rx = selx;

        for (;;)
        {
            VXSetPixelNoClip(rx, lely, c);
            if (rx==lelx) break;
            rx += (selx<lelx ? 1 : -1);
        }
    }
}

void VXDrawTriangleNoClip(Vei2 v0, Vei2 v1, Vei2 v2, Uint32 c)
{
    const Vei2* pv0 = &v0;
    const Vei2* pv1 = &v1;
    const Vei2* pv2 = &v2;

    if( pv1->y < pv0->y ) std::swap( pv0,pv1 );
    if( pv2->y < pv1->y ) std::swap( pv1,pv2 );
    if( pv1->y < pv0->y ) std::swap( pv0,pv1 );

    VXDrawTriangleNoClip(pv0->x, pv0->y, pv1->x, pv1->y, pv2->x, pv2->y, c);
}