]> git.lizzy.rs Git - minetest.git/blobdiff - src/nodedef.cpp
projects / minetest.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[CSM] Add flavour limits controlled by server (#5930)
[minetest.git] / src / nodedef.cpp
diff --git a/src/nodedef.cpp b/src/nodedef.cpp
index 2ac59f8aef798297bfd4ac392174f8486a437aed..6bb2bf9047792cac1c699f1fd86a4f6a89b5f55b 100644 (file)
--- a/src/nodedef.cpp
+++ b/src/nodedef.cpp
@@ -21,9 +21,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "itemdef.h"
 #ifndef SERVER
-#include "client/tile.h"
 #include "mesh.h"
 #include "client.h"
+#include "client/renderingengine.h"
+#include "client/tile.h"
 #include <IMeshManipulator.h>
 #endif
 #include "log.h"
@@ -248,15 +249,21 @@ void TileDef::deSerialize(std::istream &is, const u8 contenfeatures_version, con
 */
 
 static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss,
-               std::ostream &os)
+               std::ostream &os, u8 version)
 {
        os<<serializeString(ss.name);
        writeF1000(os, ss.gain);
+
+       if (version >= 11)
+               writeF1000(os, ss.pitch);
 }
-static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss, std::istream &is)
+static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss, std::istream &is, u8 version)
 {
        ss.name = deSerializeString(is);
        ss.gain = readF1000(is);
+
+       if (version >= 11)
+               ss.pitch = readF1000(is);
 }
 
 void TextureSettings::readSettings()
@@ -384,7 +391,8 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
        }
 
        // version
-       writeU8(os, 10);
+       u8 version = (protocol_version >= 34) ? 11 : 10;
+       writeU8(os, version);
 
        // general
        os << serializeString(name);
@@ -460,9 +468,9 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
        collision_box.serialize(os, protocol_version);
 
        // sound
-       serializeSimpleSoundSpec(sound_footstep, os);
-       serializeSimpleSoundSpec(sound_dig, os);
-       serializeSimpleSoundSpec(sound_dug, os);
+       serializeSimpleSoundSpec(sound_footstep, os, version);
+       serializeSimpleSoundSpec(sound_dig, os, version);
+       serializeSimpleSoundSpec(sound_dug, os, version);
 
        // legacy
        writeU8(os, legacy_facedir_simple);
@@ -491,7 +499,7 @@ void ContentFeatures::deSerialize(std::istream &is)
        if (version < 9) {
                deSerializeOld(is, version);
                return;
-       } else if (version > 10) {
+       } else if (version > 11) {
                throw SerializationError("unsupported ContentFeatures version");
        }
 
@@ -573,9 +581,9 @@ void ContentFeatures::deSerialize(std::istream &is)
        collision_box.deSerialize(is);
 
        // sounds
-       deSerializeSimpleSoundSpec(sound_footstep, is);
-       deSerializeSimpleSoundSpec(sound_dig, is);
-       deSerializeSimpleSoundSpec(sound_dug, is);
+       deSerializeSimpleSoundSpec(sound_footstep, is, version);
+       deSerializeSimpleSoundSpec(sound_dig, is, version);
+       deSerializeSimpleSoundSpec(sound_dug, is, version);
 
        // read legacy properties
        legacy_facedir_simple = readU8(is);
@@ -682,6 +690,8 @@ void ContentFeatures::updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc
        switch (drawtype) {
        default:
        case NDT_NORMAL:
+               material_type = (alpha == 255) ?
+                       TILE_MATERIAL_OPAQUE : TILE_MATERIAL_ALPHA;
                solidness = 2;
                break;
        case NDT_AIRLIKE:
@@ -762,6 +772,9 @@ void ContentFeatures::updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc
        case NDT_RAILLIKE:
                solidness = 0;
                break;
+       case NDT_PLANTLIKE_ROOTED:
+               solidness = 2;
+               break;
        }
 
        if (is_liquid) {
@@ -773,28 +786,41 @@ void ContentFeatures::updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc
                        TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT;
        }
 
