tiler.h

Go to the documentation of this file.

/*
    MIT License

    Copyright (c) 2018, Alexey Dynda

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
*/
#ifndef _NANO_ENGINE_TILER_H_
#define _NANO_ENGINE_TILER_H_

#include "canvas.h"
#include "lcd/lcd_common.h"

extern "C" SFixedFontInfo s_fixedFont;

/* The table below defines arguments for NanoEngineTiler.          *
 *                            canvas        width   height  bits   */
// Tiles for monochrome displays
#define TILE_128x64_MONO      NanoCanvas1,  128,    64,     7    
#define TILE_8x8_MONO         NanoCanvas1,  8,      8,      3    
#define TILE_16x16_MONO       NanoCanvas1,  16,     16,     4    
#define TILE_32x32_MONO       NanoCanvas1,  32,     32,     4    
// Tiles for 8-bit displays
#define TILE_8x8_RGB8         NanoCanvas8,  8,      8,      3    
#define TILE_16x16_RGB8       NanoCanvas8,  16,     16,     4    
#define TILE_32x32_RGB8       NanoCanvas8,  32,     32,     5    
#define TILE_8x8_MONO_8       NanoCanvas1_8,8,      8,      3    
// Tiles for 16-bit displays
#define TILE_8x8_RGB16        NanoCanvas16, 8,      8,      3    
// Adafruit tiles
#define ADATILE_8x8_MONO      AdafruitCanvas1,  8,  8,      3    
#define ADATILE_8x8_RGB8      AdafruitCanvas8,  8,  8,      3    
#define ADATILE_8x8_RGB16     AdafruitCanvas16, 8,  8,      3    


typedef bool (*TNanoEngineOnDraw)(void);

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
class NanoEngineTiler
{
protected:
    NanoEngineTiler()
    {
        refresh();
    };

public:
    static const uint8_t NE_TILE_SIZE_BITS = B;
    static const lcduint_t NE_TILE_WIDTH = W;
    static const lcduint_t NE_TILE_HEIGHT = H;
    static const uint8_t NE_MAX_TILES_NUM = 64 >> (B - 3);

    static C canvas;

    static void refresh()
    {
        memset(m_refreshFlags,0xFF,sizeof(uint16_t) * NanoEngineTiler<C,W,H,B>::NE_MAX_TILES_NUM);
    }

    static void refresh(const NanoRect &rect)
    {
        refresh(rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);
    }

    static void refresh(const NanoPoint &point)
    {
        if ((point.y<0) || ((point.y>>B)>=NE_MAX_TILES_NUM)) return;
        m_refreshFlags[(point.y>>B)] |= (1<<(point.x>>B));
    }

    static void refresh(lcdint_t x1, lcdint_t y1, lcdint_t x2, lcdint_t y2)
    {
        if (y2 < 0) return;
        if (y1 < 0) y1 = 0;
        if (x1 < 0) x1 = 0;
        y1 = y1>>B;
        y2 = min((y2>>B), NE_MAX_TILES_NUM - 1);
        for (uint8_t y=y1; y<=y2; y++)
        {
            for(uint8_t x=x1>>B; x<=(x2>>B); x++)
            {
                m_refreshFlags[y] |= (1<<x);
            }
        }
    }

    static void refreshWorld(const NanoRect &rect)
    {
        refreshWorld(rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);
    }

    static void refreshWorld(lcdint_t x1, lcdint_t y1, lcdint_t x2, lcdint_t y2)
    {
        refresh(x1 - offset.x, y1 - offset.y, x2 - offset.x, y2 - offset.y);
    }

    static void refreshWorld(const NanoPoint &point)
    {
        refresh( point - offset );
    }

    static void localCoordinates()
    {
        canvas.offset -= offset;
    }

    static void worldCoordinates()
    {
        canvas.offset += offset;
    }

    static void moveTo(const NanoPoint & position)
    {
        offset = position;
    }

    static void moveToAndRefresh(const NanoPoint & position)
    {
        moveTo(position);
        refresh();
    }

    const NanoPoint & getPosition() const
    {
        return offset;
    }

    static void drawCallback(TNanoEngineOnDraw callback)
    {
        m_onDraw = callback;
    }

    static bool collision(NanoPoint &p, NanoRect &rect) { return rect.collision( p ); }

protected:
    static uint16_t   m_refreshFlags[NE_MAX_TILES_NUM];

    static TNanoEngineOnDraw m_onDraw;

    static void displayBuffer();

    static void displayPopup(const char *msg);
private:
    static uint8_t    m_buffer[W * H * C::BITS_PER_PIXEL / 8];

    static NanoPoint offset;
};

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
uint16_t NanoEngineTiler<C,W,H,B>::m_refreshFlags[NE_MAX_TILES_NUM];

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
uint8_t NanoEngineTiler<C,W,H,B>::m_buffer[W * H * C::BITS_PER_PIXEL / 8];

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
C NanoEngineTiler<C,W,H,B>::canvas(W, H, m_buffer);

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
NanoPoint NanoEngineTiler<C,W,H,B>::offset = {0, 0};

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
TNanoEngineOnDraw NanoEngineTiler<C,W,H,B>::m_onDraw = nullptr;

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
void NanoEngineTiler<C,W,H,B>::displayBuffer()
{
    if (!m_onDraw)  // If onDraw handler is not set, just output current canvas
    {
        canvas.blt();
        return;
    }
    for (lcduint_t y = 0; y < ssd1306_lcd.height; y = y + NE_TILE_HEIGHT)
    {
        uint16_t flag = m_refreshFlags[y >> NE_TILE_SIZE_BITS];
        m_refreshFlags[y >> NE_TILE_SIZE_BITS] = 0;
        for (lcduint_t x = 0; x < ssd1306_lcd.width; x = x + NE_TILE_WIDTH)
        {
            if (flag & 0x01)
            {
                canvas.setOffset(x, y);
                if (m_onDraw())
                {
                    canvas.setOffset(x, y);
                    canvas.blt();
                }
            }
            flag >>=1;
        }
    }
}

template<class C, lcduint_t W, lcduint_t H, uint8_t B>
void NanoEngineTiler<C,W,H,B>::displayPopup(const char *msg)
{
    NanoRect rect = { {8, (ssd1306_lcd.height>>1) - 8}, {ssd1306_lcd.width - 8, (ssd1306_lcd.height>>1) + 8} };
    // TODO: It would be nice to calculate message height
    NanoPoint textPos = { (ssd1306_lcd.width - (lcdint_t)strlen(msg)*s_fixedFont.h.width) >> 1, (ssd1306_lcd.height>>1) - 4 };
    refresh(rect);
    for (lcduint_t y = 0; y < ssd1306_lcd.height; y = y + NE_TILE_HEIGHT)
    {
        uint16_t flag = m_refreshFlags[y >> NE_TILE_SIZE_BITS];
        m_refreshFlags[y >> NE_TILE_SIZE_BITS] = 0;
        for (lcduint_t x = 0; x < ssd1306_lcd.width; x = x + NE_TILE_WIDTH)
        {
            if (flag & 0x01)
            {
                canvas.setOffset(x, y);
                if (m_onDraw) m_onDraw();
                canvas.setOffset(x, y);
                canvas.setColor(RGB_COLOR8(0,0,0));
                canvas.fillRect(rect);
                canvas.setColor(RGB_COLOR8(192,192,192));
                canvas.drawRect(rect);
                canvas.printFixed( textPos.x, textPos.y, msg);

                canvas.blt();
            }
            flag >>=1;
        }
    }
}

#endif