X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fitemdef.cpp;h=e7e4948a3eaea64c24e89643eac57b6f42e870bb;hb=925309eba69a95bcd2a49233125ce32e530fa663;hp=381773bb4b1e3c95a6a16d408556dd91238b7e2d;hpb=0d1eedcccc8b83fd5f5a9a75389fe8ac97d2c697;p=minetest.git diff --git a/src/itemdef.cpp b/src/itemdef.cpp index 381773bb4..e7e4948a3 100644 --- a/src/itemdef.cpp +++ b/src/itemdef.cpp @@ -20,18 +20,17 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "itemdef.h" -#include "gamedef.h" #include "nodedef.h" #include "tool.h" #include "inventory.h" #ifndef SERVER -#include "mapblock_mesh.h" -#include "mesh.h" -#include "wieldmesh.h" +#include "client/mapblock_mesh.h" +#include "client/mesh.h" +#include "client/wieldmesh.h" #include "client/tile.h" +#include "client/client.h" #endif #include "log.h" -#include "main.h" // g_settings #include "settings.h" #include "util/serialize.h" #include "util/container.h" @@ -39,10 +38,6 @@ with this program; if not, write to the Free Software Foundation, Inc., #include #include -#ifdef __ANDROID__ -#include -#endif - /* ItemDefinition */ @@ -67,21 +62,29 @@ ItemDefinition& ItemDefinition::operator=(const ItemDefinition &def) type = def.type; name = def.name; description = def.description; + short_description = def.short_description; inventory_image = def.inventory_image; + inventory_overlay = def.inventory_overlay; wield_image = def.wield_image; + wield_overlay = def.wield_overlay; wield_scale = def.wield_scale; stack_max = def.stack_max; usable = def.usable; liquids_pointable = def.liquids_pointable; - if(def.tool_capabilities) - { - tool_capabilities = new ToolCapabilities( - *def.tool_capabilities); - } + if (def.tool_capabilities) + tool_capabilities = new ToolCapabilities(*def.tool_capabilities); groups = def.groups; node_placement_prediction = def.node_placement_prediction; + place_param2 = def.place_param2; + has_on_place = def.has_on_place; + has_on_secondary_use = def.has_on_secondary_use; sound_place = def.sound_place; + sound_place_failed = def.sound_place_failed; + sound_use = def.sound_use; + sound_use_air = def.sound_use_air; range = def.range; + palette_image = def.palette_image; + color = def.color; return *this; } @@ -100,122 +103,147 @@ void ItemDefinition::resetInitial() void ItemDefinition::reset() { type = ITEM_NONE; - name = ""; - description = ""; - inventory_image = ""; - wield_image = ""; + name.clear(); + description.clear(); + short_description.clear(); + inventory_image.clear(); + inventory_overlay.clear(); + wield_image.clear(); + wield_overlay.clear(); + palette_image.clear(); + 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(); + sound_use = SimpleSoundSpec(); + sound_use_air = SimpleSoundSpec(); range = -1; - - node_placement_prediction = ""; + node_placement_prediction.clear(); + place_param2 = 0; + has_on_place = false; + has_on_secondary_use = false; } void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const { - if(protocol_version <= 17) - writeU8(os, 1); // version - else if(protocol_version <= 20) - writeU8(os, 2); // version - else - writeU8(os, 3); // version + // protocol_version >= 37 + u8 version = 6; + writeU8(os, version); writeU8(os, type); - os<serialize(tmp_os, protocol_version); tool_capabilities_s = tmp_os.str(); } - os<::const_iterator - i = groups.begin(); i != groups.end(); i++){ - os<first); - writeS16(os, i->second); - } - os< 17){ - //serializeSimpleSoundSpec(sound_place, os); - os< 20){ - writeF1000(os, range); + for (const auto &group : groups) { + os << serializeString16(group.first); + writeS16(os, group.second); } + + os << serializeString16(node_placement_prediction); + + // Version from ContentFeatures::serialize to keep in sync + sound_place.serialize(os, protocol_version); + sound_place_failed.serialize(os, protocol_version); + + writeF32(os, range); + os << serializeString16(palette_image); + writeARGB8(os, color); + os << serializeString16(inventory_overlay); + os << serializeString16(wield_overlay); + + os << serializeString16(short_description); + + os << place_param2; + + sound_use.serialize(os, protocol_version); + sound_use_air.serialize(os, protocol_version); + + writeU8(os, has_on_place); + writeU8(os, has_on_secondary_use); } -void ItemDefinition::deSerialize(std::istream &is) +void ItemDefinition::deSerialize(std::istream &is, u16 protocol_version) { // Reset everything reset(); // Deserialize int version = readU8(is); - if(version < 1 || version > 3) + if (version < 6) throw SerializationError("unsupported ItemDefinition version"); + type = (enum ItemType)readU8(is); - name = deSerializeString(is); - description = deSerializeString(is); - inventory_image = deSerializeString(is); - wield_image = deSerializeString(is); - wield_scale = readV3F1000(is); + name = deSerializeString16(is); + description = deSerializeString16(is); + inventory_image = deSerializeString16(is); + wield_image = deSerializeString16(is); + wield_scale = readV3F32(is); stack_max = readS16(is); usable = readU8(is); liquids_pointable = readU8(is); - std::string tool_capabilities_s = deSerializeString(is); - if(!tool_capabilities_s.empty()) - { + + std::string tool_capabilities_s = deSerializeString16(is); + if (!tool_capabilities_s.empty()) { std::istringstream tmp_is(tool_capabilities_s, std::ios::binary); tool_capabilities = new ToolCapabilities; tool_capabilities->deSerialize(tmp_is); } + groups.clear(); u32 groups_size = readU16(is); for(u32 i=0; i= 2) { - node_placement_prediction = deSerializeString(is); - //deserializeSimpleSoundSpec(sound_place, is); - sound_place.name = deSerializeString(is); - sound_place.gain = readF1000(is); - } - if(version == 3) { - range = readF1000(is); - } - // If you add anything here, insert it primarily inside the try-catch + + node_placement_prediction = deSerializeString16(is); + + sound_place.deSerialize(is, protocol_version); + sound_place_failed.deSerialize(is, protocol_version); + + range = readF32(is); + palette_image = deSerializeString16(is); + color = readARGB8(is); + inventory_overlay = deSerializeString16(is); + wield_overlay = deSerializeString16(is); + + // If you add anything here, insert it inside the try-catch // block to not need to increase the version. - try{ - }catch(SerializationError &e) {}; + try { + short_description = deSerializeString16(is); + + place_param2 = readU8(is); // 0 if missing + + sound_use.deSerialize(is, protocol_version); + sound_use_air.deSerialize(is, protocol_version); + + has_on_place = readU8(is); + has_on_secondary_use = readU8(is); + } catch(SerializationError &e) {}; } + /* CItemDefManager */ @@ -228,11 +256,12 @@ 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) + palette(NULL) {} }; #endif @@ -242,7 +271,7 @@ class CItemDefManager: public IWritableItemDefManager { #ifndef SERVER - m_main_thread = get_current_thread_id(); + m_main_thread = std::this_thread::get_id(); #endif clear(); } @@ -250,20 +279,15 @@ class CItemDefManager: public IWritableItemDefManager { #ifndef SERVER const std::vector &values = m_clientcached.getValues(); - for(std::vector::const_iterator - i = values.begin(); i != values.end(); ++i) - { - ClientCached *cc = *i; - if (cc->wield_mesh) - cc->wield_mesh->drop(); + for (ClientCached *cc : values) { + if (cc->wield_mesh.mesh) + cc->wield_mesh.mesh->drop(); delete cc; } #endif - for (std::map::iterator iter = - m_item_definitions.begin(); iter != m_item_definitions.end(); - iter ++) { - delete iter->second; + for (auto &item_definition : m_item_definitions) { + delete item_definition.second; } m_item_definitions.clear(); } @@ -272,56 +296,47 @@ class CItemDefManager: public IWritableItemDefManager // Convert name according to possible alias std::string name = getAlias(name_); // Get the definition - std::map::const_iterator i; - i = m_item_definitions.find(name); - if(i == m_item_definitions.end()) + auto i = m_item_definitions.find(name); + if (i == m_item_definitions.cend()) i = m_item_definitions.find("unknown"); - assert(i != m_item_definitions.end()); + assert(i != m_item_definitions.cend()); return *(i->second); } - virtual std::string getAlias(const std::string &name) const + virtual const std::string &getAlias(const std::string &name) const { - std::map::const_iterator i; - i = m_aliases.find(name); - if(i != m_aliases.end()) - return i->second; + auto it = m_aliases.find(name); + if (it != m_aliases.cend()) + return it->second; return name; } - virtual std::set getAll() const + virtual void getAll(std::set &result) const { - std::set result; - for(std::map::const_iterator - i = m_item_definitions.begin(); - i != m_item_definitions.end(); i++) - { - result.insert(i->first); + result.clear(); + for (const auto &item_definition : m_item_definitions) { + result.insert(item_definition.first); } - for(std::map::const_iterator - i = m_aliases.begin(); - i != m_aliases.end(); i++) - { - result.insert(i->first); + + for (const auto &alias : m_aliases) { + result.insert(alias.first); } - return result; } virtual bool isKnown(const std::string &name_) const { // Convert name according to possible alias std::string name = getAlias(name_); // Get the definition - std::map::const_iterator i; - return m_item_definitions.find(name) != m_item_definitions.end(); + return m_item_definitions.find(name) != m_item_definitions.cend(); } #ifndef SERVER public: ClientCached* createClientCachedDirect(const std::string &name, - IGameDef *gamedef) const + Client *client) const { infostream<<"Lazily creating item texture and mesh for \"" <getTextureSource(); - INodeDefManager *nodedef = gamedef->getNodeDefManager(); + ITextureSource *tsrc = client->getTextureSource(); const ItemDefinition &def = get(name); // Create new ClientCached @@ -338,106 +352,15 @@ class CItemDefManager: public IWritableItemDefManager // Create an inventory texture cc->inventory_texture = NULL; - if(def.inventory_image != "") + if (!def.inventory_image.empty()) cc->inventory_texture = tsrc->getTexture(def.inventory_image); - // Additional processing for nodes: - // - Create a wield mesh if WieldMeshSceneNode can't render - // the node on its own. - // - If inventory_texture isn't set yet, create one using - // render-to-texture. - if (def.type == ITEM_NODE) { - // Get node properties - content_t id = nodedef->getId(name); - const ContentFeatures &f = nodedef->get(id); - - bool need_rtt_mesh = cc->inventory_texture == NULL; - - // Keep this in sync with WieldMeshSceneNode::setItem() - bool need_wield_mesh = - !(f.mesh_ptr[0] || - f.drawtype == NDT_NORMAL || - f.drawtype == NDT_ALLFACES || - f.drawtype == NDT_AIRLIKE); - - scene::IMesh *node_mesh = NULL; - - if (need_rtt_mesh || need_wield_mesh) { - u8 param1 = 0; - if (f.param_type == CPT_LIGHT) - param1 = 0xee; - - /* - Make a mesh from the node - */ - MeshMakeData mesh_make_data(gamedef, false); - u8 param2 = 0; - if (f.param_type_2 == CPT2_WALLMOUNTED) - param2 = 1; - MapNode mesh_make_node(id, param1, param2); - mesh_make_data.fillSingleNode(&mesh_make_node); - MapBlockMesh mapblock_mesh(&mesh_make_data, v3s16(0, 0, 0)); - node_mesh = mapblock_mesh.getMesh(); - node_mesh->grab(); - video::SColor c(255, 255, 255, 255); - setMeshColor(node_mesh, c); - - // scale and translate the mesh so it's a - // unit cube centered on the origin - scaleMesh(node_mesh, v3f(1.0/BS, 1.0/BS, 1.0/BS)); - translateMesh(node_mesh, v3f(-1.0, -1.0, -1.0)); - } + ItemStack item = ItemStack(); + item.name = def.name; - /* - Draw node mesh into a render target texture - */ - if (need_rtt_mesh) { - TextureFromMeshParams params; - params.mesh = node_mesh; - params.dim.set(64, 64); - params.rtt_texture_name = "INVENTORY_" - + def.name + "_RTT"; - params.delete_texture_on_shutdown = true; - params.camera_position.set(0, 1.0, -1.5); - params.camera_position.rotateXZBy(45); - params.camera_lookat.set(0, 0, 0); - // Set orthogonal projection - params.camera_projection_matrix.buildProjectionMatrixOrthoLH( - 1.65, 1.65, 0, 100); - params.ambient_light.set(1.0, 0.2, 0.2, 0.2); - params.light_position.set(10, 100, -50); - params.light_color.set(1.0, 0.5, 0.5, 0.5); - params.light_radius = 1000; - -#ifdef __ANDROID__ - params.camera_position.set(0, -1.0, -1.5); - params.camera_position.rotateXZBy(45); - params.light_position.set(10, -100, -50); -#endif - cc->inventory_texture = - tsrc->generateTextureFromMesh(params); + getItemMesh(client, item, &(cc->wield_mesh)); - // render-to-target didn't work - if (cc->inventory_texture == NULL) { - cc->inventory_texture = - tsrc->getTexture(f.tiledef[0].name); - } - } - - /* - Use the node mesh as the wield mesh - */ - if (need_wield_mesh) { - cc->wield_mesh = node_mesh; - cc->wield_mesh->grab(); - - // no way reference count can be smaller than 2 in this place! - assert(cc->wield_mesh->getReferenceCount() >= 2); - } - - if (node_mesh) - node_mesh->drop(); - } + cc->palette = tsrc->getPalette(def.palette_image); // Put in cache m_clientcached.set(name, cc); @@ -445,68 +368,108 @@ class CItemDefManager: public IWritableItemDefManager return cc; } ClientCached* getClientCached(const std::string &name, - IGameDef *gamedef) const + Client *client) const { ClientCached *cc = NULL; m_clientcached.get(name, &cc); - if(cc) + if (cc) return cc; - if(get_current_thread_id() == m_main_thread) - { - return createClientCachedDirect(name, gamedef); + if (std::this_thread::get_id() == m_main_thread) { + return createClientCachedDirect(name, client); } - else - { - // We're gonna ask the result to be put into here - static ResultQueue result_queue; - - // Throw a request in - m_get_clientcached_queue.add(name, 0, 0, &result_queue); - try{ - while(true) { - // Wait result for a second - GetResult - result = result_queue.pop_front(1000); - - if (result.key == name) { - return result.item; - } + + // We're gonna ask the result to be put into here + static ResultQueue result_queue; + + // Throw a request in + m_get_clientcached_queue.add(name, 0, 0, &result_queue); + try { + while(true) { + // Wait result for a second + GetResult + result = result_queue.pop_front(1000); + + if (result.key == name) { + return result.item; } } - catch(ItemNotFoundException &e) - { - errorstream<<"Waiting for clientcached " << name << " timed out."<inventory_texture; } // Get item wield mesh - virtual scene::IMesh* getWieldMesh(const std::string &name, - IGameDef *gamedef) const + 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, gamedef); + 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.empty() && 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 && !index.empty()) + return (*palette)[mystoi(index, 0, 255)]; + // Fallback color + return get(stack.name).color; } #endif + void applyTextureOverrides(const std::vector &overrides) + { + infostream << "ItemDefManager::applyTextureOverrides(): Applying " + "overrides to textures" << std::endl; + + for (const TextureOverride& texture_override : overrides) { + if (m_item_definitions.find(texture_override.id) == m_item_definitions.end()) { + continue; // Ignore unknown item + } + + ItemDefinition* itemdef = m_item_definitions[texture_override.id]; + + if (texture_override.hasTarget(OverrideTarget::INVENTORY)) + itemdef->inventory_image = texture_override.texture; + + if (texture_override.hasTarget(OverrideTarget::WIELD)) + itemdef->wield_image = texture_override.texture; + } + } void clear() { - for(std::map::const_iterator - i = m_item_definitions.begin(); - i != m_item_definitions.end(); i++) + for (auto &i : m_item_definitions) { - delete i->second; + delete i.second; } m_item_definitions.clear(); m_aliases.clear(); @@ -519,7 +482,7 @@ class CItemDefManager: public IWritableItemDefManager // "ignore" is the ignore node ItemDefinition* hand_def = new ItemDefinition; - hand_def->name = ""; + hand_def->name.clear(); hand_def->wield_image = "wieldhand.png"; hand_def->tool_capabilities = new ToolCapabilities; m_item_definitions.insert(std::make_pair("", hand_def)); @@ -541,10 +504,10 @@ class CItemDefManager: public IWritableItemDefManager } virtual void registerItem(const ItemDefinition &def) { - verbosestream<<"ItemDefManager: registering \""< "< " << convert_to << std::endl); m_aliases[name] = convert_to; } } @@ -572,47 +541,45 @@ class CItemDefManager: public IWritableItemDefManager writeU8(os, 0); // version u16 count = m_item_definitions.size(); writeU16(os, count); - for(std::map::const_iterator - i = m_item_definitions.begin(); - i != m_item_definitions.end(); i++) - { - ItemDefinition *def = i->second; + + for (const auto &it : m_item_definitions) { + ItemDefinition *def = it.second; // Serialize ItemDefinition and write wrapped in a string std::ostringstream tmp_os(std::ios::binary); def->serialize(tmp_os, protocol_version); - os<::const_iterator - i = m_aliases.begin(); i != m_aliases.end(); i++) - { - os<first); - os<second); + + for (const auto &it : m_aliases) { + os << serializeString16(it.first); + os << serializeString16(it.second); } } - void deSerialize(std::istream &is) + void deSerialize(std::istream &is, u16 protocol_version) { // Clear everything clear(); - // Deserialize - int version = readU8(is); - if(version != 0) + + if(readU8(is) != 0) throw SerializationError("unsupported ItemDefManager version"); + u16 count = readU16(is); for(u16 i=0; i m_item_definitions; // Aliases - std::map m_aliases; + 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