inMemory.hpp

#ifndef VOXEL_SIMPLE_CONTAINER_INMEMORY_HPP
#define VOXEL_SIMPLE_CONTAINER_INMEMORY_HPP


#include "blub/math/vector3int32map.hpp"
#include "blub/procedural/voxel/simple/container/base.hpp"
#include "blub/serialization/access.hpp"
#include "blub/serialization/nameValuePair.hpp"
#include "blub/serialization/saveLoad.hpp"


namespace blub
{
namespace procedural
{
namespace voxel
{
namespace simple
{
namespace container
{


template <class configType>
class inMemory : public base<configType>
{
public:
    typedef base<configType> t_base;

    typedef vector3int32map<typename t_base::t_utilsTile> t_tilesMap;

    inMemory(blub::async::dispatcher &worker)
        : t_base(worker)
    {
#ifdef BLUB_LOG_VOXEL
        blub::BOUT("inMemory::inMemory()");
#endif
    }

    ~inMemory()
    {
    #ifdef BLUB_LOG_VOXEL
        blub::BOUT("inMemory::~inMemory()");
    #endif
    }

    typename t_base::t_utilsTile getTileHolder(const blub::vector3int32& id) const override
    {
        const axisAlignedBoxInt32 bounds(m_tiles.getBounds().getMinimum(), m_tiles.getBounds().getMaximum() - vector3int32(1));
        if (bounds.isInside(id))
        {
            return m_tiles.getValue(id);
        }
        typename t_base::t_utilsTile result;
        return result;
    }

    const t_tilesMap& getTilesMap() const
    {
        return m_tiles;
    }

    void setTileBounds(const axisAlignedBoxInt32& bounds)
    {
        m_tiles.resize(bounds);
    }

    const axisAlignedBoxInt32& getTileBounds() const
    {
        return m_tiles.getBounds();
    }

protected:
    virtual void setTileToContainerMaster(const typename t_base::t_tileId id, const typename t_base::t_utilsTile &oldOne, const typename t_base::t_utilsTile &toSet)
    {
        (void)oldOne;

        m_tiles.extend(axisAlignedBoxInt32(id, id+vector3int32(1)));
        m_tiles.setValue(id, toSet);
    }

    void setTileMaster(const blub::vector3int32& id, const typename t_base::t_utilsTile& toSet) override
    {
#ifdef BLUB_LOG_VOXEL
        blub::BOUT("inMemory::setTileMaster id:" + blub::string::number(id));
#endif

        typename t_base::t_utilsTile holder(getTileHolder(id));
        bool alreadyEmpty(holder.state == utils::tileState::empty);

        if (toSet.state == utils::tileState::empty && alreadyEmpty)
        {
            return;
        }
        if (!alreadyEmpty)
        {
            if (toSet.state == utils::tileState::full &&
                holder.state == utils::tileState::full) // nothing will change
            {
                return;
            }
        }
        setTileToContainerMaster(id, holder, toSet);

        if (toSet.state == utils::tileState::partitial)
        {
            BASSERT(!toSet.data->isEmpty());
            BASSERT(!toSet.data->isFull());

            if (!toSet.data->getEditedVoxelBoundingBox().isValid()) // no voxel changed
            {
                toSet.data->endEdit();
                return;
            }
        }
        t_base::addToChangeList(id, toSet);
    }

    void setTileToFullMaster(const vector3int32& id) override
    {
#ifdef BLUB_LOG_VOXEL
        blub::BOUT("inMemory::setTileToFullMaster id:" + blub::string::number(id));
#endif
        const typename t_base::t_utilsTile holder(utils::tileState::full);
        setTileMaster(id, holder);
    }
    void setTileToEmtpyMaster(const vector3int32& id) override
    {
#ifdef BLUB_LOG_VOXEL
        blub::BOUT("inMemory::setTileToEmtpyMaster id:" + blub::string::number(id));
#endif
        const typename t_base::t_utilsTile holder(utils::tileState::empty);
        setTileMaster(id, holder);
    }

protected:
    BLUB_SERIALIZATION_ACCESS

    template <class formatType>
    void save(formatType & readWrite, const uint32& version) const
    {
        (void)version;

        const axisAlignedBoxInt32& bounds(getTileBounds());
        readWrite & BLUB_SERIALIZATION_NAMEVALUEPAIR(bounds);

        for (int32 indX = bounds.getMinimum().x; indX < bounds.getMaximum().x; ++indX)
        {
            for (int32 indY = bounds.getMinimum().y; indY < bounds.getMaximum().y; ++indY)
            {
                for (int32 indZ = bounds.getMinimum().z; indZ < bounds.getMaximum().z; ++indZ)
                {
                    const vector3int32 id(indX, indY, indZ);
                    const typename t_base::t_utilsTile holder(getTileHolder(id));

                    readWrite & BLUB_SERIALIZATION_NAMEVALUEPAIR(id);
                    readWrite & serialization::nameValuePair::create("state", holder.state);

                    if (holder.state != utils::tileState::partitial)
                    {
                        continue;
                    }

                    readWrite & serialization::nameValuePair::create("tile", *holder.data.data());
                }
            }
        }
    }
    template <class formatType>
    void load(formatType & readWrite, const uint32& version)
    {
        (void)version;

        t_base::lockForEdit();

        axisAlignedBoxInt32 bounds;
        readWrite & BLUB_SERIALIZATION_NAMEVALUEPAIR(bounds);

        setTileBounds(bounds);

        for (int32 indX = bounds.getMinimum().x; indX < bounds.getMaximum().x; ++indX)
        {
            for (int32 indY = bounds.getMinimum().y; indY < bounds.getMaximum().y; ++indY)
            {
                for (int32 indZ = bounds.getMinimum().z; indZ < bounds.getMaximum().z; ++indZ)
                {
                    vector3int32 id;
                    readWrite & BLUB_SERIALIZATION_NAMEVALUEPAIR(id);
                    BASSERT(id == vector3int32(indX, indY, indZ));

                    typename t_base::t_utilsTile holder;
                    readWrite & serialization::nameValuePair::create("state", holder.state);

                    if (holder.state == utils::tileState::partitial)
                    {
                        holder.data = t_base::createTile();
                        readWrite & serialization::nameValuePair::create("tile", *holder.data.data());
                    }

                    setTile(id, holder);
                }
            }
        }

        t_base::unlockForEdit();
    }
    template <class formatType>
    void serialize(formatType & readWrite, const uint32& version)
    {
        using namespace serialization;

        saveLoad(readWrite, *this, version);
    }

private:
    t_tilesMap m_tiles;

};


}
}
}
}
}


#endif // VOXEL_SIMPLE_CONTAINER_INMEMORY_HPP