-#ifndef VOXEL_HEADER
-#define VOXEL_HEADER
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.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.
+*/
-#include "common_irrlicht.h"
-#include "mapblock.h"
+#pragma once
+
+#include "irrlichttypes.h"
+#include "irr_v3d.h"
#include <iostream>
+#include <cassert>
+#include "exceptions.h"
+#include "mapnode.h"
+#include <set>
+#include <list>
+#include "util/basic_macros.h"
+
+class NodeDefManager;
+
+// For VC++
+#undef min
+#undef max
/*
- TODO: A fast voxel manipulator class
+ A fast voxel manipulator class.
+
+ In normal operation, it fetches more map when it is requested.
+ It can also be used so that all allowed area is fetched at the
+ start, using ManualMapVoxelManipulator.
Not thread-safe.
*/
+/*
+ Debug stuff
+*/
+extern u64 emerge_time;
+extern u64 emerge_load_time;
+
/*
This class resembles aabbox3d<s16> a lot, but has inclusive
edges for saner handling of integer sizes
{
public:
// Starts as zero sized
- VoxelArea():
- MinEdge(1,1,1),
- MaxEdge(0,0,0)
- {
- }
- VoxelArea(v3s16 min_edge, v3s16 max_edge):
+ VoxelArea() = default;
+
+ VoxelArea(const v3s16 &min_edge, const v3s16 &max_edge):
MinEdge(min_edge),
MaxEdge(max_edge)
{
+ cacheExtent();
}
- VoxelArea(v3s16 p):
+
+ VoxelArea(const v3s16 &p):
MinEdge(p),
MaxEdge(p)
{
+ cacheExtent();
}
- void addArea(VoxelArea &a)
+
+ /*
+ Modifying methods
+ */
+
+ void addArea(const VoxelArea &a)
{
+ if (hasEmptyExtent())
+ {
+ *this = a;
+ return;
+ }
if(a.MinEdge.X < MinEdge.X) MinEdge.X = a.MinEdge.X;
if(a.MinEdge.Y < MinEdge.Y) MinEdge.Y = a.MinEdge.Y;
if(a.MinEdge.Z < MinEdge.Z) MinEdge.Z = a.MinEdge.Z;
if(a.MaxEdge.X > MaxEdge.X) MaxEdge.X = a.MaxEdge.X;
if(a.MaxEdge.Y > MaxEdge.Y) MaxEdge.Y = a.MaxEdge.Y;
if(a.MaxEdge.Z > MaxEdge.Z) MaxEdge.Z = a.MaxEdge.Z;
+ cacheExtent();
}
- void addPoint(v3s16 p)
+
+ void addPoint(const v3s16 &p)
{
+ if(hasEmptyExtent())
+ {
+ MinEdge = p;
+ MaxEdge = p;
+ cacheExtent();
+ return;
+ }
if(p.X < MinEdge.X) MinEdge.X = p.X;
if(p.Y < MinEdge.Y) MinEdge.Y = p.Y;
if(p.Z < MinEdge.Z) MinEdge.Z = p.Z;
if(p.X > MaxEdge.X) MaxEdge.X = p.X;
if(p.Y > MaxEdge.Y) MaxEdge.Y = p.Y;
if(p.Z > MaxEdge.Z) MaxEdge.Z = p.Z;
+ cacheExtent();
}
- v3s16 getExtent()
+
+ // Pad with d nodes
+ void pad(const v3s16 &d)
{
- return MaxEdge - MinEdge + v3s16(1,1,1);
+ MinEdge -= d;
+ MaxEdge += d;
}
- s32 getVolume()
+
+ /*
+ const methods
+ */
+
+ const v3s16 &getExtent() const
{
- v3s16 e = getExtent();
- return (s32)e.X * (s32)e.Y * (s32)e.Z;
+ return m_cache_extent;
}
- bool isInside(v3s16 p)
+
+ /* Because MaxEdge and MinEdge are included in the voxel area an empty extent
+ * is not represented by (0, 0, 0), but instead (-1, -1, -1)
+ */
+ bool hasEmptyExtent() const
+ {
+ return MaxEdge - MinEdge == v3s16(-1, -1, -1);
+ }
+
+ s32 getVolume() const
+ {
+ return (s32)m_cache_extent.X * (s32)m_cache_extent.Y * (s32)m_cache_extent.Z;
+ }
+
+ bool contains(const VoxelArea &a) const
+ {
+ // No area contains an empty area
+ // NOTE: Algorithms depend on this, so do not change.
+ if(a.hasEmptyExtent())
+ return false;
+
+ return(
+ a.MinEdge.X >= MinEdge.X && a.MaxEdge.X <= MaxEdge.X &&
+ a.MinEdge.Y >= MinEdge.Y && a.MaxEdge.Y <= MaxEdge.Y &&
+ a.MinEdge.Z >= MinEdge.Z && a.MaxEdge.Z <= MaxEdge.Z
+ );
+ }
+ bool contains(v3s16 p) const
{
return(
p.X >= MinEdge.X && p.X <= MaxEdge.X &&
p.Z >= MinEdge.Z && p.Z <= MaxEdge.Z
);
}
- bool operator==(const VoxelArea &other)
+ bool contains(s32 i) const
+ {
+ return (i >= 0 && i < getVolume());
+ }
+ bool operator==(const VoxelArea &other) const
{
return (MinEdge == other.MinEdge
&& MaxEdge == other.MaxEdge);
}
-
+
+ VoxelArea operator+(const v3s16 &off) const
+ {
+ return {MinEdge+off, MaxEdge+off};
+ }
+
+ VoxelArea operator-(const v3s16 &off) const
+ {
+ return {MinEdge-off, MaxEdge-off};
+ }
+
+ /*
+ Returns 0-6 non-overlapping areas that can be added to
+ a to make up this area.
+
+ a: area inside *this
+ */
+ void diff(const VoxelArea &a, std::list<VoxelArea> &result)
+ {
+ /*
+ This can result in a maximum of 6 areas
+ */
+
+ // If a is an empty area, return the current area as a whole
+ if(a.getExtent() == v3s16(0,0,0))
+ {
+ VoxelArea b = *this;
+ if(b.getVolume() != 0)
+ result.push_back(b);
+ return;
+ }
+
+ assert(contains(a)); // pre-condition
+
+ // Take back area, XY inclusive
+ {
+ v3s16 min(MinEdge.X, MinEdge.Y, a.MaxEdge.Z+1);
+ v3s16 max(MaxEdge.X, MaxEdge.Y, MaxEdge.Z);
+ VoxelArea b(min, max);
+ if(b.getVolume() != 0)
+ result.push_back(b);
+ }
+
+ // Take front area, XY inclusive
+ {
+ v3s16 min(MinEdge.X, MinEdge.Y, MinEdge.Z);
+ v3s16 max(MaxEdge.X, MaxEdge.Y, a.MinEdge.Z-1);
+ VoxelArea b(min, max);
+ if(b.getVolume() != 0)
+ result.push_back(b);
+ }
+
+ // Take top area, X inclusive
+ {
+ v3s16 min(MinEdge.X, a.MaxEdge.Y+1, a.MinEdge.Z);
+ v3s16 max(MaxEdge.X, MaxEdge.Y, a.MaxEdge.Z);
+ VoxelArea b(min, max);
+ if(b.getVolume() != 0)
+ result.push_back(b);
+ }
+
+ // Take bottom area, X inclusive
+ {
+ v3s16 min(MinEdge.X, MinEdge.Y, a.MinEdge.Z);
+ v3s16 max(MaxEdge.X, a.MinEdge.Y-1, a.MaxEdge.Z);
+ VoxelArea b(min, max);
+ if(b.getVolume() != 0)
+ result.push_back(b);
+ }
+
+ // Take left area, non-inclusive
+ {
+ v3s16 min(MinEdge.X, a.MinEdge.Y, a.MinEdge.Z);
+ v3s16 max(a.MinEdge.X-1, a.MaxEdge.Y, a.MaxEdge.Z);
+ VoxelArea b(min, max);
+ if(b.getVolume() != 0)
+ result.push_back(b);
+ }
+
+ // Take right area, non-inclusive
+ {
+ v3s16 min(a.MaxEdge.X+1, a.MinEdge.Y, a.MinEdge.Z);
+ v3s16 max(MaxEdge.X, a.MaxEdge.Y, a.MaxEdge.Z);
+ VoxelArea b(min, max);
+ if(b.getVolume() != 0)
+ result.push_back(b);
+ }
+
+ }
+
/*
Translates position from virtual coordinates to array index
*/
- s32 index(s16 x, s16 y, s16 z)
+ s32 index(s16 x, s16 y, s16 z) const
{
- v3s16 em = getExtent();
- v3s16 off = MinEdge;
- s32 i = (s32)(z-off.Z)*em.Y*em.X + (y-off.Y)*em.X + (x-off.X);
- //dstream<<" i("<<x<<","<<y<<","<<z<<")="<<i<<" ";
+ s32 i = (s32)(z - MinEdge.Z) * m_cache_extent.Y * m_cache_extent.X
+ + (y - MinEdge.Y) * m_cache_extent.X
+ + (x - MinEdge.X);
return i;
}
- s32 index(v3s16 p)
+ s32 index(v3s16 p) const
{
return index(p.X, p.Y, p.Z);
}
- void print(std::ostream &o)
+ /**
+ * Translate index in the X coordinate
+ */
+ static void add_x(const v3s16 &extent, u32 &i, s16 a)
+ {
+ i += a;
+ }
+
+ /**
+ * Translate index in the Y coordinate
+ */
+ static void add_y(const v3s16 &extent, u32 &i, s16 a)
+ {
+ i += a * extent.X;
+ }
+
+ /**
+ * Translate index in the Z coordinate
+ */
+ static void add_z(const v3s16 &extent, u32 &i, s16 a)
+ {
+ i += a * extent.X * extent.Y;
+ }
+
+ /**
+ * Translate index in space
+ */
+ static void add_p(const v3s16 &extent, u32 &i, v3s16 a)
+ {
+ i += a.Z * extent.X * extent.Y + a.Y * extent.X + a.X;
+ }
+
+ /*
+ Print method for debugging
+ */
+ void print(std::ostream &o) const
{
- o<<"("<<MinEdge.X
- <<","<<MinEdge.Y
- <<","<<MinEdge.Z
- <<")("<<MaxEdge.X
- <<","<<MaxEdge.Y
- <<","<<MaxEdge.Z
- <<")";
+ o << PP(MinEdge) << PP(MaxEdge) << "="
+ << m_cache_extent.X << "x" << m_cache_extent.Y << "x" << m_cache_extent.Z
+ << "=" << getVolume();
}
// Edges are inclusive
- v3s16 MinEdge;
+ v3s16 MinEdge = v3s16(1,1,1);
v3s16 MaxEdge;
+private:
+ void cacheExtent()
+ {
+ m_cache_extent = MaxEdge - MinEdge + v3s16(1,1,1);
+ }
+
+ v3s16 m_cache_extent = v3s16(0,0,0);
+};
+
+// unused
+#define VOXELFLAG_UNUSED (1 << 0)
+// no data about that node
+#define VOXELFLAG_NO_DATA (1 << 1)
+// Algorithm-dependent
+#define VOXELFLAG_CHECKED1 (1 << 2)
+// Algorithm-dependent
+#define VOXELFLAG_CHECKED2 (1 << 3)
+// Algorithm-dependent
+#define VOXELFLAG_CHECKED3 (1 << 4)
+// Algorithm-dependent
+#define VOXELFLAG_CHECKED4 (1 << 5)
+
+enum VoxelPrintMode
+{
+ VOXELPRINT_NOTHING,
+ VOXELPRINT_MATERIAL,
+ VOXELPRINT_WATERPRESSURE,
+ VOXELPRINT_LIGHT_DAY,
};
-class VoxelManipulator : public NodeContainer
+class VoxelManipulator
{
public:
- VoxelManipulator();
- ~VoxelManipulator();
-
+ VoxelManipulator() = default;
+ virtual ~VoxelManipulator();
+
/*
- Virtuals from NodeContainer
+ These are a bit slow and shouldn't be used internally.
+ Use m_data[m_area.index(p)] instead.
*/
- virtual u16 nodeContainerId() const
+ MapNode getNode(const v3s16 &p)
{
- return NODECONTAINER_ID_VOXELMANIPULATOR;
+ VoxelArea voxel_area(p);
+ addArea(voxel_area);
+
+ if (m_flags[m_area.index(p)] & VOXELFLAG_NO_DATA) {
+ /*dstream<<"EXCEPT: VoxelManipulator::getNode(): "
+ <<"p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+ <<", index="<<m_area.index(p)
+ <<", flags="<<(int)m_flags[m_area.index(p)]
+ <<" is inexistent"<<std::endl;*/
+ throw InvalidPositionException
+ ("VoxelManipulator: getNode: inexistent");
+ }
+
+ return m_data[m_area.index(p)];
}
- bool isValidPosition(v3s16 p)
+ MapNode getNodeNoEx(const v3s16 &p)
{
- return m_area.isInside(p);
+ VoxelArea voxel_area(p);
+ addArea(voxel_area);
+
+ if (m_flags[m_area.index(p)] & VOXELFLAG_NO_DATA) {
+ return {CONTENT_IGNORE};
+ }
+
+ return m_data[m_area.index(p)];
}
- // These are a bit slow and shouldn't be used internally
- MapNode getNode(v3s16 p)
+ MapNode getNodeNoExNoEmerge(const v3s16 &p)
{
- if(isValidPosition(p) == false)
- emerge(VoxelArea(p));
+ if (!m_area.contains(p))
+ return {CONTENT_IGNORE};
+ if (m_flags[m_area.index(p)] & VOXELFLAG_NO_DATA)
+ return {CONTENT_IGNORE};
+ return m_data[m_area.index(p)];
+ }
+ // Stuff explodes if non-emerged area is touched with this.
+ // Emerge first, and check VOXELFLAG_NO_DATA if appropriate.
+ MapNode & getNodeRefUnsafe(const v3s16 &p)
+ {
+ return m_data[m_area.index(p)];
+ }
- MapNode &n = m_data[m_area.index(p)];
+ const MapNode & getNodeRefUnsafeCheckFlags(const v3s16 &p)
+ {
+ s32 index = m_area.index(p);
- //TODO: Is this the right behaviour?
- if(n.d == MATERIAL_IGNORE)
- throw InvalidPositionException
- ("Not returning MATERIAL_IGNORE in VoxelManipulator");
+ if (m_flags[index] & VOXELFLAG_NO_DATA)
+ return ContentIgnoreNode;
- return n;
+ return m_data[index];
}
- void setNode(v3s16 p, MapNode & n)
+
+ u8 & getFlagsRefUnsafe(const v3s16 &p)
{
- if(isValidPosition(p) == false)
- emerge(VoxelArea(p));
+ return m_flags[m_area.index(p)];
+ }
+
+ bool exists(const v3s16 &p)
+ {
+ return m_area.contains(p) &&
+ !(getFlagsRefUnsafe(p) & VOXELFLAG_NO_DATA);
+ }
+
+ void setNode(const v3s16 &p, const MapNode &n)
+ {
+ VoxelArea voxel_area(p);
+ addArea(voxel_area);
+
m_data[m_area.index(p)] = n;
+ m_flags[m_area.index(p)] &= ~VOXELFLAG_NO_DATA;
}
-
- MapNode & operator[](v3s16 p)
+ // TODO: Should be removed and replaced with setNode
+ void setNodeNoRef(const v3s16 &p, const MapNode &n)
{
- //dstream<<"operator[] p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
- if(isValidPosition(p) == false)
- emerge(VoxelArea(p));
- return m_data[m_area.index(p)];
+ setNode(p, n);
}
/*
- Manipulation of bigger chunks
+ Set stuff if available without an emerge.
+ Return false if failed.
+ This is convenient but slower than playing around directly
+ with the m_data table with indices.
+ */
+ bool setNodeNoEmerge(const v3s16 &p, MapNode n)
+ {
+ if(!m_area.contains(p))
+ return false;
+ m_data[m_area.index(p)] = n;
+ return true;
+ }
+
+ /*
+ Control
*/
-
- void print(std::ostream &o);
-
- void addArea(VoxelArea area);
- void interpolate(VoxelArea area);
+ virtual void clear();
- /*void blitFromNodeContainer
- (v3s16 p_from, v3s16 p_to, v3s16 size, NodeContainer *c);
-
- void blitToNodeContainer
- (v3s16 p_from, v3s16 p_to, v3s16 size, NodeContainer *c);*/
+ void print(std::ostream &o, const NodeDefManager *nodemgr,
+ VoxelPrintMode mode=VOXELPRINT_MATERIAL);
+
+ void addArea(const VoxelArea &area);
/*
- Virtual functions
+ Copy data and set flags to 0
+ dst_area.getExtent() <= src_area.getExtent()
*/
-
- /*
- Get the contents of the requested area from somewhere.
+ void copyFrom(MapNode *src, const VoxelArea& src_area,
+ v3s16 from_pos, v3s16 to_pos, const v3s16 &size);
- If not found from source, add as MATERIAL_IGNORE.
+ // Copy data
+ void copyTo(MapNode *dst, const VoxelArea& dst_area,
+ v3s16 dst_pos, v3s16 from_pos, const v3s16 &size);
+
+ /*
+ Algorithms
*/
- virtual void emerge(VoxelArea a)
- {
- //dstream<<"emerge p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
- addArea(a);
- }
+
+ void clearFlag(u8 flag);
/*
Member variables
MaxEdge is 1 higher than maximum allowed position
*/
VoxelArea m_area;
+
/*
- NULL if data size is 0
+ nullptr if data size is 0 (extent (0,0,0))
Data is stored as [z*h*w + y*h + x]
- Special data values:
- MATERIAL_IGNORE: Unspecified node
*/
- MapNode *m_data;
-private:
-};
-
-class Map;
-
-class MapVoxelManipulator : public VoxelManipulator
-{
-public:
- MapVoxelManipulator(Map *map);
+ MapNode *m_data = nullptr;
- virtual void emerge(VoxelArea a);
-
- void blitBack(core::map<v3s16, MapBlock*> & modified_blocks);
+ /*
+ Flags of all nodes
+ */
+ u8 *m_flags = nullptr;
-private:
- Map *m_map;
+ static const MapNode ContentIgnoreNode;
};
-
-#endif
-
projects / minetest.git / blobdiff