Code modernization: src/m* (part 2)

[oweals/minetest.git] / src / nodedef.cpp

diff --git a/src/nodedef.cpp b/src/nodedef.cpp
index 6b2718636cde7d143c9a56ad9f12946b9347c8bc..651418cd80c46029020f29c1563b46098d6b3e9b 100644 (file)
--- a/src/nodedef.cpp
+++ b/src/nodedef.cpp
@@ -21,9 +21,11 @@ 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 "shader.h"
 #include "client.h"
+#include "client/renderingengine.h"
+#include "client/tile.h"
 #include <IMeshManipulator.h>
 #endif
 #include "log.h"
@@ -248,15 +250,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 +392,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 +469,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 +500,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 +582,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);
@@ -629,7 +638,10 @@ void ContentFeatures::fillTileAttribs(ITextureSource *tsrc, TileLayer *tile,
                tile->material_flags &= ~MATERIAL_FLAG_ANIMATION;
        } else {
                std::ostringstream os(std::ios::binary);
-               tile->frames.resize(frame_count);
+               if (!tile->frames) {
+                       tile->frames = std::make_shared<std::vector<FrameSpec>>();
+               }
+               tile->frames->resize(frame_count);
 
                for (int i = 0; i < frame_count; i++) {
 
@@ -644,7 +656,7 @@ void ContentFeatures::fillTileAttribs(ITextureSource *tsrc, TileLayer *tile,
                        if (tile->normal_texture)
                                frame.normal_texture = tsrc->getNormalTexture(os.str());
                        frame.flags_texture = tile->flags_texture;
-                       tile->frames[i] = frame;
+                       (*tile->frames)[i] = frame;
                }
        }
 }
@@ -682,6 +694,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 +776,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 +790,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 ||
@@ -1420,8 +1450,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();
 
@@ -1604,9 +1634,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);
@@ -1676,9 +1706,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();
@@ -1726,9 +1756,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);
@@ -1781,9 +1811,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);
@@ -1916,11 +1946,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);
 }