X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fnodedef.cpp;h=5a1578bba589f416fd0f26770b648df6f501a82f;hb=9c635f28ac2b103bf7196e47947bf64673c13393;hp=f62c9e82ceb320b27a31f5f17f2635bd50c82175;hpb=eadde1e74113ee175708795fc24f8f5d1c746c1d;p=minetest.git diff --git a/src/nodedef.cpp b/src/nodedef.cpp index f62c9e82c..5a1578bba 100644 --- a/src/nodedef.cpp +++ b/src/nodedef.cpp @@ -19,17 +19,21 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "nodedef.h" -#include "main.h" // For g_settings #include "itemdef.h" #ifndef SERVER -#include "tile.h" +#include "client/tile.h" +#include "mesh.h" +#include #endif #include "log.h" #include "settings.h" #include "nameidmapping.h" #include "util/numeric.h" #include "util/serialize.h" -//#include "profiler.h" // For TimeTaker +#include "exceptions.h" +#include "debug.h" +#include "gamedef.h" +#include // Used in applyTextureOverrides() /* NodeBox @@ -61,7 +65,7 @@ void NodeBox::serialize(std::ostream &os, u16 protocol_version) const writeU16(os, fixed.size()); for(std::vector::const_iterator i = fixed.begin(); - i != fixed.end(); i++) + i != fixed.end(); ++i) { writeV3F1000(os, i->MinEdge); writeV3F1000(os, i->MaxEdge); @@ -116,7 +120,9 @@ void NodeBox::deSerialize(std::istream &is) void TileDef::serialize(std::ostream &os, u16 protocol_version) const { - if(protocol_version >= 17) + if (protocol_version >= 26) + writeU8(os, 2); + else if (protocol_version >= 17) writeU8(os, 1); else writeU8(os, 0); @@ -125,8 +131,12 @@ void TileDef::serialize(std::ostream &os, u16 protocol_version) const writeU16(os, animation.aspect_w); writeU16(os, animation.aspect_h); writeF1000(os, animation.length); - if(protocol_version >= 17) + if (protocol_version >= 17) writeU8(os, backface_culling); + if (protocol_version >= 26) { + writeU8(os, tileable_horizontal); + writeU8(os, tileable_vertical); + } } void TileDef::deSerialize(std::istream &is) @@ -137,10 +147,15 @@ void TileDef::deSerialize(std::istream &is) animation.aspect_w = readU16(is); animation.aspect_h = readU16(is); animation.length = readF1000(is); - if(version >= 1) + if (version >= 1) backface_culling = readU8(is); + if (version >= 2) { + tileable_horizontal = readU8(is); + tileable_vertical = readU8(is); + } } + /* SimpleSoundSpec serialization */ @@ -179,6 +194,7 @@ void ContentFeatures::reset() solidness = 2; visual_solidness = 0; backface_culling = true; + #endif has_on_construct = false; has_on_destruct = false; @@ -194,10 +210,16 @@ void ContentFeatures::reset() // Unknown nodes can be dug groups["dig_immediate"] = 2; drawtype = NDT_NORMAL; + mesh = ""; +#ifndef SERVER + for(u32 i = 0; i < 24; i++) + mesh_ptr[i] = NULL; + minimap_color = video::SColor(0, 0, 0, 0); +#endif visual_scale = 1.0; - for(u32 i=0; i<6; i++) + for(u32 i = 0; i < 6; i++) tiledef[i] = TileDef(); - for(u16 j=0; jfirst); writeS16(os, i->second); } writeU8(os, drawtype); writeF1000(os, visual_scale); writeU8(os, 6); - for(u32 i=0; i<6; i++) + for(u32 i = 0; i < 6; i++) tiledef[i].serialize(os, protocol_version); writeU8(os, CF_SPECIAL_COUNT); - for(u32 i=0; i &result) const; + virtual const ContentFeatures& get(const std::string &name) const; + content_t allocateId(); + virtual content_t set(const std::string &name, const ContentFeatures &def); + virtual content_t allocateDummy(const std::string &name); + virtual void updateAliases(IItemDefManager *idef); + virtual void applyTextureOverrides(const std::string &override_filepath); + virtual void updateTextures(IGameDef *gamedef, + void (*progress_cbk)(void *progress_args, u32 progress, u32 max_progress), + void *progress_cbk_args); + void serialize(std::ostream &os, u16 protocol_version) const; + void deSerialize(std::istream &is); - // Set CONTENT_AIR - { - ContentFeatures f; - f.name = "air"; - f.drawtype = NDT_AIRLIKE; - f.param_type = CPT_LIGHT; - f.light_propagates = true; - f.sunlight_propagates = true; - f.walkable = false; - f.pointable = false; - f.diggable = false; - f.buildable_to = true; - f.is_ground_content = true; - // Insert directly into containers - content_t c = CONTENT_AIR; - m_content_features[c] = f; - addNameIdMapping(c, f.name); - } + inline virtual bool getNodeRegistrationStatus() const; + inline virtual void setNodeRegistrationStatus(bool completed); - // Set CONTENT_IGNORE - { - ContentFeatures f; - f.name = "ignore"; - f.drawtype = NDT_AIRLIKE; - f.param_type = CPT_NONE; - f.light_propagates = false; - f.sunlight_propagates = false; - f.walkable = false; - f.pointable = false; - f.diggable = false; - f.buildable_to = true; // A way to remove accidental CONTENT_IGNOREs - f.is_ground_content = true; - // Insert directly into containers - content_t c = CONTENT_IGNORE; - m_content_features[c] = f; - addNameIdMapping(c, f.name); + virtual void pendNodeResolve(NodeResolver *nr); + virtual bool cancelNodeResolveCallback(NodeResolver *nr); + virtual void runNodeResolveCallbacks(); + virtual void resetNodeResolveState(); + +private: + void addNameIdMapping(content_t i, std::string name); +#ifndef SERVER + void fillTileAttribs(ITextureSource *tsrc, TileSpec *tile, TileDef *tiledef, + u32 shader_id, bool use_normal_texture, bool backface_culling, + u8 alpha, u8 material_type); +#endif + + // Features indexed by id + std::vector m_content_features; + + // A mapping for fast converting back and forth between names and ids + NameIdMapping m_name_id_mapping; + + // Like m_name_id_mapping, but only from names to ids, and includes + // item aliases too. Updated by updateAliases() + // Note: Not serialized. + + std::map 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. + std::map m_group_to_items; + + // Next possibly free id + content_t m_next_id; + + // NodeResolvers to callback once node registration has ended + std::vector m_pending_resolve_callbacks; + + // True when all nodes have been registered + bool m_node_registration_complete; +}; + + +CNodeDefManager::CNodeDefManager() +{ + clear(); +} + + +CNodeDefManager::~CNodeDefManager() +{ +#ifndef SERVER + for (u32 i = 0; i < m_content_features.size(); i++) { + ContentFeatures *f = &m_content_features[i]; + for (u32 j = 0; j < 24; j++) { + if (f->mesh_ptr[j]) + f->mesh_ptr[j]->drop(); } } - CNodeDefManager() - { - clear(); - } - virtual ~CNodeDefManager() - { - } - virtual IWritableNodeDefManager* clone() - { - CNodeDefManager *mgr = new CNodeDefManager(); - *mgr = *this; - return mgr; - } - virtual const ContentFeatures& get(content_t c) const +#endif +} + + +void CNodeDefManager::clear() +{ + m_content_features.clear(); + m_name_id_mapping.clear(); + m_name_id_mapping_with_aliases.clear(); + m_group_to_items.clear(); + m_next_id = 0; + + resetNodeResolveState(); + + u32 initial_length = 0; + initial_length = MYMAX(initial_length, CONTENT_UNKNOWN + 1); + initial_length = MYMAX(initial_length, CONTENT_AIR + 1); + initial_length = MYMAX(initial_length, CONTENT_IGNORE + 1); + m_content_features.resize(initial_length); + + // Set CONTENT_UNKNOWN { - if(c < m_content_features.size()) - return m_content_features[c]; - else - return m_content_features[CONTENT_UNKNOWN]; + ContentFeatures f; + f.name = "unknown"; + // Insert directly into containers + content_t c = CONTENT_UNKNOWN; + m_content_features[c] = f; + addNameIdMapping(c, f.name); } - virtual const ContentFeatures& get(const MapNode &n) const + + // Set CONTENT_AIR { - return get(n.getContent()); + ContentFeatures f; + f.name = "air"; + f.drawtype = NDT_AIRLIKE; + f.param_type = CPT_LIGHT; + f.light_propagates = true; + f.sunlight_propagates = true; + f.walkable = false; + f.pointable = false; + f.diggable = false; + f.buildable_to = true; + f.is_ground_content = true; + // Insert directly into containers + content_t c = CONTENT_AIR; + m_content_features[c] = f; + addNameIdMapping(c, f.name); } - virtual bool getId(const std::string &name, content_t &result) const + + // Set CONTENT_IGNORE { - std::map::const_iterator - i = m_name_id_mapping_with_aliases.find(name); - if(i == m_name_id_mapping_with_aliases.end()) - return false; - result = i->second; - return true; + ContentFeatures f; + f.name = "ignore"; + f.drawtype = NDT_AIRLIKE; + f.param_type = CPT_NONE; + f.light_propagates = false; + f.sunlight_propagates = false; + f.walkable = false; + f.pointable = false; + f.diggable = false; + f.buildable_to = true; // A way to remove accidental CONTENT_IGNOREs + f.is_ground_content = true; + // Insert directly into containers + content_t c = CONTENT_IGNORE; + m_content_features[c] = f; + addNameIdMapping(c, f.name); } - virtual content_t getId(const std::string &name) const - { +} + + +IWritableNodeDefManager *CNodeDefManager::clone() +{ + CNodeDefManager *mgr = new CNodeDefManager(); + *mgr = *this; + return mgr; +} + + +inline const ContentFeatures& CNodeDefManager::get(content_t c) const +{ + return c < m_content_features.size() + ? m_content_features[c] : m_content_features[CONTENT_UNKNOWN]; +} + + +inline const ContentFeatures& CNodeDefManager::get(const MapNode &n) const +{ + return get(n.getContent()); +} + + +bool CNodeDefManager::getId(const std::string &name, content_t &result) const +{ + std::map::const_iterator + i = m_name_id_mapping_with_aliases.find(name); + if(i == m_name_id_mapping_with_aliases.end()) + return false; + result = i->second; + return true; +} + + +content_t CNodeDefManager::getId(const std::string &name) const +{ + content_t id = CONTENT_IGNORE; + getId(name, id); + return id; +} + + +void CNodeDefManager::getIds(const std::string &name, + std::set &result) const +{ + //TimeTaker t("getIds", NULL, PRECISION_MICRO); + if (name.substr(0,6) != "group:") { content_t id = CONTENT_IGNORE; - getId(name, id); - return id; + if(getId(name, id)) + result.insert(id); + return; } - virtual void getIds(const std::string &name, std::set &result) - const - { - //TimeTaker t("getIds", NULL, PRECISION_MICRO); - if(name.substr(0,6) != "group:"){ - content_t id = CONTENT_IGNORE; - if(getId(name, id)) - result.insert(id); - return; + std::string group = name.substr(6); + + std::map::const_iterator + i = m_group_to_items.find(group); + if (i == m_group_to_items.end()) + return; + + const GroupItems &items = i->second; + for (GroupItems::const_iterator j = items.begin(); + j != items.end(); ++j) { + if ((*j).second != 0) + result.insert((*j).first); + } + //printf("getIds: %dus\n", t.stop()); +} + + +const ContentFeatures& CNodeDefManager::get(const std::string &name) const +{ + content_t id = CONTENT_UNKNOWN; + getId(name, id); + return get(id); +} + + +// returns CONTENT_IGNORE if no free ID found +content_t CNodeDefManager::allocateId() +{ + for (content_t id = m_next_id; + id >= m_next_id; // overflow? + ++id) { + while (id >= m_content_features.size()) { + m_content_features.push_back(ContentFeatures()); } - std::string group = name.substr(6); - - std::map::const_iterator - i = m_group_to_items.find(group); - if (i == m_group_to_items.end()) - return; - - const GroupItems &items = i->second; - for (GroupItems::const_iterator j = items.begin(); - j != items.end(); ++j) { - if ((*j).second != 0) - result.insert((*j).first); + const ContentFeatures &f = m_content_features[id]; + if (f.name == "") { + m_next_id = id + 1; + return id; } - //printf("getIds: %dus\n", t.stop()); } - virtual const ContentFeatures& get(const std::string &name) const - { - content_t id = CONTENT_UNKNOWN; - getId(name, id); - return get(id); - } - // returns CONTENT_IGNORE if no free ID found - content_t allocateId() - { - for(content_t id = m_next_id; - id >= m_next_id; // overflow? - ++id){ - while(id >= m_content_features.size()){ - m_content_features.push_back(ContentFeatures()); - } - const ContentFeatures &f = m_content_features[id]; - if(f.name == ""){ - m_next_id = id + 1; - return id; - } - } - // If we arrive here, an overflow occurred in id. - // That means no ID was found + // If we arrive here, an overflow occurred in id. + // That means no ID was found + return CONTENT_IGNORE; +} + + +// IWritableNodeDefManager +content_t CNodeDefManager::set(const std::string &name, const ContentFeatures &def) +{ + // Pre-conditions + assert(name != ""); + assert(name == def.name); + + // Don't allow redefining ignore (but allow air and unknown) + if (name == "ignore") { + infostream << "NodeDefManager: WARNING: Ignoring " + "CONTENT_IGNORE redefinition"<first; - - std::map::iterator - j = m_group_to_items.find(group_name); - if (j == m_group_to_items.end()) { - m_group_to_items[group_name].push_back( - std::make_pair(id, i->second)); - } else { - GroupItems &items = j->second; - items.push_back(std::make_pair(id, i->second)); - } + // Add this content to the list of all groups it belongs to + // FIXME: This should remove a node from groups it no longer + // belongs to when a node is re-registered + for (ItemGroupList::const_iterator i = def.groups.begin(); + i != def.groups.end(); ++i) { + std::string group_name = i->first; + + std::map::iterator + j = m_group_to_items.find(group_name); + if (j == m_group_to_items.end()) { + m_group_to_items[group_name].push_back( + std::make_pair(id, i->second)); + } else { + GroupItems &items = j->second; + items.push_back(std::make_pair(id, i->second)); } - return id; } - virtual content_t allocateDummy(const std::string &name) - { - assert(name != ""); - ContentFeatures f; - f.name = name; - return set(name, f); + return id; +} + + +content_t CNodeDefManager::allocateDummy(const std::string &name) +{ + assert(name != ""); // Pre-condition + ContentFeatures f; + f.name = name; + return set(name, f); +} + + +void CNodeDefManager::updateAliases(IItemDefManager *idef) +{ + std::set all = idef->getAll(); + m_name_id_mapping_with_aliases.clear(); + for (std::set::iterator + i = all.begin(); i != all.end(); ++i) { + std::string name = *i; + std::string convert_to = idef->getAlias(name); + content_t id; + if (m_name_id_mapping.getId(convert_to, id)) { + m_name_id_mapping_with_aliases.insert( + std::make_pair(name, id)); + } } - virtual void updateAliases(IItemDefManager *idef) - { - std::set all = idef->getAll(); - m_name_id_mapping_with_aliases.clear(); - for(std::set::iterator - i = all.begin(); i != all.end(); i++) - { - std::string name = *i; - std::string convert_to = idef->getAlias(name); - content_t id; - if(m_name_id_mapping.getId(convert_to, id)) - { - m_name_id_mapping_with_aliases.insert( - std::make_pair(name, id)); - } +} + +void CNodeDefManager::applyTextureOverrides(const std::string &override_filepath) +{ + infostream << "CNodeDefManager::applyTextureOverrides(): Applying " + "overrides to textures from " << override_filepath << std::endl; + + std::ifstream infile(override_filepath.c_str()); + std::string line; + int line_c = 0; + while (std::getline(infile, line)) { + line_c++; + if (trim(line) == "") + continue; + std::vector splitted = str_split(line, ' '); + if (splitted.size() != 3) { + errorstream << override_filepath + << ":" << line_c << " Could not apply texture override \"" + << line << "\": Syntax error" << std::endl; + continue; + } + + content_t id; + if (!getId(splitted[0], id)) { + errorstream << override_filepath + << ":" << line_c << " Could not apply texture override \"" + << line << "\": Unknown node \"" + << splitted[0] << "\"" << std::endl; + continue; + } + + ContentFeatures &nodedef = m_content_features[id]; + + if (splitted[1] == "top") + nodedef.tiledef[0].name = splitted[2]; + else if (splitted[1] == "bottom") + nodedef.tiledef[1].name = splitted[2]; + else if (splitted[1] == "right") + nodedef.tiledef[2].name = splitted[2]; + else if (splitted[1] == "left") + nodedef.tiledef[3].name = splitted[2]; + else if (splitted[1] == "back") + nodedef.tiledef[4].name = splitted[2]; + else if (splitted[1] == "front") + nodedef.tiledef[5].name = splitted[2]; + else if (splitted[1] == "all" || splitted[1] == "*") + for (int i = 0; i < 6; i++) + nodedef.tiledef[i].name = splitted[2]; + else if (splitted[1] == "sides") + for (int i = 2; i < 6; i++) + nodedef.tiledef[i].name = splitted[2]; + else { + errorstream << override_filepath + << ":" << line_c << " Could not apply texture override \"" + << line << "\": Unknown node side \"" + << splitted[1] << "\"" << std::endl; + continue; } } - virtual void updateTextures(ITextureSource *tsrc, - IShaderSource *shdsrc) - { +} + +void CNodeDefManager::updateTextures(IGameDef *gamedef, + void (*progress_callback)(void *progress_args, u32 progress, u32 max_progress), + void *progress_callback_args) +{ #ifndef SERVER - infostream<<"CNodeDefManager::updateTextures(): Updating " - <<"textures in node definitions"<tsrc(); + IShaderSource *shdsrc = gamedef->getShaderSource(); + scene::ISceneManager* smgr = gamedef->getSceneManager(); + scene::IMeshManipulator* meshmanip = smgr->getMeshManipulator(); - bool new_style_water = g_settings->getBool("new_style_water"); - bool new_style_leaves = g_settings->getBool("new_style_leaves"); - bool opaque_water = g_settings->getBool("opaque_water"); + bool new_style_water = g_settings->getBool("new_style_water"); + bool connected_glass = g_settings->getBool("connected_glass"); + bool opaque_water = g_settings->getBool("opaque_water"); + bool enable_shaders = g_settings->getBool("enable_shaders"); + bool enable_bumpmapping = g_settings->getBool("enable_bumpmapping"); + bool enable_parallax_occlusion = g_settings->getBool("enable_parallax_occlusion"); + bool enable_mesh_cache = g_settings->getBool("enable_mesh_cache"); + bool enable_minimap = g_settings->getBool("enable_minimap"); + std::string leaves_style = g_settings->get("leaves_style"); - for(u32 i=0; itiledef[j]; - if(tiledef[j].name == "") - tiledef[j].name = "unknown_node.png"; - } + bool use_normal_texture = enable_shaders && + (enable_bumpmapping || enable_parallax_occlusion); - bool is_liquid = false; - bool is_water_surface = false; + u32 size = m_content_features.size(); - u8 material_type; - material_type = (f->alpha == 255) ? TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA; + for (u32 i = 0; i < size; i++) { + ContentFeatures *f = &m_content_features[i]; - switch(f->drawtype){ - default: - case NDT_NORMAL: - f->solidness = 2; - break; - case NDT_AIRLIKE: - f->solidness = 0; - break; - case NDT_LIQUID: - assert(f->liquid_type == LIQUID_SOURCE); - if(opaque_water) - f->alpha = 255; - if(new_style_water){ - f->solidness = 0; - } else { - f->solidness = 1; - f->backface_culling = false; - } - is_liquid = true; - break; - case NDT_FLOWINGLIQUID: - assert(f->liquid_type == LIQUID_FLOWING); - f->solidness = 0; - if(opaque_water) - f->alpha = 255; - is_liquid = true; - break; - case NDT_GLASSLIKE: - f->solidness = 0; - f->visual_solidness = 1; - break; - case NDT_GLASSLIKE_FRAMED: + // minimap pixel color - the average color of a texture + if (enable_minimap && f->tiledef[0].name != "") + f->minimap_color = tsrc->getTextureAverageColor(f->tiledef[0].name); + + // Figure out the actual tiles to use + TileDef tiledef[6]; + for (u32 j = 0; j < 6; j++) { + tiledef[j] = f->tiledef[j]; + if (tiledef[j].name == "") + tiledef[j].name = "unknown_node.png"; + } + + bool is_liquid = false; + bool is_water_surface = false; + + u8 material_type = (f->alpha == 255) ? + TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA; + + switch (f->drawtype) { + default: + case NDT_NORMAL: + f->solidness = 2; + break; + case NDT_AIRLIKE: + f->solidness = 0; + break; + case NDT_LIQUID: + assert(f->liquid_type == LIQUID_SOURCE); + if (opaque_water) + f->alpha = 255; + if (new_style_water){ f->solidness = 0; - f->visual_solidness = 1; - break; - case NDT_ALLFACES: + } else { + f->solidness = 1; + f->backface_culling = false; + } + is_liquid = true; + break; + case NDT_FLOWINGLIQUID: + assert(f->liquid_type == LIQUID_FLOWING); + f->solidness = 0; + if (opaque_water) + f->alpha = 255; + is_liquid = true; + break; + case NDT_GLASSLIKE: + f->solidness = 0; + f->visual_solidness = 1; + break; + case NDT_GLASSLIKE_FRAMED: + f->solidness = 0; + f->visual_solidness = 1; + break; + case NDT_GLASSLIKE_FRAMED_OPTIONAL: + f->solidness = 0; + f->visual_solidness = 1; + f->drawtype = connected_glass ? NDT_GLASSLIKE_FRAMED : NDT_GLASSLIKE; + break; + case NDT_ALLFACES: + f->solidness = 0; + f->visual_solidness = 1; + break; + case NDT_ALLFACES_OPTIONAL: + if (leaves_style == "fancy") { + f->drawtype = NDT_ALLFACES; f->solidness = 0; f->visual_solidness = 1; - break; - case NDT_ALLFACES_OPTIONAL: - if(new_style_leaves){ - f->drawtype = NDT_ALLFACES; - f->solidness = 0; - f->visual_solidness = 1; - } else { - f->drawtype = NDT_NORMAL; - f->solidness = 2; - for(u32 i=0; i<6; i++){ - tiledef[i].name += std::string("^[noalpha"); - } + } else if (leaves_style == "simple") { + for (u32 j = 0; j < 6; j++) { + if (f->tiledef_special[j].name != "") + tiledef[j].name = f->tiledef_special[j].name; } - if (f->waving == 1) - material_type = TILE_MATERIAL_WAVING_LEAVES; - break; - case NDT_PLANTLIKE: + f->drawtype = NDT_GLASSLIKE; f->solidness = 0; - f->backface_culling = false; - if (f->waving == 1) - material_type = TILE_MATERIAL_WAVING_PLANTS; - break; - case NDT_TORCHLIKE: - case NDT_SIGNLIKE: - case NDT_FENCELIKE: - case NDT_RAILLIKE: - case NDT_NODEBOX: - f->solidness = 0; - break; + f->visual_solidness = 1; + } else { + f->drawtype = NDT_NORMAL; + f->solidness = 2; + for (u32 i = 0; i < 6; i++) + tiledef[i].name += std::string("^[noalpha"); } + if (f->waving == 1) + material_type = TILE_MATERIAL_WAVING_LEAVES; + break; + case NDT_PLANTLIKE: + f->solidness = 0; + f->backface_culling = false; + if (f->waving == 1) + material_type = TILE_MATERIAL_WAVING_PLANTS; + break; + case NDT_FIRELIKE: + f->backface_culling = false; + f->solidness = 0; + break; + case NDT_MESH: + f->solidness = 0; + f->backface_culling = false; + break; + case NDT_TORCHLIKE: + case NDT_SIGNLIKE: + case NDT_FENCELIKE: + case NDT_RAILLIKE: + case NDT_NODEBOX: + f->solidness = 0; + break; + } + + if (is_liquid) { + material_type = (f->alpha == 255) ? + TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT; + if (f->name == "default:water_source") + is_water_surface = true; + } + + u32 tile_shader[6]; + for (u16 j = 0; j < 6; j++) { + tile_shader[j] = shdsrc->getShader("nodes_shader", + material_type, f->drawtype); + } + + if (is_water_surface) { + tile_shader[0] = shdsrc->getShader("water_surface_shader", + material_type, f->drawtype); + } + + // Tiles (fill in f->tiles[]) + for (u16 j = 0; j < 6; j++) { + fillTileAttribs(tsrc, &f->tiles[j], &tiledef[j], tile_shader[j], + use_normal_texture, f->backface_culling, f->alpha, material_type); + } + + // Special tiles (fill in f->special_tiles[]) + for (u16 j = 0; j < CF_SPECIAL_COUNT; j++) { + fillTileAttribs(tsrc, &f->special_tiles[j], &f->tiledef_special[j], + tile_shader[j], use_normal_texture, + f->tiledef_special[j].backface_culling, f->alpha, material_type); + } - if (is_liquid){ - material_type = (f->alpha == 255) ? TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT; - if (f->name == "default:water_source") - is_water_surface = true; + if ((f->drawtype == NDT_MESH) && (f->mesh != "")) { + // Meshnode drawtype + // Read the mesh and apply scale + f->mesh_ptr[0] = gamedef->getMesh(f->mesh); + if (f->mesh_ptr[0]){ + v3f scale = v3f(1.0, 1.0, 1.0) * BS * f->visual_scale; + scaleMesh(f->mesh_ptr[0], scale); + recalculateBoundingBox(f->mesh_ptr[0]); + meshmanip->recalculateNormals(f->mesh_ptr[0], true, false); } - u32 tile_shader[6]; - for(u16 j=0; j<6; j++) - tile_shader[j] = shdsrc->getShader("nodes_shader",material_type, f->drawtype); - - if (is_water_surface) - tile_shader[0] = shdsrc->getShader("water_surface_shader",material_type, f->drawtype); - - // Tiles (fill in f->tiles[]) - for(u16 j=0; j<6; j++){ - // Shader - f->tiles[j].shader_id = tile_shader[j]; - // Texture - f->tiles[j].texture = tsrc->getTexture( - tiledef[j].name, - &f->tiles[j].texture_id); - // Alpha - f->tiles[j].alpha = f->alpha; - // Material type - f->tiles[j].material_type = material_type; - // Material flags - f->tiles[j].material_flags = 0; - if(f->backface_culling) - f->tiles[j].material_flags |= MATERIAL_FLAG_BACKFACE_CULLING; - if(tiledef[j].animation.type == TAT_VERTICAL_FRAMES) - f->tiles[j].material_flags |= MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES; - // Animation parameters - if(f->tiles[j].material_flags & - MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES) - { - // Get texture size to determine frame count by - // aspect ratio - v2u32 size = f->tiles[j].texture->getOriginalSize(); - int frame_height = (float)size.X / - (float)tiledef[j].animation.aspect_w * - (float)tiledef[j].animation.aspect_h; - int frame_count = size.Y / frame_height; - int frame_length_ms = 1000.0 * - tiledef[j].animation.length / frame_count; - f->tiles[j].animation_frame_count = frame_count; - f->tiles[j].animation_frame_length_ms = frame_length_ms; - - // If there are no frames for an animation, switch - // animation off (so that having specified an animation - // for something but not using it in the texture pack - // gives no overhead) - if(frame_count == 1){ - f->tiles[j].material_flags &= - ~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES; - } - } + } else if ((f->drawtype == NDT_NODEBOX) && + ((f->node_box.type == NODEBOX_REGULAR) || + (f->node_box.type == NODEBOX_FIXED)) && + (!f->node_box.fixed.empty())) { + //Convert regular nodebox nodes to meshnodes + //Change the drawtype and apply scale + f->drawtype = NDT_MESH; + f->mesh_ptr[0] = convertNodeboxNodeToMesh(f); + v3f scale = v3f(1.0, 1.0, 1.0) * f->visual_scale; + scaleMesh(f->mesh_ptr[0], scale); + recalculateBoundingBox(f->mesh_ptr[0]); + meshmanip->recalculateNormals(f->mesh_ptr[0], true, false); + } + + //Cache 6dfacedir and wallmounted rotated clones of meshes + if (enable_mesh_cache && f->mesh_ptr[0] && (f->param_type_2 == CPT2_FACEDIR)) { + for (u16 j = 1; j < 24; j++) { + f->mesh_ptr[j] = cloneMesh(f->mesh_ptr[0]); + rotateMeshBy6dFacedir(f->mesh_ptr[j], j); + recalculateBoundingBox(f->mesh_ptr[j]); + meshmanip->recalculateNormals(f->mesh_ptr[j], true, false); } - // Special tiles (fill in f->special_tiles[]) - for(u16 j=0; jspecial_tiles[j].shader_id = tile_shader[j]; - // Texture - f->special_tiles[j].texture = tsrc->getTexture( - f->tiledef_special[j].name, - &f->special_tiles[j].texture_id); - // Alpha - f->special_tiles[j].alpha = f->alpha; - // Material type - f->special_tiles[j].material_type = material_type; - // Material flags - f->special_tiles[j].material_flags = 0; - if(f->tiledef_special[j].backface_culling) - f->special_tiles[j].material_flags |= MATERIAL_FLAG_BACKFACE_CULLING; - if(f->tiledef_special[j].animation.type == TAT_VERTICAL_FRAMES) - f->special_tiles[j].material_flags |= MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES; - // Animation parameters - if(f->special_tiles[j].material_flags & - MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES) - { - // Get texture size to determine frame count by - // aspect ratio - v2u32 size = f->special_tiles[j].texture->getOriginalSize(); - int frame_height = (float)size.X / - (float)f->tiledef_special[j].animation.aspect_w * - (float)f->tiledef_special[j].animation.aspect_h; - int frame_count = size.Y / frame_height; - int frame_length_ms = 1000.0 * - f->tiledef_special[j].animation.length / frame_count; - f->special_tiles[j].animation_frame_count = frame_count; - f->special_tiles[j].animation_frame_length_ms = frame_length_ms; - - // If there are no frames for an animation, switch - // animation off (so that having specified an animation - // for something but not using it in the texture pack - // gives no overhead) - if(frame_count == 1){ - f->special_tiles[j].material_flags &= - ~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES; - } - } + } else if (enable_mesh_cache && f->mesh_ptr[0] && (f->param_type_2 == CPT2_WALLMOUNTED)) { + static const u8 wm_to_6d[6] = {20, 0, 16+1, 12+3, 8, 4+2}; + for (u16 j = 1; j < 6; j++) { + f->mesh_ptr[j] = cloneMesh(f->mesh_ptr[0]); + rotateMeshBy6dFacedir(f->mesh_ptr[j], wm_to_6d[j]); + recalculateBoundingBox(f->mesh_ptr[j]); + meshmanip->recalculateNormals(f->mesh_ptr[j], true, false); } + rotateMeshBy6dFacedir(f->mesh_ptr[0], wm_to_6d[0]); + recalculateBoundingBox(f->mesh_ptr[0]); + meshmanip->recalculateNormals(f->mesh_ptr[0], true, false); } + + progress_callback(progress_callback_args, i, size); + } #endif +} + + +#ifndef SERVER +void CNodeDefManager::fillTileAttribs(ITextureSource *tsrc, TileSpec *tile, + TileDef *tiledef, u32 shader_id, bool use_normal_texture, + bool backface_culling, u8 alpha, u8 material_type) +{ + tile->shader_id = shader_id; + tile->texture = tsrc->getTextureForMesh(tiledef->name, &tile->texture_id); + tile->alpha = alpha; + tile->material_type = material_type; + + // Normal texture and shader flags texture + if (use_normal_texture) { + tile->normal_texture = tsrc->getNormalTexture(tiledef->name); } - void serialize(std::ostream &os, u16 protocol_version) - { - writeU8(os, 1); // version - u16 count = 0; - std::ostringstream os2(std::ios::binary); - for(u32 i=0; iname == "") - continue; - writeU16(os2, i); - // Wrap it in a string to allow different lengths without - // strict version incompatibilities - std::ostringstream wrapper_os(std::ios::binary); - f->serialize(wrapper_os, protocol_version); - os2< count); // must not overflow - count++; - } - writeU16(os, count); - os<flags_texture = tsrc->getShaderFlagsTexture(tile->normal_texture ? true : false); + + // Material flags + tile->material_flags = 0; + if (backface_culling) + tile->material_flags |= MATERIAL_FLAG_BACKFACE_CULLING; + if (tiledef->animation.type == TAT_VERTICAL_FRAMES) + tile->material_flags |= MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES; + if (tiledef->tileable_horizontal) + tile->material_flags |= MATERIAL_FLAG_TILEABLE_HORIZONTAL; + if (tiledef->tileable_vertical) + tile->material_flags |= MATERIAL_FLAG_TILEABLE_VERTICAL; + + // Animation parameters + int frame_count = 1; + if (tile->material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES) { + // Get texture size to determine frame count by aspect ratio + v2u32 size = tile->texture->getOriginalSize(); + int frame_height = (float)size.X / + (float)tiledef->animation.aspect_w * + (float)tiledef->animation.aspect_h; + frame_count = size.Y / frame_height; + int frame_length_ms = 1000.0 * tiledef->animation.length / frame_count; + tile->animation_frame_count = frame_count; + tile->animation_frame_length_ms = frame_length_ms; } - void deSerialize(std::istream &is) - { - clear(); - int version = readU8(is); - if(version != 1) - throw SerializationError("unsupported NodeDefinitionManager version"); - u16 count = readU16(is); - std::istringstream is2(deSerializeLongString(is), std::ios::binary); - ContentFeatures f; - for(u16 n=0; n= m_content_features.size()) - m_content_features.resize((u32)(i) + 1); - m_content_features[i] = f; - addNameIdMapping(i, f.name); - verbosestream<<"deserialized "<material_flags &= ~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES; + } else { + std::ostringstream os(std::ios::binary); + tile->frames.resize(frame_count); + + for (int i = 0; i < frame_count; i++) { + + FrameSpec frame; + + os.str(""); + os << tiledef->name << "^[verticalframe:" + << frame_count << ":" << i; + + frame.texture = tsrc->getTextureForMesh(os.str(), &frame.texture_id); + if (tile->normal_texture) + frame.normal_texture = tsrc->getNormalTexture(os.str()); + frame.flags_texture = tile->flags_texture; + tile->frames[i] = frame; } } -private: - void addNameIdMapping(content_t i, std::string name) - { - m_name_id_mapping.set(i, name); - m_name_id_mapping_with_aliases.insert(std::make_pair(name, i)); +} +#endif + + +void CNodeDefManager::serialize(std::ostream &os, u16 protocol_version) const +{ + writeU8(os, 1); // version + u16 count = 0; + std::ostringstream os2(std::ios::binary); + for (u32 i = 0; i < m_content_features.size(); i++) { + if (i == CONTENT_IGNORE || i == CONTENT_AIR + || i == CONTENT_UNKNOWN) + continue; + const ContentFeatures *f = &m_content_features[i]; + if (f->name == "") + continue; + writeU16(os2, i); + // Wrap it in a string to allow different lengths without + // strict version incompatibilities + std::ostringstream wrapper_os(std::ios::binary); + f->serialize(wrapper_os, protocol_version); + os2< m_content_features; - // A mapping for fast converting back and forth between names and ids - NameIdMapping m_name_id_mapping; - // Like m_name_id_mapping, but only from names to ids, and includes - // item aliases too. Updated by updateAliases() - // Note: Not serialized. - std::map 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. - std::map m_group_to_items; - // Next possibly free id - content_t m_next_id; -}; + writeU16(os, count); + os << serializeLongString(os2.str()); +} + + +void CNodeDefManager::deSerialize(std::istream &is) +{ + clear(); + int version = readU8(is); + if (version != 1) + throw SerializationError("unsupported NodeDefinitionManager version"); + u16 count = readU16(is); + std::istringstream is2(deSerializeLongString(is), std::ios::binary); + ContentFeatures f; + for (u16 n = 0; n < count; n++) { + u16 i = readU16(is2); + + // Read it from the string wrapper + std::string wrapper = deSerializeString(is2); + std::istringstream wrapper_is(wrapper, std::ios::binary); + f.deSerialize(wrapper_is); + + // Check error conditions + if (i == CONTENT_IGNORE || i == CONTENT_AIR || i == CONTENT_UNKNOWN) { + infostream << "NodeDefManager::deSerialize(): WARNING: " + "not changing builtin node " << i << std::endl; + continue; + } + if (f.name == "") { + infostream << "NodeDefManager::deSerialize(): WARNING: " + "received empty name" << std::endl; + continue; + } -IWritableNodeDefManager* createNodeDefManager() + // Ignore aliases + u16 existing_id; + if (m_name_id_mapping.getId(f.name, existing_id) && i != existing_id) { + infostream << "NodeDefManager::deSerialize(): WARNING: " + "already defined with different ID: " << f.name << std::endl; + continue; + } + + // All is ok, add node definition with the requested ID + if (i >= m_content_features.size()) + m_content_features.resize((u32)(i) + 1); + m_content_features[i] = f; + addNameIdMapping(i, f.name); + verbosestream << "deserialized " << f.name << std::endl; + } +} + + +void CNodeDefManager::addNameIdMapping(content_t i, std::string name) +{ + m_name_id_mapping.set(i, name); + m_name_id_mapping_with_aliases.insert(std::make_pair(name, i)); +} + + +IWritableNodeDefManager *createNodeDefManager() { return new CNodeDefManager(); } -/* - Serialization of old ContentFeatures formats -*/ -void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) +//// Serialization of old ContentFeatures formats +void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) const { - if(protocol_version == 13) + if (protocol_version == 13) { writeU8(os, 5); // version os<first); writeS16(os, i->second); } writeU8(os, drawtype); writeF1000(os, visual_scale); writeU8(os, 6); - for(u32 i=0; i<6; i++) + for (u32 i = 0; i < 6; i++) tiledef[i].serialize(os, protocol_version); - writeU8(os, CF_SPECIAL_COUNT); - for(u32 i=0; i 13 && protocol_version < 24) { + writeU8(os, 6); // version + os<first); + writeS16(os, i->second); + } + writeU8(os, drawtype); + writeF1000(os, visual_scale); + writeU8(os, 6); + for (u32 i = 0; i < 6; i++) + tiledef[i].serialize(os, protocol_version); + //CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24 + writeU8(os, 2); + for (u32 i = 0; i < 2; i++) + tiledef_special[i].serialize(os, protocol_version); + writeU8(os, alpha); + writeU8(os, post_effect_color.getAlpha()); + writeU8(os, post_effect_color.getRed()); + writeU8(os, post_effect_color.getGreen()); + writeU8(os, post_effect_color.getBlue()); + writeU8(os, param_type); + writeU8(os, param_type_2); + writeU8(os, is_ground_content); + writeU8(os, light_propagates); + writeU8(os, sunlight_propagates); + writeU8(os, walkable); + writeU8(os, pointable); + writeU8(os, diggable); + writeU8(os, climbable); + writeU8(os, buildable_to); + os<m_ndef = this; + if (m_node_registration_complete) + nr->nodeResolveInternal(); else - { - throw SerializationError("unsupported ContentFeatures version"); + m_pending_resolve_callbacks.push_back(nr); +} + + +bool CNodeDefManager::cancelNodeResolveCallback(NodeResolver *nr) +{ + size_t len = m_pending_resolve_callbacks.size(); + for (size_t i = 0; i != len; i++) { + if (nr != m_pending_resolve_callbacks[i]) + continue; + + len--; + m_pending_resolve_callbacks[i] = m_pending_resolve_callbacks[len]; + m_pending_resolve_callbacks.resize(len); + return true; } + + return false; +} + + +void CNodeDefManager::runNodeResolveCallbacks() +{ + for (size_t i = 0; i != m_pending_resolve_callbacks.size(); i++) { + NodeResolver *nr = m_pending_resolve_callbacks[i]; + nr->nodeResolveInternal(); + } + + m_pending_resolve_callbacks.clear(); +} + + +void CNodeDefManager::resetNodeResolveState() +{ + m_node_registration_complete = false; + m_pending_resolve_callbacks.clear(); +} + + +//// +//// NodeResolver +//// + +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); +} + + +NodeResolver::~NodeResolver() +{ + if (!m_resolve_done && m_ndef) + m_ndef->cancelNodeResolveCallback(this); +} + + +void NodeResolver::nodeResolveInternal() +{ + m_nodenames_idx = 0; + m_nnlistsizes_idx = 0; + + resolveNodeNames(); + m_resolve_done = true; + + m_nodenames.clear(); + m_nnlistsizes.clear(); +} + + +bool NodeResolver::getIdFromNrBacklog(content_t *result_out, + const std::string &node_alt, content_t c_fallback) +{ + if (m_nodenames_idx == m_nodenames.size()) { + *result_out = c_fallback; + errorstream << "NodeResolver: no more nodes in list" << std::endl; + return false; + } + + content_t c; + std::string name = m_nodenames[m_nodenames_idx++]; + + bool success = m_ndef->getId(name, c); + if (!success && node_alt != "") { + name = node_alt; + success = m_ndef->getId(name, c); + } + + if (!success) { + errorstream << "NodeResolver: failed to resolve node name '" << name + << "'." << std::endl; + c = c_fallback; + } + + *result_out = c; + return success; +} + + +bool NodeResolver::getIdsFromNrBacklog(std::vector *result_out, + bool all_required, content_t c_fallback) +{ + bool success = true; + + if (m_nnlistsizes_idx == m_nnlistsizes.size()) { + errorstream << "NodeResolver: no more node lists" << std::endl; + return false; + } + + size_t length = m_nnlistsizes[m_nnlistsizes_idx++]; + + while (length--) { + if (m_nodenames_idx == m_nodenames.size()) { + errorstream << "NodeResolver: no more nodes in list" << std::endl; + return false; + } + + content_t c; + std::string &name = m_nodenames[m_nodenames_idx++]; + + if (name.substr(0,6) != "group:") { + if (m_ndef->getId(name, c)) { + result_out->push_back(c); + } else if (all_required) { + errorstream << "NodeResolver: failed to resolve node name '" + << name << "'." << std::endl; + result_out->push_back(c_fallback); + success = false; + } + } else { + std::set cids; + std::set::iterator it; + m_ndef->getIds(name, cids); + for (it = cids.begin(); it != cids.end(); ++it) + result_out->push_back(*it); + } + } + + return success; }