-       u32 tile_shader[6];
-       for (u16 j = 0; j < 6; j++) {
-               tile_shader[j] = shdsrc->getShader("nodes_shader",
-                       material_type, drawtype);
-       }
+       u32 tile_shader = shdsrc->getShader("nodes_shader", material_type, drawtype);
+
+       u8 overlay_material = material_type;
+       if (overlay_material == TILE_MATERIAL_OPAQUE)
+               overlay_material = TILE_MATERIAL_BASIC;
+       else if (overlay_material == TILE_MATERIAL_LIQUID_OPAQUE)
+               overlay_material = TILE_MATERIAL_LIQUID_TRANSPARENT;
+
+       u32 overlay_shader = shdsrc->getShader("nodes_shader", overlay_material, drawtype);
 
        // Tiles (fill in f->tiles[])
        for (u16 j = 0; j < 6; j++) {
-               fillTileAttribs(tsrc, &tiles[j].layers[0], &tdef[j], tile_shader[j],
+               fillTileAttribs(tsrc, &tiles[j].layers[0], &tdef[j], tile_shader,
                        tsettings.use_normal_texture,
                        tdef[j].backface_culling, material_type);
                if (tdef_overlay[j].name != "")
                        fillTileAttribs(tsrc, &tiles[j].layers[1], &tdef_overlay[j],
-                               tile_shader[j], tsettings.use_normal_texture,
-                               tdef[j].backface_culling, material_type);
+                               overlay_shader, tsettings.use_normal_texture,
+                               tdef[j].backface_culling, overlay_material);
        }
 
