minetest/src/areastore.h

178 lines
4.6 KiB
C
Raw Normal View History

2015-07-11 02:24:00 +02:00
/*
Minetest
Copyright (C) 2015 est31 <mtest31@outlook.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef AREASTORE_H_
#define AREASTORE_H_
#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() {}
2015-10-30 04:08:32 +01:00
Area(const v3s16 &mine, const v3s16 &maxe)
2015-07-11 02:24:00 +02:00
{
2015-10-30 04:08:32 +01:00
minedge = mine;
maxedge = maxe;
sortBoxVerticies(minedge, maxedge);
2015-07-11 02:24:00 +02:00
}
u32 id;
v3s16 minedge;
v3s16 maxedge;
std::string data;
};
std::vector<std::string> get_areastore_typenames();
class AreaStore {
protected:
void invalidateCache();
virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos) = 0;
2015-10-30 04:08:32 +01:00
u32 getNextId() { return m_next_id++; }
// TODO change to unordered_map when we can
std::map<u32, Area> areas_map;
2015-07-11 02:24:00 +02:00
public:
2015-10-30 04:08:32 +01:00
// Updates the area's ID
virtual bool insertArea(Area *a) = 0;
2015-07-11 02:24:00 +02:00
virtual void reserve(size_t count) {};
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;
#if 0
// calls a passed function for every stored area, until the
// callback returns true. If that happens, it returns true,
// if the search is exhausted, it returns false
virtual bool forEach(bool (*callback)(void *args, Area *a), void *args) const = 0;
#endif
virtual ~AreaStore()
{}
AreaStore() :
m_cacheblock_radius(64),
m_res_cache(1000, &cacheMiss, this),
2015-10-30 04:17:44 +01:00
m_next_id(0),
m_cache_enabled(true)
2015-07-11 02:24:00 +02:00
{
}
void setCacheParams(bool enabled, u8 block_radius, size_t limit);
const Area *getArea(u32 id) const;
u16 size() const;
#if 0
bool deserialize(std::istream &is);
void serialize(std::ostream &is) const;
#endif
private:
static void cacheMiss(void *data, const v3s16 &mpos, std::vector<Area *> *dest);
u8 m_cacheblock_radius; // if you modify this, call invalidateCache()
LRUCache<v3s16, std::vector<Area *> > m_res_cache;
2015-10-30 04:08:32 +01:00
u32 m_next_id;
2015-10-30 04:17:44 +01:00
bool m_cache_enabled;
2015-07-11 02:24:00 +02:00
};
class VectorAreaStore : public AreaStore {
protected:
virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos);
public:
2015-10-30 04:08:32 +01:00
virtual bool insertArea(Area *a);
2015-07-11 02:24:00 +02:00
virtual void reserve(size_t count);
virtual bool removeArea(u32 id);
virtual void getAreasInArea(std::vector<Area *> *result,
v3s16 minedge, v3s16 maxedge, bool accept_overlap);
// virtual bool forEach(bool (*callback)(void *args, Area *a), void *args) const;
private:
std::vector<Area *> m_areas;
};
#if USE_SPATIAL
class SpatialAreaStore : public AreaStore {
protected:
virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos);
public:
SpatialAreaStore();
2015-10-30 04:08:32 +01:00
virtual bool insertArea(Area *a);
2015-07-11 02:24:00 +02:00
virtual bool removeArea(u32 id);
virtual void getAreasInArea(std::vector<Area *> *result,
v3s16 minedge, v3s16 maxedge, bool accept_overlap);
// virtual bool forEach(bool (*callback)(void *args, Area *a), void *args) const;
virtual ~SpatialAreaStore();
private:
SpatialIndex::ISpatialIndex *m_tree;
SpatialIndex::IStorageManager *m_storagemanager;
class VectorResultVisitor : public SpatialIndex::IVisitor {
private:
SpatialAreaStore *m_store;
std::vector<Area *> *m_result;
public:
VectorResultVisitor(std::vector<Area *> *result, SpatialAreaStore *store)
{
m_store = store;
m_result = result;
}
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]));
}
~VectorResultVisitor() {}
};
};
#endif
#endif /* AREASTORE_H_ */