/*
-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 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 MAPBLOCK_HEADER
-#define MAPBLOCK_HEADER
+#pragma once
-#include <jmutex.h>
-#include <jmutexautolock.h>
-#include <exception>
-#include "debug.h"
-#include "common_irrlicht.h"
+#include <set>
+#include "irr_v3d.h"
#include "mapnode.h"
#include "exceptions.h"
-#include "serialization.h"
#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
-
+#include "nodemetadata.h"
+#include "nodetimer.h"
+#include "modifiedstate.h"
+#include "util/numeric.h" // getContainerPos
+#include "settings.h"
+#include "mapgen/mapgen.h"
+
+class Map;
+class NodeMetadataList;
+class IGameDef;
+class MapBlockMesh;
+class VoxelManipulator;
#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
-/*// Named by looking towards z+
-enum{
- FACE_BACK=0,
- FACE_TOP,
- FACE_RIGHT,
- FACE_FRONT,
- FACE_BOTTOM,
- FACE_LEFT
-};*/
-
-enum ModifiedState
-{
- // Has not been modified.
- MOD_STATE_CLEAN = 0,
- MOD_RESERVED1 = 1,
- // Has been modified, and will be saved when being unloaded.
- MOD_STATE_WRITE_AT_UNLOAD = 2,
- MOD_RESERVED3 = 3,
- // Has been modified, and will be saved as soon as possible.
- MOD_STATE_WRITE_NEEDED = 4,
- MOD_RESERVED5 = 5,
-};
-
-// NOTE: If this is enabled, set MapBlock to be initialized with
-// CONTENT_IGNORE.
-/*enum BlockGenerationStatus
-{
- // Completely non-generated (filled with CONTENT_IGNORE).
- BLOCKGEN_UNTOUCHED=0,
- // Trees or similar might have been blitted from other blocks to here.
- // Otherwise, the block contains CONTENT_IGNORE
- BLOCKGEN_FROM_NEIGHBORS=2,
- // Has been generated, but some neighbors might put some stuff in here
- // when they are generated.
- // Does not contain any CONTENT_IGNORE
- BLOCKGEN_SELF_GENERATED=4,
- // The block and all its neighbors have been generated
- BLOCKGEN_FULLY_GENERATED=6
-};*/
-
-enum
-{
- NODECONTAINER_ID_MAPBLOCK,
- NODECONTAINER_ID_MAPSECTOR,
- NODECONTAINER_ID_MAP,
- NODECONTAINER_ID_MAPBLOCKCACHE,
- NODECONTAINER_ID_VOXELMANIPULATOR,
-};
-
-class NodeContainer
+////
+//// MapBlock modified reason flags
+////
+
+#define MOD_REASON_INITIAL (1 << 0)
+#define MOD_REASON_REALLOCATE (1 << 1)
+#define MOD_REASON_SET_IS_UNDERGROUND (1 << 2)
+#define MOD_REASON_SET_LIGHTING_COMPLETE (1 << 3)
+#define MOD_REASON_SET_GENERATED (1 << 4)
+#define MOD_REASON_SET_NODE (1 << 5)
+#define MOD_REASON_SET_NODE_NO_CHECK (1 << 6)
+#define MOD_REASON_SET_TIMESTAMP (1 << 7)
+#define MOD_REASON_REPORT_META_CHANGE (1 << 8)
+#define MOD_REASON_CLEAR_ALL_OBJECTS (1 << 9)
+#define MOD_REASON_BLOCK_EXPIRED (1 << 10)
+#define MOD_REASON_ADD_ACTIVE_OBJECT_RAW (1 << 11)
+#define MOD_REASON_REMOVE_OBJECTS_REMOVE (1 << 12)
+#define MOD_REASON_REMOVE_OBJECTS_DEACTIVATE (1 << 13)
+#define MOD_REASON_TOO_MANY_OBJECTS (1 << 14)
+#define MOD_REASON_STATIC_DATA_ADDED (1 << 15)
+#define MOD_REASON_STATIC_DATA_REMOVED (1 << 16)
+#define MOD_REASON_STATIC_DATA_CHANGED (1 << 17)
+#define MOD_REASON_EXPIRE_DAYNIGHTDIFF (1 << 18)
+#define MOD_REASON_VMANIP (1 << 19)
+#define MOD_REASON_UNKNOWN (1 << 20)
+
+////
+//// MapBlock itself
+////
+
+class MapBlock
{
public:
- virtual bool isValidPosition(v3s16 p) = 0;
- 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:
- MapBlock(NodeContainer *parent, v3s16 pos, bool dummy=false);
+ MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false);
~MapBlock();
-
- virtual u16 nodeContainerId() const
+
+ /*virtual u16 nodeContainerId() const
{
return NODECONTAINER_ID_MAPBLOCK;
- }
-
- NodeContainer * getParent()
+ }*/
+
+ Map * 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();
+ delete[] data;
+ data = new MapNode[nodecount];
+ for (u32 i = 0; i < nodecount; i++)
data[i] = MapNode(CONTENT_IGNORE);
- }
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- /*
- Flags
- */
-
- bool isDummy()
- {
- return (data == NULL);
+ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
}
- void unDummify()
+
+ MapNode* getData()
{
- assert(isDummy());
- reallocate();
+ return data;
}
-
- /*
- This is called internally or externally after the block is
- modified, so that the block is saved and possibly not deleted from
- memory.
- */
- // DEPRECATED, use *Modified()
- void setChangedFlag()
+
+ ////
+ //// Modification tracking methods
+ ////
+ void raiseModified(u32 mod, u32 reason=MOD_REASON_UNKNOWN)
{
- //dstream<<"Deprecated setChangedFlag() called"<<std::endl;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ if (mod > m_modified) {
+ m_modified = mod;
+ m_modified_reason = reason;
+ if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD)
+ m_disk_timestamp = m_timestamp;
+ } else if (mod == m_modified) {
+ m_modified_reason |= reason;
+ }
+ if (mod == MOD_STATE_WRITE_NEEDED)
+ contents_cached = false;
}
- // DEPRECATED, use *Modified()
- void resetChangedFlag()
+
+ inline u32 getModified()
{
- //dstream<<"Deprecated resetChangedFlag() called"<<std::endl;
- resetModified();
+ return m_modified;
}
- // DEPRECATED, use *Modified()
- bool getChangedFlag()
+
+ inline u32 getModifiedReason()
{
- //dstream<<"Deprecated getChangedFlag() called"<<std::endl;
- if(getModified() == MOD_STATE_CLEAN)
- return false;
- else
- return true;
+ return m_modified_reason;
}
-
- // m_modified methods
- void raiseModified(u32 mod)
+
+ std::string getModifiedReasonString();
+
+ inline void resetModified()
{
- m_modified = MYMAX(m_modified, mod);
+ m_modified = MOD_STATE_CLEAN;
+ m_modified_reason = 0;
}
- u32 getModified()
+
+ ////
+ //// Flags
+ ////
+
+ inline bool isDummy()
{
- return m_modified;
+ return !data;
}
- void resetModified()
+
+ inline void unDummify()
{
- m_modified = MOD_STATE_CLEAN;
+ assert(isDummy()); // Pre-condition
+ reallocate();
}
-
+
// is_underground getter/setter
- bool getIsUnderground()
+ inline bool getIsUnderground()
{
return is_underground;
}
- void setIsUnderground(bool a_is_underground)
+
+ inline void setIsUnderground(bool a_is_underground)
{
is_underground = a_is_underground;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND);
}
-#ifndef SERVER
- void setMeshExpired(bool expired)
+ inline void setLightingComplete(u16 newflags)
{
- m_mesh_expired = expired;
+ if (newflags != m_lighting_complete) {
+ m_lighting_complete = newflags;
+ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE);
+ }
}
-
- bool getMeshExpired()
+
+ inline u16 getLightingComplete()
{
- return m_mesh_expired;
+ return m_lighting_complete;
}
-#endif
- void setLightingExpired(bool expired)
+ inline void setLightingComplete(LightBank bank, u8 direction,
+ bool is_complete)
{
- m_lighting_expired = expired;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ assert(direction >= 0 && direction <= 5);
+ if (bank == LIGHTBANK_NIGHT) {
+ direction += 6;
+ }
+ u16 newflags = m_lighting_complete;
+ if (is_complete) {
+ newflags |= 1 << direction;
+ } else {
+ newflags &= ~(1 << direction);
+ }
+ setLightingComplete(newflags);
}
- bool getLightingExpired()
+
+ inline bool isLightingComplete(LightBank bank, u8 direction)
{
- return m_lighting_expired;
+ assert(direction >= 0 && direction <= 5);
+ if (bank == LIGHTBANK_NIGHT) {
+ direction += 6;
+ }
+ return (m_lighting_complete & (1 << direction)) != 0;
}
- bool isGenerated()
+ inline bool isGenerated()
{
return m_generated;
}
- void setGenerated(bool b)
- {
- raiseModified(MOD_STATE_WRITE_NEEDED);
- m_generated = b;
- }
- bool isValid()
+ inline void setGenerated(bool b)
{
- if(m_lighting_expired)
- return false;
- if(data == NULL)
- return false;
- return true;
+ if (b != m_generated) {
+ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED);
+ m_generated = b;
+ }
}
- /*
- Position stuff
- */
+ ////
+ //// Position stuff
+ ////
- v3s16 getPos()
+ inline v3s16 getPos()
{
return m_pos;
}
-
- v3s16 getPosRelative()
+
+ inline v3s16 getPosRelative()
{
- return m_pos * MAP_BLOCKSIZE;
+ return m_pos_relative;
}
-
- core::aabbox3d<s16> getBox()
+
+ inline core::aabbox3d<s16> getBox()
{
return core::aabbox3d<s16>(getPosRelative(),
getPosRelative()
- v3s16(1,1,1));
}
- /*
- Regular MapNode get-setters
- */
-
- bool isValidPosition(v3s16 p)
+ ////
+ //// Regular MapNode get-setters
+ ////
+
+ inline bool isValidPosition(s16 x, s16 y, s16 z)
{
- if(data == NULL)
- return false;
- return (p.X >= 0 && p.X < MAP_BLOCKSIZE
- && p.Y >= 0 && p.Y < MAP_BLOCKSIZE
- && p.Z >= 0 && p.Z < MAP_BLOCKSIZE);
+ return data
+ && x >= 0 && x < MAP_BLOCKSIZE
+ && y >= 0 && y < MAP_BLOCKSIZE
+ && z >= 0 && z < MAP_BLOCKSIZE;
}
- MapNode getNode(s16 x, s16 y, s16 z)
+ inline bool isValidPosition(v3s16 p)
{
- 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();
- return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
+ return isValidPosition(p.X, p.Y, p.Z);
}
-
- MapNode getNode(v3s16 p)
+
+ inline MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position)
{
- return getNode(p.X, p.Y, p.Z);
+ *valid_position = isValidPosition(x, y, z);
+
+ if (!*valid_position)
+ return {CONTENT_IGNORE};
+
+ return data[z * zstride + y * ystride + x];
}
-
- MapNode getNodeNoEx(v3s16 p)
+
+ inline MapNode getNode(v3s16 p, bool *valid_position)
{
- try{
- return getNode(p.X, p.Y, p.Z);
- }catch(InvalidPositionException &e){
- return MapNode(CONTENT_IGNORE);
- }
+ return getNode(p.X, p.Y, p.Z, valid_position);
+ }
+
+ inline MapNode getNodeNoEx(v3s16 p)
+ {
+ bool is_valid;
+ return getNode(p.X, p.Y, p.Z, &is_valid);
}
-
- void setNode(s16 x, s16 y, s16 z, MapNode & n)
+
+ inline void setNode(s16 x, s16 y, s16 z, MapNode & n)
{
- if(data == NULL)
+ if (!isValidPosition(x, y, z))
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();
- data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+
+ data[z * zstride + y * ystride + x] = n;
+ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE);
}
-
- void setNode(v3s16 p, MapNode & n)
+
+ inline void setNode(v3s16 p, MapNode & n)
{
setNode(p.X, p.Y, p.Z, n);
}
- /*
- Non-checking variants of the above
- */
+ ////
+ //// Non-checking variants of the above
+ ////
- MapNode getNodeNoCheck(s16 x, s16 y, s16 z)
+ inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position)
{
- if(data == NULL)
- throw InvalidPositionException();
- return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
+ *valid_position = data != nullptr;
+ if (!*valid_position)
+ return {CONTENT_IGNORE};
+
+ return data[z * zstride + y * ystride + x];
+ }
+
+ inline MapNode getNodeNoCheck(v3s16 p, bool *valid_position)
+ {
+ return getNodeNoCheck(p.X, p.Y, p.Z, valid_position);
+ }
+
+ ////
+ //// Non-checking, unsafe variants of the above
+ //// MapBlock must be loaded by another function in the same scope/function
+ //// Caller must ensure that this is not a dummy block (by calling isDummy())
+ ////
+
+ inline const MapNode &getNodeUnsafe(s16 x, s16 y, s16 z)
+ {
+ return data[z * zstride + y * ystride + x];
}
-
- MapNode getNodeNoCheck(v3s16 p)
+
+ inline const MapNode &getNodeUnsafe(v3s16 &p)
{
- return getNodeNoCheck(p.X, p.Y, p.Z);
+ return getNodeUnsafe(p.X, p.Y, p.Z);
}
-
- void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
+
+ inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
{
- if(data == NULL)
+ if (!data)
throw InvalidPositionException();
- data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
- raiseModified(MOD_STATE_WRITE_NEEDED);
+
+ data[z * zstride + y * ystride + x] = n;
+ raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK);
}
-
- void setNodeNoCheck(v3s16 p, MapNode & n)
+
+ inline void setNodeNoCheck(v3s16 p, MapNode & n)
{
setNodeNoCheck(p.X, p.Y, p.Z, n);
}
- /*
- These functions consult the parent container if the position
- is not valid on this MapBlock.
- */
+ // These functions consult the parent container if the position
+ // is not valid on this MapBlock.
bool isValidPositionParent(v3s16 p);
- MapNode getNodeParent(v3s16 p);
+ MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL);
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)
+ inline void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
{
- for(u16 z=0; z<d; z++)
- for(u16 y=0; y<h; y++)
- for(u16 x=0; x<w; x++)
- setNode(x0+x, y0+y, z0+z, node);
+ for (u16 z = 0; z < d; z++)
+ for (u16 y = 0; y < h; y++)
+ for (u16 x = 0; x < w; x++)
+ setNode(x0 + x, y0 + y, z0 + z, node);
}
- /*
- 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),
- getNodeParentNoEx(p + face_dir),
- face_dir);
- }
-
-#ifndef SERVER // Only on client
-
-#if 1
- /*
- Thread-safely updates the whole mesh of the mapblock.
- NOTE: Prefer generating the mesh separately and then using
- replaceMesh().
- */
- void updateMesh(u32 daynight_ratio);
-#endif
- // Replace the mesh with a new one
- void replaceMesh(scene::SMesh *mesh_new);
-#endif
-
- // See comments in mapblock.cpp
- bool propagateSunlight(core::map<v3s16, bool> & light_sources,
- bool remove_light=false, bool *black_air_left=NULL);
-
// Copies data to VoxelManipulator to getPosRelative()
void copyTo(VoxelManipulator &dst);
+
// Copies data from VoxelManipulator getPosRelative()
void copyFrom(VoxelManipulator &dst);
- /*
- MapBlockObject stuff
- DEPRECATED
- */
-
- /*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)
- {
- m_objects.update(is, version, smgr, daynight_ratio);
+ // Update day-night lighting difference flag.
+ // Sets m_day_night_differs to appropriate value.
+ // These methods don't care about neighboring blocks.
+ void actuallyUpdateDayNightDiff();
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- void clearObjects()
- {
- m_objects.clear();
+ // Call this to schedule what the previous function does to be done
+ // when the value is actually needed.
+ void expireDayNightDiff();
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- void addObject(MapBlockObject *object)
- throw(ContainerFullException, AlreadyExistsException)
+ inline bool getDayNightDiff()
{
- m_objects.add(object);
-
- raiseModified(MOD_STATE_WRITE_NEEDED);
+ if (m_day_night_differs_expired)
+ actuallyUpdateDayNightDiff();
+ return m_day_night_differs;
}
- void removeObject(s16 id)
- {
- m_objects.remove(id);
- raiseModified(MOD_STATE_WRITE_NEEDED);
- }
- MapBlockObject * getObject(s16 id)
- {
- return m_objects.get(id);
- }
- JMutexAutoLock * getObjectLock()
- {
- return m_objects.getLock();
- }
+ ////
+ //// Miscellaneous stuff
+ ////
/*
- Moves objects, deletes objects and spawns new objects
+ Tries to measure ground level.
+ Return value:
+ -1 = only air
+ -2 = only ground
+ -3 = random fail
+ 0...MAP_BLOCKSIZE-1 = ground level
*/
- void stepObjects(float dtime, bool server, u32 daynight_ratio);
+ s16 getGroundLevel(v2s16 p2d);
- // origin is relative to block
- void getObjects(v3f origin, f32 max_d,
- core::array<DistanceSortedObject> &dest)
+ ////
+ //// Timestamp (see m_timestamp)
+ ////
+
+ // NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
+
+ inline void setTimestamp(u32 time)
{
- m_objects.getObjects(origin, max_d, dest);
+ m_timestamp = time;
+ raiseModified(MOD_STATE_WRITE_AT_UNLOAD, MOD_REASON_SET_TIMESTAMP);
}
- s32 getObjectCount()
+ inline void setTimestampNoChangedFlag(u32 time)
{
- return m_objects.getCount();
+ m_timestamp = time;
}
-#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, const NodeMod &mod)
+ inline u32 getTimestamp()
{
- /*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);
-
- return m_temp_mods.set(p, mod);
+ return m_timestamp;
}
- // 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)
+ inline u32 getDiskTimestamp()
{
- JMutexAutoLock lock(m_temp_mods_mutex);
+ return m_disk_timestamp;
+ }
+
+ ////
+ //// Usage timer (see m_usage_timer)
+ ////
- return m_temp_mods.clear(p);
+ inline void resetUsageTimer()
+ {
+ m_usage_timer = 0;
}
- bool clearTempMods()
+
+ inline void incrementUsageTimer(float dtime)
{
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- return m_temp_mods.clear();
+ m_usage_timer += dtime;
}
- void copyTempMods(NodeModMap &dst)
+
+ inline float getUsageTimer()
{
- JMutexAutoLock lock(m_temp_mods_mutex);
- m_temp_mods.copy(dst);
+ return m_usage_timer;
}
-#endif
- /*
- 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
- update between day and night, the neighboring blocks have
- to be taken into account. Use Map::dayNightDiffed().
- */
- void updateDayNightDiff();
+ ////
+ //// Reference counting (see m_refcount)
+ ////
- bool dayNightDiffed()
+ inline void refGrab()
{
- return m_day_night_differs;
+ m_refcount++;
}
- /*
- 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);
-
- /*
- Timestamp (see m_timestamp)
- NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
- */
- void setTimestamp(u32 time)
+ inline void refDrop()
{
- m_timestamp = time;
- raiseModified(MOD_STATE_WRITE_AT_UNLOAD);
+ m_refcount--;
}
- void setTimestampNoChangedFlag(u32 time)
+
+ inline int refGet()
{
- m_timestamp = time;
+ return m_refcount;
}
- u32 getTimestamp()
+
+ ////
+ //// Node Timers
+ ////
+
+ inline NodeTimer getNodeTimer(const v3s16 &p)
{
- return m_timestamp;
+ return m_node_timers.get(p);
}
-
- /*
- See m_usage_timer
- */
- void resetUsageTimer()
+
+ inline void removeNodeTimer(const v3s16 &p)
{
- m_usage_timer = 0;
+ m_node_timers.remove(p);
}
- void incrementUsageTimer(float dtime)
+
+ inline void setNodeTimer(const NodeTimer &t)
{
- m_usage_timer += dtime;
+ m_node_timers.set(t);
}
- u32 getUsageTimer()
+
+ inline void clearNodeTimers()
{
- return m_usage_timer;
+ m_node_timers.clear();
}
- /*
- Serialization
- */
-
- // 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);
+ ////
+ //// Serialization
+ ///
+ // These don't write or read version by itself
+ // Set disk to true for on-disk format, false for over-the-network format
+ // Precondition: version >= SER_FMT_VER_LOWEST_WRITE
+ void serialize(std::ostream &os, u8 version, bool disk);
+ // If disk == true: In addition to doing other things, will add
+ // unknown blocks from id-name mapping to wndef
+ void deSerialize(std::istream &is, u8 version, bool disk);
+
+ void serializeNetworkSpecific(std::ostream &os);
+ void deSerializeNetworkSpecific(std::istream &is);
private:
/*
Private methods
*/
+ void deSerialize_pre22(std::istream &is, u8 version, bool disk);
+
/*
Used only internally, because changes can't be tracked
*/
- MapNode & getNodeRef(s16 x, s16 y, s16 z)
+ inline MapNode &getNodeRef(s16 x, s16 y, s16 z)
{
- if(data == NULL)
+ if (!isValidPosition(x, y, z))
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();
- return data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x];
+
+ return data[z * zstride + y * ystride + x];
}
- MapNode & getNodeRef(v3s16 &p)
+
+ inline MapNode &getNodeRef(v3s16 &p)
{
return getNodeRef(p.X, p.Y, p.Z);
}
*/
#ifndef SERVER // Only on client
- scene::SMesh *mesh;
- JMutex mesh_mutex;
+ MapBlockMesh *mesh = nullptr;
#endif
-
+
NodeMetadataList m_node_metadata;
+ NodeTimerList m_node_timers;
StaticObjectList m_static_objects;
-
+
+ static const u32 ystride = MAP_BLOCKSIZE;
+ static const u32 zstride = MAP_BLOCKSIZE * MAP_BLOCKSIZE;
+
+ static const u32 nodecount = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
+
+ //// ABM optimizations ////
+ // Cache of content types
+ std::unordered_set<content_t> contents;
+ // True if content types are cached
+ bool contents_cached = false;
+ // True if we never want to cache content types for this block
+ bool do_not_cache_contents = false;
+
private:
/*
Private member variables
*/
// NOTE: Lots of things rely on this being the Map
- NodeContainer *m_parent;
+ Map *m_parent;
// Position in blocks on parent
v3s16 m_pos;
-
+
+ /* This is the precalculated m_pos_relative value
+ * This caches the value, improving performance by removing 3 s16 multiplications
+ * at runtime on each getPosRelative call
+ * For a 5 minutes runtime with valgrind this removes 3 * 19M s16 multiplications
+ * The gain can be estimated in Release Build to 3 * 100M multiply operations for 5 mins
+ */
+ v3s16 m_pos_relative;
+
+ IGameDef *m_gamedef;
+
/*
If NULL, block is a dummy block.
Dummy blocks are used for caching not-found-on-disk blocks.
*/
- MapNode * data;
+ MapNode *data = nullptr;
/*
- On the server, this is used for telling whether the
block has been modified from the one on disk.
- On the client, this is used for nothing.
*/
- u32 m_modified;
+ u32 m_modified = MOD_STATE_WRITE_NEEDED;
+ u32 m_modified_reason = MOD_REASON_INITIAL;
/*
When propagating sunlight and the above block doesn't exist,
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 is_underground = false;
+
+ /*!
+ * Each bit indicates if light spreading was finished
+ * in a direction. (Because the neighbor could also be unloaded.)
+ * Bits (most significant first):
+ * nothing, nothing, nothing, nothing,
+ * night X-, night Y-, night Z-, night Z+, night Y+, night X+,
+ * day X-, day Y-, day Z-, day Z+, day Y+, day X+.
*/
- bool m_lighting_expired;
-
+ u16 m_lighting_complete = 0xFFFF;
+
// Whether day and night lighting differs
- bool m_day_night_differs;
+ bool m_day_night_differs = false;
+ bool m_day_night_differs_expired = true;
- bool m_generated;
-
- // DEPRECATED
- MapBlockObjectList m_objects;
+ bool m_generated = false;
-#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
- 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;
+ u32 m_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
+ // The on-disk (or to-be on-disk) timestamp value
+ u32 m_disk_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
/*
When the block is accessed, this is set to 0.
Map will unload the block when this reaches a timeout.
*/
- float m_usage_timer;
+ float m_usage_timer = 0;
+
+ /*
+ Reference count; currently used for determining if this block is in
+ the list of blocks to be drawn.
+ */
+ int m_refcount = 0;
};
-inline bool blockpos_over_limit(v3s16 p)
+typedef std::vector<MapBlock*> MapBlockVect;
+
+inline bool objectpos_over_limit(v3f p)
{
- return
- (p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
- || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
- || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
- || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
- || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
- || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE);
+ const float max_limit_bs = MAX_MAP_GENERATION_LIMIT * BS;
+ return p.X < -max_limit_bs ||
+ p.X > max_limit_bs ||
+ p.Y < -max_limit_bs ||
+ p.Y > max_limit_bs ||
+ p.Z < -max_limit_bs ||
+ p.Z > max_limit_bs;
}
-/*
- Returns the position of the block where the node is located
-*/
-inline v3s16 getNodeBlockPos(v3s16 p)
+inline bool blockpos_over_max_limit(v3s16 p)
{
- return getContainerPos(p, MAP_BLOCKSIZE);
+ const s16 max_limit_bp = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE;
+ return p.X < -max_limit_bp ||
+ p.X > max_limit_bp ||
+ p.Y < -max_limit_bp ||
+ p.Y > max_limit_bp ||
+ p.Z < -max_limit_bp ||
+ p.Z > max_limit_bp;
}
-inline v2s16 getNodeSectorPos(v2s16 p)
+/*
+ Returns the position of the block where the node is located
+*/
+inline v3s16 getNodeBlockPos(const v3s16 &p)
{
return getContainerPos(p, MAP_BLOCKSIZE);
}
-inline s16 getNodeBlockY(s16 y)
+inline void getNodeBlockPosWithOffset(const v3s16 &p, v3s16 &block, v3s16 &offset)
{
- return getContainerPos(y, MAP_BLOCKSIZE);
+ getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset);
}
-#endif
-
+/*
+ Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block);
projects / oweals / minetest.git / blobdiff