base.hpp

#ifndef VOXEL_SIMPLE_CONTAINER_BASE_HPP
#define VOXEL_SIMPLE_CONTAINER_BASE_HPP

#include "blub/core/sharedPointer.hpp"
#include "blub/math/axisAlignedBox.hpp"
#include "blub/math/axisAlignedBoxInt32.hpp"
#include "blub/math/transform.hpp"
#include "blub/procedural/voxel/simple/base.hpp"
#include "blub/procedural/voxel/simple/container/utils/tile.hpp"


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


template <class configType>
class base : public simple::base<typename configType::t_container::t_tile>
{
public:
    typedef configType t_config;
    typedef typename t_config::t_data t_voxel;
    typedef typename configType::t_container::t_tile t_tile;
    typedef simple::base<t_tile> t_base;
    typedef sharedPointer<t_tile> t_tilePtr;
    typedef utils::tile<t_tile> t_utilsTile;

    typedef sharedPointer<edit::base<t_config> const> t_editConstPtr;
    typedef sharedPointer<edit::base<t_config> > t_editPtr;
    typedef typename t_base::t_tileId t_tileId;

    typedef hashMap<t_tileId, t_utilsTile> t_tilesGotChangedMap;

    base(blub::async::dispatcher &worker)
        : t_base(worker)
        , m_numInTilesInTask(0)
    {

    }

    void editVoxel(t_editConstPtr change, const transform &trans = blub::transform())
    {
        t_base::m_master.post(boost::bind(&base::editMaster, this, change, trans));
    }

//    void editVoxel(t_editPtr change, const transform &trans = blub::transform())
//    {
//        editVoxel(change.template staticCast<const edit::base<t_config> >(), trans);
//    }

    void setTile(const t_tileId& id, const t_utilsTile& toSet)
    {
        t_base::m_master.post(boost::bind(&base::setTileMaster, this, id, toSet));
    }

    virtual t_utilsTile getTileHolder(const t_tileId& id) const = 0;
    t_utilsTile getTileHolderByVoxelPosition(const blub::vector3int32& pos) const
    {
        return getTileHolder(calculateVoxelPosToTileId(pos));
    }

    t_voxel getVoxel(const vector3int32& voxelPos) const
    {
        t_utilsTile workTile(getTileHolderByVoxelPosition(voxelPos));

        t_voxel result;
        if (workTile.state == utils::tileState::full)
        {
            result.setMax();
            return result;
        }
        if (workTile.state == utils::tileState::empty)
        {
            result.setMin();
            return result;
        }
        return workTile.data->getVoxel(calculateVoxelPosInTile(voxelPos));
    }

    static t_tileId calculateVoxelPosToTileId(const vector3int32& voxelPos)
    {
        return vector3int32((blub::vector3(voxelPos) / (real)t_config::voxelsPerTile).getFloor());
    }

    static vector3int32 calculateVoxelPosInTile(const vector3int32& voxelPos) // TODO floor?!
    {
        vector3int32 result(voxelPos % t_config::voxelsPerTile);
        if (voxelPos.x < 0 && voxelPos.x%t_config::voxelsPerTile != 0)
        {
            result.x = t_config::voxelsPerTile + result.x;
        }
        if (voxelPos.y < 0 && voxelPos.y%t_config::voxelsPerTile != 0)
        {
            result.y = t_config::voxelsPerTile + result.y;
        }
        if (voxelPos.z < 0 && voxelPos.z%t_config::voxelsPerTile != 0)
        {
            result.z = t_config::voxelsPerTile + result.z;
        }
        return result;
    }

    const t_tilesGotChangedMap &getTilesThatGotEdited() const
    {
        return m_tilesThatGotEdited;
    }

protected:
    void addToChangeList(const t_tileId &id, t_utilsTile toAdd)
    {
        BASSERT(!t_base::m_classLocker.tryLockForWrite());
        m_tilesThatGotEdited.insert(id, toAdd);
    }
    void unlockForEditMaster() override
    {
        t_base::unlockForEditMaster();
        if (!m_tilesThatGotEdited.empty())
        {
            t_base::m_sigEditDone();
        }
    }
    bool tryLockForEditMaster() override
    {
        const bool success(t_base::tryLockForEditMaster());
        if (success)
        {
            m_tilesThatGotEdited.clear();
        }
        return success;
    }
    void lockForEditMaster() override
    {
        t_base::lockForEditMaster();
        m_tilesThatGotEdited.clear();
    }

    struct editTodo
    {
        editTodo(const t_editConstPtr change, const blub::transform& trans_)
            : edit_(change)
            , trans(trans_)
        {
            ;
        }
        editTodo(const editTodo& other)
            : edit_(other.edit_)
            , trans(other.trans)
        {
            ;
        }
        const editTodo& operator = (const editTodo& other)
        {
            edit_ = other.edit_;
            trans = other.trans;

            return *this;
        }

        t_editConstPtr edit_;
        transform trans;
    };


    void editMaster(t_editConstPtr change, const blub::transform& trans)
    {
    #ifdef BLUB_LOG_VOXEL
        blub::BOUT("base::editVoxel");
    #endif

        editTodo edit(change, trans);

        m_editsTodo.push_back(edit);

        doNextEditMaster();
    }

