areastore.h

Go to the documentation of this file.

// Luanti
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2015 est31 <mtest31@outlook.com>
 
#pragma once
 
#include "irr_v3d.h"
#include "noise.h" // for PcgRandom
#include <map>
#include <list>
#include <vector>
#include <istream>
#include "util/container.h"
#include "util/numeric.h"
#ifndef ANDROID
        #include "cmake_config.h"
#endif
#if USE_SPATIAL
        #include <spatialindex/SpatialIndex.h>
        #include "util/serialize.h"
#endif
 
 
struct Area {
        Area(u32 area_id) : id(area_id) {}
 
        Area(const v3s16 &mine, const v3s16 &maxe, u32 area_id = U32_MAX) :
                id(area_id), minedge(mine), maxedge(maxe)
        {
                sortBoxVerticies(minedge, maxedge);
        }
 
        u32 id;
        v3s16 minedge, maxedge;
        std::string data;
};
 
 
class AreaStore {
public:
        AreaStore() :
                m_res_cache(1000, &cacheMiss, this)
        {}
 
        virtual ~AreaStore() = default;
 
        static AreaStore *getOptimalImplementation();
 
        virtual void reserve(size_t count) {};
        size_t size() const { return areas_map.size(); }
 
        virtual bool insertArea(Area *a) = 0;
 
        virtual bool removeArea(u32 id) = 0;
 
        void getAreasForPos(std::vector<Area *> *result, v3s16 pos);
 
        virtual void getAreasInArea(std::vector<Area *> *result,
                v3s16 minedge, v3s16 maxedge, bool accept_overlap) = 0;
 
        void setCacheParams(bool enabled, u8 block_radius, size_t limit);
 
        const Area *getArea(u32 id) const;
 
        void serialize(std::ostream &is) const;
 
        void deserialize(std::istream &is);
 
protected:
        void invalidateCache();
 
        virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos) = 0;
 
        u32 getNextId() const;
 
        // Note: This can't be an unordered_map, since all
        // references would be invalidated on rehash.
        typedef std::map<u32, Area> AreaMap;
        AreaMap areas_map;
 
private:
        static void cacheMiss(void *data, const v3s16 &mpos, std::vector<Area *> *dest);
 
        bool m_cache_enabled = true;
        u8 m_cacheblock_radius = 64;
        LRUCache<v3s16, std::vector<Area *> > m_res_cache;
};
 
 
class VectorAreaStore : public AreaStore {
public:
        virtual void reserve(size_t count) { m_areas.reserve(count); }
        virtual bool insertArea(Area *a);
        virtual bool removeArea(u32 id);
        virtual void getAreasInArea(std::vector<Area *> *result,
                v3s16 minedge, v3s16 maxedge, bool accept_overlap);
 
protected:
        virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos);
 
private:
        std::vector<Area *> m_areas;
};
 
 
#if USE_SPATIAL
 
class SpatialAreaStore : public AreaStore {
public:
        SpatialAreaStore();
        virtual ~SpatialAreaStore();
 
        virtual bool insertArea(Area *a);
        virtual bool removeArea(u32 id);
        virtual void getAreasInArea(std::vector<Area *> *result,
                v3s16 minedge, v3s16 maxedge, bool accept_overlap);
 
protected:
        virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos);
 
private:
        SpatialIndex::ISpatialIndex *m_tree = nullptr;
        SpatialIndex::IStorageManager *m_storagemanager = nullptr;
 
        class VectorResultVisitor : public SpatialIndex::IVisitor {
        public:
                VectorResultVisitor(std::vector<Area *> *result, SpatialAreaStore *store) :
                        m_store(store),
                        m_result(result)
                {}
                ~VectorResultVisitor() {}
 
                virtual void visitNode(const SpatialIndex::INode &in) {}
 
                virtual void visitData(const SpatialIndex::IData &in)
                {
                        u32 id = in.getIdentifier();
 
                        std::map<u32, Area>::iterator itr = m_store->areas_map.find(id);
                        assert(itr != m_store->areas_map.end());
                        m_result->push_back(&itr->second);
                }
 
                virtual void visitData(std::vector<const SpatialIndex::IData *> &v)
                {
                        for (size_t i = 0; i < v.size(); i++)
                                visitData(*(v[i]));
                }
 
        private:
                SpatialAreaStore *m_store = nullptr;
                std::vector<Area *> *m_result = nullptr;
        };
};
 
#endif // USE_SPATIAL