X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=sidebyside;f=src%2Fnodedef.h;h=0fce6eab14a3f59ed9acb290cfc3ac5b285c08f1;hb=6e1372bd894d955300c40d69e5c882e9cc7d7523;hp=97697e746dd6a6d0fc7077bfb3caf727929afd21;hpb=4faaadc8d50d6ab7a19d22bd5a760c4b8321a51f;p=minetest.git diff --git a/src/nodedef.h b/src/nodedef.h index 97697e746..0fce6eab1 100644 --- a/src/nodedef.h +++ b/src/nodedef.h @@ -17,35 +17,34 @@ 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" -class INodeDefManager; +// PROTOCOL_VERSION >= 37 +static const u8 CONTENTFEATURES_VERSION = 13; + class IItemDefManager; class ITextureSource; class IShaderSource; class IGameDef; class NodeResolver; -typedef std::list > GroupItems; - enum ContentParamType { CPT_NONE, @@ -112,6 +111,14 @@ struct NodeBox 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(); } @@ -130,16 +137,32 @@ enum LeavesStyle { LEAVES_OPAQUE, }; +enum AutoScale : u8 { + AUTOSCALE_DISABLE, + AUTOSCALE_ENABLE, + AUTOSCALE_FORCE, +}; + +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 use_normal_texture; bool enable_mesh_cache; bool enable_minimap; - TextureSettings() {} + TextureSettings() = default; void readSettings(); }; @@ -186,6 +209,8 @@ enum NodeDrawType NDT_GLASSLIKE_FRAMED_OPTIONAL, // Uses static meshes NDT_MESH, + // Combined plantlike-on-solid + NDT_PLANTLIKE_ROOTED, }; // Mesh options for NDT_PLANTLIKE with CPT2_MESHOPTIONS @@ -201,6 +226,12 @@ enum PlantlikeStyle { PLANT_STYLE_HASH2, }; +enum AlignStyle : u8 { + ALIGN_STYLE_NODE, + ALIGN_STYLE_WORLD, + ALIGN_STYLE_USER_DEFINED, +}; + /* Stand-alone definition of a TileSpec (basically a server-side TileSpec) */ @@ -215,6 +246,8 @@ struct TileDef 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; @@ -224,7 +257,8 @@ struct TileDef } void serialize(std::ostream &os, u16 protocol_version) const; - void deSerialize(std::istream &is, const u8 contentfeatures_version, const NodeDrawType drawtype); + void deSerialize(std::istream &is, u8 contentfeatures_version, + NodeDrawType drawtype); }; #define CF_SPECIAL_COUNT 6 @@ -289,7 +323,7 @@ struct ContentFeatures // for NDT_CONNECTED pairing u8 connect_sides; std::vector connects_to; - std::set connects_to_ids; + std::vector connects_to_ids; // Post effect color, drawn when the camera is inside the node. video::SColor post_effect_color; // Flowing liquid or snow, value = default level @@ -323,6 +357,8 @@ struct ContentFeatures // Player cannot build to these (placement prediction disabled) bool rightclickable; u32 damage_per_second; + // client dig prediction + std::string node_dig_prediction; // --- LIQUID PROPERTIES --- @@ -369,12 +405,10 @@ struct ContentFeatures */ ContentFeatures(); - ~ContentFeatures(); + ~ContentFeatures() = default; 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); /*! * Since vertex alpha is no longer supported, this method * adds opacity directly to the texture pixels. @@ -401,99 +435,303 @@ struct ContentFeatures } #ifndef SERVER - void fillTileAttribs(ITextureSource *tsrc, TileLayer *tile, TileDef *tiledef, - u32 shader_id, bool use_normal_texture, bool backface_culling, - u8 material_type); void updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc, scene::IMeshManipulator *meshmanip, Client *client, const TextureSettings &tsettings); #endif }; -class 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: - 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 - // returns false if node name not found, true otherwise - virtual bool 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 void pendNodeResolve(NodeResolver *nr)=0; - virtual bool cancelNodeResolveCallback(NodeResolver *nr)=0; - virtual bool nodeboxConnects(const MapNode from, const MapNode to, u8 connect_face)=0; - /*! - * Returns the smallest box in node coordinates that - * contains all nodes' selection boxes. + /*! + * Creates a NodeDefManager, and registers three ContentFeatures: + * \ref CONTENT_AIR, \ref CONTENT_UNKNOWN and \ref CONTENT_IGNORE. */ - virtual core::aabbox3d getSelectionBoxIntUnion() const=0; -}; + NodeDefManager(); + ~NodeDefManager(); -class IWritableNodeDefManager : public INodeDefManager { -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 bool 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; - // Remove a node - virtual void removeNode(const std::string &name)=0; + /*! + * 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; - /* - Update tile textures to latest return values of TextueSource. - */ - virtual void updateTextures(IGameDef *gamedef, + /*! + * 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; + } + + /*! + * 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); + + /*! + * 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); + + /*! + * 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; + } + + /*! + * 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 the IDs to which connecting nodes connect from names. + * Must be called after node registration has finished! + */ + void mapNodeboxConnections(); + +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(); - virtual void serialize(std::ostream &os, u16 protocol_version) const=0; - virtual void deSerialize(std::istream &is)=0; + /*! + * 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(); - virtual void setNodeRegistrationStatus(bool completed)=0; + //! Features indexed by ID. + std::vector m_content_features; - virtual void pendNodeResolve(NodeResolver *nr)=0; - virtual bool cancelNodeResolveCallback(NodeResolver *nr)=0; - virtual void runNodeResolveCallbacks()=0; - virtual void resetNodeResolveState()=0; - virtual void mapNodeboxConnections()=0; - virtual core::aabbox3d getSelectionBoxIntUnion() const=0; + //! 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(); class NodeResolver { public: @@ -501,10 +739,14 @@ class NodeResolver { virtual ~NodeResolver(); 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(); @@ -512,8 +754,6 @@ class NodeResolver { u32 m_nnlistsizes_idx = 0; std::vector m_nodenames; std::vector m_nnlistsizes; - INodeDefManager *m_ndef = nullptr; + const NodeDefManager *m_ndef = nullptr; bool m_resolve_done = false; }; - -#endif