Copyright (C) 2010 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 General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+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 General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+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 VOXEL_HEADER
#define VOXEL_HEADER
-#include "common_irrlicht.h"
+#include "irrlichttypes.h"
+#include "irr_v3d.h"
+#include <irrList.h>
#include <iostream>
#include "debug.h"
#include "mapnode.h"
+class INodeDefManager;
+
// For VC++
#undef min
#undef max
/*
- 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.
*/
p.Z >= MinEdge.Z && p.Z <= MaxEdge.Z
);
}
+ bool contains(s32 i) const
+ {
+ return (i >= 0 && i < getVolume());
+ }
bool operator==(const VoxelArea &other) const
{
return (MinEdge == other.MinEdge
{
return index(p.X, p.Y, p.Z);
}
+
+ // Translate index in the X coordinate
+ 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)
+ {
+ i += a * extent.X;
+ }
+ // Translate index in the Z coordinate
+ void add_z(const v3s16 &extent, u32 &i, s16 a)
+ {
+ i += a * extent.X*extent.Y;
+ }
+ // Translate index in space
+ 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
{
v3s16 e = getExtent();
// Checked as being inexistent in source
#define VOXELFLAG_INEXISTENT (1<<1)
// Algorithm-dependent
-// flowWater: "visited"
-#define VOXELFLAG_CHECKED (1<<2)
+#define VOXELFLAG_CHECKED1 (1<<2)
// Algorithm-dependent
-// getWaterPressure: "visited"
#define VOXELFLAG_CHECKED2 (1<<3)
// Algorithm-dependent
-// spreadWaterPressure: "visited"
#define VOXELFLAG_CHECKED3 (1<<4)
// Algorithm-dependent
-// water: "pressure check route node"
#define VOXELFLAG_CHECKED4 (1<<5)
enum VoxelPrintMode
VOXELPRINT_NOTHING,
VOXELPRINT_MATERIAL,
VOXELPRINT_WATERPRESSURE,
+ VOXELPRINT_LIGHT_DAY,
};
class VoxelManipulator /*: public NodeContainer*/
emerge(p);
return !(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT);
}*/
- // These are a bit slow and shouldn't be used internally
+
+ /*
+ These are a bit slow and shouldn't be used internally.
+ Use m_data[m_area.index(p)] instead.
+ */
MapNode getNode(v3s16 p)
{
emerge(p);
if(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT)
{
- dstream<<"EXCEPT: VoxelManipulator::getNode(): "
+ /*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;
+ <<" is inexistent"<<std::endl;*/
throw InvalidPositionException
("VoxelManipulator: getNode: inexistent");
}
return m_data[m_area.index(p)];
}
- void setNode(v3s16 p, MapNode &n)
+ MapNode getNodeNoEx(v3s16 p)
+ {
+ emerge(p);
+
+ if(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT)
+ {
+ return MapNode(CONTENT_IGNORE);
+ }
+
+ return m_data[m_area.index(p)];
+ }
+ MapNode getNodeNoExNoEmerge(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);
+ 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)
+ {
+ return m_data[m_area.index(p)];
+ }
+ u8 & getFlagsRefUnsafe(v3s16 p)
+ {
+ return m_flags[m_area.index(p)];
+ }
+ bool exists(v3s16 p)
+ {
+ return m_area.contains(p) &&
+ !(getFlagsRefUnsafe(p) & VOXELFLAG_INEXISTENT);
+ }
+ MapNode & getNodeRef(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);
+ }
+ void setNode(v3s16 p, const MapNode &n)
{
emerge(p);
m_flags[m_area.index(p)] &= ~VOXELFLAG_INEXISTENT;
m_flags[m_area.index(p)] &= ~VOXELFLAG_NOT_LOADED;
}
- void setNodeNoRef(v3s16 p, MapNode n)
+ // TODO: Should be removed and replaced with setNode
+ void setNodeNoRef(v3s16 p, const MapNode &n)
{
setNode(p, n);
}
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)
+ {
+ if(m_area.contains(p) == false)
+ 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, VoxelPrintMode mode=VOXELPRINT_MATERIAL);
+ void print(std::ostream &o, INodeDefManager *nodemgr,
+ VoxelPrintMode mode=VOXELPRINT_MATERIAL);
void addArea(VoxelArea area);
*/
void copyFrom(MapNode *src, VoxelArea src_area,
v3s16 from_pos, v3s16 to_pos, v3s16 size);
+
+ // Copy data
+ void copyTo(MapNode *dst, VoxelArea dst_area,
+ v3s16 dst_pos, v3s16 from_pos, v3s16 size);
/*
Algorithms
void clearFlag(u8 flag);
-#if 0
- // VOXELFLAG_CHECKED2s must usually be cleared before calling
- // -1: dead end, 0-255: pressure
- // highest_y: Highest found water y is stored here.
- // Must be initialized to -32768
- int getWaterPressure(v3s16 p, s16 &highest_y, int recur_count);
+ // TODO: Move to voxelalgorithms.h
- /*
- VOXELFLAG_CHECKED3s must usually be cleared before calling.
-
- active_nodes: surface-touching air nodes with flow-causing
- pressure. set-like dummy map container.
-
- Spreads pressure pr at node p to request_area or as far as
- there is invalid pressure.
- */
- void spreadWaterPressure(v3s16 p, int pr,
- VoxelArea request_area,
- core::map<v3s16, u8> &active_nodes,
- int recur_count);
+ 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);
- /*
- VOXELFLAG_CHECKED3s must usually be cleared before calling.
- */
- void updateAreaWaterPressure(VoxelArea a,
- core::map<v3s16, u8> &active_nodes,
- bool checked3_is_clear=false);
+ void spreadLight(enum LightBank bank, v3s16 p, INodeDefManager *nodemgr);
+ void spreadLight(enum LightBank bank,
+ core::map<v3s16, bool> & from_nodes, INodeDefManager *nodemgr);
- /*
- Returns true if moved something
- */
- bool flowWater(v3s16 removed_pos,
- core::map<v3s16, u8> &active_nodes,
- int recursion_depth=0,
- bool debugprint=false,
- u32 stoptime=0
- );
-
- /*
- To flow some water, call this with the target node in
- active_nodes
- TODO: Make the active_nodes map to contain some vectors
- that are properly sorted according to water flow order.
- The current order makes water flow strangely if the
- first one is always taken.
- No, active_nodes should preserve the order stuff is
- added to it, in addition to adhering the water flow
- order.
- */
- void flowWater(core::map<v3s16, u8> &active_nodes,
- int recursion_depth=0,
- bool debugprint=false,
- u32 timelimit=50
- );
-#endif
-
/*
Virtual functions
*/
/*
Some settings
*/
- bool m_disable_water_climb;
+ //bool m_disable_water_climb;
private:
};
projects / dragonfireclient.git / blobdiff