    void doNextEditMaster(const bool &alreadyLocked = false)
    {
    #ifdef BLUB_LOG_VOXEL
        blub::BOUT("base::doNextEditMaster");
    #endif
        BASSERT(m_numInTilesInTask >= 0);

        if (m_editsTodo.empty())
        {
            return;
        }
        if (m_numInTilesInTask > 0)
        {
            return;
        }

        if (!alreadyLocked)
        {
            lockForEditMaster();
        }

        BASSERT(m_numInTilesInTask == 0);

        editTodo edit(*m_editsTodo.begin());
        m_editsTodo.erase(m_editsTodo.begin());
        t_editConstPtr change(edit.edit_);

        const blub::transform trans(edit.trans);
        const blub::axisAlignedBox aabb(change->getAxisAlignedBoundingBox(trans));
        const blub::axisAlignedBoxInt32 aabbScaled(aabb.getMinimum(), aabb.getMaximum());
        blub::vector3int32 startEdit;
        blub::vector3int32 endEdit;

        calculateAffectetedTilesByAabb(aabbScaled, startEdit, endEdit);

        for (blub::int32 indX = startEdit.x; indX < endEdit.x; ++indX)
        {
            for (blub::int32 indY = startEdit.y; indY < endEdit.y; ++indY)
            {
                for (blub::int32 indZ = startEdit.z; indZ < endEdit.z; ++indZ)
                {
                    const blub::vector3int32 id(indX, indY, indZ);
                    const t_utilsTile workTile(getTileHolder(id));

                    ++m_numInTilesInTask;
                    t_base::m_worker.post(boost::bind(&base::editVoxelWorker, this, change, workTile, id, trans));
                }
            }
        }
    }

    void editVoxelWorker(t_editConstPtr change, const t_utilsTile &holder, const blub::vector3int32& id, const blub::transform& trans)
    {
    #ifdef BLUB_LOG_VOXEL
        blub::BOUT("base::editVoxelTS id:" + blub::string::number(id));
    #endif
        t_tilePtr workTile;
        if (holder.state == utils::tileState::partitial)
        {
            workTile = holder.data;
        }
        else
        {
            workTile = createTileFull(holder.state == utils::tileState::full);
        }

        if (!workTile->getEditing())
        {
            workTile->startEdit();
        }
        change->calculateVoxel(workTile.data(), id, trans);

        t_utilsTile result;
        if (workTile->isEmpty())
        {
            result.state = utils::tileState::empty;
        }
        else
        {
            if (workTile->isFull())
            {
                result.state = utils::tileState::full;
            }
            else
            {
                result.state = utils::tileState::partitial;
                result.data = workTile;
            }
        }
        t_base::m_master.post(boost::bind(&base::editVoxelDoneMaster, this, result, id));
    }

    void editVoxelDoneMaster(t_utilsTile tileHolder_, const blub::vector3int32& id)
    {
        setTileMaster(id, tileHolder_);

        --m_numInTilesInTask;
        if (m_numInTilesInTask == 0)
        {
            if (m_editsTodo.isEmpty())
            {
                // unlock all tiles
                for (const typename t_tilesGotChangedMap::value_type& work : getTilesThatGotEdited())
                {
                    if (!work.second.data.isNull())
                    {
                        work.second.data->endEdit();
                    }
                }
                unlockForEditMaster();
            }
            else
            {
                doNextEditMaster(true);
            }
        }
    }

    virtual void setTileMaster(const t_tileId& id, const t_utilsTile& toSet) = 0;

    t_tilePtr getOrCreateTile(const vector3int32& id)
    {
    #ifdef BLUB_LOG_VOXEL
        blub::BOUT("base::getOrCreateTile id:" + blub::string::number(id));
    #endif

        t_utilsTile foundTile(getTileHolder(id));
        if (foundTile.state == utils::tileState::empty)
        {
            return createTileFull(false);
        }
        if (foundTile.state == utils::tileState::full)
        {
            return createTileFull(true);
        }
        return foundTile.data;
    }

    static t_tilePtr createTileFull(const bool &full)
    {
    #ifdef BLUB_LOG_VOXEL
        blub::BOUT("base::createTile id: full:" + blub::string::number(full));
    #endif
        t_tilePtr newOne(t_tile::create()); // FIXME call base class

        if (full)
        {
            newOne->startEdit();
            newOne->setFull();
            newOne->endEdit();
        }

        return newOne;
    }

    virtual void setTileToFullMaster(const t_tileId& id) = 0;
    virtual void setTileToEmtpyMaster(const t_tileId& id) = 0;

    static void calculateAffectetedTilesByAabb(const axisAlignedBoxInt32& voxelAabb, t_tileId& startResult, t_tileId& endResult)
    {
        startResult = calculateVoxelPosToTileId(voxelAabb.getMinimum());
        endResult = calculateVoxelPosToTileId(voxelAabb.getMaximum()) + blub::vector3int32(1, 1, 1);
    }

protected:
    int32 m_numInTilesInTask;

    typedef list<editTodo> t_editTodoList;
    t_editTodoList m_editsTodo;

    // overwrite/reimpl stuff from t_base - because no usage of sharedPointer<>
    t_tilesGotChangedMap m_tilesThatGotEdited;

};


}
}
}
}
}

#endif // VOXEL_SIMPLE_CONTAINER_BASE_HPP