Modernize client code (#6250)

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

diff --git a/src/itemdef.cpp b/src/itemdef.cpp
index 627ad1b6c45164a7e57d6999b39d6978bb3bf1dc..e73246115acaa04942fd42af70057d444965c731 100644 (file)
--- a/src/itemdef.cpp
+++ b/src/itemdef.cpp
@@ -82,6 +82,8 @@ ItemDefinition& ItemDefinition::operator=(const ItemDefinition &def)
        sound_place = def.sound_place;
        sound_place_failed = def.sound_place_failed;
        range = def.range;
+       palette_image = def.palette_image;
+       color = def.color;
        return *this;
 }
 
@@ -104,15 +106,14 @@ void ItemDefinition::reset()
        description = "";
        inventory_image = "";
        wield_image = "";
+       palette_image = "";
+       color = video::SColor(0xFFFFFFFF);
        wield_scale = v3f(1.0, 1.0, 1.0);
        stack_max = 99;
        usable = false;
        liquids_pointable = false;
-       if(tool_capabilities)
-       {
-               delete tool_capabilities;
-               tool_capabilities = NULL;
-       }
+       delete tool_capabilities;
+       tool_capabilities = NULL;
        groups.clear();
        sound_place = SimpleSoundSpec();
        sound_place_failed = SimpleSoundSpec();
@@ -123,8 +124,8 @@ void ItemDefinition::reset()
 
 void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
 {
-
-       writeU8(os, 3); // version (proto > 20)
+       u8 version = (protocol_version >= 34) ? 4 : 3;
+       writeU8(os, version);
        writeU8(os, type);
        os << serializeString(name);
        os << serializeString(description);
@@ -153,6 +154,13 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
        writeF1000(os, range);
        os << serializeString(sound_place_failed.name);
        writeF1000(os, sound_place_failed.gain);
+       os << serializeString(palette_image);
+       writeU32(os, color.color);
+
+       if (version >= 4) {
+               writeF1000(os, sound_place.pitch);
+               writeF1000(os, sound_place_failed.pitch);
+       }
 }
 
 void ItemDefinition::deSerialize(std::istream &is)
@@ -162,7 +170,7 @@ void ItemDefinition::deSerialize(std::istream &is)
 
        // Deserialize
        int version = readU8(is);
-       if(version < 1 || version > 3)
+       if (version < 1 || version > 4)
                throw SerializationError("unsupported ItemDefinition version");
        type = (enum ItemType)readU8(is);
        name = deSerializeString(is);
@@ -201,7 +209,7 @@ void ItemDefinition::deSerialize(std::istream &is)
                sound_place.name = deSerializeString(is);
                sound_place.gain = readF1000(is);
        }
-       if(version == 3) {
+       if(version >= 3) {
                range = readF1000(is);
        }
        // If you add anything here, insert it primarily inside the try-catch
@@ -209,6 +217,13 @@ void ItemDefinition::deSerialize(std::istream &is)
        try {
                sound_place_failed.name = deSerializeString(is);
                sound_place_failed.gain = readF1000(is);
+               palette_image = deSerializeString(is);
+               color.set(readU32(is));
+
+               if (version >= 4) {
+                       sound_place.pitch = readF1000(is);
+                       sound_place_failed.pitch = readF1000(is);
+               }
        } catch(SerializationError &e) {};
 }
 
@@ -224,11 +239,13 @@ class CItemDefManager: public IWritableItemDefManager
        struct ClientCached
        {
                video::ITexture *inventory_texture;
-               scene::IMesh *wield_mesh;
+               ItemMesh wield_mesh;
+               Palette *palette;
 
                ClientCached():
                        inventory_texture(NULL),
-                       wield_mesh(NULL)
+                       wield_mesh(),
+                       palette(NULL)
                {}
        };
 #endif
@@ -238,7 +255,7 @@ public:
        {
 
 #ifndef SERVER
-               m_main_thread = thr_get_current_thread_id();
+               m_main_thread = std::this_thread::get_id();
 #endif
                clear();
        }
@@ -250,8 +267,8 @@ public:
                                i = values.begin(); i != values.end(); ++i)
                {
                        ClientCached *cc = *i;
-                       if (cc->wield_mesh)
-                               cc->wield_mesh->drop();
+                       if (cc->wield_mesh.mesh)
+                               cc->wield_mesh.mesh->drop();
                        delete cc;
                }
 
@@ -313,7 +330,7 @@ public:
                                <<name<<"\""<<std::endl;
 
                // This is not thread-safe
-               sanity_check(thr_is_current_thread(m_main_thread));
+               sanity_check(std::this_thread::get_id() == m_main_thread);
 
                // Skip if already in cache
                ClientCached *cc = NULL;
@@ -335,8 +352,9 @@ public:
                ItemStack item = ItemStack();
                item.name = def.name;
 
-               scene::IMesh *mesh = getItemMesh(client, item);
-               cc->wield_mesh = mesh;
+               getItemMesh(client, item, &(cc->wield_mesh));
+
+               cc->palette = tsrc->getPalette(def.palette_image);
 
                // Put in cache
                m_clientcached.set(name, cc);
@@ -348,15 +366,12 @@ public:
        {
                ClientCached *cc = NULL;
                m_clientcached.get(name, &cc);
-               if(cc)
+               if (cc)
                        return cc;
 
-               if(thr_is_current_thread(m_main_thread))
-               {
+               if (std::this_thread::get_id() == m_main_thread) {
                        return createClientCachedDirect(name, client);
-               }
-               else
-               {
+               } else {
                        // We're gonna ask the result to be put into here
                        static ResultQueue<std::string, ClientCached*, u8, u8> result_queue;
 
@@ -390,13 +405,41 @@ public:
                return cc->inventory_texture;
        }
        // Get item wield mesh
-       virtual scene::IMesh* getWieldMesh(const std::string &name,
+       virtual ItemMesh* getWieldMesh(const std::string &name,
+                       Client *client) const
+       {
+               ClientCached *cc = getClientCached(name, client);
+               if(!cc)
+                       return NULL;
+               return &(cc->wield_mesh);
+       }
+
+       // Get item palette
+       virtual Palette* getPalette(const std::string &name,
                        Client *client) const
        {
                ClientCached *cc = getClientCached(name, client);
                if(!cc)
                        return NULL;
-               return cc->wield_mesh;
+               return cc->palette;
+       }
+
+       virtual video::SColor getItemstackColor(const ItemStack &stack,
+               Client *client) const
+       {
+               // Look for direct color definition
+               const std::string &colorstring = stack.metadata.getString("color", 0);
+               video::SColor directcolor;
+               if ((colorstring != "")
+                               && parseColorString(colorstring, directcolor, true))
+                       return directcolor;
+               // See if there is a palette
+               Palette *palette = getPalette(stack.name, client);
+               const std::string &index = stack.metadata.getString("palette_index", 0);
+               if ((palette != NULL) && (index != ""))
+                       return (*palette)[mystoi(index, 0, 255)];
+               // Fallback color
+               return get(stack.name).color;
        }
 #endif
        void clear()
@@ -544,7 +587,7 @@ private:
        StringMap m_aliases;
 #ifndef SERVER
        // The id of the thread that is allowed to use irrlicht directly
-       threadid_t m_main_thread;
+       std::thread::id m_main_thread;
        // A reference to this can be returned when nothing is found, to avoid NULLs
        mutable ClientCached m_dummy_clientcached;
        // Cached textures and meshes