line.c

Go to the documentation of this file.

#include "gfx.h"
#include "gfx_p.h"

#include <cfg/debug.h>   /* ASSERT() */
#include <cfg/macros.h>  /* SWAP() */
#include <appconfig.h>   /* CONFIG_GFX_CLIPPING */

/* Configuration sanity checks */
#if !defined(CONFIG_GFX_CLIPPING) || (CONFIG_GFX_CLIPPING != 0 && CONFIG_GFX_CLIPPING != 1)
    #error CONFIG_GFX_CLIPPING must be defined to either 0 or 1
#endif
#if !defined(CONFIG_GFX_VCOORDS) || (CONFIG_GFX_VCOORDS != 0 && CONFIG_GFX_VCOORDS != 1)
    #error CONFIG_GFX_VCOORDS must be defined to either 0 or 1
#endif

static void gfx_lineUnclipped(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
{
    int x, y, e, len, adx, ady, signx, signy;

    if (x2 > x1)
    {
        /* left to right */
        signx = +1;
        adx = x2 - x1;
    }
    else
    {
        /* right to left */
        signx = -1;
        adx = x1 - x2;
    }

    if (y2 > y1)
    {
        /* top to bottom */
        signy = +1;
        ady = y2 - y1;
    }
    else
    {
        /* bottom to top */
        signy = -1;
        ady = y1 - y2;
    }

    x = x1;
    y = y1;

    if (adx > ady)
    {
        /* X-major line (octants 1/4/5/8) */

        len = adx;
        e = -adx;
        while (len--)
        {
            /* Sanity check */
            ASSERT((x >= 0) && (x < bm->width) && (y >= 0) && (y < bm->height));
            BM_PLOT(bm, x, y);
            x += signx;
            e += ady;
            if (e >= 0)
            {
                y += signy;
                e -= adx;
            }
        }
    }
    else
    {
        /* Y-major line (octants 2/3/6/7) */

        len = ady;
        e = -ady;
        while (len--)
        {
            /* Sanity check */
            ASSERT ((x >= 0) && (x < bm->width) && (y >= 0) && (y < bm->height));
            BM_PLOT(bm, x, y);
            y += signy;
            e += adx;
            if (e >= 0)
            {
                x += signx;
                e -= ady;
            }
        }
    }
}

#if CONFIG_GFX_CLIPPING

static int gfx_findRegion(int x, int y, Rect *cr)
{
    int code = 0;

    if (y >= cr->ymax)
        code |= 1; /* below */
    else if (y < cr->ymin)
        code |= 2; /* above */

    if (x >= cr->xmax)
        code |= 4; /* right */
    else if (x < cr->xmin)
        code |= 8; /* left */

    return code;
}

#endif /* CONFIG_CLIPPING */

void gfx_line(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
{
#if CONFIG_GFX_CLIPPING
    int clip1 = gfx_findRegion(x1, y1, &bm->cr);
    int clip2 = gfx_findRegion(x2, y2, &bm->cr);

    /* Loop while there is at least one point outside */
    while (clip1 | clip2)
    {
        /* Check for line totally outside */
        if (clip1 & clip2)
            return;

        int c = clip1 ? clip1 : clip2;
        int x, y;

        if (c & 1) /* Below */
        {
            x = x1 + (x2 - x1) * (bm->cr.ymax - y1) / (y2 - y1);
            y = bm->cr.ymax - 1;
        }
        else if (c & 2) /* Above */
        {
            x = x1 + (x2 - x1) * (bm->cr.ymin - y1) / (y2 - y1);
            y = bm->cr.ymin;
        }
        else if (c & 4) /* Right */
        {
            y = y1 + (y2 - y1) * (bm->cr.xmax - x1) / (x2 - x1);
            x = bm->cr.xmax - 1;
        }
        else /* Left */
        {
            y = y1 + (y2 - y1) * (bm->cr.xmin - x1) / (x2 - x1);
            x = bm->cr.xmin;
        }

        if (c == clip1) /* First endpoint was clipped */
        {
            // TODO: adjust Bresenham error term
            //coord_t clipdx = ABS(x - x1);
            //coord_t clipdy = ABS(y - y1);
            //e += (clipdy * e2) + ((clipdx - clipdy) * e1);

            x1 = x;
            y1 = y;
            clip1 = gfx_findRegion(x1, y1, &bm->cr);
        }
        else /* Second endpoint was clipped */
        {
            x2 = x;
            y2 = y;
            clip2 = gfx_findRegion(x2, y2, &bm->cr);
        }
    }
#endif /* CONFIG_GFX_CLIPPING */

    gfx_lineUnclipped(bm, x1, y1, x2, y2);
}

void gfx_moveTo(Bitmap *bm, coord_t x, coord_t y)
{
    bm->penX = x;
    bm->penY = y;
}

void gfx_lineTo(Bitmap *bm, coord_t x, coord_t y)
{
    gfx_line(bm, bm->penX, bm->penY, x, y);
    gfx_moveTo(bm, x, y);
}


void gfx_rectDraw(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
{
    /* Sort coords (needed for correct bottom-right semantics) */
    if (x1 > x2) SWAP(x1, x2);
    if (y1 > y2) SWAP(y1, y2);

    /* Draw rectangle */
    gfx_line(bm, x1,   y1,   x2-1, y1);
    gfx_line(bm, x2-1, y1,   x2-1, y2-1);
    gfx_line(bm, x2-1, y2-1, x1,   y2-1);
    gfx_line(bm, x1,   y2-1, x1,   y1);
}


void gfx_rectFillC(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2, uint8_t color)
{
    coord_t x, y;

    /* Sort coords */
    if (x1 > x2) SWAP(x1, x2);
    if (y1 > y2) SWAP(y1, y2);

#if CONFIG_GFX_CLIPPING
    /* Clip rect to bitmap clip region */
    if (x1 < bm->cr.xmin)   x1 = bm->cr.xmin;
    if (x2 < bm->cr.xmin)   x2 = bm->cr.xmin;
    if (x1 > bm->cr.xmax)   x1 = bm->cr.xmax;
    if (x2 > bm->cr.xmax)   x2 = bm->cr.xmax;
    if (y1 < bm->cr.ymin)   y1 = bm->cr.ymin;
    if (y2 < bm->cr.ymin)   y2 = bm->cr.ymin;
    if (y1 > bm->cr.ymax)   y1 = bm->cr.ymax;
    if (y2 > bm->cr.ymax)   y2 = bm->cr.ymax;
#endif /* CONFIG_GFX_CLIPPING */

    /* NOTE: Code paths are duplicated for efficiency */
    if (color) /* fill */
    {
        for (x = x1; x < x2; x++)
            for (y = y1; y < y2; y++)
                BM_PLOT(bm, x, y);
    }
    else /* clear */
    {
        for (x = x1; x < x2; x++)
            for (y = y1; y < y2; y++)
                BM_CLEAR(bm, x, y);
    }
}


void gfx_rectFill(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
{
    gfx_rectFillC(bm, x1, y1, x2, y2, 0xFF);
}


void gfx_rectClear(Bitmap *bm, coord_t x1, coord_t y1, coord_t x2, coord_t y2)
{
    gfx_rectFillC(bm, x1, y1, x2, y2, 0x00);
}


#if CONFIG_GFX_VCOORDS

void gfx_setViewRect(Bitmap *bm, vcoord_t x1, vcoord_t y1, vcoord_t x2, vcoord_t y2)
{
    ASSERT(x1 != x2);
    ASSERT(y1 != y2);

    bm->orgX    = x1;
    bm->orgY    = y1;
    bm->scaleX  = (vcoord_t)(bm->cr.xmax - bm->cr.xmin - 1) / (vcoord_t)(x2 - x1);
    bm->scaleY  = (vcoord_t)(bm->cr.ymax - bm->cr.ymin - 1) / (vcoord_t)(y2 - y1);

/*  DB(kprintf("orgX = %f, orgY = %f, scaleX = %f, scaleY = %f\n",
        bm->orgX, bm->orgY, bm->scaleX, bm->scaleY);)
*/
}


coord_t gfx_transformX(Bitmap *bm, vcoord_t x)
{
    return bm->cr.xmin + (coord_t)((x - bm->orgX) * bm->scaleX);
}

coord_t gfx_transformY(Bitmap *bm, vcoord_t y)
{
    return bm->cr.ymin + (coord_t)((y - bm->orgY) * bm->scaleY);
}


void gfx_vline(Bitmap *bm, vcoord_t x1, vcoord_t y1, vcoord_t x2, vcoord_t y2)
{
    gfx_line(bm,
        gfx_transformX(bm, x1), gfx_transformY(bm, y1),
        gfx_transformY(bm, x2), gfx_transformY(bm, y2));
}
#endif /* CONFIG_GFX_VCOORDS */