dl_locator.h

浏览该文件的文档.

#pragma once
 
#include "io/dl_log.h"
#include "math/dl_math.h"
#include "misc/dl_layout.h"
 
namespace dl
{
class Locator
{
public:
    enum class Mode
    {
        DIRECT, // 直接定位，按i计算偏移
        ADAPT, // 自适应，一个元素可能占多个位置
    };

    struct SL
    {
        Position _start;
        Position _dt;
        Layout _layout;
        size_t _num;
        Mode _mode;
        SL() :
            _start{},
            _dt{ 0, 0 },
            _layout{ Layout::ORIGIN },
            _num{ 0 },
            _mode{ Mode::DIRECT }
        {}
 
        bool Check()
        {
            // 由于需要计算大小，必须dt合法
            return (_layout == Layout::X && _dt[0])
                || (_layout == Layout::Y && _dt[1])
                || (_layout == Layout::XY && _dt[0] && _dt[1])
                || (_layout == Layout::ORIGIN && _dt[0] == 0 && _dt[1] == 0);
        }
    };

    Locator(const SL& sl = SL()) :
        _sl{sl},
        _x{0},
        _y{0}
    {
        if (!_sl.Check())
        {
            log_err0("定位器无效！");
            _sl = SL();
        }
    }

    Position Get(const Size& size);
    Position Get(std::size_t i);
 
    bool ExGet(size_t i, const Size& size, Position& pos);
 
    Position GetSize()
    {
        size_t x = _x;
        size_t y = _y;
        switch (_sl._layout)
        {
        case Layout::X:
            ++y;
            break;
        case Layout::Y:
            ++x;
            break;
        case Layout::XY:
            break;
        case Layout::ORIGIN:
            ++x;
            ++y;
            break;
        default:
            assert(0);
        }
        return toPosition(x, y) * _sl._dt;
    }
 
    Mode GetMode() { return _sl._mode; }
    Layout GetLayout() { return _sl._layout; }
 
    Float GetDx() const
    {
        return _sl._dt[0];
    }
    Float GetDy() const
    {
        return _sl._dt[1];
    }
    void SetX(size_t x)
    {
        _x = x;
    }
    void SetY(size_t y)
    {
        _y = y;
    }
    void Reset()
    {
        _x = 0;
        _y = 0;
    }
private:
    SL _sl;
    size_t _x;  // 最后Get后，下一个的x
    size_t _y;  // 最最后Get后，下一个的y
 
    Position _get_direct(std::size_t i);
    Position _get_adapt(const Size& size);
};

inline Locator createLocatorZero()
{
    Locator::SL sl;
    sl._dt = {};
    sl._layout = Layout::ORIGIN;
    sl._num = 0;
    sl._mode = Locator::Mode::DIRECT;
    return sl;
}

inline Locator createLocatorX(float dx, std::size_t num = 0, float dy = 32.0f,
    Locator::Mode mode = Locator::Mode::DIRECT)
{
    Locator::SL sl;
    sl._dt = { dx, dy };
    sl._layout = Layout::X;
    sl._num = num;
    sl._mode = mode;
    return sl;
}

inline Locator createLocatorY(float dy, std::size_t num = 0, float dx = 32.0f,
    Locator::Mode mode = Locator::Mode::DIRECT)
{
    Locator::SL sl;
    sl._dt = { dx, dy };
    sl._layout = Layout::Y;
    sl._num = num;
    sl._mode = mode;
    return sl;
}
 
}