X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fnodedef.cpp;h=db4043aa159c390b235d92ca25f646d4ba55c154;hb=850293bae6013fe020c454541d61af2c816b3204;hp=2ebe1c1316250d31075e57875e9c98413555724d;hpb=0bbbc6e13dc8180cf1d98f9866bc72a510162eb3;p=dragonfireclient.git diff --git a/src/nodedef.cpp b/src/nodedef.cpp index 2ebe1c131..db4043aa1 100644 --- a/src/nodedef.cpp +++ b/src/nodedef.cpp @@ -21,8 +21,11 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "itemdef.h" #ifndef SERVER +#include "client/mesh.h" +#include "client/shader.h" +#include "client/client.h" +#include "client/renderingengine.h" #include "client/tile.h" -#include "mesh.h" #include #endif #include "log.h" @@ -33,7 +36,10 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "exceptions.h" #include "debug.h" #include "gamedef.h" +#include "mapnode.h" #include // Used in applyTextureOverrides() +#include +#include /* NodeBox @@ -48,44 +54,86 @@ void NodeBox::reset() wall_top = aabb3f(-BS/2, BS/2-BS/16., -BS/2, BS/2, BS/2, BS/2); wall_bottom = aabb3f(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2); wall_side = aabb3f(-BS/2, -BS/2, -BS/2, -BS/2+BS/16., BS/2, BS/2); + // no default for other parts + connect_top.clear(); + connect_bottom.clear(); + connect_front.clear(); + connect_left.clear(); + connect_back.clear(); + connect_right.clear(); + disconnected_top.clear(); + disconnected_bottom.clear(); + disconnected_front.clear(); + disconnected_left.clear(); + disconnected_back.clear(); + disconnected_right.clear(); + disconnected.clear(); + disconnected_sides.clear(); } void NodeBox::serialize(std::ostream &os, u16 protocol_version) const { - int version = protocol_version >= 21 ? 2 : 1; + // Protocol >= 36 + const u8 version = 6; writeU8(os, version); - if (version == 1 && type == NODEBOX_LEVELED) - writeU8(os, NODEBOX_FIXED); - else + switch (type) { + case NODEBOX_LEVELED: + case NODEBOX_FIXED: writeU8(os, type); - if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED) - { writeU16(os, fixed.size()); - for(std::vector::const_iterator - i = fixed.begin(); - i != fixed.end(); ++i) - { - writeV3F1000(os, i->MinEdge); - writeV3F1000(os, i->MaxEdge); + for (const aabb3f &nodebox : fixed) { + writeV3F32(os, nodebox.MinEdge); + writeV3F32(os, nodebox.MaxEdge); } - } - else if(type == NODEBOX_WALLMOUNTED) - { - writeV3F1000(os, wall_top.MinEdge); - writeV3F1000(os, wall_top.MaxEdge); - writeV3F1000(os, wall_bottom.MinEdge); - writeV3F1000(os, wall_bottom.MaxEdge); - writeV3F1000(os, wall_side.MinEdge); - writeV3F1000(os, wall_side.MaxEdge); + break; + case NODEBOX_WALLMOUNTED: + writeU8(os, type); + + writeV3F32(os, wall_top.MinEdge); + writeV3F32(os, wall_top.MaxEdge); + writeV3F32(os, wall_bottom.MinEdge); + writeV3F32(os, wall_bottom.MaxEdge); + writeV3F32(os, wall_side.MinEdge); + writeV3F32(os, wall_side.MaxEdge); + break; + case NODEBOX_CONNECTED: + writeU8(os, type); + +#define WRITEBOX(box) \ + writeU16(os, (box).size()); \ + for (const aabb3f &i: (box)) { \ + writeV3F32(os, i.MinEdge); \ + writeV3F32(os, i.MaxEdge); \ + }; + + WRITEBOX(fixed); + WRITEBOX(connect_top); + WRITEBOX(connect_bottom); + WRITEBOX(connect_front); + WRITEBOX(connect_left); + WRITEBOX(connect_back); + WRITEBOX(connect_right); + WRITEBOX(disconnected_top); + WRITEBOX(disconnected_bottom); + WRITEBOX(disconnected_front); + WRITEBOX(disconnected_left); + WRITEBOX(disconnected_back); + WRITEBOX(disconnected_right); + WRITEBOX(disconnected); + WRITEBOX(disconnected_sides); + break; + default: + writeU8(os, type); + break; } } void NodeBox::deSerialize(std::istream &is) { int version = readU8(is); - if(version < 1 || version > 2) + if (version < 6) throw SerializationError("unsupported NodeBox version"); reset(); @@ -98,19 +146,47 @@ void NodeBox::deSerialize(std::istream &is) while(fixed_count--) { aabb3f box; - box.MinEdge = readV3F1000(is); - box.MaxEdge = readV3F1000(is); + box.MinEdge = readV3F32(is); + box.MaxEdge = readV3F32(is); fixed.push_back(box); } } else if(type == NODEBOX_WALLMOUNTED) { - wall_top.MinEdge = readV3F1000(is); - wall_top.MaxEdge = readV3F1000(is); - wall_bottom.MinEdge = readV3F1000(is); - wall_bottom.MaxEdge = readV3F1000(is); - wall_side.MinEdge = readV3F1000(is); - wall_side.MaxEdge = readV3F1000(is); + wall_top.MinEdge = readV3F32(is); + wall_top.MaxEdge = readV3F32(is); + wall_bottom.MinEdge = readV3F32(is); + wall_bottom.MaxEdge = readV3F32(is); + wall_side.MinEdge = readV3F32(is); + wall_side.MaxEdge = readV3F32(is); + } + else if (type == NODEBOX_CONNECTED) + { +#define READBOXES(box) { \ + count = readU16(is); \ + (box).reserve(count); \ + while (count--) { \ + v3f min = readV3F32(is); \ + v3f max = readV3F32(is); \ + (box).emplace_back(min, max); }; } + + u16 count; + + READBOXES(fixed); + READBOXES(connect_top); + READBOXES(connect_bottom); + READBOXES(connect_front); + READBOXES(connect_left); + READBOXES(connect_back); + READBOXES(connect_right); + READBOXES(disconnected_top); + READBOXES(disconnected_bottom); + READBOXES(disconnected_front); + READBOXES(disconnected_left); + READBOXES(disconnected_back); + READBOXES(disconnected_right); + READBOXES(disconnected); + READBOXES(disconnected_sides); } } @@ -118,58 +194,113 @@ void NodeBox::deSerialize(std::istream &is) TileDef */ +#define TILE_FLAG_BACKFACE_CULLING (1 << 0) +#define TILE_FLAG_TILEABLE_HORIZONTAL (1 << 1) +#define TILE_FLAG_TILEABLE_VERTICAL (1 << 2) +#define TILE_FLAG_HAS_COLOR (1 << 3) +#define TILE_FLAG_HAS_SCALE (1 << 4) +#define TILE_FLAG_HAS_ALIGN_STYLE (1 << 5) + void TileDef::serialize(std::ostream &os, u16 protocol_version) const { - if (protocol_version >= 26) - writeU8(os, 2); - else if (protocol_version >= 17) - writeU8(os, 1); - else - writeU8(os, 0); - os<= 17) - writeU8(os, backface_culling); - if (protocol_version >= 26) { - writeU8(os, tileable_horizontal); - writeU8(os, tileable_vertical); + // protocol_version >= 36 + u8 version = 6; + writeU8(os, version); + + os << serializeString16(name); + animation.serialize(os, version); + bool has_scale = scale > 0; + u16 flags = 0; + if (backface_culling) + flags |= TILE_FLAG_BACKFACE_CULLING; + if (tileable_horizontal) + flags |= TILE_FLAG_TILEABLE_HORIZONTAL; + if (tileable_vertical) + flags |= TILE_FLAG_TILEABLE_VERTICAL; + if (has_color) + flags |= TILE_FLAG_HAS_COLOR; + if (has_scale) + flags |= TILE_FLAG_HAS_SCALE; + if (align_style != ALIGN_STYLE_NODE) + flags |= TILE_FLAG_HAS_ALIGN_STYLE; + writeU16(os, flags); + if (has_color) { + writeU8(os, color.getRed()); + writeU8(os, color.getGreen()); + writeU8(os, color.getBlue()); } + if (has_scale) + writeU8(os, scale); + if (align_style != ALIGN_STYLE_NODE) + writeU8(os, align_style); } -void TileDef::deSerialize(std::istream &is) +void TileDef::deSerialize(std::istream &is, u8 contentfeatures_version, + NodeDrawType drawtype) { int version = readU8(is); - name = deSerializeString(is); - animation.type = (TileAnimationType)readU8(is); - animation.aspect_w = readU16(is); - animation.aspect_h = readU16(is); - animation.length = readF1000(is); - if (version >= 1) - backface_culling = readU8(is); - if (version >= 2) { - tileable_horizontal = readU8(is); - tileable_vertical = readU8(is); + if (version < 6) + throw SerializationError("unsupported TileDef version"); + name = deSerializeString16(is); + animation.deSerialize(is, version); + u16 flags = readU16(is); + backface_culling = flags & TILE_FLAG_BACKFACE_CULLING; + tileable_horizontal = flags & TILE_FLAG_TILEABLE_HORIZONTAL; + tileable_vertical = flags & TILE_FLAG_TILEABLE_VERTICAL; + has_color = flags & TILE_FLAG_HAS_COLOR; + bool has_scale = flags & TILE_FLAG_HAS_SCALE; + bool has_align_style = flags & TILE_FLAG_HAS_ALIGN_STYLE; + if (has_color) { + color.setRed(readU8(is)); + color.setGreen(readU8(is)); + color.setBlue(readU8(is)); } + scale = has_scale ? readU8(is) : 0; + if (has_align_style) + align_style = static_cast(readU8(is)); + else + align_style = ALIGN_STYLE_NODE; } +void TextureSettings::readSettings() +{ + connected_glass = g_settings->getBool("connected_glass"); + opaque_water = g_settings->getBool("opaque_water"); + bool smooth_lighting = g_settings->getBool("smooth_lighting"); + enable_mesh_cache = g_settings->getBool("enable_mesh_cache"); + enable_minimap = g_settings->getBool("enable_minimap"); + node_texture_size = g_settings->getU16("texture_min_size"); + std::string leaves_style_str = g_settings->get("leaves_style"); + std::string world_aligned_mode_str = g_settings->get("world_aligned_mode"); + std::string autoscale_mode_str = g_settings->get("autoscale_mode"); + + // Mesh cache is not supported in combination with smooth lighting + if (smooth_lighting) + enable_mesh_cache = false; + + if (leaves_style_str == "fancy") { + leaves_style = LEAVES_FANCY; + } else if (leaves_style_str == "simple") { + leaves_style = LEAVES_SIMPLE; + } else { + leaves_style = LEAVES_OPAQUE; + } -/* - SimpleSoundSpec serialization -*/ + if (world_aligned_mode_str == "enable") + world_aligned_mode = WORLDALIGN_ENABLE; + else if (world_aligned_mode_str == "force_solid") + world_aligned_mode = WORLDALIGN_FORCE; + else if (world_aligned_mode_str == "force_nodebox") + world_aligned_mode = WORLDALIGN_FORCE_NODEBOX; + else + world_aligned_mode = WORLDALIGN_DISABLE; -static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss, - std::ostream &os) -{ - os<first); - writeS16(os, i->second); + for (const auto &group : groups) { + os << serializeString16(group.first); + writeS16(os, group.second); } + writeU8(os, param_type); + writeU8(os, param_type_2); + + // visual writeU8(os, drawtype); - writeF1000(os, visual_scale); + os << serializeString16(mesh); + writeF32(os, visual_scale); writeU8(os, 6); - for(u32 i = 0; i < 6; i++) - tiledef[i].serialize(os, protocol_version); + for (const TileDef &td : tiledef) + td.serialize(os, protocol_version); + for (const TileDef &td : tiledef_overlay) + td.serialize(os, protocol_version); writeU8(os, CF_SPECIAL_COUNT); - for(u32 i = 0; i < CF_SPECIAL_COUNT; i++){ - tiledef_special[i].serialize(os, protocol_version); + for (const TileDef &td : tiledef_special) { + td.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, getAlphaForLegacy()); + writeU8(os, color.getRed()); + writeU8(os, color.getGreen()); + writeU8(os, color.getBlue()); + os << serializeString16(palette_name); + writeU8(os, waving); + writeU8(os, connect_sides); + writeU16(os, connects_to_ids.size()); + for (u16 connects_to_id : connects_to_ids) + writeU16(os, connects_to_id); + writeARGB8(os, post_effect_color); + writeU8(os, leveled); + + // lighting writeU8(os, light_propagates); writeU8(os, sunlight_propagates); + writeU8(os, light_source); + + // map generation + writeU8(os, is_ground_content); + + // interaction writeU8(os, walkable); writeU8(os, pointable); writeU8(os, diggable); writeU8(os, climbable); writeU8(os, buildable_to); - os<(tmp); + } catch(SerializationError &e) {}; +} -class CNodeDefManager: public IWritableNodeDefManager { -public: - CNodeDefManager(); - virtual ~CNodeDefManager(); - void clear(); - virtual IWritableNodeDefManager *clone(); - inline virtual const ContentFeatures& get(content_t c) const; - inline virtual const ContentFeatures& get(const MapNode &n) const; - virtual bool getId(const std::string &name, content_t &result) const; - virtual content_t getId(const std::string &name) const; - virtual void getIds(const std::string &name, std::set &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); - - inline virtual bool getNodeRegistrationStatus() const; - inline virtual void setNodeRegistrationStatus(bool completed); - - 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 +static void fillTileAttribs(ITextureSource *tsrc, TileLayer *layer, + const TileSpec &tile, const TileDef &tiledef, video::SColor color, + u8 material_type, u32 shader_id, bool backface_culling, + const TextureSettings &tsettings) +{ + layer->shader_id = shader_id; + layer->texture = tsrc->getTextureForMesh(tiledef.name, &layer->texture_id); + layer->material_type = material_type; + + bool has_scale = tiledef.scale > 0; + bool use_autoscale = tsettings.autoscale_mode == AUTOSCALE_FORCE || + (tsettings.autoscale_mode == AUTOSCALE_ENABLE && !has_scale); + if (use_autoscale) { + auto texture_size = layer->texture->getOriginalSize(); + float base_size = tsettings.node_texture_size; + float size = std::fmin(texture_size.Width, texture_size.Height); + layer->scale = std::fmax(base_size, size) / base_size; + } else if (has_scale) { + layer->scale = tiledef.scale; + } else { + layer->scale = 1; + } + if (!tile.world_aligned) + layer->scale = 1; + + layer->flags_texture = tsrc->getShaderFlagsTexture(layer->normal_texture ? true : false); + + // Material flags + layer->material_flags = 0; + if (backface_culling) + layer->material_flags |= MATERIAL_FLAG_BACKFACE_CULLING; + if (tiledef.animation.type != TAT_NONE) + layer->material_flags |= MATERIAL_FLAG_ANIMATION; + if (tiledef.tileable_horizontal) + layer->material_flags |= MATERIAL_FLAG_TILEABLE_HORIZONTAL; + if (tiledef.tileable_vertical) + layer->material_flags |= MATERIAL_FLAG_TILEABLE_VERTICAL; + + // Color + layer->has_color = tiledef.has_color; + if (tiledef.has_color) + layer->color = tiledef.color; + else + layer->color = color; + + // Animation parameters + int frame_count = 1; + if (layer->material_flags & MATERIAL_FLAG_ANIMATION) { + int frame_length_ms; + tiledef.animation.determineParams(layer->texture->getOriginalSize(), + &frame_count, &frame_length_ms, NULL); + layer->animation_frame_count = frame_count; + layer->animation_frame_length_ms = frame_length_ms; + } - // Features indexed by id - std::vector m_content_features; + if (frame_count == 1) { + layer->material_flags &= ~MATERIAL_FLAG_ANIMATION; + } else { + std::ostringstream os(std::ios::binary); + if (!layer->frames) { + layer->frames = new std::vector(); + } + layer->frames->resize(frame_count); - // A mapping for fast converting back and forth between names and ids - NameIdMapping m_name_id_mapping; + for (int i = 0; i < frame_count; i++) { - // Like m_name_id_mapping, but only from names to ids, and includes - // item aliases too. Updated by updateAliases() - // Note: Not serialized. + FrameSpec frame; - std::map m_name_id_mapping_with_aliases; + os.str(""); + os << tiledef.name; + tiledef.animation.getTextureModifer(os, + layer->texture->getOriginalSize(), i); - // 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; + frame.texture = tsrc->getTextureForMesh(os.str(), &frame.texture_id); + if (layer->normal_texture) + frame.normal_texture = tsrc->getNormalTexture(os.str()); + frame.flags_texture = layer->flags_texture; + (*layer->frames)[i] = frame; + } + } +} - // Next possibly free id - content_t m_next_id; +bool ContentFeatures::textureAlphaCheck(ITextureSource *tsrc, const TileDef *tiles, int length) +{ + video::IVideoDriver *driver = RenderingEngine::get_video_driver(); + static thread_local bool long_warning_printed = false; + std::set seen; - // NodeResolvers to callback once node registration has ended - std::vector m_pending_resolve_callbacks; + for (int i = 0; i < length; i++) { + if (seen.find(tiles[i].name) != seen.end()) + continue; + seen.insert(tiles[i].name); - // True when all nodes have been registered - bool m_node_registration_complete; -}; + // Load the texture and see if there's any transparent pixels + video::ITexture *texture = tsrc->getTexture(tiles[i].name); + video::IImage *image = driver->createImage(texture, + core::position2d(0, 0), texture->getOriginalSize()); + if (!image) + continue; + core::dimension2d dim = image->getDimension(); + bool ok = true; + for (u16 x = 0; x < dim.Width; x++) { + for (u16 y = 0; y < dim.Height; y++) { + if (image->getPixel(x, y).getAlpha() < 255) { + ok = false; + goto break_loop; + } + } + } +break_loop: + image->drop(); + if (ok) + continue; + warningstream << "Texture \"" << tiles[i].name << "\" of " + << name << " has transparency, assuming " + "use_texture_alpha = \"clip\"." << std::endl; + if (!long_warning_printed) { + warningstream << " This warning can be a false-positive if " + "unused pixels in the texture are transparent. However if " + "it is meant to be transparent, you *MUST* update the " + "nodedef and set use_texture_alpha = \"clip\"! This " + "compatibility code will be removed in a few releases." + << std::endl; + long_warning_printed = true; + } + return true; + } + return false; +} -CNodeDefManager::CNodeDefManager() +bool isWorldAligned(AlignStyle style, WorldAlignMode mode, NodeDrawType drawtype) +{ + if (style == ALIGN_STYLE_WORLD) + return true; + if (mode == WORLDALIGN_DISABLE) + return false; + if (style == ALIGN_STYLE_USER_DEFINED) + return true; + if (drawtype == NDT_NORMAL) + return mode >= WORLDALIGN_FORCE; + if (drawtype == NDT_NODEBOX) + return mode >= WORLDALIGN_FORCE_NODEBOX; + return false; +} + +void ContentFeatures::updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc, + scene::IMeshManipulator *meshmanip, Client *client, const TextureSettings &tsettings) +{ + // minimap pixel color - the average color of a texture + if (tsettings.enable_minimap && !tiledef[0].name.empty()) + minimap_color = tsrc->getTextureAverageColor(tiledef[0].name); + + // Figure out the actual tiles to use + TileDef tdef[6]; + for (u32 j = 0; j < 6; j++) { + tdef[j] = tiledef[j]; + if (tdef[j].name.empty()) + tdef[j].name = "unknown_node.png"; + } + // also the overlay tiles + TileDef tdef_overlay[6]; + for (u32 j = 0; j < 6; j++) + tdef_overlay[j] = tiledef_overlay[j]; + // also the special tiles + TileDef tdef_spec[6]; + for (u32 j = 0; j < CF_SPECIAL_COUNT; j++) + tdef_spec[j] = tiledef_special[j]; + + bool is_liquid = false; + + if (alpha == ALPHAMODE_LEGACY_COMPAT) { + // Before working with the alpha mode, resolve any legacy kludges + alpha = textureAlphaCheck(tsrc, tdef, 6) ? ALPHAMODE_CLIP : ALPHAMODE_OPAQUE; + } + + MaterialType material_type = alpha == ALPHAMODE_OPAQUE ? + TILE_MATERIAL_OPAQUE : (alpha == ALPHAMODE_CLIP ? TILE_MATERIAL_BASIC : + TILE_MATERIAL_ALPHA); + + switch (drawtype) { + default: + case NDT_NORMAL: + solidness = 2; + break; + case NDT_AIRLIKE: + solidness = 0; + break; + case NDT_LIQUID: + if (tsettings.opaque_water) + alpha = ALPHAMODE_OPAQUE; + solidness = 1; + is_liquid = true; + break; + case NDT_FLOWINGLIQUID: + solidness = 0; + if (tsettings.opaque_water) + alpha = ALPHAMODE_OPAQUE; + is_liquid = true; + break; + case NDT_GLASSLIKE: + solidness = 0; + visual_solidness = 1; + break; + case NDT_GLASSLIKE_FRAMED: + solidness = 0; + visual_solidness = 1; + break; + case NDT_GLASSLIKE_FRAMED_OPTIONAL: + solidness = 0; + visual_solidness = 1; + drawtype = tsettings.connected_glass ? NDT_GLASSLIKE_FRAMED : NDT_GLASSLIKE; + break; + case NDT_ALLFACES: + solidness = 0; + visual_solidness = 1; + break; + case NDT_ALLFACES_OPTIONAL: + if (tsettings.leaves_style == LEAVES_FANCY) { + drawtype = NDT_ALLFACES; + solidness = 0; + visual_solidness = 1; + } else if (tsettings.leaves_style == LEAVES_SIMPLE) { + for (u32 j = 0; j < 6; j++) { + if (!tdef_spec[j].name.empty()) + tdef[j].name = tdef_spec[j].name; + } + drawtype = NDT_GLASSLIKE; + solidness = 0; + visual_solidness = 1; + } else { + drawtype = NDT_NORMAL; + solidness = 2; + for (TileDef &td : tdef) + td.name += std::string("^[noalpha"); + } + if (waving >= 1) + material_type = TILE_MATERIAL_WAVING_LEAVES; + break; + case NDT_PLANTLIKE: + solidness = 0; + if (waving >= 1) + material_type = TILE_MATERIAL_WAVING_PLANTS; + break; + case NDT_FIRELIKE: + solidness = 0; + break; + case NDT_MESH: + case NDT_NODEBOX: + solidness = 0; + if (waving == 1) { + material_type = TILE_MATERIAL_WAVING_PLANTS; + } else if (waving == 2) { + material_type = TILE_MATERIAL_WAVING_LEAVES; + } else if (waving == 3) { + material_type = alpha == ALPHAMODE_OPAQUE ? + TILE_MATERIAL_WAVING_LIQUID_OPAQUE : (alpha == ALPHAMODE_CLIP ? + TILE_MATERIAL_WAVING_LIQUID_BASIC : TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT); + } + break; + case NDT_TORCHLIKE: + case NDT_SIGNLIKE: + case NDT_FENCELIKE: + case NDT_RAILLIKE: + solidness = 0; + break; + case NDT_PLANTLIKE_ROOTED: + solidness = 2; + break; + } + + if (is_liquid) { + if (waving == 3) { + material_type = alpha == ALPHAMODE_OPAQUE ? + TILE_MATERIAL_WAVING_LIQUID_OPAQUE : (alpha == ALPHAMODE_CLIP ? + TILE_MATERIAL_WAVING_LIQUID_BASIC : TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT); + } else { + material_type = alpha == ALPHAMODE_OPAQUE ? TILE_MATERIAL_LIQUID_OPAQUE : + TILE_MATERIAL_LIQUID_TRANSPARENT; + } + } + + u32 tile_shader = shdsrc->getShader("nodes_shader", material_type, drawtype); + + MaterialType 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++) { + tiles[j].world_aligned = isWorldAligned(tdef[j].align_style, + tsettings.world_aligned_mode, drawtype); + fillTileAttribs(tsrc, &tiles[j].layers[0], tiles[j], tdef[j], + color, material_type, tile_shader, + tdef[j].backface_culling, tsettings); + if (!tdef_overlay[j].name.empty()) + fillTileAttribs(tsrc, &tiles[j].layers[1], tiles[j], tdef_overlay[j], + color, overlay_material, overlay_shader, + tdef[j].backface_culling, tsettings); + } + + MaterialType 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], special_tiles[j], tdef_spec[j], + color, special_material, special_shader, + tdef_spec[j].backface_culling, tsettings); + + if (param_type_2 == CPT2_COLOR || + param_type_2 == CPT2_COLORED_FACEDIR || + param_type_2 == CPT2_COLORED_WALLMOUNTED || + param_type_2 == CPT2_COLORED_DEGROTATE) + palette = tsrc->getPalette(palette_name); + + if (drawtype == NDT_MESH && !mesh.empty()) { + // Meshnode drawtype + // Read the mesh and apply scale + mesh_ptr[0] = client->getMesh(mesh); + if (mesh_ptr[0]){ + v3f scale = v3f(1.0, 1.0, 1.0) * BS * visual_scale; + scaleMesh(mesh_ptr[0], scale); + recalculateBoundingBox(mesh_ptr[0]); + meshmanip->recalculateNormals(mesh_ptr[0], true, false); + } + } + + //Cache 6dfacedir and wallmounted rotated clones of meshes + if (tsettings.enable_mesh_cache && mesh_ptr[0] && + (param_type_2 == CPT2_FACEDIR + || param_type_2 == CPT2_COLORED_FACEDIR)) { + for (u16 j = 1; j < 24; j++) { + mesh_ptr[j] = cloneMesh(mesh_ptr[0]); + rotateMeshBy6dFacedir(mesh_ptr[j], j); + recalculateBoundingBox(mesh_ptr[j]); + meshmanip->recalculateNormals(mesh_ptr[j], true, false); + } + } else if (tsettings.enable_mesh_cache && mesh_ptr[0] + && (param_type_2 == CPT2_WALLMOUNTED || + param_type_2 == CPT2_COLORED_WALLMOUNTED)) { + static const u8 wm_to_6d[6] = { 20, 0, 16 + 1, 12 + 3, 8, 4 + 2 }; + for (u16 j = 1; j < 6; j++) { + mesh_ptr[j] = cloneMesh(mesh_ptr[0]); + rotateMeshBy6dFacedir(mesh_ptr[j], wm_to_6d[j]); + recalculateBoundingBox(mesh_ptr[j]); + meshmanip->recalculateNormals(mesh_ptr[j], true, false); + } + rotateMeshBy6dFacedir(mesh_ptr[0], wm_to_6d[0]); + recalculateBoundingBox(mesh_ptr[0]); + meshmanip->recalculateNormals(mesh_ptr[0], true, false); + } +} +#endif + +/* + NodeDefManager +*/ + + + + +NodeDefManager::NodeDefManager() { clear(); } -CNodeDefManager::~CNodeDefManager() +NodeDefManager::~NodeDefManager() { #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(); + for (ContentFeatures &f : m_content_features) { + for (auto &j : f.mesh_ptr) { + if (j) + j->drop(); } } #endif } -void CNodeDefManager::clear() +void NodeDefManager::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; + m_selection_box_union.reset(0,0,0); + m_selection_box_int_union.reset(0,0,0); resetNodeResolveState(); @@ -552,30 +1082,9 @@ void CNodeDefManager::clear() } -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 +bool NodeDefManager::getId(const std::string &name, content_t &result) const { - return get(n.getContent()); -} - - -bool CNodeDefManager::getId(const std::string &name, content_t &result) const -{ - std::map::const_iterator + std::unordered_map::const_iterator i = m_name_id_mapping_with_aliases.find(name); if(i == m_name_id_mapping_with_aliases.end()) return false; @@ -584,7 +1093,7 @@ bool CNodeDefManager::getId(const std::string &name, content_t &result) const } -content_t CNodeDefManager::getId(const std::string &name) const +content_t NodeDefManager::getId(const std::string &name) const { content_t id = CONTENT_IGNORE; getId(name, id); @@ -592,34 +1101,32 @@ content_t CNodeDefManager::getId(const std::string &name) const } -void CNodeDefManager::getIds(const std::string &name, - std::set &result) const +bool NodeDefManager::getIds(const std::string &name, + std::vector &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; + bool exists = getId(name, id); + if (exists) + result.push_back(id); + return exists; } std::string group = name.substr(6); - std::map::const_iterator + std::unordered_map>::const_iterator i = m_group_to_items.find(group); if (i == m_group_to_items.end()) - return; + return true; - 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 std::vector &items = i->second; + result.insert(result.end(), items.begin(), items.end()); //printf("getIds: %dus\n", t.stop()); + return true; } -const ContentFeatures& CNodeDefManager::get(const std::string &name) const +const ContentFeatures& NodeDefManager::get(const std::string &name) const { content_t id = CONTENT_UNKNOWN; getId(name, id); @@ -628,16 +1135,16 @@ const ContentFeatures& CNodeDefManager::get(const std::string &name) const // returns CONTENT_IGNORE if no free ID found -content_t CNodeDefManager::allocateId() +content_t NodeDefManager::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()); + m_content_features.emplace_back(); } const ContentFeatures &f = m_content_features[id]; - if (f.name == "") { + if (f.name.empty()) { m_next_id = id + 1; return id; } @@ -648,20 +1155,159 @@ content_t CNodeDefManager::allocateId() } +/*! + * Returns the smallest box that contains all boxes + * in the vector. Box_union is expanded. + * @param[in] boxes the vector containing the boxes + * @param[in, out] box_union the union of the arguments + */ +void boxVectorUnion(const std::vector &boxes, aabb3f *box_union) +{ + for (const aabb3f &box : boxes) { + box_union->addInternalBox(box); + } +} + + +/*! + * Returns a box that contains the nodebox in every case. + * The argument node_union is expanded. + * @param[in] nodebox the nodebox to be measured + * @param[in] features used to decide whether the nodebox + * can be rotated + * @param[in, out] box_union the union of the arguments + */ +void getNodeBoxUnion(const NodeBox &nodebox, const ContentFeatures &features, + aabb3f *box_union) +{ + switch(nodebox.type) { + case NODEBOX_FIXED: + case NODEBOX_LEVELED: { + // Raw union + aabb3f half_processed(0, 0, 0, 0, 0, 0); + boxVectorUnion(nodebox.fixed, &half_processed); + // Set leveled boxes to maximal + if (nodebox.type == NODEBOX_LEVELED) { + half_processed.MaxEdge.Y = +BS / 2; + } + if (features.param_type_2 == CPT2_FACEDIR || + features.param_type_2 == CPT2_COLORED_FACEDIR) { + // Get maximal coordinate + f32 coords[] = { + fabsf(half_processed.MinEdge.X), + fabsf(half_processed.MinEdge.Y), + fabsf(half_processed.MinEdge.Z), + fabsf(half_processed.MaxEdge.X), + fabsf(half_processed.MaxEdge.Y), + fabsf(half_processed.MaxEdge.Z) }; + f32 max = 0; + for (float coord : coords) { + if (max < coord) { + max = coord; + } + } + // Add the union of all possible rotated boxes + box_union->addInternalPoint(-max, -max, -max); + box_union->addInternalPoint(+max, +max, +max); + } else { + box_union->addInternalBox(half_processed); + } + break; + } + case NODEBOX_WALLMOUNTED: { + // Add fix boxes + box_union->addInternalBox(nodebox.wall_top); + box_union->addInternalBox(nodebox.wall_bottom); + // Find maximal coordinate in the X-Z plane + f32 coords[] = { + fabsf(nodebox.wall_side.MinEdge.X), + fabsf(nodebox.wall_side.MinEdge.Z), + fabsf(nodebox.wall_side.MaxEdge.X), + fabsf(nodebox.wall_side.MaxEdge.Z) }; + f32 max = 0; + for (float coord : coords) { + if (max < coord) { + max = coord; + } + } + // Add the union of all possible rotated boxes + box_union->addInternalPoint(-max, nodebox.wall_side.MinEdge.Y, -max); + box_union->addInternalPoint(max, nodebox.wall_side.MaxEdge.Y, max); + break; + } + case NODEBOX_CONNECTED: { + // Add all possible connected boxes + boxVectorUnion(nodebox.fixed, box_union); + boxVectorUnion(nodebox.connect_top, box_union); + boxVectorUnion(nodebox.connect_bottom, box_union); + boxVectorUnion(nodebox.connect_front, box_union); + boxVectorUnion(nodebox.connect_left, box_union); + boxVectorUnion(nodebox.connect_back, box_union); + boxVectorUnion(nodebox.connect_right, box_union); + boxVectorUnion(nodebox.disconnected_top, box_union); + boxVectorUnion(nodebox.disconnected_bottom, box_union); + boxVectorUnion(nodebox.disconnected_front, box_union); + boxVectorUnion(nodebox.disconnected_left, box_union); + boxVectorUnion(nodebox.disconnected_back, box_union); + boxVectorUnion(nodebox.disconnected_right, box_union); + boxVectorUnion(nodebox.disconnected, box_union); + boxVectorUnion(nodebox.disconnected_sides, box_union); + break; + } + default: { + // NODEBOX_REGULAR + box_union->addInternalPoint(-BS / 2, -BS / 2, -BS / 2); + box_union->addInternalPoint(+BS / 2, +BS / 2, +BS / 2); + } + } +} + + +inline void NodeDefManager::fixSelectionBoxIntUnion() +{ + m_selection_box_int_union.MinEdge.X = floorf( + m_selection_box_union.MinEdge.X / BS + 0.5f); + m_selection_box_int_union.MinEdge.Y = floorf( + m_selection_box_union.MinEdge.Y / BS + 0.5f); + m_selection_box_int_union.MinEdge.Z = floorf( + m_selection_box_union.MinEdge.Z / BS + 0.5f); + m_selection_box_int_union.MaxEdge.X = ceilf( + m_selection_box_union.MaxEdge.X / BS - 0.5f); + m_selection_box_int_union.MaxEdge.Y = ceilf( + m_selection_box_union.MaxEdge.Y / BS - 0.5f); + m_selection_box_int_union.MaxEdge.Z = ceilf( + m_selection_box_union.MaxEdge.Z / BS - 0.5f); +} + + +void NodeDefManager::eraseIdFromGroups(content_t id) +{ + // For all groups in m_group_to_items... + for (auto iter_groups = m_group_to_items.begin(); + iter_groups != m_group_to_items.end();) { + // Get the group items vector. + std::vector &items = iter_groups->second; + + // Remove any occurence of the id in the group items vector. + items.erase(std::remove(items.begin(), items.end(), id), items.end()); + + // If group is empty, erase its vector from the map. + if (items.empty()) + iter_groups = m_group_to_items.erase(iter_groups); + else + ++iter_groups; + } +} + + // IWritableNodeDefManager -content_t CNodeDefManager::set(const std::string &name, const ContentFeatures &def) +content_t NodeDefManager::set(const std::string &name, const ContentFeatures &def) { // Pre-conditions assert(name != ""); + assert(name != "ignore"); assert(name == def.name); - // Don't allow redefining ignore (but allow air and unknown) - if (name == "ignore") { - warningstream << "NodeDefManager: 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)); - } + for (const auto &group : def.groups) { + const std::string &group_name = group.first; + m_group_to_items[group_name].push_back(id); } + return id; } -content_t CNodeDefManager::allocateDummy(const std::string &name) +content_t NodeDefManager::allocateDummy(const std::string &name) { assert(name != ""); // Pre-condition ContentFeatures f; @@ -708,14 +1351,29 @@ content_t CNodeDefManager::allocateDummy(const std::string &name) } -void CNodeDefManager::updateAliases(IItemDefManager *idef) +void NodeDefManager::removeNode(const std::string &name) { - std::set all = idef->getAll(); + // Pre-condition + assert(name != ""); + + // Erase name from name ID mapping + content_t id = CONTENT_IGNORE; + if (m_name_id_mapping.getId(name, id)) { + m_name_id_mapping.eraseName(name); + m_name_id_mapping_with_aliases.erase(name); + } + + eraseIdFromGroups(id); +} + + +void NodeDefManager::updateAliases(IItemDefManager *idef) +{ + std::set all; + idef->getAll(all); 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); + for (const std::string &name : all) { + const 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( @@ -724,351 +1382,84 @@ void CNodeDefManager::updateAliases(IItemDefManager *idef) } } -void CNodeDefManager::applyTextureOverrides(const std::string &override_filepath) +void NodeDefManager::applyTextureOverrides(const std::vector &overrides) { - 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; - } + infostream << "NodeDefManager::applyTextureOverrides(): Applying " + "overrides to textures" << std::endl; + for (const TextureOverride& texture_override : overrides) { 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; - } + if (!getId(texture_override.id, id)) + continue; // Ignore unknown node 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; - } - } -} + // Override tiles + if (texture_override.hasTarget(OverrideTarget::TOP)) + nodedef.tiledef[0].name = texture_override.texture; -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" << std::endl; - ITextureSource *tsrc = gamedef->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 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"); - - bool use_normal_texture = enable_shaders && - (enable_bumpmapping || enable_parallax_occlusion); + if (texture_override.hasTarget(OverrideTarget::BOTTOM)) + nodedef.tiledef[1].name = texture_override.texture; - u32 size = m_content_features.size(); + if (texture_override.hasTarget(OverrideTarget::RIGHT)) + nodedef.tiledef[2].name = texture_override.texture; - for (u32 i = 0; i < size; i++) { - ContentFeatures *f = &m_content_features[i]; - - // 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"; - } + if (texture_override.hasTarget(OverrideTarget::LEFT)) + nodedef.tiledef[3].name = texture_override.texture; - bool is_liquid = false; - bool is_water_surface = false; + if (texture_override.hasTarget(OverrideTarget::BACK)) + nodedef.tiledef[4].name = texture_override.texture; - u8 material_type = (f->alpha == 255) ? - TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA; + if (texture_override.hasTarget(OverrideTarget::FRONT)) + nodedef.tiledef[5].name = texture_override.texture; - 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: - 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; - } 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; - } - f->drawtype = NDT_GLASSLIKE; - 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"); - } - 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); - } + // Override special tiles, if applicable + if (texture_override.hasTarget(OverrideTarget::SPECIAL_1)) + nodedef.tiledef_special[0].name = texture_override.texture; - // 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); - } + if (texture_override.hasTarget(OverrideTarget::SPECIAL_2)) + nodedef.tiledef_special[1].name = texture_override.texture; - // 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 (texture_override.hasTarget(OverrideTarget::SPECIAL_3)) + nodedef.tiledef_special[2].name = texture_override.texture; - 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); - } - } 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); - } + if (texture_override.hasTarget(OverrideTarget::SPECIAL_4)) + nodedef.tiledef_special[3].name = texture_override.texture; - //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); - } - } 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); - } + if (texture_override.hasTarget(OverrideTarget::SPECIAL_5)) + nodedef.tiledef_special[4].name = texture_override.texture; - progress_callback(progress_callback_args, i, size); + if (texture_override.hasTarget(OverrideTarget::SPECIAL_6)) + nodedef.tiledef_special[5].name = texture_override.texture; } -#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) +void NodeDefManager::updateTextures(IGameDef *gamedef, void *progress_callback_args) { - 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); - } - tile->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; - } - - if (frame_count == 1) { - tile->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++) { +#ifndef SERVER + infostream << "NodeDefManager::updateTextures(): Updating " + "textures in node definitions" << std::endl; - FrameSpec frame; + Client *client = (Client *)gamedef; + ITextureSource *tsrc = client->tsrc(); + IShaderSource *shdsrc = client->getShaderSource(); + auto smgr = client->getSceneManager(); + scene::IMeshManipulator *meshmanip = smgr->getMeshManipulator(); + TextureSettings tsettings; + tsettings.readSettings(); - os.str(""); - os << tiledef->name << "^[verticalframe:" - << frame_count << ":" << i; + u32 size = m_content_features.size(); - 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; - } + for (u32 i = 0; i < size; i++) { + ContentFeatures *f = &(m_content_features[i]); + f->updateTextures(tsrc, shdsrc, meshmanip, client, tsettings); + client->showUpdateProgressTexture(progress_callback_args, i, size); } -} #endif +} - -void CNodeDefManager::serialize(std::ostream &os, u16 protocol_version) const +void NodeDefManager::serialize(std::ostream &os, u16 protocol_version) const { writeU8(os, 1); // version u16 count = 0; @@ -1078,14 +1469,14 @@ void CNodeDefManager::serialize(std::ostream &os, u16 protocol_version) const || i == CONTENT_UNKNOWN) continue; const ContentFeatures *f = &m_content_features[i]; - if (f->name == "") + if (f->name.empty()) 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<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< 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) @@ -1400,7 +1565,7 @@ void CNodeDefManager::pendNodeResolve(NodeResolver *nr) } -bool CNodeDefManager::cancelNodeResolveCallback(NodeResolver *nr) +bool NodeDefManager::cancelNodeResolveCallback(NodeResolver *nr) const { size_t len = m_pending_resolve_callbacks.size(); for (size_t i = 0; i != len; i++) { @@ -1417,7 +1582,7 @@ bool CNodeDefManager::cancelNodeResolveCallback(NodeResolver *nr) } -void CNodeDefManager::runNodeResolveCallbacks() +void NodeDefManager::runNodeResolveCallbacks() { for (size_t i = 0; i != m_pending_resolve_callbacks.size(); i++) { NodeResolver *nr = m_pending_resolve_callbacks[i]; @@ -1428,12 +1593,80 @@ void CNodeDefManager::runNodeResolveCallbacks() } -void CNodeDefManager::resetNodeResolveState() +void NodeDefManager::resetNodeResolveState() { m_node_registration_complete = false; m_pending_resolve_callbacks.clear(); } +static void removeDupes(std::vector &list) +{ + std::sort(list.begin(), list.end()); + auto new_end = std::unique(list.begin(), list.end()); + list.erase(new_end, list.end()); +} + +void NodeDefManager::resolveCrossrefs() +{ + for (ContentFeatures &f : m_content_features) { + if (f.liquid_type != LIQUID_NONE || f.drawtype == NDT_LIQUID || f.drawtype == NDT_FLOWINGLIQUID) { + f.liquid_alternative_flowing_id = getId(f.liquid_alternative_flowing); + f.liquid_alternative_source_id = getId(f.liquid_alternative_source); + continue; + } + if (f.drawtype != NDT_NODEBOX || f.node_box.type != NODEBOX_CONNECTED) + continue; + + for (const std::string &name : f.connects_to) { + getIds(name, f.connects_to_ids); + } + removeDupes(f.connects_to_ids); + } +} + +bool NodeDefManager::nodeboxConnects(MapNode from, MapNode to, + u8 connect_face) const +{ + const ContentFeatures &f1 = get(from); + + if ((f1.drawtype != NDT_NODEBOX) || (f1.node_box.type != NODEBOX_CONNECTED)) + return false; + + // lookup target in connected set + if (!CONTAINS(f1.connects_to_ids, to.param0)) + return false; + + const ContentFeatures &f2 = get(to); + + if ((f2.drawtype == NDT_NODEBOX) && (f2.node_box.type == NODEBOX_CONNECTED)) + // ignores actually looking if back connection exists + return CONTAINS(f2.connects_to_ids, from.param0); + + // does to node declare usable faces? + if (f2.connect_sides > 0) { + if ((f2.param_type_2 == CPT2_FACEDIR || + f2.param_type_2 == CPT2_COLORED_FACEDIR) + && (connect_face >= 4)) { + static const u8 rot[33 * 4] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 32, 16, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, // 4 - back + 8, 4, 32, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, // 8 - right + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 8, 4, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, // 16 - front + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 32, 16, 8, 4 // 32 - left + }; + return (f2.connect_sides + & rot[(connect_face * 4) + (to.param2 & 0x1F)]); + } + return (f2.connect_sides & connect_face); + } + // the target is just a regular node, so connect no matter back connection + return true; +} //// //// NodeResolver @@ -1441,13 +1674,7 @@ void CNodeDefManager::resetNodeResolveState() 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); + reset(); } @@ -1458,6 +1685,18 @@ NodeResolver::~NodeResolver() } +void NodeResolver::cloneTo(NodeResolver *res) const +{ + FATAL_ERROR_IF(!m_resolve_done, "NodeResolver can only be cloned" + " after resolving has completed"); + /* We don't actually do anything significant. Since the node resolving has + * already completed, the class that called us will already have the + * resolved IDs in its data structures (which it copies on its own) */ + res->m_ndef = m_ndef; + res->m_resolve_done = true; +} + + void NodeResolver::nodeResolveInternal() { m_nodenames_idx = 0; @@ -1472,7 +1711,7 @@ void NodeResolver::nodeResolveInternal() bool NodeResolver::getIdFromNrBacklog(content_t *result_out, - const std::string &node_alt, content_t c_fallback) + const std::string &node_alt, content_t c_fallback, bool error_on_fallback) { if (m_nodenames_idx == m_nodenames.size()) { *result_out = c_fallback; @@ -1484,14 +1723,15 @@ bool NodeResolver::getIdFromNrBacklog(content_t *result_out, std::string name = m_nodenames[m_nodenames_idx++]; bool success = m_ndef->getId(name, c); - if (!success && node_alt != "") { + if (!success && !node_alt.empty()) { name = node_alt; success = m_ndef->getId(name, c); } if (!success) { - errorstream << "NodeResolver: failed to resolve node name '" << name - << "'." << std::endl; + if (error_on_fallback) + errorstream << "NodeResolver: failed to resolve node name '" << name + << "'." << std::endl; c = c_fallback; } @@ -1531,13 +1771,22 @@ bool NodeResolver::getIdsFromNrBacklog(std::vector *result_out, 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); + m_ndef->getIds(name, *result_out); } } return success; } + +void NodeResolver::reset(bool resolve_done) +{ + m_nodenames.clear(); + m_nodenames_idx = 0; + m_nnlistsizes.clear(); + m_nnlistsizes_idx = 0; + + m_resolve_done = resolve_done; + + m_nodenames.reserve(16); + m_nnlistsizes.reserve(4); +}