#include "mapblockobject.h"
#include "voxel.h"
-#define MAP_BLOCKSIZE 16
-
// Named by looking towards z+
enum{
FACE_BACK=0,
struct FastFace
{
- u16 tile;
+ TileSpec tile;
video::S3DVertex vertices[4]; // Precalculated vertices
};
+enum NodeModType
+{
+ NODEMOD_NONE,
+ NODEMOD_CHANGECONTENT, //param is content id
+ NODEMOD_CRACK // param is crack progression
+};
+
+struct NodeMod
+{
+ NodeMod(enum NodeModType a_type=NODEMOD_NONE, u16 a_param=0)
+ {
+ type = a_type;
+ param = a_param;
+ }
+ bool operator==(const NodeMod &other)
+ {
+ return (type == other.type && param == other.param);
+ }
+ enum NodeModType type;
+ u16 param;
+};
+
enum
{
NODECONTAINER_ID_MAPBLOCK,
class MapBlock : public NodeContainer
{
public:
-
- /*
- This used by Server's block creation stuff for not sending
- blocks that are waiting a lighting update.
-
- If true, the block needs some work by the one who set this
- to true.
-
- While true, nobody else should touch the block.
- */
- //bool is_incomplete;
-
- scene::SMesh *mesh;
- JMutex mesh_mutex;
-
- MapBlock(NodeContainer *parent, v3s16 pos, bool dummy=false):
- m_parent(parent),
- m_pos(pos),
- changed(true),
- is_underground(false),
- m_objects(this)
- //is_incomplete(false)
- {
- data = NULL;
- if(dummy == false)
- reallocate();
- mesh_mutex.Init();
- mesh = NULL;
- }
-
- ~MapBlock()
- {
- {
- JMutexAutoLock lock(mesh_mutex);
-
- if(mesh != NULL)
- {
- mesh->drop();
- mesh = NULL;
- }
- }
-
- if(data)
- delete[] data;
- }
+ MapBlock(NodeContainer *parent, v3s16 pos, bool dummy=false);
+ ~MapBlock();
virtual u16 nodeContainerId() const
{
{
changed = true;
}
-
+#ifndef SERVER
+ void setMeshExpired(bool expired)
+ {
+ m_mesh_expired = expired;
+ }
+
+ bool getMeshExpired()
+ {
+ return m_mesh_expired;
+ }
+#endif
v3s16 getPos()
{
return m_pos;
bool isValidPositionParent(v3s16 p);
MapNode getNodeParent(v3s16 p);
void setNodeParent(v3s16 p, MapNode & n);
+ MapNode getNodeParentNoEx(v3s16 p);
void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
{
setNode(x0+x, y0+y, z0+z, node);
}
- static FastFace * makeFastFace(u16 tile, u8 light, v3f p,
- v3s16 dir, v3f scale, v3f posRelative_f);
+ u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
+ v3s16 face_dir);
+
+ u8 getFaceLight(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
+ {
+ return getFaceLight(daynight_ratio,
+ getNodeParentNoEx(p),
+ getNodeParentNoEx(p + face_dir),
+ face_dir);
+ }
- u8 getFaceLight(v3s16 p, v3s16 face_dir);
+#ifndef SERVER
+ // light = 0...255
+ static void makeFastFace(TileSpec tile, u8 light, v3f p,
+ v3s16 dir, v3f scale, v3f posRelative_f,
+ core::array<FastFace> &dest);
- u16 getNodeTile(v3s16 p, v3s16 face_dir);
- u8 getNodeContent(v3s16 p);
+ TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir);
+ u8 getNodeContent(v3s16 p, MapNode mn);
/*
startpos:
translate_dir: unit vector with only one of x, y or z
face_dir: unit vector with only one of x, y or z
*/
- void updateFastFaceRow(v3s16 startpos,
+ void updateFastFaceRow(
+ u32 daynight_ratio,
+ v3f posRelative_f,
+ v3s16 startpos,
u16 length,
v3s16 translate_dir,
+ v3f translate_dir_f,
v3s16 face_dir,
- core::list<FastFace*> &dest);
-
- void updateMesh();
-
- bool propagateSunlight(core::map<v3s16, bool> & light_sources);
+ v3f face_dir_f,
+ core::array<FastFace> &dest);
+
+ void updateMesh(u32 daynight_ratio);
+ /*void updateMesh(s32 daynight_i);
+ // Updates all DAYNIGHT_CACHE_COUNT meshes
+ void updateMeshes(s32 first_i=0);*/
+#endif // !SERVER
+
+ // See comments in mapblock.cpp
+ bool propagateSunlight(core::map<v3s16, bool> & light_sources,
+ bool remove_light=false, bool *black_air_left=NULL,
+ bool grow_grass=false);
// Copies data to VoxelManipulator to getPosRelative()
void copyTo(VoxelManipulator &dst);
}
// If smgr!=NULL, new objects are added to the scene
void updateObjects(std::istream &is, u8 version,
- scene::ISceneManager *smgr)
+ scene::ISceneManager *smgr, u32 daynight_ratio)
{
- m_objects.update(is, version, smgr);
+ m_objects.update(is, version, smgr, daynight_ratio);
setChangedFlag();
}
{
return m_objects.getLock();
}
- void stepObjects(float dtime, bool server)
- {
- m_objects.step(dtime, server);
- setChangedFlag();
- }
+ /*
+ Moves objects, deletes objects and spawns new objects
+ */
+ void stepObjects(float dtime, bool server, u32 daynight_ratio);
/*void wrapObject(MapBlockObject *object)
{
return m_objects.getCount();
}
+#ifndef SERVER
+ /*
+ Methods for setting temporary modifications to nodes for
+ drawing
+
+ returns true if the mod was different last time
+ */
+ bool setTempMod(v3s16 p, NodeMod mod)
+ {
+ /*dstream<<"setTempMod called on block"
+ <<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+ <<", mod.type="<<mod.type
+ <<", mod.param="<<mod.param
+ <<std::endl;*/
+ JMutexAutoLock lock(m_temp_mods_mutex);
+
+ // See if old is different, cancel if it is not different.
+ core::map<v3s16, NodeMod>::Node *n = m_temp_mods.find(p);
+ if(n)
+ {
+ NodeMod old = n->getValue();
+ if(old == mod)
+ return false;
+ }
+
+ m_temp_mods[p] = mod;
+ return true;
+ }
+ // Returns true if there was one
+ bool getTempMod(v3s16 p, struct NodeMod *mod)
+ {
+ JMutexAutoLock lock(m_temp_mods_mutex);
+ core::map<v3s16, NodeMod>::Node *n;
+ n = m_temp_mods.find(p);
+ if(n == NULL)
+ return false;
+ if(mod)
+ *mod = n->getValue();
+ return true;
+ }
+ bool clearTempMod(v3s16 p)
+ {
+ JMutexAutoLock lock(m_temp_mods_mutex);
+ if(m_temp_mods.find(p))
+ {
+ m_temp_mods.remove(p);
+ return true;
+ }
+ return false;
+ }
+ bool clearTempMods()
+ {
+ JMutexAutoLock lock(m_temp_mods_mutex);
+ if(m_temp_mods.size() == 0)
+ return false;
+ m_temp_mods.clear();
+ return true;
+ }
+#endif
+
+ /*
+ Day-night lighting difference
+
+ These methods don't care about neighboring blocks.
+ It means that to know if a block really doesn't need a mesh
+ update between day and night, the neighboring blocks have
+ to be taken into account. Use Map::dayNightDiffed().
+ */
+ void updateDayNightDiff();
+
+ bool dayNightDiffed()
+ {
+ return m_day_night_differs;
+ }
+
+ /*
+ Miscellaneous stuff
+ */
+
+ /*
+ Tries to measure ground level.
+ Return value:
+ -1 = only air
+ -2 = only ground
+ -3 = random fail
+ 0...MAP_BLOCKSIZE-1 = ground level
+ */
+ s16 getGroundLevel(v2s16 p2d);
+
/*
Serialization
*/
void deSerialize(std::istream &is, u8 version);
+ /*
+ Public member variables
+ */
+
+#ifndef SERVER
+ //scene::SMesh *mesh[DAYNIGHT_CACHE_COUNT];
+ scene::SMesh *mesh;
+ JMutex mesh_mutex;
+#endif
+
private:
/*
MapNode & getNodeRef(s16 x, s16 y, s16 z)
{
+ if(data == NULL)
+ throw InvalidPositionException();
if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
/*
Used for some initial lighting stuff.
At least /has been/ used. 8)
+ It's probably useless now.
*/
bool is_underground;
+ // Whether day and night lighting differs
+ bool m_day_night_differs;
+
MapBlockObjectList m_objects;
+
+ // Object spawning stuff
+ float m_spawn_timer;
+#ifndef SERVER
+ bool m_mesh_expired;
+
+ // Temporary modifications to nodes
+ // These are only used when drawing
+ core::map<v3s16, NodeMod> m_temp_mods;
+ JMutex m_temp_mods_mutex;
+#endif
};
inline bool blockpos_over_limit(v3s16 p)