minetest/src/util/areastore.h

205 lines
5.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.
*/
2015-10-30 04:26:03 +01:00
#ifndef AREA_STORE_H_
#define AREA_STORE_H_
2015-07-11 02:24:00 +02:00
#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 {
2015-10-31 01:38:22 +01:00
Area() : id(U32_MAX) {}
2015-10-30 05:52:45 +01:00
Area(const v3s16 &mine, const v3s16 &maxe) :
2015-10-31 01:38:22 +01:00
id(U32_MAX), minedge(mine), maxedge(maxe)
2015-07-11 02:24:00 +02:00
{
2015-10-30 04:08:32 +01:00
sortBoxVerticies(minedge, maxedge);
2015-07-11 02:24:00 +02:00
}
u32 id;
2015-10-30 05:52:45 +01:00
v3s16 minedge, maxedge;
2015-07-11 02:24:00 +02:00
std::string data;
};
class AreaStore {
public:
2015-10-30 05:52:45 +01:00
AreaStore() :
m_cache_enabled(true),
m_cacheblock_radius(64),
m_res_cache(1000, &cacheMiss, this),
m_next_id(0)
{}
virtual ~AreaStore() {}
static AreaStore *getOptimalImplementation();
virtual void reserve(size_t count) {};
size_t size() const { return areas_map.size(); }
/// Add an area to the store.
2015-10-31 01:38:22 +01:00
/// Updates the area's ID if it hasn't already been set.
/// @return Whether the area insertion was successful.
2015-10-30 04:08:32 +01:00
virtual bool insertArea(Area *a) = 0;
/// Removes an area from the store by ID.
/// @return Whether the area was in the store and removed.
2015-07-11 02:24:00 +02:00
virtual bool removeArea(u32 id) = 0;
/// Finds areas that the passed position is contained in.
/// Stores output in passed vector.
2015-07-11 02:24:00 +02:00
void getAreasForPos(std::vector<Area *> *result, v3s16 pos);
/// Finds areas that are completely contained inside the area defined
/// by the passed edges. If @p accept_overlap is true this finds any
/// areas that intersect with the passed area at any point.
2015-07-11 02:24:00 +02:00
virtual void getAreasInArea(std::vector<Area *> *result,
v3s16 minedge, v3s16 maxedge, bool accept_overlap) = 0;
/// Sets cache parameters.
2015-07-11 02:24:00 +02:00
void setCacheParams(bool enabled, u8 block_radius, size_t limit);
/// Returns a pointer to the area coresponding to the passed ID,
/// or NULL if it doesn't exist.
2015-07-11 02:24:00 +02:00
const Area *getArea(u32 id) const;
2015-10-31 00:27:48 +01:00
/// Serializes the store's areas to a binary ostream.
2015-07-11 02:24:00 +02:00
void serialize(std::ostream &is) const;
2015-10-31 00:27:48 +01:00
/// Deserializes the Areas from a binary istream.
/// This does not currently clear the AreaStore before adding the
/// areas, making it possible to deserialize multiple serialized
/// AreaStores.
void deserialize(std::istream &is);
2015-10-30 05:52:45 +01:00
protected:
/// Invalidates the getAreasForPos cache.
/// Call after adding or removing an area.
2015-10-30 05:52:45 +01:00
void invalidateCache();
/// Implementation of getAreasForPos.
/// getAreasForPos calls this if the cache is disabled.
2015-10-30 05:52:45 +01:00
virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos) = 0;
/// Returns the next area ID and increments it.
2015-10-30 05:52:45 +01:00
u32 getNextId() { return m_next_id++; }
// 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;
2015-07-11 02:24:00 +02:00
private:
/// Called by the cache when a value isn't found in the cache.
2015-07-11 02:24:00 +02:00
static void cacheMiss(void *data, const v3s16 &mpos, std::vector<Area *> *dest);
2015-10-30 05:52:45 +01:00
bool m_cache_enabled;
/// Range, in nodes, of the getAreasForPos cache.
/// If you modify this, call invalidateCache()
u8 m_cacheblock_radius;
2015-07-11 02:24:00 +02:00
LRUCache<v3s16, std::vector<Area *> > m_res_cache;
2015-10-30 05:52:45 +01:00
2015-10-30 04:08:32 +01:00
u32 m_next_id;
2015-07-11 02:24:00 +02:00
};
class VectorAreaStore : public AreaStore {
public:
2015-10-30 05:04:10 +01:00
virtual void reserve(size_t count) { m_areas.reserve(count); }
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);
2015-10-30 05:52:45 +01:00
protected:
virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos);
2015-07-11 02:24:00 +02:00
private:
std::vector<Area *> m_areas;
};
2015-10-30 05:52:45 +01:00
2015-07-11 02:24:00 +02:00
#if USE_SPATIAL
class SpatialAreaStore : public AreaStore {
public:
SpatialAreaStore();
2015-10-30 05:52:45 +01:00
virtual ~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);
2015-10-30 05:52:45 +01:00
protected:
virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos);
2015-07-11 02:24:00 +02:00
private:
SpatialIndex::ISpatialIndex *m_tree;
SpatialIndex::IStorageManager *m_storagemanager;
class VectorResultVisitor : public SpatialIndex::IVisitor {
public:
2015-10-30 05:52:45 +01:00
VectorResultVisitor(std::vector<Area *> *result, SpatialAreaStore *store) :
m_store(store),
m_result(result)
{}
~VectorResultVisitor() {}
2015-07-11 02:24:00 +02:00
2015-10-30 05:52:45 +01:00
virtual void visitNode(const SpatialIndex::INode &in) {}
2015-07-11 02:24:00 +02:00
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]));
}
2015-10-30 05:52:45 +01:00
private:
SpatialAreaStore *m_store;
std::vector<Area *> *m_result;
2015-07-11 02:24:00 +02:00
};
};
2015-10-30 05:52:45 +01:00
#endif // USE_SPATIAL
2015-07-11 02:24:00 +02:00
2015-10-30 04:26:03 +01:00
#endif // AREA_STORE_H_