+       u8 special_material = material_type;
+       if (drawtype == NDT_PLANTLIKE_ROOTED) {
+               if (waving == 1)
+                       special_material = TILE_MATERIAL_WAVING_PLANTS;
+               else if (waving == 2)
+                       special_material = TILE_MATERIAL_WAVING_LEAVES;
+       }
+       u32 special_shader = shdsrc->getShader("nodes_shader", special_material, drawtype);
+
        // Special tiles (fill in f->special_tiles[])
        for (u16 j = 0; j < CF_SPECIAL_COUNT; j++) {
                fillTileAttribs(tsrc, &special_tiles[j].layers[0], &tdef_spec[j],
-                       tile_shader[j], tsettings.use_normal_texture,
-                       tdef_spec[j].backface_culling, material_type);
+                       special_shader, tsettings.use_normal_texture,
+                       tdef_spec[j].backface_culling, special_material);
        }
 
        if (param_type_2 == CPT2_COLOR ||
@@ -881,7 +907,6 @@ class CNodeDefManager: public IWritableNodeDefManager {
        void serialize(std::ostream &os, u16 protocol_version) const;
        void deSerialize(std::istream &is);
 
-       inline virtual bool getNodeRegistrationStatus() const;
        inline virtual void setNodeRegistrationStatus(bool completed);
 
        virtual void pendNodeResolve(NodeResolver *nr);
@@ -913,12 +938,12 @@ class CNodeDefManager: public IWritableNodeDefManager {
        // item aliases too. Updated by updateAliases()
        // Note: Not serialized.
 
-       UNORDERED_MAP<std::string, content_t> m_name_id_mapping_with_aliases;
+       std::unordered_map<std::string, content_t> m_name_id_mapping_with_aliases;
 
        // A mapping from groups to a list of content_ts (and their levels)
        // that belong to it.  Necessary for a direct lookup in getIds().
        // Note: Not serialized.
-       UNORDERED_MAP<std::string, GroupItems> m_group_to_items;
+       std::unordered_map<std::string, GroupItems> m_group_to_items;
 
        // Next possibly free id
        content_t m_next_id;
@@ -1051,7 +1076,7 @@ inline const ContentFeatures& CNodeDefManager::get(const MapNode &n) const
 
 bool CNodeDefManager::getId(const std::string &name, content_t &result) const
 {
-       UNORDERED_MAP<std::string, content_t>::const_iterator
+       std::unordered_map<std::string, content_t>::const_iterator
                i = m_name_id_mapping_with_aliases.find(name);
        if(i == m_name_id_mapping_with_aliases.end())
                return false;
@@ -1081,7 +1106,7 @@ bool CNodeDefManager::getIds(const std::string &name,
        }
        std::string group = name.substr(6);
 
-       UNORDERED_MAP<std::string, GroupItems>::const_iterator
+       std::unordered_map<std::string, GroupItems>::const_iterator
                i = m_group_to_items.find(group);
        if (i == m_group_to_items.end())
                return true;
@@ -1283,7 +1308,7 @@ content_t CNodeDefManager::set(const std::string &name, const ContentFeatures &d
                i != def.groups.end(); ++i) {
                std::string group_name = i->first;
 
-               UNORDERED_MAP<std::string, GroupItems>::iterator
+               std::unordered_map<std::string, GroupItems>::iterator
                        j = m_group_to_items.find(group_name);
                if (j == m_group_to_items.end()) {
                        m_group_to_items[group_name].push_back(
@@ -1319,7 +1344,7 @@ void CNodeDefManager::removeNode(const std::string &name)
        }
 
        // Erase node content from all groups it belongs to
-       for (UNORDERED_MAP<std::string, GroupItems>::iterator iter_groups =
+       for (std::unordered_map<std::string, GroupItems>::iterator iter_groups =
                        m_group_to_items.begin(); iter_groups != m_group_to_items.end();) {
                GroupItems &items = iter_groups->second;
                for (GroupItems::iterator iter_groupitems = items.begin();
@@ -1421,8 +1446,8 @@ void CNodeDefManager::updateTextures(IGameDef *gamedef,
        Client *client = (Client *)gamedef;
        ITextureSource *tsrc = client->tsrc();
        IShaderSource *shdsrc = client->getShaderSource();
-       scene::ISceneManager* smgr = client->getSceneManager();
-       scene::IMeshManipulator* meshmanip = smgr->getMeshManipulator();
+       scene::IMeshManipulator *meshmanip =
+               RenderingEngine::get_scene_manager()->getMeshManipulator();
        TextureSettings tsettings;
        tsettings.readSettings();
 
@@ -1605,9 +1630,9 @@ void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) const
                selection_box.serialize(os, protocol_version);
                writeU8(os, legacy_facedir_simple);
                writeU8(os, legacy_wallmounted);
-               serializeSimpleSoundSpec(sound_footstep, os);
-               serializeSimpleSoundSpec(sound_dig, os);
-               serializeSimpleSoundSpec(sound_dug, os);
+               serializeSimpleSoundSpec(sound_footstep, os, 10);
+               serializeSimpleSoundSpec(sound_dig, os, 10);
+               serializeSimpleSoundSpec(sound_dug, os, 10);
                writeU8(os, rightclickable);
                writeU8(os, drowning);
                writeU8(os, leveled);
@@ -1677,9 +1702,9 @@ void ContentFeatures::deSerializeOld(std::istream &is, int version)
                selection_box.deSerialize(is);
                legacy_facedir_simple = readU8(is);
                legacy_wallmounted = readU8(is);
-               deSerializeSimpleSoundSpec(sound_footstep, is);
-               deSerializeSimpleSoundSpec(sound_dig, is);
-               deSerializeSimpleSoundSpec(sound_dug, is);
+               deSerializeSimpleSoundSpec(sound_footstep, is, version);
+               deSerializeSimpleSoundSpec(sound_dig, is, version);
+               deSerializeSimpleSoundSpec(sound_dug, is, version);
        } else if (version == 6) {
                name = deSerializeString(is);
                groups.clear();
@@ -1727,9 +1752,9 @@ void ContentFeatures::deSerializeOld(std::istream &is, int version)
                selection_box.deSerialize(is);
                legacy_facedir_simple = readU8(is);
                legacy_wallmounted = readU8(is);
-               deSerializeSimpleSoundSpec(sound_footstep, is);
-               deSerializeSimpleSoundSpec(sound_dig, is);
-               deSerializeSimpleSoundSpec(sound_dug, is);
+               deSerializeSimpleSoundSpec(sound_footstep, is, version);
+               deSerializeSimpleSoundSpec(sound_dig, is, version);
+               deSerializeSimpleSoundSpec(sound_dug, is, version);
                rightclickable = readU8(is);
                drowning = readU8(is);
                leveled = readU8(is);
@@ -1782,9 +1807,9 @@ void ContentFeatures::deSerializeOld(std::istream &is, int version)
                selection_box.deSerialize(is);
                legacy_facedir_simple = readU8(is);
                legacy_wallmounted = readU8(is);
-               deSerializeSimpleSoundSpec(sound_footstep, is);
-               deSerializeSimpleSoundSpec(sound_dig, is);
-               deSerializeSimpleSoundSpec(sound_dug, is);
+               deSerializeSimpleSoundSpec(sound_footstep, is, version);
+               deSerializeSimpleSoundSpec(sound_dig, is, version);
+               deSerializeSimpleSoundSpec(sound_dug, is, version);
                rightclickable = readU8(is);
                drowning = readU8(is);
                leveled = readU8(is);
@@ -1805,13 +1830,6 @@ void ContentFeatures::deSerializeOld(std::istream &is, int version)
        }
 }
 
-
-inline bool CNodeDefManager::getNodeRegistrationStatus() const
-{
-       return m_node_registration_complete;
-}
-
-
 inline void CNodeDefManager::setNodeRegistrationStatus(bool completed)
 {
        m_node_registration_complete = completed;
@@ -1924,11 +1942,6 @@ bool CNodeDefManager::nodeboxConnects(MapNode from, MapNode to, u8 connect_face)
 
 NodeResolver::NodeResolver()
 {
-       m_ndef            = NULL;
-       m_nodenames_idx   = 0;
-       m_nnlistsizes_idx = 0;
-       m_resolve_done    = false;
-
        m_nodenames.reserve(16);
        m_nnlistsizes.reserve(4);
 }
Minetest is an open source voxel game engine with easy modding and game creation