262 lines
8.5 KiB
C++
262 lines
8.5 KiB
C++
|
|
#ifndef BLOCKPOS_H
|
|
#define BLOCKPOS_H
|
|
|
|
#include <cstdlib>
|
|
#include <limits>
|
|
#include <climits>
|
|
#include <cctype>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
#include <stdexcept>
|
|
#include <iterator>
|
|
|
|
class BlockPosIterator;
|
|
|
|
struct BlockPos {
|
|
// m_strFormat is used to record the original format that was obtained
|
|
// from the database (and thus, the format to use when querying
|
|
// the database again). DO NOT USE M_STRfORMAT FOR ANYTHING ELSE.
|
|
// Use the argument to databasePosStrFmt to force a specific display format.
|
|
enum StrFormat {
|
|
Unknown = 0,
|
|
I64, // Minetest & Freeminer
|
|
XYZ,
|
|
AXYZ, // Freeminer
|
|
STRFORMAT_MAX
|
|
};
|
|
int dimension[3];
|
|
int &x(void) { return dimension[0]; }
|
|
int &y(void) { return dimension[1]; }
|
|
int &z(void) { return dimension[2]; }
|
|
const int &x(void) const { return dimension[0]; }
|
|
const int &y(void) const { return dimension[1]; }
|
|
const int &z(void) const { return dimension[2]; }
|
|
//#if SIZE_MAX > (1LL << 36)
|
|
// std::size_t hash(void) const { return databasePosI64(); }
|
|
//#else
|
|
// std::size_t hash(void) const { return databasePosI64() % SIZE_MAX; }
|
|
//#endif
|
|
BlockPos() : dimension{0, 0, 0}, m_strFormat(Unknown), m_id(INT64_MIN) {}
|
|
BlockPos(int _x, int _y, int _z, StrFormat format = Unknown) : dimension{_x, _y, _z}, m_strFormat(format), m_id(INT64_MIN) {}
|
|
BlockPos(int _x, int _y, int _z, int64_t id) : dimension{_x, _y, _z}, m_strFormat(Unknown), m_id(id) {}
|
|
BlockPos(const BlockPos &pos) : dimension{pos.x(), pos.y(), pos.z()}, m_strFormat(pos.m_strFormat), m_id(pos.m_id) {}
|
|
BlockPos(int64_t i) { operator=(i); }
|
|
BlockPos(int64_t i, int64_t id) { operator=(i); m_id = id; }
|
|
BlockPos(const std::string &s) { operator=(s); }
|
|
StrFormat databaseFormat(void) const { return m_strFormat; }
|
|
int64_t databasePosI64(void) const { return getDBPos(); }
|
|
int64_t databasePosId(void) const { return m_id; }
|
|
bool databasePosIdIsValid(void) const { return m_id != INT64_MIN; }
|
|
std::string databasePosStr(StrFormat defaultFormat = Unknown) const;
|
|
std::string databasePosStrFmt(StrFormat format) const;
|
|
|
|
bool operator<(const BlockPos& p) const;
|
|
bool operator==(const BlockPos& p) const;
|
|
bool operator!=(const BlockPos& p) const { return !operator==(p); }
|
|
void operator=(const BlockPos &p) { x() = p.x(); y() = p.y(); z() = p.z(); m_strFormat = p.m_strFormat; m_id = p.m_id; }
|
|
void operator=(int64_t i) { setFromDBPos(i); m_strFormat = I64; m_id = INT64_MIN; }
|
|
void operator=(const std::string &s);
|
|
|
|
static const int Any = INT_MIN;
|
|
static const int Invalid = INT_MAX;
|
|
|
|
protected:
|
|
// Include code copied from the minetest codebase.
|
|
// Defines (at least) the following functions:
|
|
// setFromDBPos(int64_t i);
|
|
// int64_t getDBPos(void) const;
|
|
#include "minetest-database.h"
|
|
|
|
private:
|
|
// WARNING: see comment about m_strFormat above !!
|
|
StrFormat m_strFormat;
|
|
int64_t m_id;
|
|
friend class BlockPosIterator;
|
|
};
|
|
|
|
// This could be a random access iterator, but it is not needed, and it
|
|
// is more complex to implement
|
|
//class BlockPosIterator : public std::iterator<std::bidirectional_iterator_tag, BlockPos, long long>
|
|
class BlockPosIterator
|
|
{
|
|
public:
|
|
enum State { Start = -1, Middle = 0, End = 1 };
|
|
// NOTE: if m_state is initialized to Middle, the value of the iterator will be undefined
|
|
BlockPosIterator(void) : m_value(0,0,0), m_start(0,0,0), m_end(0,0,0), m_state(Start) {}
|
|
BlockPosIterator(BlockPos start, BlockPos end, State state = Middle) : m_value(start), m_start(start), m_end(end), m_state(state) {}
|
|
BlockPosIterator(const BlockPosIterator &i) : m_value(i.m_value), m_start(i.m_start), m_end(i.m_end), m_state(i.m_state) {}
|
|
BlockPosIterator &operator=(const BlockPosIterator &i);
|
|
bool operator==(const BlockPosIterator &i) const;
|
|
bool operator!=(const BlockPosIterator &i) const { return !operator==(i); }
|
|
|
|
BlockPos &operator*(void) { return m_value; }
|
|
BlockPos *operator->(void) { return &m_value; }
|
|
BlockPosIterator &operator++(void) { stepForward(); return *this; }
|
|
BlockPosIterator operator++(int) { BlockPosIterator rv(*this); stepForward(); return rv; }
|
|
BlockPosIterator &operator--(void) { stepReverse(); return *this; }
|
|
BlockPosIterator operator--(int) { BlockPosIterator rv(*this); stepReverse(); return rv; }
|
|
|
|
void breakDim(int i, int step = 1);
|
|
private:
|
|
BlockPos m_value;
|
|
BlockPos m_start;
|
|
BlockPos m_end;
|
|
State m_state;
|
|
void stepForward(void);
|
|
void stepReverse(void);
|
|
bool stepDim(int i, int step);
|
|
};
|
|
|
|
struct NodeCoord : BlockPos
|
|
{
|
|
bool isBlock[3];
|
|
bool &xBlock(void) { return isBlock[0]; }
|
|
bool &yBlock(void) { return isBlock[1]; }
|
|
bool &zBlock(void) { return isBlock[2]; }
|
|
const bool &xBlock(void) const { return isBlock[0]; }
|
|
const bool &yBlock(void) const { return isBlock[1]; }
|
|
const bool &zBlock(void) const { return isBlock[2]; }
|
|
|
|
NodeCoord() : BlockPos(), isBlock{false, false, false} {}
|
|
NodeCoord(int _x, int _y, int _z) : BlockPos(_x, _y, _z), isBlock{false, false, false} {}
|
|
NodeCoord(const BlockPos &pos, bool node = false) : BlockPos(pos), isBlock{pos.x() == Any ? false : !node, pos.y() == Any ? false : !node, pos.z() == Any ? false : !node} {}
|
|
NodeCoord(const NodeCoord &coord) : BlockPos(coord), isBlock{coord.xBlock(), coord.yBlock(), coord.zBlock()} {}
|
|
NodeCoord(int64_t i) : isBlock{true, true, true} { setFromDBPos(i); }
|
|
|
|
size_t hash(void) const;
|
|
|
|
bool operator==(const NodeCoord &coord) const;
|
|
void operator=(const BlockPos &coord) { x() = coord.x(); y() = coord.y(); z() = coord.z(); xBlock() = true; yBlock() = true; zBlock() = true; }
|
|
void operator=(const NodeCoord &coord) { x() = coord.x(); y() = coord.y(); z() = coord.z(); xBlock() = coord.xBlock(); yBlock() = coord.yBlock(); zBlock() = coord.zBlock(); }
|
|
};
|
|
|
|
// Use this for map or set storage only...
|
|
struct NodeCoordHashed : NodeCoord
|
|
{
|
|
private:
|
|
size_t m_hash;
|
|
public:
|
|
NodeCoordHashed(const BlockPos &pos) : NodeCoord(pos) { rehash(); }
|
|
NodeCoordHashed(const NodeCoord &coord) : NodeCoord(coord) { rehash(); }
|
|
void rehash(void) { m_hash = NodeCoord::hash(); }
|
|
size_t hash(void) { rehash(); return m_hash; }
|
|
size_t hash(void) const { return m_hash; }
|
|
bool operator==(const NodeCoordHashed &coord) const { if (m_hash != coord.m_hash) return false; return NodeCoord::operator==(coord); }
|
|
void operator=(const NodeCoord &coord) { NodeCoord::operator=(coord); rehash(); }
|
|
bool operator<(const NodeCoordHashed &coord) { return m_hash < coord.m_hash; }
|
|
};
|
|
|
|
namespace std {
|
|
template<>
|
|
struct hash<NodeCoordHashed>
|
|
{
|
|
size_t operator()(const NodeCoordHashed &nch) const { return nch.hash(); }
|
|
};
|
|
}
|
|
|
|
inline std::string BlockPos::databasePosStr(StrFormat defaultFormat) const
|
|
{
|
|
StrFormat format = m_strFormat;
|
|
if (format == Unknown)
|
|
format = defaultFormat;
|
|
return databasePosStrFmt(format);
|
|
}
|
|
|
|
// operator< should order the positions in the
|
|
// order the corresponding pixels are generated:
|
|
// First (most significant): z coordinate, descending (i.e. reversed)
|
|
// Then : x coordinate, ascending
|
|
// Last (least significant): y coordinate, descending (i.e. reversed)
|
|
inline bool BlockPos::operator<(const BlockPos& p) const
|
|
{
|
|
if (z() > p.z())
|
|
return true;
|
|
if (z() < p.z())
|
|
return false;
|
|
if (x() < p.x())
|
|
return true;
|
|
if (x() > p.x())
|
|
return false;
|
|
if (y() > p.y())
|
|
return true;
|
|
if (y() < p.y())
|
|
return false;
|
|
return false;
|
|
}
|
|
|
|
inline bool BlockPos::operator==(const BlockPos &p) const
|
|
{
|
|
if (z() != p.z())
|
|
return false;
|
|
if (y() != p.y())
|
|
return false;
|
|
if (x() != p.x())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
inline BlockPosIterator &BlockPosIterator::operator=(const BlockPosIterator &i)
|
|
{
|
|
m_value = i.m_value;
|
|
m_start = i.m_start;
|
|
m_end = i.m_end;
|
|
m_state = i.m_state;
|
|
return *this;
|
|
}
|
|
|
|
inline bool BlockPosIterator::operator==(const BlockPosIterator &i) const
|
|
{
|
|
if (m_state != i.m_state)
|
|
return false;
|
|
else
|
|
return m_value == i.m_value;
|
|
}
|
|
|
|
inline bool BlockPosIterator::stepDim(int i, int step)
|
|
{
|
|
bool forward = true;
|
|
if (step < 0)
|
|
forward = false;
|
|
if (m_start.dimension[i] <= m_end.dimension[i] || !forward) {
|
|
if (m_value.dimension[i] < m_end.dimension[i]) {
|
|
m_value.dimension[i]++;
|
|
return true;
|
|
}
|
|
else {
|
|
m_value.dimension[i] = m_start.dimension[i];
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if (m_value.dimension[i] > m_end.dimension[i]) {
|
|
m_value.dimension[i]--;
|
|
return true;
|
|
}
|
|
else {
|
|
m_value.dimension[i] = m_start.dimension[i];
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
inline bool NodeCoord::operator==(const NodeCoord &coord) const
|
|
{
|
|
if (z() != coord.z())
|
|
return false;
|
|
if (y() != coord.y())
|
|
return false;
|
|
if (x() != coord.x())
|
|
return false;
|
|
if (zBlock() != coord.zBlock())
|
|
return false;
|
|
if (yBlock() != coord.yBlock())
|
|
return false;
|
|
if (xBlock() != coord.xBlock())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
#endif // BLOCKPOS_H
|