Subversion Repositories chibiosIgnition

void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) {

        bool bSwap = false;

        switch (rotation) {

        case 0:

                // 0 degree rotation, do nothing

                break;

        case 1:

                // 90 degree rotation, swap x & y for rotation, then invert x

                bSwap = true;

                swap(x, y)

                ;

                x = WIDTH - x - 1;

                break;

        case 2:

                // 180 degree rotation, invert x and y - then shift y around for height.

                x = WIDTH - x - 1;

                y = HEIGHT - y - 1;

                x -= (w - 1);

                break;

        case 3:

                // 270 degree rotation, swap x & y for rotation, then invert y  and adjust y for w (not to become h)

                bSwap = true;

                swap(x, y)

                ;

                y = HEIGHT - y - 1;

                y -= (w - 1);

                break;

        }

        if (bSwap) {

                drawFastVLineInternal(x, y, w, color);

        } else {

                drawFastHLineInternal(x, y, w, color);

        }

}

void drawFastHLineInternal(int16_t x, int16_t y, int16_t w, uint16_t color) {

        // Do bounds/limit checks

        if (y < 0 || y >= HEIGHT) {

                return;

        }

        // make sure we don't try to draw below 0

        if (x < 0) {

                w += x;

                x = 0;

        }

        // make sure we don't go off the edge of the display

        if ((x + w) > WIDTH) {

                w = (HEIGHT - x);

        }

        // if our width is now negative, punt

        if (w <= 0) {

                return;

        }

        // set up the pointer for  movement through the buffer

        register uint8_t *pBuf = &display_buffer[0];

        // adjust the buffer pointer for the current row

        pBuf += ((y / 8) * SSD1306_LCDWIDTH);

        // and offset x columns in

        pBuf += x;

        register uint8_t mask = 1 << (y & 7);

        if (color == WHITE) {

                while (w--) {

                        *pBuf++ |= mask;

                }

        } else {

                mask = ~mask;

                while (w--) {

                        *pBuf++ &= mask;

                }

        }

}

void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {

        bool bSwap = false;

        switch (rotation) {

        case 0:

                break;

        case 1:

                // 90 degree rotation, swap x & y for rotation, then invert x and adjust x for h (now to become w)

                bSwap = true;

                swap(x, y)

                ;

                x = WIDTH - x - 1;

                x -= (h - 1);

                break;

        case 2:

                // 180 degree rotation, invert x and y - then shift y around for height.

                x = WIDTH - x - 1;

                y = HEIGHT - y - 1;

                y -= (h - 1);

                break;

        case 3:

                // 270 degree rotation, swap x & y for rotation, then invert y

                bSwap = true;

                swap(x, y)

                ;

                y = HEIGHT - y - 1;

                break;

        }

        if (bSwap) {

                drawFastHLineInternal(x, y, h, color);

        } else {

                drawFastVLineInternal(x, y, h, color);

        }

}

void drawFastVLineInternal(int16_t x, int16_t __y, int16_t __h, uint16_t color) {

        // do nothing if we're off the left or right side of the screen

        if (x < 0 || x >= WIDTH) {

                return;

        }

        // make sure we don't try to draw below 0

        if (__y < 0) {

                // __y is negative, this will subtract enough from __h to account for __y being 0

                __h += __y;

                __y = 0;

        }

        // make sure we don't go past the height of the display

        if ((__y + __h) > HEIGHT) {

                __h = (HEIGHT - __y);

        }

        // if our height is now negative, punt

        if (__h <= 0) {

                return;

        }

        // this display doesn't need ints for coordinates, use local byte registers for faster juggling

        register uint8_t y = __y;

        register uint8_t h = __h;

        // set up the pointer for fast movement through the buffer

        register uint8_t *pBuf = &display_buffer[0];

        // adjust the buffer pointer for the current row

        pBuf += ((y / 8) * SSD1306_LCDWIDTH);

        // and offset x columns in

        pBuf += x;

        // do the first partial byte, if necessary - this requires some masking

        register uint8_t mod = (y & 7);

        if (mod) {

                // mask off the high n bits we want to set

                mod = 8 - mod;

                // note - lookup table results in a nearly 10% performance improvement in fill* functions

                // register uint8_t mask = ~(0xFF >> (mod));

                static uint8_t premask[8] = { 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC,

                                0xFE };

                register uint8_t mask = premask[mod];

                // adjust the mask if we're not going to reach the end of this byte

                if (h < mod) {

                        mask &= (0XFF >> (mod - h));

                }

                if (color == WHITE) {

                        *pBuf |= mask;

                } else {

                        *pBuf &= ~mask;

                }

                // fast exit if we're done here!

                if (h < mod) {

                        return;

                }

                h -= mod;

                pBuf += SSD1306_LCDWIDTH;

        }

        // write solid bytes while we can - effectively doing 8 rows at a time

        if (h >= 8) {

                // store a local value to work with

                register uint8_t val = (color == WHITE) ? 255 : 0;

                do {

                        // write our value in

                        *pBuf = val;

                        // adjust the buffer forward 8 rows worth of data

                        pBuf += SSD1306_LCDWIDTH;

                        // adjust h & y (there's got to be a faster way for me to do this, but this should still help a fair bit for now)

                        h -= 8;

                } while (h >= 8);

        }

        // now do the final partial byte, if necessary

        if (h) {

                mod = h & 7;

                // this time we want to mask the low bits of the byte, vs the high bits we did above

                // register uint8_t mask = (1 << mod) - 1;

                // note - lookup table results in a nearly 10% performance improvement in fill* functions

                static uint8_t postmask[8] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F,

                                0x7F };

                register uint8_t mask = postmask[mod];

                if (color == WHITE) {

                        *pBuf |= mask;

                } else {

                        *pBuf &= ~mask;

                }

        }

}