/*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+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
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#ifndef VOXEL_HEADER
-#define VOXEL_HEADER
+#pragma once
#include "irrlichttypes.h"
#include "irr_v3d.h"
-#include <irrList.h>
#include <iostream>
-#include "debug.h"
+#include <cassert>
+#include "exceptions.h"
#include "mapnode.h"
+#include <set>
+#include <list>
+#include "util/basic_macros.h"
-class INodeDefManager;
+class NodeDefManager;
// For VC++
#undef min
/*
Debug stuff
*/
-extern u32 emerge_time;
-extern u32 emerge_load_time;
+extern u64 emerge_time;
+extern u64 emerge_load_time;
/*
This class resembles aabbox3d<s16> a lot, but has inclusive
{
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();
}
/*
Modifying methods
*/
- void addArea(VoxelArea &a)
+ void addArea(const VoxelArea &a)
{
- if(getExtent() == v3s16(0,0,0))
+ if (hasEmptyExtent())
{
*this = a;
return;
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(getExtent() == v3s16(0,0,0))
+ if(hasEmptyExtent())
{
MinEdge = p;
MaxEdge = p;
+ cacheExtent();
return;
}
if(p.X < MinEdge.X) MinEdge.X = p.X;
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();
}
// Pad with d nodes
- void pad(v3s16 d)
+ void pad(const v3s16 &d)
{
MinEdge -= d;
MaxEdge += d;
}
- /*void operator+=(v3s16 off)
- {
- MinEdge += off;
- MaxEdge += off;
- }
-
- void operator-=(v3s16 off)
- {
- MinEdge -= off;
- MaxEdge -= off;
- }*/
-
/*
const methods
*/
- v3s16 getExtent() const
+ const v3s16 &getExtent() const
{
- return MaxEdge - MinEdge + v3s16(1,1,1);
+ return m_cache_extent;
}
+
+ /* 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
{
- v3s16 e = getExtent();
- return (s32)e.X * (s32)e.Y * (s32)e.Z;
+ 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.getExtent() == v3s16(0,0,0))
+ if(a.hasEmptyExtent())
return false;
return(
&& MaxEdge == other.MaxEdge);
}
- VoxelArea operator+(v3s16 off) const
+ VoxelArea operator+(const v3s16 &off) const
{
- return VoxelArea(MinEdge+off, MaxEdge+off);
+ return {MinEdge+off, MaxEdge+off};
}
- VoxelArea operator-(v3s16 off) const
+ VoxelArea operator-(const v3s16 &off) const
{
- return VoxelArea(MinEdge-off, MaxEdge-off);
+ return {MinEdge-off, MaxEdge-off};
}
/*
a: area inside *this
*/
- void diff(const VoxelArea &a, core::list<VoxelArea> &result)
+ void diff(const VoxelArea &a, std::list<VoxelArea> &result)
{
/*
This can result in a maximum of 6 areas
return;
}
- assert(contains(a));
+ assert(contains(a)); // pre-condition
// Take back area, XY inclusive
{
*/
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) const
return index(p.X, p.Y, p.Z);
}
- // Translate index in the X coordinate
- void add_x(const v3s16 &extent, u32 &i, s16 a)
+ /**
+ * 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
- void add_y(const v3s16 &extent, u32 &i, s16 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
- void add_z(const v3s16 &extent, u32 &i, s16 a)
+
+ /**
+ * Translate index in the Z coordinate
+ */
+ static void add_z(const v3s16 &extent, u32 &i, s16 a)
{
- i += a * extent.X*extent.Y;
+ i += a * extent.X * extent.Y;
}
- // Translate index in space
- void add_p(const v3s16 &extent, u32 &i, v3s16 a)
+
+ /**
+ * 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;
+ i += a.Z * extent.X * extent.Y + a.Y * extent.X + a.X;
}
/*
*/
void print(std::ostream &o) const
{
- v3s16 e = getExtent();
- o<<"("<<MinEdge.X
- <<","<<MinEdge.Y
- <<","<<MinEdge.Z
- <<")("<<MaxEdge.X
- <<","<<MaxEdge.Y
- <<","<<MaxEdge.Z
- <<")"
- <<"="<<e.X<<"x"<<e.Y<<"x"<<e.Z<<"="<<getVolume();
+ 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);
};
-// Hasn't been copied from source (emerged)
-#define VOXELFLAG_NOT_LOADED (1<<0)
-// Checked as being inexistent in source
-#define VOXELFLAG_INEXISTENT (1<<1)
+// unused
+#define VOXELFLAG_UNUSED (1 << 0)
+// no data about that node
+#define VOXELFLAG_NO_DATA (1 << 1)
// Algorithm-dependent
-#define VOXELFLAG_CHECKED1 (1<<2)
+#define VOXELFLAG_CHECKED1 (1 << 2)
// Algorithm-dependent
-#define VOXELFLAG_CHECKED2 (1<<3)
+#define VOXELFLAG_CHECKED2 (1 << 3)
// Algorithm-dependent
-#define VOXELFLAG_CHECKED3 (1<<4)
+#define VOXELFLAG_CHECKED3 (1 << 4)
// Algorithm-dependent
-#define VOXELFLAG_CHECKED4 (1<<5)
+#define VOXELFLAG_CHECKED4 (1 << 5)
enum VoxelPrintMode
{
VOXELPRINT_LIGHT_DAY,
};
-class VoxelManipulator /*: public NodeContainer*/
+class VoxelManipulator
{
public:
- VoxelManipulator();
+ VoxelManipulator() = default;
virtual ~VoxelManipulator();
- /*
- Virtuals from NodeContainer
- */
- /*virtual u16 nodeContainerId() const
- {
- return NODECONTAINER_ID_VOXELMANIPULATOR;
- }
- bool isValidPosition(v3s16 p)
- {
- emerge(p);
- return !(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT);
- }*/
-
/*
These are a bit slow and shouldn't be used internally.
Use m_data[m_area.index(p)] instead.
*/
- MapNode getNode(v3s16 p)
+ MapNode getNode(const v3s16 &p)
{
- emerge(p);
+ VoxelArea voxel_area(p);
+ addArea(voxel_area);
- if(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT)
- {
+ 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)
return m_data[m_area.index(p)];
}
- MapNode getNodeNoEx(v3s16 p)
+ MapNode getNodeNoEx(const v3s16 &p)
{
- emerge(p);
+ VoxelArea voxel_area(p);
+ addArea(voxel_area);
- if(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT)
- {
- return MapNode(CONTENT_IGNORE);
+ if (m_flags[m_area.index(p)] & VOXELFLAG_NO_DATA) {
+ return {CONTENT_IGNORE};
}
return m_data[m_area.index(p)];
}
- MapNode getNodeNoExNoEmerge(v3s16 p)
+ MapNode getNodeNoExNoEmerge(const v3s16 &p)
{
- if(m_area.contains(p) == false)
- return MapNode(CONTENT_IGNORE);
- if(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT)
- return MapNode(CONTENT_IGNORE);
+ 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_INEXISTENT if appropriate.
- MapNode & getNodeRefUnsafe(v3s16 p)
+ // Emerge first, and check VOXELFLAG_NO_DATA if appropriate.
+ MapNode & getNodeRefUnsafe(const v3s16 &p)
{
return m_data[m_area.index(p)];
}
- u8 & getFlagsRefUnsafe(v3s16 p)
+
+ const MapNode & getNodeRefUnsafeCheckFlags(const v3s16 &p)
{
- return m_flags[m_area.index(p)];
+ s32 index = m_area.index(p);
+
+ if (m_flags[index] & VOXELFLAG_NO_DATA)
+ return ContentIgnoreNode;
+
+ return m_data[index];
}
- bool exists(v3s16 p)
+
+ u8 & getFlagsRefUnsafe(const v3s16 &p)
{
- return m_area.contains(p) &&
- !(getFlagsRefUnsafe(p) & VOXELFLAG_INEXISTENT);
+ return m_flags[m_area.index(p)];
}
- MapNode & getNodeRef(v3s16 p)
+
+ bool exists(const v3s16 &p)
{
- emerge(p);
- if(getFlagsRefUnsafe(p) & VOXELFLAG_INEXISTENT)
- {
- /*dstream<<"EXCEPT: VoxelManipulator::getNode(): "
- <<"p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<", index="<<m_area.index(p)
- <<", flags="<<(int)getFlagsRefUnsafe(p)
- <<" is inexistent"<<std::endl;*/
- throw InvalidPositionException
- ("VoxelManipulator: getNode: inexistent");
- }
- return getNodeRefUnsafe(p);
+ return m_area.contains(p) &&
+ !(getFlagsRefUnsafe(p) & VOXELFLAG_NO_DATA);
}
- void setNode(v3s16 p, const MapNode &n)
+
+ void setNode(const v3s16 &p, const MapNode &n)
{
- emerge(p);
+ VoxelArea voxel_area(p);
+ addArea(voxel_area);
m_data[m_area.index(p)] = n;
- m_flags[m_area.index(p)] &= ~VOXELFLAG_INEXISTENT;
- m_flags[m_area.index(p)] &= ~VOXELFLAG_NOT_LOADED;
+ m_flags[m_area.index(p)] &= ~VOXELFLAG_NO_DATA;
}
// TODO: Should be removed and replaced with setNode
- void setNodeNoRef(v3s16 p, const MapNode &n)
+ void setNodeNoRef(const v3s16 &p, const MapNode &n)
{
setNode(p, n);
}
- /*void setExists(VoxelArea a)
- {
- emerge(a);
- for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
- for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
- for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++)
- {
- m_flags[m_area.index(x,y,z)] &= ~VOXELFLAG_INEXISTENT;
- }
- }*/
-
- /*MapNode & operator[](v3s16 p)
- {
- //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)];
- }*/
-
/*
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(v3s16 p, MapNode n)
+ bool setNodeNoEmerge(const v3s16 &p, MapNode n)
{
- if(m_area.contains(p) == false)
+ if(!m_area.contains(p))
return false;
m_data[m_area.index(p)] = n;
return true;
}
- bool setNodeNoEmerge(s32 i, MapNode n)
- {
- if(m_area.contains(i) == false)
- return false;
- m_data[i] = n;
- return true;
- }
- /*bool setContentNoEmerge(v3s16 p, u8 c)
- {
- if(isValidPosition(p) == false)
- return false;
- m_data[m_area.index(p)].d = c;
- }*/
/*
Control
virtual void clear();
- void print(std::ostream &o, INodeDefManager *nodemgr,
+ void print(std::ostream &o, const NodeDefManager *nodemgr,
VoxelPrintMode mode=VOXELPRINT_MATERIAL);
- void addArea(VoxelArea area);
+ void addArea(const VoxelArea &area);
/*
Copy data and set flags to 0
dst_area.getExtent() <= src_area.getExtent()
*/
- void copyFrom(MapNode *src, VoxelArea src_area,
- v3s16 from_pos, v3s16 to_pos, v3s16 size);
+ void copyFrom(MapNode *src, const VoxelArea& src_area,
+ v3s16 from_pos, v3s16 to_pos, const v3s16 &size);
// Copy data
- void copyTo(MapNode *dst, VoxelArea dst_area,
- v3s16 dst_pos, v3s16 from_pos, v3s16 size);
+ void copyTo(MapNode *dst, const VoxelArea& dst_area,
+ v3s16 dst_pos, v3s16 from_pos, const v3s16 &size);
/*
Algorithms
void clearFlag(u8 flag);
- // TODO: Move to voxelalgorithms.h
-
- void unspreadLight(enum LightBank bank, v3s16 p, u8 oldlight,
- core::map<v3s16, bool> & light_sources, INodeDefManager *nodemgr);
- void unspreadLight(enum LightBank bank,
- core::map<v3s16, u8> & from_nodes,
- core::map<v3s16, bool> & light_sources, INodeDefManager *nodemgr);
-
- void spreadLight(enum LightBank bank, v3s16 p, INodeDefManager *nodemgr);
- void spreadLight(enum LightBank bank,
- core::map<v3s16, bool> & from_nodes, INodeDefManager *nodemgr);
-
- /*
- Virtual functions
- */
-
- /*
- Get the contents of the requested area from somewhere.
- Shall touch only nodes that have VOXELFLAG_NOT_LOADED
- Shall reset VOXELFLAG_NOT_LOADED
-
- If not found from source, add with VOXELFLAG_INEXISTENT
- */
- virtual void emerge(VoxelArea a, s32 caller_id=-1)
- {
- //dstream<<"emerge p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
- addArea(a);
- for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
- for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
- for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++)
- {
- s32 i = m_area.index(x,y,z);
- // Don't touch nodes that have already been loaded
- if(!(m_flags[i] & VOXELFLAG_NOT_LOADED))
- continue;
- m_flags[i] = VOXELFLAG_INEXISTENT;
- }
- }
-
/*
Member variables
*/
VoxelArea m_area;
/*
- NULL if data size is 0 (extent (0,0,0))
+ nullptr if data size is 0 (extent (0,0,0))
Data is stored as [z*h*w + y*h + x]
*/
- MapNode *m_data;
+ MapNode *m_data = nullptr;
/*
Flags of all nodes
*/
- u8 *m_flags;
-
- //TODO: Use these or remove them
- //TODO: Would these make any speed improvement?
- //bool m_pressure_route_valid;
- //v3s16 m_pressure_route_surface;
-
- /*
- Some settings
- */
- //bool m_disable_water_climb;
+ u8 *m_flags = nullptr;
-private:
+ static const MapNode ContentIgnoreNode;
};
-
-#endif
-
projects / dragonfireclient.git / blobdiff