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;
}
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();
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
+ u8 version = (protocol_version >= 34) ? 4 : 3;
+ writeU8(os, version);
writeU8(os, type);
- os<<serializeString(name);
- os<<serializeString(description);
- os<<serializeString(inventory_image);
- os<<serializeString(wield_image);
+ os << serializeString(name);
+ os << serializeString(description);
+ os << serializeString(inventory_image);
+ os << serializeString(wield_image);
writeV3F1000(os, wield_scale);
writeS16(os, stack_max);
writeU8(os, usable);
tool_capabilities->serialize(tmp_os, protocol_version);
tool_capabilities_s = tmp_os.str();
}
- os<<serializeString(tool_capabilities_s);
+ os << serializeString(tool_capabilities_s);
writeU16(os, groups.size());
for (ItemGroupList::const_iterator
i = groups.begin(); i != groups.end(); ++i){
os << serializeString(i->first);
writeS16(os, i->second);
}
- os<<serializeString(node_placement_prediction);
- if(protocol_version > 17){
- //serializeSimpleSoundSpec(sound_place, os);
- os<<serializeString(sound_place.name);
- writeF1000(os, sound_place.gain);
- }
- if (protocol_version > 20) {
- writeF1000(os, range);
- os << serializeString(sound_place_failed.name);
- writeF1000(os, sound_place_failed.gain);
+ os << serializeString(node_placement_prediction);
+ os << serializeString(sound_place.name);
+ writeF1000(os, sound_place.gain);
+ 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);
}
}
// 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);
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
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) {};
}
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
{
#ifndef SERVER
- m_main_thread = thr_get_current_thread_id();
+ m_main_thread = std::this_thread::get_id();
#endif
clear();
}
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;
}
assert(i != m_item_definitions.end());
return *(i->second);
}
- virtual std::string getAlias(const std::string &name) const
+ virtual const std::string &getAlias(const std::string &name) const
{
StringMap::const_iterator it = m_aliases.find(name);
if (it != m_aliases.end())
return it->second;
return name;
}
- virtual std::set<std::string> getAll() const
+ virtual void getAll(std::set<std::string> &result) const
{
- std::set<std::string> result;
+ result.clear();
for(std::map<std::string, ItemDefinition *>::const_iterator
it = m_item_definitions.begin();
it != m_item_definitions.end(); ++it) {
it != m_aliases.end(); ++it) {
result.insert(it->first);
}
- return result;
}
virtual bool isKnown(const std::string &name_) const
{
<<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;
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);
{
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;
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;
+ 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->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()
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
projects / oweals / minetest.git / blobdiff