drivers/gfx/gfx_bitmap.c

Go to the documentation of this file.

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <assert.h>
#include <gfx/gfx.h>


void gfx_draw_bitmap(const struct gfx_bitmap *bmp, gfx_coord_t x, gfx_coord_t y)
{
        assert(bmp);

        gfx_put_bitmap(bmp, 0, 0, x, y, bmp->width, bmp->height);
}

void gfx_draw_bitmap_tiled(const struct gfx_bitmap *bmp, gfx_coord_t x1,
                gfx_coord_t y1, gfx_coord_t x2, gfx_coord_t y2,
                gfx_coord_t tile_origin_x, gfx_coord_t tile_origin_y)
{
        gfx_coord_t map_width;
        gfx_coord_t map_height;
        gfx_coord_t start_x;
        gfx_coord_t start_y;
        gfx_coord_t index_x;
        gfx_coord_t index_y;

        // Sanity check on parameters.
        assert(bmp);
        assert(x1 >= 0);
        assert(y1 >= 0);
        assert(x2 > x1);
        assert(y2 > y1);
        assert(tile_origin_x <= x1);
        assert(tile_origin_y <= y1);

        // Faster handling for solid color bitmaps
        if (bmp->type == BITMAP_SOLID) {
                gfx_draw_filled_rect(x1, y1, x2 - x1 + 1, y2 - y1 + 1,
                                bmp->data.color);
                return;
        }

        // Find starting position
        map_width = bmp->width;
        map_height = bmp->height;
        start_x = tile_origin_x;
        start_y = tile_origin_y;

        while (start_x <= (x1 - map_width)) {
                start_x += map_width;
        }
        while (start_y <= (y1 - map_height)) {
                start_y += map_height;
        }

        // Draw tiles to cover the output area
        for (index_y = start_y; index_y <= y2; index_y += map_height) {
                for (index_x = start_x; index_x <= x2; index_x += map_width) {
                        gfx_put_bitmap(bmp, 0, 0, index_x, index_y, map_width, map_height);
                }
        }
}

