#include "constants.h"
#include "mapblockobject.h"
#include "voxel.h"
+#include "nodemetadata.h"
+#include "staticobject.h"
-#define MAP_BLOCKSIZE 16
// Named by looking towards z+
enum{
type = a_type;
param = a_param;
}
+ bool operator==(const NodeMod &other)
+ {
+ return (type == other.type && param == other.param);
+ }
enum NodeModType type;
u16 param;
};
+class NodeModMap
+{
+public:
+ /*
+ returns true if the mod was different last time
+ */
+ bool set(v3s16 p, const NodeMod &mod)
+ {
+ // See if old is different, cancel if it is not different.
+ core::map<v3s16, NodeMod>::Node *n = m_mods.find(p);
+ if(n)
+ {
+ NodeMod old = n->getValue();
+ if(old == mod)
+ return false;
+
+ n->setValue(mod);
+ }
+ else
+ {
+ m_mods.insert(p, mod);
+ }
+
+ return true;
+ }
+ // Returns true if there was one
+ bool get(v3s16 p, NodeMod *mod)
+ {
+ core::map<v3s16, NodeMod>::Node *n;
+ n = m_mods.find(p);
+ if(n == NULL)
+ return false;
+ if(mod)
+ *mod = n->getValue();
+ return true;
+ }
+ bool clear(v3s16 p)
+ {
+ if(m_mods.find(p))
+ {
+ m_mods.remove(p);
+ return true;
+ }
+ return false;
+ }
+ bool clear()
+ {
+ if(m_mods.size() == 0)
+ return false;
+ m_mods.clear();
+ return true;
+ }
+ void copy(NodeModMap &dest)
+ {
+ dest.m_mods.clear();
+
+ for(core::map<v3s16, NodeMod>::Iterator
+ i = m_mods.getIterator();
+ i.atEnd() == false; i++)
+ {
+ dest.m_mods.insert(i.getNode()->getKey(), i.getNode()->getValue());
+ }
+ }
+
+private:
+ core::map<v3s16, NodeMod> m_mods;
+};
+
enum
{
NODECONTAINER_ID_MAPBLOCK,
virtual MapNode getNode(v3s16 p) = 0;
virtual void setNode(v3s16 p, MapNode & n) = 0;
virtual u16 nodeContainerId() const = 0;
+
+ MapNode getNodeNoEx(v3s16 p)
+ {
+ try{
+ return getNode(p);
+ }
+ catch(InvalidPositionException &e){
+ return MapNode(CONTENT_IGNORE);
+ }
+ }
+};
+
+/*
+ Mesh making stuff
+*/
+
+class MapBlock;
+
+#ifndef SERVER
+
+struct MeshMakeData
+{
+ u32 m_daynight_ratio;
+ NodeModMap m_temp_mods;
+ VoxelManipulator m_vmanip;
+ v3s16 m_blockpos;
+
+ /*
+ Copy central data directly from block, and other data from
+ parent of block.
+ */
+ void fill(u32 daynight_ratio, MapBlock *block);
};
+scene::SMesh* makeMapBlockMesh(MeshMakeData *data);
+
+#endif
+
+u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
+ v3s16 face_dir);
+
+/*
+ MapBlock itself
+*/
+
class MapBlock : public NodeContainer
{
public:
{
return NODECONTAINER_ID_MAPBLOCK;
}
-
+
NodeContainer * getParent()
{
return m_parent;
}
+ void reallocate()
+ {
+ if(data != NULL)
+ delete[] data;
+ u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
+ data = new MapNode[l];
+ for(u32 i=0; i<l; i++){
+ data[i] = MapNode();
+ }
+ setChangedFlag();
+ }
+
+ /*
+ Flags
+ */
+
bool isDummy()
{
return (data == NULL);
}
-
void unDummify()
{
assert(isDummy());
{
return changed;
}
-
void resetChangedFlag()
{
changed = false;
}
-
void setChangedFlag()
{
changed = true;
}
+
+ bool getIsUnderground()
+ {
+ return is_underground;
+ }
+
+ void setIsUnderground(bool a_is_underground)
+ {
+ is_underground = a_is_underground;
+ setChangedFlag();
+ }
+
#ifndef SERVER
void setMeshExpired(bool expired)
{
return m_mesh_expired;
}
#endif
- v3s16 getPos()
+
+ void setLightingExpired(bool expired)
{
- return m_pos;
+ m_lighting_expired = expired;
+ setChangedFlag();
}
-
- v3s16 getPosRelative()
+ bool getLightingExpired()
{
- return m_pos * MAP_BLOCKSIZE;
+ return m_lighting_expired;
}
-
- bool getIsUnderground()
+
+ /*bool isFullyGenerated()
{
- return is_underground;
+ return !m_not_fully_generated;
}
-
- void setIsUnderground(bool a_is_underground)
+ void setFullyGenerated(bool b)
{
- is_underground = a_is_underground;
setChangedFlag();
+ m_not_fully_generated = !b;
+ }*/
+
+ bool isValid()
+ {
+ if(m_lighting_expired)
+ return false;
+ if(data == NULL)
+ return false;
+ return true;
}
+ /*
+ Position stuff
+ */
+
+ v3s16 getPos()
+ {
+ return m_pos;
+ }
+
+ v3s16 getPosRelative()
+ {
+ return m_pos * MAP_BLOCKSIZE;
+ }
+
core::aabbox3d<s16> getBox()
{
return core::aabbox3d<s16>(getPosRelative(),
+ v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
- v3s16(1,1,1));
}
-
- void reallocate()
- {
- if(data != NULL)
- delete[] data;
- u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
- data = new MapNode[l];
- for(u32 i=0; i<l; i++){
- data[i] = MapNode();
- }
- setChangedFlag();
- }
+ /*
+ Regular MapNode get-setters
+ */
+
bool isValidPosition(v3s16 p)
{
if(data == NULL)
&& p.Z >= 0 && p.Z < MAP_BLOCKSIZE);
}
- /*
- Regular MapNode get-setters
- */
-
MapNode getNode(s16 x, s16 y, s16 z)
{
if(data == NULL)
setNode(x0+x, y0+y, z0+z, node);
}
- u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
- v3s16 face_dir);
+ /*
+ Graphics-related methods
+ */
+ /*// A quick version with nodes passed as parameters
+ u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
+ v3s16 face_dir);*/
+ /*// A more convenient version
u8 getFaceLight(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
+ {
+ return getFaceLight(daynight_ratio,
+ getNodeParentNoEx(p),
+ getNodeParentNoEx(p + face_dir),
+ face_dir);
+ }*/
+ u8 getFaceLight2(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
{
return getFaceLight(daynight_ratio,
getNodeParentNoEx(p),
#ifndef SERVER
// light = 0...255
- static void makeFastFace(TileSpec tile, u8 light, v3f p,
+ /*static void makeFastFace(TileSpec tile, u8 light, v3f p,
v3s16 dir, v3f scale, v3f posRelative_f,
- core::array<FastFace> &dest);
+ core::array<FastFace> &dest);*/
- TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir);
- u8 getNodeContent(v3s16 p, MapNode mn);
+ /*TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir,
+ NodeModMap &temp_mods);*/
+ /*u8 getNodeContent(v3s16 p, MapNode mn,
+ NodeModMap &temp_mods);*/
/*
- startpos:
+ Generates the FastFaces of a node row. This has a
+ ridiculous amount of parameters because that way they
+ can be precalculated by the caller.
+
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(
+ /*void updateFastFaceRow(
u32 daynight_ratio,
v3f posRelative_f,
v3s16 startpos,
v3f translate_dir_f,
v3s16 face_dir,
v3f face_dir_f,
- core::array<FastFace> &dest);
-
+ core::array<FastFace> &dest,
+ NodeModMap &temp_mods);*/
+
+ /*
+ Thread-safely updates the whole mesh of the mapblock.
+ */
+#if 1
void updateMesh(u32 daynight_ratio);
- /*void updateMesh(s32 daynight_i);
- // Updates all DAYNIGHT_CACHE_COUNT meshes
- void updateMeshes(s32 first_i=0);*/
-#endif // !SERVER
+#endif
- bool propagateSunlight(core::map<v3s16, bool> & light_sources);
+ void replaceMesh(scene::SMesh *mesh_new);
+
+#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);
+ // Copies data from VoxelManipulator getPosRelative()
+ void copyFrom(VoxelManipulator &dst);
/*
- Object stuff
+ MapBlockObject stuff
*/
void serializeObjects(std::ostream &os, u8 version)
m_objects.getObjects(origin, max_d, dest);
}
- /*void getPseudoObjects(v3f origin, f32 max_d,
- core::array<DistanceSortedObject> &dest);*/
-
s32 getObjectCount()
{
return m_objects.getCount();
/*
Methods for setting temporary modifications to nodes for
drawing
+
+ returns true if the mod was different last time
*/
- void setTempMod(v3s16 p, NodeMod mod)
+ bool setTempMod(v3s16 p, const NodeMod &mod)
{
/*dstream<<"setTempMod called on block"
<<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<", mod.type="<<mod.type
<<", mod.param="<<mod.param
<<std::endl;*/
- m_temp_mods[p] = mod;
+ JMutexAutoLock lock(m_temp_mods_mutex);
+
+ return m_temp_mods.set(p, mod);
+ }
+ // Returns true if there was one
+ bool getTempMod(v3s16 p, NodeMod *mod)
+ {
+ JMutexAutoLock lock(m_temp_mods_mutex);
+
+ return m_temp_mods.get(p, mod);
+ }
+ bool clearTempMod(v3s16 p)
+ {
+ JMutexAutoLock lock(m_temp_mods_mutex);
+
+ return m_temp_mods.clear(p);
}
- void clearTempMod(v3s16 p)
+ bool clearTempMods()
{
- if(m_temp_mods.find(p))
- m_temp_mods.remove(p);
+ JMutexAutoLock lock(m_temp_mods_mutex);
+
+ return m_temp_mods.clear();
}
- void clearTempMods()
+ void copyTempMods(NodeModMap &dst)
{
- m_temp_mods.clear();
+ JMutexAutoLock lock(m_temp_mods_mutex);
+ m_temp_mods.copy(dst);
}
#endif
/*
- Day-night lighting difference
+ Update day-night lighting difference flag.
+
+ Sets m_day_night_differs to appropriate value.
These methods don't care about neighboring blocks.
It means that to know if a block really doesn't need a mesh
void deSerialize(std::istream &is, u8 version);
+private:
/*
- Public member variables
+ Private methods
*/
-#ifndef SERVER
- //scene::SMesh *mesh[DAYNIGHT_CACHE_COUNT];
- scene::SMesh *mesh;
- JMutex mesh_mutex;
-#endif
-
-private:
-
/*
Used only internally, because changes can't be tracked
*/
return getNodeRef(p.X, p.Y, p.Z);
}
+public:
+ /*
+ Public member variables
+ */
+
+#ifndef SERVER
+ scene::SMesh *mesh;
+ JMutex mesh_mutex;
+#endif
+ NodeMetadataList m_node_metadata;
+ StaticObjectList m_static_objects;
+
+private:
+ /*
+ Private member variables
+ */
+
+ // NOTE: Lots of things rely on this being the Map
NodeContainer *m_parent;
// Position in blocks on parent
v3s16 m_pos;
+
/*
If NULL, block is a dummy block.
Dummy blocks are used for caching not-found-on-disk blocks.
*/
MapNode * data;
+
/*
- - On the client, this is used for checking whether to
- recalculate the face cache. (Is it anymore?)
- On the server, this is used for telling whether the
block has been changed from the one on disk.
+ - On the client, this is used for nothing.
*/
bool changed;
+
/*
- Used for some initial lighting stuff.
- At least /has been/ used. 8)
- It's probably useless now.
+ When propagating sunlight and the above block doesn't exist,
+ sunlight is assumed if this is false.
+
+ In practice this is set to true if the block is completely
+ undeground with nothing visible above the ground except
+ caves.
*/
bool is_underground;
+
+ /*
+ Set to true if changes has been made that make the old lighting
+ values wrong but the lighting hasn't been actually updated.
+
+ If this is false, lighting is exactly right.
+ If this is true, lighting might be wrong or right.
+ */
+ bool m_lighting_expired;
// Whether day and night lighting differs
bool m_day_night_differs;
+ // TODO: Remove this
MapBlockObjectList m_objects;
// Object spawning stuff
- float m_spawn_timer;
-
-#ifndef SERVER
+ //float m_spawn_timer;
+
+#ifndef SERVER // Only on client
+ /*
+ Set to true if the mesh has been ordered to be updated
+ sometime in the background.
+ In practice this is set when the day/night lighting switches.
+ */
bool m_mesh_expired;
// Temporary modifications to nodes
// These are only used when drawing
- core::map<v3s16, NodeMod> m_temp_mods;
+ NodeModMap m_temp_mods;
+ JMutex m_temp_mods_mutex;
#endif
};
projects / dragonfireclient.git / blobdiff