accessor.hpp

#ifndef PROCEDURAL_VOXEL_ACCESSOR_ACCESSOR_HPP
#define PROCEDURAL_VOXEL_ACCESSOR_ACCESSOR_HPP

#include "blub/async/mutexReadWrite.hpp"
#include "blub/core/globals.hpp"
#include "blub/core/hashList.hpp"
#include "blub/core/hashMap.hpp"
#include "blub/core/noncopyable.hpp"
#include "blub/core/signal.hpp"
#include "blub/math/axisAlignedBoxInt32.hpp"
#include "blub/math/vector3.hpp"
#include "blub/procedural/log/global.hpp"
#include "blub/procedural/voxel/simple/base.hpp"
#include "blub/procedural/voxel/simple/container/base.hpp"
#include "blub/procedural/voxel/simple/container/utils/tile.hpp"
#include "blub/procedural/voxel/tile/accessor.hpp"
#include "blub/procedural/voxel/tile/container.hpp"


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


template <class configType>
class accessor : public base<typename configType::t_accessor::t_tile>
{
public:
    typedef configType t_config;
    typedef typename t_config::t_accessor::t_tile t_tile;
    typedef sharedPointer<t_tile> t_tilePtr;
    typedef base<t_tile> t_base;
    typedef typename t_config::t_data t_voxel;

    typedef typename t_base::t_tileId t_tileId;
    typedef hashMap<vector3int32, t_tilePtr> t_tiles;

    typedef typename t_config::t_container::t_tile t_tileContainer;
    typedef sharedPointer<t_tileContainer> t_tileContainerPtr;
    typedef hashList<vector3int32> t_tileIdList;
    typedef container::utils::tileState t_tileState;
    typedef container::utils::tile<t_tileContainer> t_tileHolder;
    typedef hashMap<t_tileId, t_tileHolder> t_tileHolderMap;

    typedef typename t_config::t_container::t_simple t_simpleContainerVoxel;


    accessor(async::dispatcher &worker,
             t_simpleContainerVoxel &voxels,
             const int32& lod)
        : t_base(worker)
        , m_voxels(voxels)
        , m_lod(lod)
        , m_voxelSkip(math::pow(2, m_lod))
        , m_numTilesInWork(0)
    {
        m_connTilesGotChanged = m_voxels.signalEditDone()->connect(boost::bind(&accessor::tilesGotChanged, this));

        t_base::setCreateTileCallback(boost::bind(&t_tile::create));
    }

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

    t_simpleContainerVoxel &getVoxelContainer() const
    {
        return m_voxels;
    }

    t_tilePtr getTile(const t_tileId& id) const
    {
        typename t_tiles::const_iterator it = m_tiles.find(id);
        if (it == m_tiles.cend())
        {
            return nullptr;
        }
        return it->second;
    }

protected:
    void tilesGotChanged()
    {
        m_voxels.lockForRead();
        t_base::m_master.post(boost::bind(&accessor::tilesGotChangedMaster, this));
    }

    void tilesGotChangedMaster()
    {
        const auto& changedTiles(m_voxels.getTilesThatGotEdited());
#ifdef BLUB_LOG_VOXEL
        BLUB_PROCEDURAL_LOG_OUT() << "accessor tilesGotChangedMaster changedTiles.size():" << changedTiles.size();
#endif
        BASSERT(!changedTiles.empty());
        /*if (changedTiles.empty())
        {
            m_voxels.unlockRead();
            return;
        }*/

        t_tileIdList affectedTiles;
        for (auto change : changedTiles)
        {
            const t_tileId id(change.first);
            const t_tileHolder workTile(change.second);

            if (m_lod == 0) // optimisation on lod_0 only
            {
                if (workTile.state == container::utils::tileState::empty)
                {
                    if (m_tiles.find(id) == m_tiles.cend())
                    {
                        continue;
                    }
                }
            }

            calculateAffectedAccessorTilesByContainerTile(id, workTile, affectedTiles);
        }

        if (affectedTiles.empty())
        {
//            blub::BWARNING("affectedTiles.empty()");
            m_voxels.unlockRead();
            return;
        }

        t_base::lockForEditMaster();
        BASSERT(m_numTilesInWork == 0);
        m_numTilesInWork = affectedTiles.size();

        for (const t_tileId id : affectedTiles)
        {
            t_base::m_worker.post(boost::bind(&accessor::calculateAccessorTS, this, id, getTile(id)));
        }
    }

