render hollow circle, begin of rendering chars

libs/mare/mare_drawables.cpp

@@ -1,4 +1,5 @@
 #include "mare.h"
+#include "charmap.h"
 
 namespace Render {
 
@@ -76,11 +77,11 @@ namespace Render {
             for (uint16_t t(0); t < _thickness; ++t) {
                 for (uint16_t xx(0); xx < _length; ++xx) {
                     if (_rotation == 0 || _rotation == 180){
-                        res.x = _rotation == 0 ? xx : (_length-xx);
-                        res.y = t-(_thickness>>1);
+                        res.x = _rotation == 0 ? xx : -xx;
+                        res.y = t-_ofst;
                     } else if (_rotation == 90 || _rotation == 270){
-                        res.x = t-(_thickness>>1);
-                        res.y = _rotation == 90 ? xx : _length-xx;
+                        res.x = t-_ofst;
+                        res.y = _rotation == 90 ? xx : -xx;
                     } else {
                         res = e->rotateXY(xx,t-_ofst,_rotation/180.0f*M_PI);
                     }
@@ -172,11 +173,143 @@ namespace Render {
     //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
     //Circle
 
+    DrawableCircle::DrawableCircle(const size_t id, Drawable* parent, Mare* engine):
+        Drawable(id, parent,engine),
+        _thickness(1),
+        _radius(8),
+        _outline(false)
+    {
+
+    }
+
+    DrawableCircle::~DrawableCircle () 
+    {
+
+    }
+
+    void DrawableCircle::render()
+    {
+        auto e = engine();
+        uint8_t* buf = getBuffer();
+        auto tt = _thickness;
+        auto bm = getBlendMode();
+        const pos_t o = getOrigin();
+        const uint8_t t2 = _thickness >> 1;
+        const pos_t oo = {o.x-t2, o.y-t2};
+
+        auto dot = [buf, tt, e, bm] (p_t x, p_t y) {
+            for (uint16_t xx(0); xx < tt; ++xx) {
+                for (uint16_t yy(0); yy < tt; ++yy) {
+                    e->setPixel(buf, xx+x, yy+y, bm);
+                }
+            }
+        };
+        auto pix = [buf,e,bm](p_t x, p_t y) {
+            e->setPixel(buf, x, y, bm);
+        };
+
+        if (isDirty()){
+            if (_outline){
+                const float st = M_PI_2/45;
+                pos_t pres;
+                for (float t(0); t <= M_TWOPI; t+=st){
+                    auto res = e->rotateXY(_radius,0,t);
+                    if (res != pres) {
+                        dot(oo.x+res.x, oo.y+res.y);
+                        dot(oo.x-res.x, oo.y+res.y);
+                        dot(oo.x-res.x, oo.y+res.y);
+                        dot(oo.x-res.x, oo.y-res.y);
+                        pres=res;
+                    }
+                }
+            }
+            resetDirty();
+        }
+
+    }
+
     //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
     //Character
 
+    extern const _tFont* Font8;
+    extern const _tFont* Font12;
+    extern const _tFont* Font16;
+    extern const _tFont* Font20;
+    extern const _tFont* Font24;
+
+
+    DrawableChar::DrawableChar(const size_t id, Drawable* parent, Mare* engine, char c, Font f) :
+        Drawable(id, parent,engine),
+        _fontEnum(f),
+        _char(c)
+    {
+        switch (_fontEnum)
+        {
+        case Font::Font8:
+            _font = *Font8;
+            break;
+
+        case Font::Font12:
+            _font = *Font12;
+            break;
+
+        case Font::Font16:
+            _font = *Font16;
+            break;
+
+        case Font::Font20:
+            _font = *Font20;
+            break;
+
+        case Font::Font24:
+            _font = *Font24;
+            break;
+        
+        default:
+            break;
+        }
+    }
+
+    DrawableChar::~DrawableChar() {
+
+    }
+
+    void DrawableChar::render() {
+
+    }
+
     //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
     //String
+
+    DrawableString::DrawableString(const size_t id, Drawable* parent, Mare* engine, std::string &s, Font f) :
+        Drawable(id, parent,engine),
+        _fontEnum(f),
+        _s(s)
+    {
+        _chars.reserve(s.size());
+        uint16_t idx(0);
+        for(auto c : _s){
+            _chars.push_back(engine->addDrawable<DrawableChar>(c.c_str(),_fontEnum));
+        }
+
+    }
+
+    DrawableString::~DrawableString() 
+    {
+        //free heap of drawable characters
+        for (auto c : _chars) {
+            delete c;
+        }
+        _chars.clear();
+    }
+
+    void DrawableString::render() {
+        for (auto c : _chars){
+            if (c != nullptr){
+                c->render();
+            }
+        }
+    }
     
     //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
     //Custom