base.hpp

#ifndef PROCEDURAL_VOXEL_TERRAIN_BASE_HPP
#define PROCEDURAL_VOXEL_TERRAIN_BASE_HPP

#include "blub/async/predecl.hpp"
#include "blub/core/globals.hpp"
#include "blub/core/noncopyable.hpp"
#include "blub/core/scopedPtr.hpp"
#include "blub/core/vector.hpp"
#include "blub/procedural/predecl.hpp"
#include "blub/procedural/voxel/simple/base.hpp"

#include <boost/function/function_fwd.hpp>


namespace blub
{
namespace procedural
{
namespace voxel
{
namespace terrain
{


template <class simpleType>
class base : public noncopyable
{
public:
    typedef simpleType t_simple;
    typedef t_simple* t_lod;
    typedef vector<scopedPointer<t_simple> > t_lodList;
    typedef typename t_simple::t_createTileCallback t_createTileCallback;

    base();
    ~base();

    t_lod getLod(const uint16& lod) const;
    const t_lodList& getLodList() const;

    int32 getNumLod() const;

    void setCreateTileCallback(const t_createTileCallback &toSet);

protected:


protected:
    t_lodList m_lods;

};

template <class tileType>
base<tileType>::base()
{
    ;
}
template <class tileType>
base<tileType>::~base()
{
    ;
}

template <class tileType>
typename base<tileType>::t_lod base<tileType>::getLod(const uint16 &lod) const
{
    BASSERT(lod < m_lods.size());
    return m_lods[lod].get();
}

template <class tileType>
const typename base<tileType>::t_lodList& base<tileType>::getLodList() const
{
    return m_lods;
}

template <class tileType>
int32 base<tileType>::getNumLod() const
{
    return m_lods.size();
}

template <class tileType>
void base<tileType>::setCreateTileCallback(const t_createTileCallback &toSet)
{
    for (typename t_lodList::value_type &lod : m_lods)
    {
        lod->setCreateTileCallback(toSet);
    }
}


}
}
}
}


#endif // PROCEDURAL_VOXEL_TERRAIN_BASE_HPP