I wrote this variant of Bresenham’s for fun. I am looking to see what I can optimize as it is still slower than Bresenham’s.

The idea here was that if I could isolate out the IFs in Bresenham’s loop it’d be more efficient. Well go figure, the added multiplication (A) or array lookups (B) in the pre-calc destroy said efficiency in overhead. That said, might be more efficient in a shader on GPUs? Haven’t tested yet.

Both versions A and B have the same efficiency, weirdly enough.

Version A:

void bresenprecalcA(int x1, int y1, int x2, int y2) {
    int dx = x2 - x1, dy = y2 - y1,
        // dxyA is the sign of the quadrant xy delta.
        dxA = sgn(dx), dyA = sgn(dy),
        // dyB is the absolute quadrant xy delta (to isolate the quadrant math).
        dxB = abs(dx), dyB = abs(dy),
        // check if x>y or y>x for quadrant determination.
        cx = dxB >= dyB, cy = dyB >= dxB,
        // qx is whether we're in a horz-x facing quadrant.
        // qy is whether we're in a vert-y facing quadrant.
        qx = cy * dxB, qy = cx * dyB,
        // qr checks if we lie in a quadrant rather than one of the 8 cardinal dir.
        // pd is for the incremental error check below.
        qr = qx != qy, pd = qx + qy,
        // if the line is horz, move horz other move vert.
        xm = cx * dxA, ym = cy * dyA,
        // if the line is horz, move horz other move vert.
        xym = cx? dxB : dyB,
        // Incremental error check (see Bresenhams algorithm).
        er = pd - (xym/2), ec;

    // Create a lookup table, rather than use multiplication in the for(;;) below.
    // look*[0] is if the line is horz, vert or diag.
    // look*[1] is if the line is in between angles (direction is not mod 45 == 0).
    int lookx[2] = {xm,xm + (qr * cy * dxA)},
        looky[2] = {ym,ym + (qr * cx * dyA)},
        lookd[2] = {qr * pd, qr * (pd - xym)};

    //draw_point(xx, yy);
    for(;;) {
        // Error check above/below the line.
        ec = er >= 0;
        // Increment lookup table based on error check.
        // ec==0 -> line is horz/vert/diagonal (dir%45 = 0).
        // ec==1 -> line is between cardinals (dir%45 != 0).
        x1 += lookx[ec];
        y1 += looky[ec];
        er += lookd[ec];
        // Break loop when line is done.
        //draw_point(xx, yy);
        if (x2 == x1 && y2 == y1) break;
    };
}

Version B:

void bresenprecalcB(int x1, int y1, int x2, int y2) {
    int dx = x2 - x1, dy = y2 - y1,
        dxA = sgn(dx), dyA = sgn(dy),
        dxB = abs(dx), dyB = abs(dy),
        cx = dxB >= dyB, cy = dyB >= dxB;

    int lookm[10] = {0,dxB,0,dyB,0,dxA,0,dyA,dyB,dxB};
    int qx = lookm[cy],
        qy = lookm[2+cx],
        xm = lookm[4+cx],
        ym = lookm[6+cy],
        xym = lookm[8+cx],
        qr = qx != qy, pd = qx + qy,
        er = pd - (xym / 2), ec;

    int lookx[2] = {xm,xm + (qr * cy * dxA)},
        looky[2] = {ym,ym + (qr * cx * dyA)},
        lookd[2] = {qr * pd, qr * (pd - xym)};

    //draw_point(x1, y1);
    for(;;) {
        ec = er >= 0;
        x1 += lookx[ec];
        y1 += looky[ec];
        er += lookd[ec];
       //draw_point(x1, y1);
        if (x2 == x1 && y2 == y1) break;
    };
};

Bresenham’s from this StackOverflow post:

void bresenhams(int x1, int y1, int x2, int y2) {
    int xx, yy, dx, dy, dx1, dy1, px, py, xe, ye, i;
    dx = x2 - x1;
    dy = y2 - y1;
    dx1 = abs(dx);
    dy1 = abs(dy);
    px = 2 * dy1 - dx1;
    py = 2 * dx1 - dy1;
    if (dy1 <= dx1)
    {
        if (dx >= 0)
        {
            xx = x1;
            yy = y1;
            xe = x2;
        }
        else
        {
            xx = x2;
            yy = y2;
            xe = x1;
        }
        //draw_point(xx, yy);
        for (i = 0; xx < xe; i++)
        {
            xx = xx + 1;
            if (px < 0)
            {
                px = px + 2 * dy1;
            }
            else
            {
                if ((dx < 0 && dy < 0) || (dx > 0 && dy > 0))
                {
                    yy = yy + 1;
                }
                else
                {
                    yy = yy - 1;
                }
                px = px + 2 * (dy1 - dx1);
            }
            //draw_point(xx, yy);
        }
    }
    else
    {
        if (dy >= 0)
        {
            xx = x1;
            yy = y1;
            ye = y2;
        }
        else
        {
            xx = x2;
            yy = y2;
            ye = y1;
        }
        //draw_point(xx, yy);
        for (i = 0; yy < ye; i++)
        {
            yy = yy + 1;
            if (py <= 0)
            {
                py = py + 2 * dx1;
            }
            else
            {
                if ((dx < 0 && dy < 0) || (dx > 0 && dy > 0))
                {
                    xx = xx + 1;
                }
                else
                {
                    xx = xx - 1;
                }
                py = py + 2 * (dx1 - dy1);
            }
            //draw_point(xx, yy);
        }
    }
};