X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fnodedef.h;h=3e77624eb3134b7d25eca4b003d398005786d642;hb=880c9768a9323800ca8d44cc4b73e92278e58743;hp=7a84b0316c1df4dbaab48fe7a50043935aefc091;hpb=b0523adc5f673208b5414cf49c6640e4fc148b87;p=dragonfireclient.git diff --git a/src/nodedef.h b/src/nodedef.h index 7a84b0316..3e77624eb 100644 --- a/src/nodedef.h +++ b/src/nodedef.h @@ -17,32 +17,36 @@ with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef NODEDEF_HEADER -#define NODEDEF_HEADER +#pragma once #include "irrlichttypes_bloated.h" #include #include #include -#include -#include "util/numeric.h" #include "mapnode.h" +#include "nameidmapping.h" #ifndef SERVER #include "client/tile.h" -#include "shader.h" +#include +class Client; #endif #include "itemgroup.h" #include "sound.h" // SimpleSoundSpec #include "constants.h" // BS +#include "texture_override.h" // TextureOverride +#include "tileanimation.h" + +// PROTOCOL_VERSION >= 37 +static const u8 CONTENTFEATURES_VERSION = 13; -class INodeDefManager; class IItemDefManager; class ITextureSource; class IShaderSource; class IGameDef; class NodeResolver; - -typedef std::list > GroupItems; +#if BUILD_UNITTESTS +class TestSchematic; +#endif enum ContentParamType { @@ -65,6 +69,16 @@ enum ContentParamType2 CPT2_LEVELED, // 2D rotation for things like plants CPT2_DEGROTATE, + // Mesh options for plants + CPT2_MESHOPTIONS, + // Index for palette + CPT2_COLOR, + // 3 bits of palette index, then facedir + CPT2_COLORED_FACEDIR, + // 5 bits of palette index, then wallmounted + CPT2_COLORED_WALLMOUNTED, + // Glasslike framed drawtype internal liquid level, param2 values 0 to 63 + CPT2_GLASSLIKE_LIQUID_LEVEL, }; enum LiquidType @@ -80,6 +94,7 @@ enum NodeBoxType NODEBOX_FIXED, // Static separately defined box(es) NODEBOX_WALLMOUNTED, // Box for wall mounted nodes; (top, bottom, side) NODEBOX_LEVELED, // Same as fixed, but with dynamic height from param2. for snow, ... + NODEBOX_CONNECTED, // optionally draws nodeboxes if a neighbor node attaches }; struct NodeBox @@ -92,6 +107,21 @@ struct NodeBox aabb3f wall_top; aabb3f wall_bottom; aabb3f wall_side; // being at the -X side + // NODEBOX_CONNECTED + std::vector connect_top; + std::vector connect_bottom; + std::vector connect_front; + std::vector connect_left; + std::vector connect_back; + std::vector connect_right; + std::vector disconnected_top; + std::vector disconnected_bottom; + std::vector disconnected_front; + std::vector disconnected_left; + std::vector disconnected_back; + std::vector disconnected_right; + std::vector disconnected; + std::vector disconnected_sides; NodeBox() { reset(); } @@ -104,73 +134,155 @@ struct NodeBox struct MapNode; class NodeMetadata; -/* - Stand-alone definition of a TileSpec (basically a server-side TileSpec) -*/ -enum TileAnimationType{ - TAT_NONE=0, - TAT_VERTICAL_FRAMES=1, +enum LeavesStyle { + LEAVES_FANCY, + LEAVES_SIMPLE, + LEAVES_OPAQUE, }; -struct TileDef -{ - std::string name; - bool backface_culling; // Takes effect only in special cases - bool tileable_horizontal; - bool tileable_vertical; - struct{ - enum TileAnimationType type; - int aspect_w; // width for aspect ratio - int aspect_h; // height for aspect ratio - float length; // seconds - } animation; - TileDef() - { - name = ""; - backface_culling = true; - tileable_horizontal = true; - tileable_vertical = true; - animation.type = TAT_NONE; - animation.aspect_w = 1; - animation.aspect_h = 1; - animation.length = 1.0; - } +enum AutoScale : u8 { + AUTOSCALE_DISABLE, + AUTOSCALE_ENABLE, + AUTOSCALE_FORCE, +}; - void serialize(std::ostream &os, u16 protocol_version) const; - void deSerialize(std::istream &is); +enum WorldAlignMode : u8 { + WORLDALIGN_DISABLE, + WORLDALIGN_ENABLE, + WORLDALIGN_FORCE, + WORLDALIGN_FORCE_NODEBOX, +}; + +class TextureSettings { +public: + LeavesStyle leaves_style; + WorldAlignMode world_aligned_mode; + AutoScale autoscale_mode; + int node_texture_size; + bool opaque_water; + bool connected_glass; + bool enable_mesh_cache; + bool enable_minimap; + + TextureSettings() = default; + + void readSettings(); }; enum NodeDrawType { - NDT_NORMAL, // A basic solid block - NDT_AIRLIKE, // Nothing is drawn - NDT_LIQUID, // Do not draw face towards same kind of flowing/source liquid - NDT_FLOWINGLIQUID, // A very special kind of thing - NDT_GLASSLIKE, // Glass-like, don't draw faces towards other glass - NDT_ALLFACES, // Leaves-like, draw all faces no matter what - NDT_ALLFACES_OPTIONAL, // Fancy -> allfaces, fast -> normal + // A basic solid block + NDT_NORMAL, + // Nothing is drawn + NDT_AIRLIKE, + // Do not draw face towards same kind of flowing/source liquid + NDT_LIQUID, + // A very special kind of thing + NDT_FLOWINGLIQUID, + // Glass-like, don't draw faces towards other glass + NDT_GLASSLIKE, + // Leaves-like, draw all faces no matter what + NDT_ALLFACES, + // Enabled -> ndt_allfaces, disabled -> ndt_normal + NDT_ALLFACES_OPTIONAL, + // Single plane perpendicular to a surface NDT_TORCHLIKE, + // Single plane parallel to a surface NDT_SIGNLIKE, + // 2 vertical planes in a 'X' shape diagonal to XZ axes. + // paramtype2 = "meshoptions" allows various forms, sizes and + // vertical and horizontal random offsets. NDT_PLANTLIKE, + // Fenceposts that connect to neighbouring fenceposts with horizontal bars NDT_FENCELIKE, + // Selects appropriate junction texture to connect like rails to + // neighbouring raillikes. NDT_RAILLIKE, + // Custom Lua-definable structure of multiple cuboids NDT_NODEBOX, - NDT_GLASSLIKE_FRAMED, // Glass-like, draw connected frames and all all - // visible faces - // uses 2 textures, one for frames, second for faces - NDT_FIRELIKE, // Draw faces slightly rotated and only on connecting nodes, - NDT_GLASSLIKE_FRAMED_OPTIONAL, // enabled -> connected, disabled -> Glass-like - // uses 2 textures, one for frames, second for faces - NDT_MESH, // Uses static meshes + // Glass-like, draw connected frames and all visible faces. + // param2 > 0 defines 64 levels of internal liquid + // Uses 3 textures, one for frames, second for faces, + // optional third is a 'special tile' for the liquid. + NDT_GLASSLIKE_FRAMED, + // Draw faces slightly rotated and only on neighbouring nodes + NDT_FIRELIKE, + // Enabled -> ndt_glasslike_framed, disabled -> ndt_glasslike + NDT_GLASSLIKE_FRAMED_OPTIONAL, + // Uses static meshes + NDT_MESH, + // Combined plantlike-on-solid + NDT_PLANTLIKE_ROOTED, +}; + +// Mesh options for NDT_PLANTLIKE with CPT2_MESHOPTIONS +static const u8 MO_MASK_STYLE = 0x07; +static const u8 MO_BIT_RANDOM_OFFSET = 0x08; +static const u8 MO_BIT_SCALE_SQRT2 = 0x10; +static const u8 MO_BIT_RANDOM_OFFSET_Y = 0x20; +enum PlantlikeStyle { + PLANT_STYLE_CROSS, + PLANT_STYLE_CROSS2, + PLANT_STYLE_STAR, + PLANT_STYLE_HASH, + PLANT_STYLE_HASH2, +}; + +enum AlignStyle : u8 { + ALIGN_STYLE_NODE, + ALIGN_STYLE_WORLD, + ALIGN_STYLE_USER_DEFINED, +}; + +enum AlphaMode : u8 { + ALPHAMODE_BLEND, + ALPHAMODE_CLIP, + ALPHAMODE_OPAQUE, + ALPHAMODE_LEGACY_COMPAT, /* means either opaque or clip */ }; + +/* + Stand-alone definition of a TileSpec (basically a server-side TileSpec) +*/ + +struct TileDef +{ + std::string name = ""; + bool backface_culling = true; // Takes effect only in special cases + bool tileable_horizontal = true; + bool tileable_vertical = true; + //! If true, the tile has its own color. + bool has_color = false; + //! The color of the tile. + video::SColor color = video::SColor(0xFFFFFFFF); + AlignStyle align_style = ALIGN_STYLE_NODE; + u8 scale = 0; + + struct TileAnimationParams animation; + + TileDef() + { + animation.type = TAT_NONE; + } + + void serialize(std::ostream &os, u16 protocol_version) const; + void deSerialize(std::istream &is, u8 contentfeatures_version, + NodeDrawType drawtype); +}; + +// Defines the number of special tiles per nodedef +// +// NOTE: When changing this value, the enum entries of OverrideTarget and +// parser in TextureOverrideSource must be updated so that all special +// tiles can be overridden. #define CF_SPECIAL_COUNT 6 struct ContentFeatures { /* Cached stuff - */ + */ #ifndef SERVER // 0 1 2 3 4 5 // up down right left back front @@ -190,12 +302,19 @@ struct ContentFeatures /* Actual data - */ + */ + + // --- GENERAL PROPERTIES --- std::string name; // "" = undefined node ItemGroupList groups; // Same as in itemdef + // Type of MapNode::param1 + ContentParamType param_type; + // Type of MapNode::param2 + ContentParamType2 param_type_2; + + // --- VISUAL PROPERTIES --- - // Visual definition enum NodeDrawType drawtype; std::string mesh; #ifndef SERVER @@ -204,20 +323,41 @@ struct ContentFeatures #endif float visual_scale; // Misc. scale parameter TileDef tiledef[6]; + // These will be drawn over the base tiles. + TileDef tiledef_overlay[6]; TileDef tiledef_special[CF_SPECIAL_COUNT]; // eg. flowing liquid - u8 alpha; - + AlphaMode alpha; + // The color of the node. + video::SColor color; + std::string palette_name; + std::vector *palette; + // Used for waving leaves/plants + u8 waving; + // for NDT_CONNECTED pairing + u8 connect_sides; + std::vector connects_to; + std::vector connects_to_ids; // Post effect color, drawn when the camera is inside the node. video::SColor post_effect_color; + // Flowing liquid or leveled nodebox, value = default level + u8 leveled; + // Maximum value for leveled nodes + u8 leveled_max; + + // --- LIGHTING-RELATED --- - // Type of MapNode::param1 - ContentParamType param_type; - // Type of MapNode::param2 - ContentParamType2 param_type_2; - // True for all ground-like things like stone and mud, false for eg. trees - bool is_ground_content; bool light_propagates; bool sunlight_propagates; + // Amount of light the node emits + u8 light_source; + + // --- MAP GENERATION --- + + // True for all ground-like things like stone and mud, false for eg. trees + bool is_ground_content; + + // --- INTERACTION PROPERTIES --- + // This is used for collision detection. // Also for general solidness queries. bool walkable; @@ -231,14 +371,20 @@ struct ContentFeatures bool buildable_to; // Player cannot build to these (placement prediction disabled) bool rightclickable; - // Flowing liquid or snow, value = default level - u8 leveled; + u32 damage_per_second; + // client dig prediction + std::string node_dig_prediction; + + // --- LIQUID PROPERTIES --- + // Whether the node is non-liquid, source liquid or flowing liquid enum LiquidType liquid_type; // If the content is liquid, this is the flowing version of the liquid. std::string liquid_alternative_flowing; + content_t liquid_alternative_flowing_id; // If the content is liquid, this is the source version of the liquid. std::string liquid_alternative_source; + content_t liquid_alternative_source_id; // Viscosity for fluid flow, ranging from 1 to 7, with // 1 giving almost instantaneous propagation and 7 being // the slowest possible @@ -248,25 +394,29 @@ struct ContentFeatures // Number of flowing liquids surrounding source u8 liquid_range; u8 drowning; - // Amount of light the node emits - u8 light_source; - u32 damage_per_second; + // Liquids flow into and replace node + bool floodable; + + // --- NODEBOXES --- + NodeBox node_box; NodeBox selection_box; NodeBox collision_box; - // Used for waving leaves/plants - u8 waving; + + // --- SOUND PROPERTIES --- + + SimpleSoundSpec sound_footstep; + SimpleSoundSpec sound_dig; + SimpleSoundSpec sound_dug; + + // --- LEGACY --- + // Compatibility with old maps // Set to true if paramtype used to be 'facedir_simple' bool legacy_facedir_simple; // Set to true if wall_mounted used to be set to true bool legacy_wallmounted; - // Sound properties - SimpleSoundSpec sound_footstep; - SimpleSoundSpec sound_dig; - SimpleSoundSpec sound_dug; - /* Methods */ @@ -276,118 +426,415 @@ struct ContentFeatures void reset(); void serialize(std::ostream &os, u16 protocol_version) const; void deSerialize(std::istream &is); - void serializeOld(std::ostream &os, u16 protocol_version) const; - void deSerializeOld(std::istream &is, int version); /* Some handy methods */ + void setDefaultAlphaMode() + { + switch (drawtype) { + case NDT_NORMAL: + case NDT_LIQUID: + case NDT_FLOWINGLIQUID: + alpha = ALPHAMODE_OPAQUE; + break; + case NDT_NODEBOX: + case NDT_MESH: + alpha = ALPHAMODE_LEGACY_COMPAT; // this should eventually be OPAQUE + break; + default: + alpha = ALPHAMODE_CLIP; + break; + } + } + + bool needsBackfaceCulling() const + { + switch (drawtype) { + case NDT_TORCHLIKE: + case NDT_SIGNLIKE: + case NDT_FIRELIKE: + case NDT_RAILLIKE: + case NDT_PLANTLIKE: + case NDT_PLANTLIKE_ROOTED: + case NDT_MESH: + return false; + default: + return true; + } + } + bool isLiquid() const{ return (liquid_type != LIQUID_NONE); } bool sameLiquid(const ContentFeatures &f) const{ if(!isLiquid() || !f.isLiquid()) return false; - return (liquid_alternative_flowing == f.liquid_alternative_flowing); + return (liquid_alternative_flowing_id == f.liquid_alternative_flowing_id); } -}; -class INodeDefManager { -public: - INodeDefManager(){} - virtual ~INodeDefManager(){} - // Get node definition - virtual const ContentFeatures &get(content_t c) const=0; - virtual const ContentFeatures &get(const MapNode &n) const=0; - virtual bool getId(const std::string &name, content_t &result) const=0; - virtual content_t getId(const std::string &name) const=0; - // Allows "group:name" in addition to regular node names - virtual void getIds(const std::string &name, std::set &result) - const=0; - virtual const ContentFeatures &get(const std::string &name) const=0; - - virtual void serialize(std::ostream &os, u16 protocol_version) const=0; - - virtual bool getNodeRegistrationStatus() const=0; - - virtual void pendNodeResolve(NodeResolver *nr)=0; - virtual bool cancelNodeResolveCallback(NodeResolver *nr)=0; + int getGroup(const std::string &group) const + { + return itemgroup_get(groups, group); + } + +#ifndef SERVER + void updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc, + scene::IMeshManipulator *meshmanip, Client *client, const TextureSettings &tsettings); +#endif + +private: +#ifndef SERVER + /* + * Checks if any tile texture has any transparent pixels. + * Prints a warning and returns true if that is the case, false otherwise. + * This is supposed to be used for use_texture_alpha backwards compatibility. + */ + bool textureAlphaCheck(ITextureSource *tsrc, const TileDef *tiles, + int length); +#endif + + void setAlphaFromLegacy(u8 legacy_alpha); + + u8 getAlphaForLegacy() const; }; -class IWritableNodeDefManager : public INodeDefManager { +/*! + * @brief This class is for getting the actual properties of nodes from their + * content ID. + * + * @details The nodes on the map are represented by three numbers (see MapNode). + * The first number (param0) is the type of a node. All node types have own + * properties (see ContentFeatures). This class is for storing and getting the + * properties of nodes. + * The manager is first filled with registered nodes, then as the game begins, + * functions only get `const` pointers to it, to prevent modification of + * registered nodes. + */ +class NodeDefManager { public: - IWritableNodeDefManager(){} - virtual ~IWritableNodeDefManager(){} - virtual IWritableNodeDefManager* clone()=0; - // Get node definition - virtual const ContentFeatures &get(content_t c) const=0; - virtual const ContentFeatures &get(const MapNode &n) const=0; - virtual bool getId(const std::string &name, content_t &result) const=0; - // If not found, returns CONTENT_IGNORE - virtual content_t getId(const std::string &name) const=0; - // Allows "group:name" in addition to regular node names - virtual void getIds(const std::string &name, std::set &result) - const=0; - // If not found, returns the features of CONTENT_UNKNOWN - virtual const ContentFeatures &get(const std::string &name) const=0; - - // Register node definition by name (allocate an id) - // If returns CONTENT_IGNORE, could not allocate id - virtual content_t set(const std::string &name, - const ContentFeatures &def)=0; - // If returns CONTENT_IGNORE, could not allocate id - virtual content_t allocateDummy(const std::string &name)=0; + /*! + * Creates a NodeDefManager, and registers three ContentFeatures: + * \ref CONTENT_AIR, \ref CONTENT_UNKNOWN and \ref CONTENT_IGNORE. + */ + NodeDefManager(); + ~NodeDefManager(); + + /*! + * Returns the properties for the given content type. + * @param c content type of a node + * @return properties of the given content type, or \ref CONTENT_UNKNOWN + * if the given content type is not registered. + */ + inline const ContentFeatures& get(content_t c) const { + return + c < m_content_features.size() ? + m_content_features[c] : m_content_features[CONTENT_UNKNOWN]; + } - /* - Update item alias mapping. - Call after updating item definitions. - */ - virtual void updateAliases(IItemDefManager *idef)=0; + /*! + * Returns the properties of the given node. + * @param n a map node + * @return properties of the given node or @ref CONTENT_UNKNOWN if the + * given content type is not registered. + */ + inline const ContentFeatures& get(const MapNode &n) const { + return get(n.getContent()); + } - /* - Override textures from servers with ones specified in texturepack/override.txt - */ - virtual void applyTextureOverrides(const std::string &override_filepath)=0; + /*! + * Returns the node properties for a node name. + * @param name name of a node + * @return properties of the given node or @ref CONTENT_UNKNOWN if + * not found + */ + const ContentFeatures& get(const std::string &name) const; + + /*! + * Returns the content ID for the given name. + * @param name a node name + * @param[out] result will contain the content ID if found, otherwise + * remains unchanged + * @return true if the ID was found, false otherwise + */ + bool getId(const std::string &name, content_t &result) const; + + /*! + * Returns the content ID for the given name. + * @param name a node name + * @return ID of the node or @ref CONTENT_IGNORE if not found + */ + content_t getId(const std::string &name) const; + + /*! + * Returns the content IDs of the given node name or node group name. + * Group names start with "group:". + * @param name a node name or node group name + * @param[out] result will be appended with matching IDs + * @return true if `name` is a valid node name or a (not necessarily + * valid) group name + */ + bool getIds(const std::string &name, std::vector &result) const; + + /*! + * Returns the smallest box in integer node coordinates that + * contains all nodes' selection boxes. The returned box might be larger + * than the minimal size if the largest node is removed from the manager. + */ + inline core::aabbox3d getSelectionBoxIntUnion() const { + return m_selection_box_int_union; + } - /* - Update tile textures to latest return values of TextueSource. - */ - virtual void updateTextures(IGameDef *gamedef, + /*! + * Checks whether a node connects to an adjacent node. + * @param from the node to be checked + * @param to the adjacent node + * @param connect_face a bit field indicating which face of the node is + * adjacent to the other node. + * Bits: +y (least significant), -y, -z, -x, +z, +x (most significant). + * @return true if the node connects, false otherwise + */ + bool nodeboxConnects(MapNode from, MapNode to, + u8 connect_face) const; + + /*! + * Registers a NodeResolver to wait for the registration of + * ContentFeatures. Once the node registration finishes, all + * listeners are notified. + */ + void pendNodeResolve(NodeResolver *nr) const; + + /*! + * Stops listening to the NodeDefManager. + * @return true if the listener was registered before, false otherwise + */ + bool cancelNodeResolveCallback(NodeResolver *nr) const; + + /*! + * Registers a new node type with the given name and allocates a new + * content ID. + * Should not be called with an already existing name. + * @param name name of the node, must match with `def.name`. + * @param def definition of the registered node type. + * @return ID of the registered node or @ref CONTENT_IGNORE if + * the function could not allocate an ID. + */ + content_t set(const std::string &name, const ContentFeatures &def); + + /*! + * Allocates a blank node ID for the given name. + * @param name name of a node + * @return allocated ID or @ref CONTENT_IGNORE if could not allocate + * an ID. + */ + content_t allocateDummy(const std::string &name); + + /*! + * Removes the given node name from the manager. + * The node ID will remain in the manager, but won't be linked to any name. + * @param name name to be removed + */ + void removeNode(const std::string &name); + + /*! + * Regenerates the alias list (a map from names to node IDs). + * @param idef the item definition manager containing alias information + */ + void updateAliases(IItemDefManager *idef); + + /*! + * Replaces the textures of registered nodes with the ones specified in + * the texturepack's override.txt file + * + * @param overrides the texture overrides + */ + void applyTextureOverrides(const std::vector &overrides); + + /*! + * Only the client uses this. Loads textures and shaders required for + * rendering the nodes. + * @param gamedef must be a Client. + * @param progress_cbk called each time a node is loaded. Arguments: + * `progress_cbk_args`, number of loaded ContentFeatures, number of + * total ContentFeatures. + * @param progress_cbk_args passed to the callback function + */ + void updateTextures(IGameDef *gamedef, void (*progress_cbk)(void *progress_args, u32 progress, u32 max_progress), - void *progress_cbk_args)=0; + void *progress_cbk_args); - virtual void serialize(std::ostream &os, u16 protocol_version) const=0; - virtual void deSerialize(std::istream &is)=0; + /*! + * Writes the content of this manager to the given output stream. + * @param protocol_version serialization version of ContentFeatures + */ + void serialize(std::ostream &os, u16 protocol_version) const; + + /*! + * Restores the manager from a serialized stream. + * This clears the previous state. + * @param is input stream containing a serialized NodeDefManager + */ + void deSerialize(std::istream &is); - virtual bool getNodeRegistrationStatus() const=0; - virtual void setNodeRegistrationStatus(bool completed)=0; + /*! + * Used to indicate that node registration has finished. + * @param completed tells whether registration is complete + */ + inline void setNodeRegistrationStatus(bool completed) { + m_node_registration_complete = completed; + } - virtual void pendNodeResolve(NodeResolver *nr)=0; - virtual bool cancelNodeResolveCallback(NodeResolver *nr)=0; - virtual void runNodeResolveCallbacks()=0; - virtual void resetNodeResolveState()=0; + /*! + * Notifies the registered NodeResolver instances that node registration + * has finished, then unregisters all listeners. + * Must be called after node registration has finished! + */ + void runNodeResolveCallbacks(); + + /*! + * Sets the registration completion flag to false and unregisters all + * NodeResolver instances listening to the manager. + */ + void resetNodeResolveState(); + + /*! + * Resolves (caches the IDs) cross-references between nodes, + * like liquid alternatives. + * Must be called after node registration has finished! + */ + void resolveCrossrefs(); + +private: + /*! + * Resets the manager to its initial state. + * See the documentation of the constructor. + */ + void clear(); + + /*! + * Allocates a new content ID, and returns it. + * @return the allocated ID or \ref CONTENT_IGNORE if could not allocate + */ + content_t allocateId(); + + /*! + * Binds the given content ID and node name. + * Registers them in \ref m_name_id_mapping and + * \ref m_name_id_mapping_with_aliases. + * @param i a content ID + * @param name a node name + */ + void addNameIdMapping(content_t i, std::string name); + + /*! + * Removes a content ID from all groups. + * Erases content IDs from vectors in \ref m_group_to_items and + * removes empty vectors. + * @param id Content ID + */ + void eraseIdFromGroups(content_t id); + + /*! + * Recalculates m_selection_box_int_union based on + * m_selection_box_union. + */ + void fixSelectionBoxIntUnion(); + + //! Features indexed by ID. + std::vector m_content_features; + + //! A mapping for fast conversion between names and IDs + NameIdMapping m_name_id_mapping; + + /*! + * Like @ref m_name_id_mapping, but maps only from names to IDs, and + * includes aliases too. Updated by \ref updateAliases(). + * Note: Not serialized. + */ + std::unordered_map m_name_id_mapping_with_aliases; + + /*! + * A mapping from group names to a vector of content types that belong + * to it. Necessary for a direct lookup in \ref getIds(). + * Note: Not serialized. + */ + std::unordered_map> m_group_to_items; + + /*! + * The next ID that might be free to allocate. + * It can be allocated already, because \ref CONTENT_AIR, + * \ref CONTENT_UNKNOWN and \ref CONTENT_IGNORE are registered when the + * manager is initialized, and new IDs are allocated from 0. + */ + content_t m_next_id; + + //! True if all nodes have been registered. + bool m_node_registration_complete; + + /*! + * The union of all nodes' selection boxes. + * Might be larger if big nodes are removed from the manager. + */ + aabb3f m_selection_box_union; + + /*! + * The smallest box in integer node coordinates that + * contains all nodes' selection boxes. + * Might be larger if big nodes are removed from the manager. + */ + core::aabbox3d m_selection_box_int_union; + + /*! + * NodeResolver instances to notify once node registration has finished. + * Even constant NodeDefManager instances can register listeners. + */ + mutable std::vector m_pending_resolve_callbacks; }; -IWritableNodeDefManager *createNodeDefManager(); +NodeDefManager *createNodeDefManager(); +// NodeResolver: Queue for node names which are then translated +// to content_t after the NodeDefManager was initialized class NodeResolver { public: NodeResolver(); virtual ~NodeResolver(); + // Callback which is run as soon NodeDefManager is ready virtual void resolveNodeNames() = 0; + // required because this class is used as mixin for ObjDef + void cloneTo(NodeResolver *res) const; + bool getIdFromNrBacklog(content_t *result_out, - const std::string &node_alt, content_t c_fallback); + const std::string &node_alt, content_t c_fallback, + bool error_on_fallback = true); bool getIdsFromNrBacklog(std::vector *result_out, - bool all_required=false, content_t c_fallback=CONTENT_IGNORE); + bool all_required = false, content_t c_fallback = CONTENT_IGNORE); - void nodeResolveInternal(); + inline bool isResolveDone() const { return m_resolve_done; } + void reset(bool resolve_done = false); - u32 m_nodenames_idx; - u32 m_nnlistsizes_idx; + // Vector containing all node names in the resolve "queue" std::vector m_nodenames; + // Specifies the "set size" of node names which are to be processed + // this is used for getIdsFromNrBacklog + // TODO: replace or remove std::vector m_nnlistsizes; - INodeDefManager *m_ndef; - bool m_resolve_done; -}; +protected: + friend class NodeDefManager; // m_ndef + + const NodeDefManager *m_ndef = nullptr; + // Index of the next "m_nodenames" entry to resolve + u32 m_nodenames_idx = 0; + +private: +#if BUILD_UNITTESTS + // Unittest requires access to m_resolve_done + friend class TestSchematic; #endif + void nodeResolveInternal(); + + // Index of the next "m_nnlistsizes" entry to process + u32 m_nnlistsizes_idx = 0; + bool m_resolve_done = false; +};