dl_texture_pack.h

浏览该文件的文档.

#pragma once
 
#include <list>
#include <map>
 
#include "dl_type.h"
#include "dl_align.h"

namespace dl::TexturePack
{

template<unsigned DH>
class Dynamic
{
public:
    struct Line
    {
        unsigned _y;
        unsigned _h;
        unsigned _x;
        bool _free;
    };

    void Reset(const Size& size)
    {
        _size = size;
        _regY = 0;
        _bFull = false;
 
        _vecLine.clear();
    }

    bool Add(const Size& size, RectU& rect)
    {
        if (_bFull)
            return false;
 
        unsigned w = size[0];
        unsigned h = size[1];
        //找到一个h比自己大的，但又不能超过DH（然后还能放得下x）
        auto iter = find_if(_vecLine.begin(), _vecLine.end(), [&](Line& line)
            {
                if (line._free
                    && line._h >= h // 30 >= 28
                    && line._h <= h + DH) // 30 <= 28 + 2   {28,29,30}
                {
                    if (line._x + w > _size[0])
                    {
                        line._free = false;
                        return false;
                    }
                    else
                        return true;
                }
                return false;
            });
 
        if (iter == _vecLine.end())
        {//没有就创建一个
            if (h + _regY > _size[1])
            {
                _bFull = true;
                return false;
            }
 
            Line line;
            line._h = h;
            line._y = _regY;
            line._x = 0;
            line._free = true;
 
            _regY += h;
            _vecLine.push_back(line);
 
            iter = _vecLine.end() - 1;
        }
 
        rect = { iter->_x, iter->_y, iter->_x + w , iter->_y + h };
 
        iter->_x += w;
 
        //越界检查
        assert(rect[2] <= _size[0] && rect[3] <= _size[1]);
 
        return true;
    }
 
private:
    Size _size;
    unsigned _regY;//当前y
    bool _bFull;//满了标记
    std::vector<Line> _vecLine;
};

class Static
{
public:
    void SetSize(const Size& size)
    {
        _size = size;
    }

    template<typename T, typename FS, typename F>
    void Calc(std::list<T>& all_box, FS get_size, F call_back)
    {
        //维护一个按h排序的剩余空间
        std::multimap<unsigned, RectU> map_remain;
        //初始空间
        map_remain.insert( { _size[1], createRectU(_size) });
 
        //按面积大小排序（list的sort本身就是稳定的）
        all_box.sort([get_size](const T& box0, const T& box1)
            {
                return Accumulate::Mul(get_size(box0))
                 > Accumulate::Mul(get_size(box1));
            });
 
        for (auto iter = all_box.begin(); iter != all_box.end();)
        {
            //获取大小
            Size size = get_size(*iter);
            //寻找一个比自己h大的剩余空间
            bool failed = true;
            auto iter_remain = map_remain.begin();
            for (; iter_remain != map_remain.end(); ++iter_remain)
            {
                if (iter_remain->first >= size[1]
                    && Align::GetWidth(iter_remain->second) >= size[0])
                {//并且w也要更大
                    //放入自己，并将加入到的剩余空间拆分为新的两个剩余空间，加入到map_remain
                    PointU lt = Align::GetLT(iter_remain->second);
                    call_back(*iter, lt);
 
                    //在世界坐标里的 rect
                    RectU rect_parent = createRectU(lt, size);
 
                    //right rect
                    if (iter_remain->second[1] != rect_parent[3])
                    {//高度过小的剩余空间丢弃
                        RectU rect_right = { rect_parent[2], iter_remain->second[1], iter_remain->second[2], rect_parent[3] };
                        map_remain.insert({ Align::GetHeight(rect_right), rect_right });
                    }
 
                    //buttom rect
                    if (rect_parent[3] != iter_remain->second[3])
                    {//高度过小的剩余空间丢弃
                        RectU rect_buttom = { iter_remain->second[0], rect_parent[3], iter_remain->second[2], iter_remain->second[3] };
                        map_remain.insert({ Align::GetHeight(rect_buttom), rect_buttom });
                    }
 
                    //还需删除加入到的剩余空间
                    map_remain.erase(iter_remain);
                    //标记加入成功
                    failed = false;
                    break;
                }
            }
            //成功则移除
            if (!failed)
                all_box.erase(iter++);
            else
                ++iter;
        }
    }
private:
    Size _size;
};
 
}