void gfx_put_bitmap(const struct gfx_bitmap *bmp,
                gfx_coord_t map_x, gfx_coord_t map_y,
                gfx_coord_t x, gfx_coord_t y,
                gfx_coord_t width, gfx_coord_t height)
{

        gfx_coord_t x2;
        gfx_coord_t y2;
        gfx_coord_t map_width = bmp->width;
        gfx_color_t *pixmap;
        const gfx_color_t __progmem_arg *progmem_pixmap;
#ifdef CONFIG_HUGEMEM
        hugemem_ptr_t hugemem_pixmap;
#endif

        // Nothing to do if width or height is zero.
        if ((width == 0) || (height == 0))
                return;

        // Sanity check on parameters.
        assert(bmp);
        assert((map_x + width) <= map_width);
        assert(map_x >= 0);
        assert(map_y >= 0);
        assert(width > 0);
        assert(height > 0);

#ifdef CONFIG_GFX_USE_CLIPPING
        // Nothing to do if entire rectangle is outside clipping region.
        if ((x > gfx_max_x) || (y > gfx_max_y)
                        || ((x + width) <= gfx_min_x)
                        || ((y + height) <= gfx_min_y))
                return;

        // Clip if outside left X limit.
        if (x < gfx_min_x) {
                width -= gfx_min_x - x;
                map_x += gfx_min_x - x;
                x = gfx_min_x;
        }

        // Clip if outside top Y limit.
        if (y < gfx_min_y) {
                height -= gfx_min_y - y;
                map_y += gfx_min_y - y;
                y = gfx_min_y;
        }
#endif

        // Compute bottom right point.
        x2 = x + width - 1;
        y2 = y + height - 1;

#ifdef CONFIG_GFX_USE_CLIPPING
        // Clip if outside right X limit.
        if (x2 > gfx_max_x) {
                x2 = gfx_max_x;
                width = x2 - x + 1;
        }

        // Clip if outside bottom Y limit.
        if (y2 > gfx_max_y) {
                y2 = gfx_max_y;
                height = y2 - y + 1;
        }
#endif

        switch (bmp->type) {
        case BITMAP_SOLID:
                gfx_draw_filled_rect(x, y, x2 - x, y2 - y, bmp->data.color);
                break;

        case BITMAP_RAM:
                pixmap = bmp->data.pixmap;
                // Offset into pixmap.
                pixmap += map_x;

                if (map_y > 0)
                        pixmap += (uint32_t)map_y * map_width;

                // Set up draw area.
                gfx_set_bottom_right_limit(x2, y2);

                // In case of no horizontal pixmap clipping, easier handling is
                // possible.
                if ((map_width == width) && (map_x == 0)) {
                        gfx_set_top_left_limit(x, y);
                        gfx_copy_pixels_to_screen(pixmap, (uint32_t)width * height);
                } else {
                        gfx_coord_t lines_left = height;

                        // Copy line by line to screen.
                        while (lines_left > 0) {
                                // Set up draw area.
                                gfx_set_top_left_limit(x, y);
                                ++y;

                                // Do the pixel copying.
                                gfx_copy_pixels_to_screen(pixmap, width);
                                pixmap += map_width;
                                --lines_left;
                        }
                }
                break;

        case BITMAP_PROGMEM:
                progmem_pixmap = bmp->data.progmem;
                // Offset into pixmap.
                progmem_pixmap += map_x;

                if (map_y > 0) {
                        progmem_pixmap += (uint32_t) map_y * map_width;
                }

                // Set up draw area.
                gfx_set_bottom_right_limit(x2, y2);

                /* In case of no horizontal pixmap clipping, easier handling is
                 * possible.
                 */
                if ((map_width == width) && (map_x == 0)) {
                        gfx_set_top_left_limit(x, y);
                        gfx_copy_progmem_pixels_to_screen(progmem_pixmap,
                                        (uint32_t)width * height);
                } else {
                        gfx_coord_t lines_left = height;

                        // Copy line by line to screen.
                        while (lines_left > 0) {
                                // Set up draw area.
                                gfx_set_top_left_limit(x, y);
                                ++y;

                                // Do the pixel copying.
                                gfx_copy_progmem_pixels_to_screen(progmem_pixmap, width);
                                progmem_pixmap += map_width;
                                --lines_left;
                        }
                }
                break;

#ifdef CONFIG_HUGEMEM
        case BITMAP_HUGEMEM:
                hugemem_pixmap = bmp->data.hugemem;
                // Offset into pixmap.
                hugemem_pixmap = (hugemem_ptr_t)((uint32_t)hugemem_pixmap +
                                map_x);

                if (map_y > 0) {
                        hugemem_pixmap = (hugemem_ptr_t)
                                ((uint32_t)hugemem_pixmap +
                                 ((uint32_t)map_y *
                                  (uint32_t)map_width));
                }

                // Set up draw area.
                gfx_set_bottom_right_limit(x2, y2);

                /* In case of no horizontal pixmap clipping, easier handling is
                 * possible.
                 */
                if ((map_width == width) && (map_x == 0)) {
                        gfx_set_top_left_limit(x, y);
                        gfx_copy_hugemem_pixels_to_screen(hugemem_pixmap,
                                        (uint32_t)width * height);
                } else {
                        gfx_coord_t lines_left = height;

                        // Copy line by line to screen.
                        while (lines_left > 0) {
                                // Set up draw area.
                                gfx_set_top_left_limit(x, y);
                                ++y;

                                // Do the pixel copying.
                                gfx_copy_hugemem_pixels_to_screen(
                                                hugemem_pixmap, width);
                                hugemem_pixmap =
                                        (hugemem_ptr_t)((uint32_t)hugemem_pixmap
                                                        + map_width);
                                --lines_left;
                        }
                }
                break;
#endif
        }
}

---