    void calculateAccessorTS(const t_tileId& id, t_tilePtr workTile)
    {
        if (workTile.isNull())
        {
            workTile = createTile();
            // workTile->setEmpty();
        }

        const vector3int32 voxelStart(id*t_tile::voxelLength*m_voxelSkip);
        // axisAlignedBoxInt32 lastUsedTileBounds;
        t_tileHolderMap lastUsedTiles;

        bool valuesChanged(false);
        for (int32 indX = -1; indX < t_tile::voxelLength+2; ++indX)
        {
            for (int32 indY = -1; indY < t_tile::voxelLength+2; ++indY)
            {
                for (int32 indZ = -1; indZ < t_tile::voxelLength+2; ++indZ)
                {
                    const vector3int32 pos(indX, indY, indZ);
                    const vector3int32 voxelPosAbs(voxelStart + pos*m_voxelSkip);

                    valuesChanged |= workTile->setVoxel(pos, getVoxelData(voxelPosAbs, /*lastUsedTileBounds, */lastUsedTiles));
                }
            }
        }

        if (workTile->getCalculateLod())
        {
            BASSERT(m_voxelSkip > 0);

            const int32 voxelLengthLod = t_tile::voxelLengthLod;
            const vector3int32 toIterate[][2] = {
                                                {vector3int32(0, 0, 0), vector3int32(1, voxelLengthLod, voxelLengthLod)},
                                                {vector3int32(voxelLengthLod-2, 0, 0), vector3int32(voxelLengthLod-1, voxelLengthLod, voxelLengthLod)},
                                                {vector3int32(0, 0, 0), vector3int32(voxelLengthLod, 1, voxelLengthLod)},
                                                {vector3int32(0, voxelLengthLod-2, 0), vector3int32(voxelLengthLod, voxelLengthLod-1, voxelLengthLod)},
                                                {vector3int32(0, 0, 0), vector3int32(voxelLengthLod, voxelLengthLod, 1)},
                                                {vector3int32(0, 0, voxelLengthLod-2), vector3int32(voxelLengthLod, voxelLengthLod, voxelLengthLod-1)},
                                                };
            for (int32 lod = 0; lod < 6; ++lod)
            {
                const vector3int32& start(toIterate[lod][0]);
                const vector3int32& end(toIterate[lod][1]);
                for (int32 indX = start.x; indX < end.x; ++indX)
                {
                    for (int32 indY = start.y; indY < end.y; ++indY)
                    {
                        for (int32 indZ = start.z; indZ < end.z; ++indZ)
                        {
                            const vector3int32 pos(indX, indY, indZ);
                            const vector3int32 voxelPosAbs(voxelStart + pos*(m_voxelSkip/2));

                            const t_voxel result(getVoxelData(voxelPosAbs, /*lastUsedTileBounds, */lastUsedTiles));
    #ifdef BLUB_DEBUG
                            if (indX % 2 == 0 &&
                                indY % 2 == 0 &&
                                indZ % 2 == 0)
                            {
                                BASSERT(workTile->getVoxel(pos / 2) == result);
                            }
    #endif

                            valuesChanged |= workTile->setVoxelLod(pos-start, result, lod);
                        }
                    }
                }
            }
        }

        if (workTile->isEmpty() || workTile->isFull())
        {
            t_base::m_master.post(boost::bind(&accessor::afterCalculateAccessorMaster, this, id, nullptr, true));
            return;
        }

        t_base::m_master.post(boost::bind(&accessor::afterCalculateAccessorMaster, this, id, workTile, valuesChanged));
    }

    void afterCalculateAccessorMaster(const t_tileId& id, t_tilePtr workTile, const bool &didValuesChanged)
    {
        BASSERT(t_base::getTilesThatGotEdited().find(id) == t_base::getTilesThatGotEdited().cend());

        typename t_tiles::const_iterator it = m_tiles.find(id);

        // no indices
        if (workTile.isNull())
        {
            if (it != m_tiles.cend())
            {
                m_tiles.erase(it);
                t_base::addToChangeList(id, nullptr);
            }
        }
        else
        {
            BASSERT(!workTile.isNull());
            if (it == m_tiles.cend())
            {
                m_tiles.insert(id, workTile);
            }
            if (didValuesChanged)
            {
                t_base::addToChangeList(id, workTile);
            }
        }


        --m_numTilesInWork;
        if (m_numTilesInWork == 0)
        {
            if (t_base::m_tilesThatGotEdited.size() == 0)
            {
                BLUB_LOG_WARNING() << "nothing changed";
            }
            m_voxels.unlockRead();
            t_base::unlockForEditMaster();
        }
    }


