tb_bitmap_fragment.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TB_BITMAP_FRAGMENT_H
#define TB_BITMAP_FRAGMENT_H

#include "tb_core.h"
#include "tb_geometry.h"
#include "tb_hashtable.h"
#include "tb_list.h"
#include "tb_id.h"
#include "tb_linklist.h"

namespace tb {

class TBBitmapFragment;
class TBBitmap;

int TBGetNearestPowerOfTwo(int val);

class TBImageLoader
{
public:
    static TBImageLoader *CreateFromFile(const TBStr & filename, float dpi);

    virtual ~TBImageLoader() {}

    virtual int Width() = 0;

    virtual int Height() = 0;

    virtual uint32_t *Data() = 0;
};

class TBSpaceAllocator
{
public:
    class Space : public TBLinkOf<Space>
    {
    public:
        int x, width;
    };

    TBSpaceAllocator(int available_space)
        : m_available_space(available_space) { }

    bool IsAllAvailable() const { return !m_used_space_list.HasLinks(); }

    bool HasSpace(int needed_w) const;

    Space *AllocSpace(int needed_w);

    void FreeSpace(Space *space);
private:
    Space *GetSmallestAvailableSpace(int needed_w);
    int m_available_space;
    TBLinkListAutoDeleteOf<Space> m_free_space_list;
    TBLinkListAutoDeleteOf<Space> m_used_space_list;
};

class TBFragmentSpaceAllocator : public TBSpaceAllocator
{
public:
    TBFragmentSpaceAllocator(int y, int width, int height)
        : TBSpaceAllocator(width), y(y), height(height) {}

    int y, height;
};

enum TB_VALIDATE_TYPE {

    TB_VALIDATE_ALWAYS,

    TB_VALIDATE_FIRST_TIME
};

class TBBitmapFragmentMap
{
public:
    TBBitmapFragmentMap();
    ~TBBitmapFragmentMap();

    bool Init(int bitmap_w, int bitmap_h);

    TBBitmapFragment *CreateNewFragment(int frag_w, int frag_h, int data_stride, uint32_t *frag_data, bool add_border);

    void FreeFragmentSpace(TBBitmapFragment *frag);

    TBBitmap *GetBitmap(TB_VALIDATE_TYPE validate_type = TB_VALIDATE_ALWAYS);
private:
    friend class TBBitmapFragmentManager;
    bool ValidateBitmap();
    void DeleteBitmap();
    void CopyData(TBBitmapFragment *frag, int data_stride, uint32_t *frag_data, int border);
    TBListAutoDeleteOf<TBFragmentSpaceAllocator> m_rows;
    int m_bitmap_w, m_bitmap_h;
    uint32_t *m_bitmap_data;
    TBBitmap *m_bitmap;
    bool m_need_update;
    int m_allocated_pixels;
};

class TBBitmapFragment
{
public:
    int Width() const { return m_rect.w; }

    int Height() const { return m_rect.h; }

    TBBitmap *GetBitmap(TB_VALIDATE_TYPE validate_type = TB_VALIDATE_ALWAYS) {
        return m_map->GetBitmap(validate_type);
    }

    int GetAllocatedHeight() const { return m_row_height; }
public:
    TBBitmapFragmentMap *m_map;
    TBRect m_rect;
    TBFragmentSpaceAllocator *m_row;
    TBFragmentSpaceAllocator::Space *m_space;
    TBID m_id;
    int m_row_height;

    uint32_t m_batch_id;
};

class TBBitmapFragmentManager
{
public:
    TBBitmapFragmentManager();
    ~TBBitmapFragmentManager();

    void SetAddBorder(bool add_border) { m_add_border = add_border; }
    bool GetAddBorder() const { return m_add_border; }

    TBBitmapFragment *GetFragmentFromFile(const TBStr & filename, bool dedicated_map, float dpi);

    TBBitmapFragment *GetFragment(const TBID &id) const;

    TBBitmapFragment *CreateNewFragment(const TBID &id, bool dedicated_map,
                                        int data_w, int data_h, int data_stride,
                                        uint32_t *data);

    void FreeFragment(TBBitmapFragment *frag);

    void Clear();

    bool ValidateBitmaps();

    void DeleteBitmaps();

    int GetNumMaps() const { return m_fragment_maps.GetNumItems(); }

    void SetNumMapsLimit(int num_maps_limit);

    void SetDefaultMapSize(int w, int h);

    int GetUseRatio() const;
#ifdef TB_RUNTIME_DEBUG_INFO

    void Debug();
#endif
private:
    TBListOf<TBBitmapFragmentMap> m_fragment_maps;
    TBHashTableOf<TBBitmapFragment> m_fragments;
    int m_num_maps_limit;
    bool m_add_border;
    int m_default_map_w;
    int m_default_map_h;
};

} // namespace tb

#endif // TB_BITMAP_FRAGMENT_H