X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.h;h=ca36499acaa87930cd93230226ce9db1f8016078;hb=30c34cc23e9a060ef964854038a314a94ad5cbae;hp=e4f93a031c4d61c72b80252f59394a30b38a95d8;hpb=0fa0e0752a28eeb43195f2288c018d5c0b24520b;p=dragonfireclient.git diff --git a/src/mapblock.h b/src/mapblock.h index e4f93a031..ca36499ac 100644 --- a/src/mapblock.h +++ b/src/mapblock.h @@ -31,8 +31,17 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "constants.h" #include "mapblockobject.h" #include "voxel.h" +#include "nodemetadata.h" +#include "staticobject.h" +#include "mapblock_nodemod.h" +#ifndef SERVER + #include "mapblock_mesh.h" +#endif + + +#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff -// Named by looking towards z+ +/*// Named by looking towards z+ enum{ FACE_BACK=0, FACE_TOP, @@ -40,35 +49,7 @@ enum{ FACE_FRONT, FACE_BOTTOM, FACE_LEFT -}; - -struct FastFace -{ - 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 { @@ -86,8 +67,22 @@ class NodeContainer 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); + } + } }; +/* + MapBlock itself +*/ + class MapBlock : public NodeContainer { public: @@ -98,37 +93,66 @@ class MapBlock : public NodeContainer { 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 getBox() { return core::aabbox3d(getPosRelative(), @@ -168,19 +215,11 @@ class MapBlock : public NodeContainer + 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= 0 && p.Z < MAP_BLOCKSIZE); } - /* - Regular MapNode get-setters - */ - MapNode getNode(s16 x, s16 y, s16 z) { if(data == NULL) @@ -209,6 +244,15 @@ class MapBlock : public NodeContainer return getNode(p.X, p.Y, p.Z); } + MapNode getNodeNoEx(v3s16 p) + { + try{ + return getNode(p.X, p.Y, p.Z); + }catch(InvalidPositionException &e){ + return MapNode(CONTENT_IGNORE); + } + } + void setNode(s16 x, s16 y, s16 z, MapNode & n) { if(data == NULL) @@ -271,10 +315,22 @@ class MapBlock : public NodeContainer 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), @@ -282,36 +338,19 @@ class MapBlock : public NodeContainer 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 &dest); - - TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir); - u8 getNodeContent(v3s16 p, MapNode mn); +#ifndef SERVER // Only on client +#if 1 /* - 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 + Thread-safely updates the whole mesh of the mapblock. + NOTE: Prefer generating the mesh separately and then using + replaceMesh(). */ - void updateFastFaceRow( - u32 daynight_ratio, - v3f posRelative_f, - v3s16 startpos, - u16 length, - v3s16 translate_dir, - v3f translate_dir_f, - v3s16 face_dir, - v3f face_dir_f, - core::array &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 +#endif + // Replace the mesh with a new one + void replaceMesh(scene::SMesh *mesh_new); +#endif // See comments in mapblock.cpp bool propagateSunlight(core::map & light_sources, @@ -319,15 +358,18 @@ class MapBlock : public NodeContainer // Copies data to VoxelManipulator to getPosRelative() void copyTo(VoxelManipulator &dst); + // Copies data from VoxelManipulator getPosRelative() + void copyFrom(VoxelManipulator &dst); /* - Object stuff + MapBlockObject stuff + DEPRECATED */ - void serializeObjects(std::ostream &os, u8 version) + /*void serializeObjects(std::ostream &os, u8 version) { m_objects.serialize(os, version); - } + }*/ // If smgr!=NULL, new objects are added to the scene void updateObjects(std::istream &is, u8 version, scene::ISceneManager *smgr, u32 daynight_ratio) @@ -369,13 +411,6 @@ class MapBlock : public NodeContainer */ void stepObjects(float dtime, bool server, u32 daynight_ratio); - /*void wrapObject(MapBlockObject *object) - { - m_objects.wrapObject(object); - - setChangedFlag(); - }*/ - // origin is relative to block void getObjects(v3f origin, f32 max_d, core::array &dest) @@ -383,22 +418,19 @@ class MapBlock : public NodeContainer m_objects.getObjects(origin, max_d, dest); } - /*void getPseudoObjects(v3f origin, f32 max_d, - core::array &dest);*/ - s32 getObjectCount() { return m_objects.getCount(); } -#ifndef SERVER +#ifndef SERVER // Only on client /* Methods for setting temporary modifications to nodes for drawing returns true if the mod was different last time */ - bool setTempMod(v3s16 p, NodeMod mod) + bool setTempMod(v3s16 p, const NodeMod &mod) { /*dstream<<"setTempMod called on block" <<" ("<::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; + return m_temp_mods.set(p, mod); } // Returns true if there was one - bool getTempMod(v3s16 p, struct NodeMod *mod) + bool getTempMod(v3s16 p, NodeMod *mod) { JMutexAutoLock lock(m_temp_mods_mutex); - core::map::Node *n; - n = m_temp_mods.find(p); - if(n == NULL) - return false; - if(mod) - *mod = n->getValue(); - return true; + + return m_temp_mods.get(p, mod); } 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; + + return m_temp_mods.clear(p); } bool clearTempMods() { JMutexAutoLock lock(m_temp_mods_mutex); - if(m_temp_mods.size() == 0) - return false; - m_temp_mods.clear(); - return true; + + return m_temp_mods.clear(); + } + void copyTempMods(NodeModMap &dst) + { + 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 @@ -480,27 +498,40 @@ class MapBlock : public NodeContainer */ s16 getGroundLevel(v2s16 p2d); + /* + Timestamp (see m_timestamp) + NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. + */ + void setTimestamp(u32 time) + { + m_timestamp = time; + setChangedFlag(); + } + void setTimestampNoChangedFlag(u32 time) + { + m_timestamp = time; + } + u32 getTimestamp() + { + return m_timestamp; + } + /* Serialization */ - // Doesn't write version by itself + // These don't write or read version by itself void serialize(std::ostream &os, u8 version); - void deSerialize(std::istream &is, u8 version); + // Used after the basic ones when writing on disk (serverside) + void serializeDiskExtra(std::ostream &os, u8 version); + void deSerializeDiskExtra(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 */ @@ -519,45 +550,86 @@ class MapBlock : public NodeContainer return getNodeRef(p.X, p.Y, p.Z); } +public: + /* + Public member variables + */ + +#ifndef SERVER // Only on client + 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; + // DEPRECATED MapBlockObjectList m_objects; - // Object spawning stuff - float m_spawn_timer; - -#ifndef SERVER +#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 m_temp_mods; + NodeModMap m_temp_mods; JMutex m_temp_mods_mutex; #endif + + /* + When block is removed from active blocks, this is set to gametime. + Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp. + */ + u32 m_timestamp; }; inline bool blockpos_over_limit(v3s16 p)