游戏引擎基于Handle的资源管理

基于Handle的资源管理方案，第一时间想到的应该是Windows了，但是真正想让我实施这个方案的，是《游戏编程精粹1》里面的游戏资源管理篇章的给出的方案。在《游戏编程精粹1》里面的资源标示Handle类，是一个极为简单的32位int类型，分为前16位的index和后16位的magic num，magic num主要是用来用作资源的校验的，在获取实例资源和删除实例资源的时候，都会校验一次。这两个数据合成一个int32用来标示唯一的资源。

union
    {
        enum
        {
            MAX_BITS_INDEX = 16,
            MAX_BITS_MAGIC = 16,

            MAX_INDEX = (1 << MAX_BITS_INDEX) - 1,
            MAX_MAGIC = (1 << MAX_BITS_MAGIC) - 1,
        };

        struct
        {
            unsigned mIndex : MAX_BITS_INDEX;
            unsigned mMagic : MAX_BITS_MAGIC;
        };

        uint mHandle;
    };

当然，这个Handle在书里面是定义成模板了，主要还是转为C++的习惯，变成一种强类型的标示吧，不同资源类型不能相互赋值和转化。

接来下是定义HandleManager，这个类也是一个模板，就跟名字一样，是用来管理Handle的，里面有两个vector,一个是保存正在使用的资源的vector，一个是删除资源后放入的free vector，当用户需要新建一个Handle的时候，会优先从free vector里面查找空的Handle，重新指向新的资源。

但是这个Handle的指向资源实例数组的index是不会变的，会变的只是magic num。总的来说，Handle还是变了。

template<typename DATA, typename RESHANDLE>
DATA * ResHandleMgr<DATA, RESHANDLE>::acquire(RESHANDLE &handle)
{
    uint index;
    if (mFreeSlots.empty())
    {
        index = mMagicNums.size();
        handle.init(index);
        DATA *pData = new DATA();
        mUserVec.push_back(pData);
        mMagicNums.push_back(handle.getMagic());
    }
    else
    {
        index = mFreeSlots.back();　　　　 // init后，magic num 会加一
        handle.init(index);
        mFreeSlots.pop_back();
        mMagicNums[index] = handle.getMagic();
    }

    //return (mUserVec.begin() + index);
    UserVec::iterator iter = mUserVec.begin() + index;
    return *iter;
}

这个大体就是《游戏编程精粹1》里面的引擎资源管理方案了，要保存资源很简单，持有Handle就行了，要获取和删除资源直接用Handle就行了。但是，估计大家也看来出什么问题了，资源没有自动释放的机制！！！！！！！

于是，我在Handle类里面加了个变量，用来作为引用计数，这里暂时没有引入智能指针(这个引用计数优化的方法应该可以加入一个内存池)

private:
    union
    {
        enum
        {
            MAX_BITS_INDEX = 16,
            MAX_BITS_MAGIC = 16,

            MAX_INDEX = (1 << MAX_BITS_INDEX) - 1,
            MAX_MAGIC = (1 << MAX_BITS_MAGIC) - 1,
        };

        struct
        {
            unsigned mIndex : MAX_BITS_INDEX;
            unsigned mMagic : MAX_BITS_MAGIC;
        };

        uint mHandle;
    };
        //保存引用计数
    uint *mpRefCount;

在Handle释放的时候，handle.release()，在Handle赋值的时候，handle.addRef，当(*mpRefCount) == 0的时候，就可以释放资源资源了。

一开始的时候，将引用计数设置为static std::map<int, int>(前面一个int表示Handle,后面一个表示引用次数)，后来发现效率实在太低，于是改为 uint *mpRefCount指针这种形式，帧数上升了20 FPS左右。。。

这个Handle类大体长这个样子的，基本也可以实现资源的自动释放机制了

template<typename ResType>
class ENGINE_DLL ResHandle
{
public:
    ResHandle();
    ResHandle(const ResHandle &handle);

    ~ResHandle();

    void init(uint index);
    uint getIndex() const;
    uint getMagic() const;
    uint getHandle() const;

    bool isNull() const;

    operator uint() const;

    void addRef();

    void release();

    ResHandle &operator =(ResHandle handle)
    {
        mHandle = handle.getHandle();
        if (handle.isNull() == false)
        {
            assert(handle.mpRefCount != 0);
            if (isNull() == false && mpRefCount)
            {
                release();
                if (mpRefCount != 0)
                    assert(mpRefCount == handle.mpRefCount);
            }
        }
        mpRefCount = handle.mpRefCount;
        addRef();
        return *this;
    }

private:
    union
    {
        enum
        {
            MAX_BITS_INDEX = 16,
            MAX_BITS_MAGIC = 16,

            MAX_INDEX = (1 << MAX_BITS_INDEX) - 1,
            MAX_MAGIC = (1 << MAX_BITS_MAGIC) - 1,
        };

        struct
        {
            unsigned mIndex : MAX_BITS_INDEX;
            unsigned mMagic : MAX_BITS_MAGIC;
        };

        uint mHandle;
    };

    uint *mpRefCount;
};

template<typename ResType>
ResHandle<ResType>::ResHandle(const ResHandle &handle) :
mpRefCount(0)
{
    mHandle = handle.getHandle();
    mpRefCount = handle.mpRefCount;
    addRef();
}

template<typename ResType>
ResHandle<ResType>::~ResHandle()
{
    release();
}

template<typename ResType>
void ResHandle<ResType>::release()
{
    if (mHandle != 0)
    {
        --(*mpRefCount);
        if (*mpRefCount == 0)
        {
            //std::cout << "need delete !!!!" << std::endl;
            //delete operator
            //后面加入
            Log::getInstancePtr()->logMsg("release res handle = %d", mHandle);

            SAFE_DELETE(mpRefCount);
        }
    }
}

template<typename ResType>
void ResHandle<ResType>::addRef()
{
    if (mHandle != 0)
    {
        ++(*mpRefCount);
    }
}

template<typename ResType>
ResHandle<ResType>::ResHandle() :
mHandle(0),
mpRefCount(0)
{

}

template<typename ResType>
void ResHandle<ResType>::init(uint index)
{
    assert(isNull());
    assert(index <= MAX_INDEX);

    static uint sAutoMagic = 0;

    if (++sAutoMagic > MAX_MAGIC)
    {
        sAutoMagic = 1;
    }

    mIndex = index;
    mMagic = sAutoMagic;

    if (mpRefCount == 0)
    {
        mpRefCount = new uint;
    }
    *mpRefCount = 1;
}

template<typename ResType>
ResHandle<ResType>::operator uint() const
{
    return mHandle;
}

template<typename ResType>
bool ResHandle<ResType>::isNull() const
{
    return !mHandle;
}

template<typename ResType>
uint ResHandle<ResType>::getHandle() const
{
    return mHandle;
}

template<typename ResType>
uint ResHandle<ResType>::getMagic() const
{
    return mMagic;
}

template<typename ResType>
uint ResHandle<ResType>::getIndex() const
{
    return mIndex;
}

//-------------------------------------------------------------------

template < typename Tag>
inline bool operator != (ResHandle<Tag> l, ResHandle<Tag> r)
{
    return (l.getHandle() != r.getHandle());
}

template < typename Tag>
inline bool operator == (ResHandle<Tag> l, ResHandle<Tag> r)
{
    return (l.getHandle() == r.getHandle());
}