    void calculateAffectedAccessorTilesByContainerTile(const t_tileId& conterainerId, const t_tileHolder &holder, t_tileIdList& resultingSurfaceTiles)
    {
        const vector3 forDiv(conterainerId);
        const vector3int32 result((forDiv / (real)m_voxelSkip).getFloor());
        resultingSurfaceTiles.insert(result);

        vector3int32 minimum(0);
        if (holder.state == t_tileState::partitial)
        {
            BASSERT(holder.data->getEditedVoxelBoundingBox().isValid());
            minimum = holder.data->getEditedVoxelBoundingBox().getMinimum();
        }
        if (minimum > vector3int32(0))
        {
            return;
        }

        const vector3int32 resultMod(conterainerId%m_voxelSkip);
        if (resultMod.x == 0 && minimum.x == 0)
        {
            resultingSurfaceTiles.insert(result - vector3int32(1, 0, 0));
        }
        if (resultMod.y == 0 && minimum.y == 0)
        {
            resultingSurfaceTiles.insert(result - vector3int32(0, 1, 0));
        }
        if (resultMod.z == 0 && minimum.z == 0)
        {
            resultingSurfaceTiles.insert(result - vector3int32(0, 0, 1));
        }
        if (resultMod.x == 0 && resultMod.y == 0 && minimum.x == 0 && minimum.y == 0)
        {
            resultingSurfaceTiles.insert(result - vector3int32(1, 1, 0));
        }
        if (resultMod.x == 0 && resultMod.z == 0 && minimum.x == 0 && minimum.z == 0)
        {
            resultingSurfaceTiles.insert(result - vector3int32(1, 0, 1));
        }
        if (resultMod.y == 0 && resultMod.z == 0 && minimum.y == 0 && minimum.z == 0)
        {
            resultingSurfaceTiles.insert(result - vector3int32(0, 1, 1));
        }
        if (resultMod.x == 0 && resultMod.y == 0 && resultMod.z == 0 && minimum == vector3int32(0))
        {
            resultingSurfaceTiles.insert(result - vector3int32(1, 1, 1));
        }
    }

    t_tilePtr createTile() const override
    {
        t_tilePtr result(t_base::createTile());
        result->setCalculateLod(m_lod > 0);
        return result;
    }

    t_voxel getVoxelData(const vector3int32& voxelPosAbs, t_tileHolderMap& lastUsedTiles)
    {
        const vector3int32 &tilePos(m_voxels.calculateVoxelPosToTileId(voxelPosAbs));
        const vector3int32 &tilePosAbs(tilePos*vector3int32(t_tile::voxelLength));

        typename t_tileHolderMap::const_iterator it = lastUsedTiles.find(tilePos);

        t_voxel result;
        if (it != lastUsedTiles.cend())
        {
            const t_tileHolder &lastUsedTile(it->second);
            switch(lastUsedTile.state)
            {
            case t_tileState::partitial:
                result = lastUsedTile.data->getVoxel(voxelPosAbs-tilePosAbs);
                break;
            case t_tileState::empty:
                result.setMin();
                break;
            case t_tileState::full:
                result.setMax();
                break;
            default:
                BASSERT(false);
            }
            return result;
        }

        // get new tile
        const t_tileHolder &lastUsedTile(m_voxels.getTileHolder(tilePos));
        lastUsedTiles.insert(tilePos, lastUsedTile);

        // repeat step ahead
        switch(lastUsedTile.state)
        {
        case t_tileState::partitial:
            result = lastUsedTile.data->getVoxel(voxelPosAbs-tilePosAbs);
            break;
        case t_tileState::empty:
            result.setMin();
            break;
        case t_tileState::full:
            result.setMax();
            break;
        default:
            BASSERT(false);
        }
        return result;
    }

protected:

    t_simpleContainerVoxel& m_voxels;
    const int32 m_lod;
    const int32 m_voxelSkip;
    int32 m_numTilesInWork;

    t_tiles m_tiles;

    boost::signals2::scoped_connection m_connTilesGotChanged;
};


}
}
}
}


#endif // PROCEDURAL_VOXEL_ACCESSOR_ACCESSOR_HPP