/*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
#include "nodedef.h"
-#include "main.h" // For g_settings
#include "itemdef.h"
#ifndef SERVER
-#include "tile.h"
+#include "client/mesh.h"
+#include "client/shader.h"
+#include "client/client.h"
+#include "client/renderingengine.h"
+#include "client/tile.h"
+#include <IMeshManipulator.h>
#endif
#include "log.h"
#include "settings.h"
#include "nameidmapping.h"
+#include "util/numeric.h"
#include "util/serialize.h"
+#include "exceptions.h"
+#include "debug.h"
+#include "gamedef.h"
+#include "mapnode.h"
+#include <fstream> // Used in applyTextureOverrides()
+#include <algorithm>
+#include <cmath>
/*
NodeBox
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) const
+void NodeBox::serialize(std::ostream &os, u16 protocol_version) const
{
- writeU8(os, 1); // version
- writeU8(os, type);
+ // Protocol >= 36
+ const u8 version = 6;
+ writeU8(os, version);
+
+ switch (type) {
+ case NODEBOX_LEVELED:
+ case NODEBOX_FIXED:
+ writeU8(os, type);
- if(type == NODEBOX_FIXED)
- {
writeU16(os, fixed.size());
- for(std::vector<aabb3f>::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)
+ if (version < 6)
throw SerializationError("unsupported NodeBox version");
reset();
type = (enum NodeBoxType)readU8(is);
- if(type == NODEBOX_FIXED)
+ if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
{
u16 fixed_count = readU16(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);
}
}
/*
TileDef
*/
-
-void TileDef::serialize(std::ostream &os) const
+
+#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
{
- writeU8(os, 0); // version
- os<<serializeString(name);
- writeU8(os, animation.type);
- writeU16(os, animation.aspect_w);
- writeU16(os, animation.aspect_h);
- writeF1000(os, animation.length);
+ // 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);
- if(version != 0)
+ if (version < 6)
throw SerializationError("unsupported TileDef version");
- name = deSerializeString(is);
- animation.type = (TileAnimationType)readU8(is);
- animation.aspect_w = readU16(is);
- animation.aspect_h = readU16(is);
- animation.length = readF1000(is);
+ 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<AlignStyle>(readU8(is));
+ else
+ align_style = ALIGN_STYLE_NODE;
}
-/*
- SimpleSoundSpec serialization
-*/
-
-static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss,
- std::ostream &os)
-{
- os<<serializeString(ss.name);
- writeF1000(os, ss.gain);
-}
-static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss, std::istream &is)
+void TextureSettings::readSettings()
{
- ss.name = deSerializeString(is);
- ss.gain = readF1000(is);
+ 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;
+ }
+
+ 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;
+
+ if (autoscale_mode_str == "enable")
+ autoscale_mode = AUTOSCALE_ENABLE;
+ else if (autoscale_mode_str == "force")
+ autoscale_mode = AUTOSCALE_FORCE;
+ else
+ autoscale_mode = AUTOSCALE_DISABLE;
}
/*
ContentFeatures::~ContentFeatures()
{
+#ifndef SERVER
+ for (u16 j = 0; j < 6; j++) {
+ delete tiles[j].layers[0].frames;
+ delete tiles[j].layers[1].frames;
+ }
+ for (u16 j = 0; j < CF_SPECIAL_COUNT; j++)
+ delete special_tiles[j].layers[0].frames;
+#endif
}
void ContentFeatures::reset()
solidness = 2;
visual_solidness = 0;
backface_culling = true;
+
#endif
has_on_construct = false;
has_on_destruct = false;
has_after_destruct = false;
/*
Actual data
-
+
NOTE: Most of this is always overridden by the default values given
in builtin.lua
*/
// Unknown nodes can be dug
groups["dig_immediate"] = 2;
drawtype = NDT_NORMAL;
+ mesh = "";
+#ifndef SERVER
+ for (auto &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++)
- tiledef[i] = TileDef();
- for(u16 j=0; j<CF_SPECIAL_COUNT; j++)
- tiledef_special[j] = TileDef();
- alpha = 255;
+ for (auto &i : tiledef)
+ i = TileDef();
+ for (auto &j : tiledef_special)
+ j = TileDef();
+ alpha = ALPHAMODE_OPAQUE;
post_effect_color = video::SColor(0, 0, 0, 0);
param_type = CPT_NONE;
param_type_2 = CPT2_NONE;
diggable = true;
climbable = false;
buildable_to = false;
+ floodable = false;
+ rightclickable = true;
+ leveled = 0;
+ leveled_max = LEVELED_MAX;
liquid_type = LIQUID_NONE;
liquid_alternative_flowing = "";
+ liquid_alternative_flowing_id = CONTENT_IGNORE;
liquid_alternative_source = "";
+ liquid_alternative_source_id = CONTENT_IGNORE;
liquid_viscosity = 0;
liquid_renewable = true;
+ liquid_range = LIQUID_LEVEL_MAX+1;
+ drowning = 0;
light_source = 0;
damage_per_second = 0;
node_box = NodeBox();
selection_box = NodeBox();
+ collision_box = NodeBox();
+ waving = 0;
legacy_facedir_simple = false;
legacy_wallmounted = false;
sound_footstep = SimpleSoundSpec();
sound_dig = SimpleSoundSpec("__group");
sound_dug = SimpleSoundSpec();
+ connects_to.clear();
+ connects_to_ids.clear();
+ connect_sides = 0;
+ color = video::SColor(0xFFFFFFFF);
+ palette_name = "";
+ palette = NULL;
+ node_dig_prediction = "air";
}
-void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
+void ContentFeatures::setAlphaFromLegacy(u8 legacy_alpha)
{
- if(protocol_version < 14){
- serializeOld(os, protocol_version);
- return;
+ // No special handling for nodebox/mesh here as it doesn't make sense to
+ // throw warnings when the server is too old to support the "correct" way
+ switch (drawtype) {
+ case NDT_NORMAL:
+ alpha = legacy_alpha == 255 ? ALPHAMODE_OPAQUE : ALPHAMODE_CLIP;
+ break;
+ case NDT_LIQUID:
+ case NDT_FLOWINGLIQUID:
+ alpha = legacy_alpha == 255 ? ALPHAMODE_OPAQUE : ALPHAMODE_BLEND;
+ break;
+ default:
+ alpha = legacy_alpha == 255 ? ALPHAMODE_CLIP : ALPHAMODE_BLEND;
+ break;
}
+}
- writeU8(os, 6); // version
- os<<serializeString(name);
+u8 ContentFeatures::getAlphaForLegacy() const
+{
+ // This is so simple only because 255 and 0 mean wildly different things
+ // depending on drawtype...
+ return alpha == ALPHAMODE_OPAQUE ? 255 : 0;
+}
+
+void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
+{
+ const u8 version = CONTENTFEATURES_VERSION;
+ writeU8(os, version);
+
+ // general
+ os << serializeString16(name);
writeU16(os, groups.size());
- for(ItemGroupList::const_iterator
- i = groups.begin(); i != groups.end(); i++){
- os<<serializeString(i->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);
+ 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);
+ 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<<serializeString(""); // legacy: used to be metadata_name
+ writeU8(os, rightclickable);
+ writeU32(os, damage_per_second);
+
+ // liquid
writeU8(os, liquid_type);
- os<<serializeString(liquid_alternative_flowing);
- os<<serializeString(liquid_alternative_source);
+ os << serializeString16(liquid_alternative_flowing);
+ os << serializeString16(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable);
- writeU8(os, light_source);
- writeU32(os, damage_per_second);
- node_box.serialize(os);
- selection_box.serialize(os);
+ writeU8(os, liquid_range);
+ writeU8(os, drowning);
+ writeU8(os, floodable);
+
+ // node boxes
+ node_box.serialize(os, protocol_version);
+ selection_box.serialize(os, protocol_version);
+ collision_box.serialize(os, protocol_version);
+
+ // sound
+ sound_footstep.serialize(os, version);
+ sound_dig.serialize(os, version);
+ sound_dug.serialize(os, version);
+
+ // legacy
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
- serializeSimpleSoundSpec(sound_footstep, os);
- serializeSimpleSoundSpec(sound_dig, os);
- serializeSimpleSoundSpec(sound_dug, os);
- // Stuff below should be moved to correct place in a version that otherwise changes
- // the protocol version
+
+ os << serializeString16(node_dig_prediction);
+ writeU8(os, leveled_max);
+ writeU8(os, alpha);
}
void ContentFeatures::deSerialize(std::istream &is)
{
- int version = readU8(is);
- if(version != 6){
- deSerializeOld(is, version);
- return;
- }
+ // version detection
+ const u8 version = readU8(is);
+ if (version < CONTENTFEATURES_VERSION)
+ throw SerializationError("unsupported ContentFeatures version");
- name = deSerializeString(is);
+ // general
+ name = deSerializeString16(is);
groups.clear();
u32 groups_size = readU16(is);
- for(u32 i=0; i<groups_size; i++){
- std::string name = deSerializeString(is);
+ for (u32 i = 0; i < groups_size; i++) {
+ std::string name = deSerializeString16(is);
int value = readS16(is);
groups[name] = value;
}
- drawtype = (enum NodeDrawType)readU8(is);
- visual_scale = readF1000(is);
- if(readU8(is) != 6)
+ param_type = (enum ContentParamType) readU8(is);
+ param_type_2 = (enum ContentParamType2) readU8(is);
+
+ // visual
+ drawtype = (enum NodeDrawType) readU8(is);
+ mesh = deSerializeString16(is);
+ visual_scale = readF32(is);
+ if (readU8(is) != 6)
throw SerializationError("unsupported tile count");
- for(u32 i=0; i<6; i++)
- tiledef[i].deSerialize(is);
- if(readU8(is) != CF_SPECIAL_COUNT)
+ for (TileDef &td : tiledef)
+ td.deSerialize(is, version, drawtype);
+ for (TileDef &td : tiledef_overlay)
+ td.deSerialize(is, version, drawtype);
+ if (readU8(is) != CF_SPECIAL_COUNT)
throw SerializationError("unsupported CF_SPECIAL_COUNT");
- for(u32 i=0; i<CF_SPECIAL_COUNT; i++)
- tiledef_special[i].deSerialize(is);
- alpha = readU8(is);
- post_effect_color.setAlpha(readU8(is));
- post_effect_color.setRed(readU8(is));
- post_effect_color.setGreen(readU8(is));
- post_effect_color.setBlue(readU8(is));
- param_type = (enum ContentParamType)readU8(is);
- param_type_2 = (enum ContentParamType2)readU8(is);
- is_ground_content = readU8(is);
+ for (TileDef &td : tiledef_special)
+ td.deSerialize(is, version, drawtype);
+ setAlphaFromLegacy(readU8(is));
+ color.setRed(readU8(is));
+ color.setGreen(readU8(is));
+ color.setBlue(readU8(is));
+ palette_name = deSerializeString16(is);
+ waving = readU8(is);
+ connect_sides = readU8(is);
+ u16 connects_to_size = readU16(is);
+ connects_to_ids.clear();
+ for (u16 i = 0; i < connects_to_size; i++)
+ connects_to_ids.push_back(readU16(is));
+ post_effect_color = readARGB8(is);
+ leveled = readU8(is);
+
+ // lighting-related
light_propagates = readU8(is);
sunlight_propagates = readU8(is);
+ light_source = readU8(is);
+ light_source = MYMIN(light_source, LIGHT_MAX);
+
+ // map generation
+ is_ground_content = readU8(is);
+
+ // interaction
walkable = readU8(is);
pointable = readU8(is);
diggable = readU8(is);
climbable = readU8(is);
buildable_to = readU8(is);
- deSerializeString(is); // legacy: used to be metadata_name
- liquid_type = (enum LiquidType)readU8(is);
- liquid_alternative_flowing = deSerializeString(is);
- liquid_alternative_source = deSerializeString(is);
+ rightclickable = readU8(is);
+ damage_per_second = readU32(is);
+
+ // liquid
+ liquid_type = (enum LiquidType) readU8(is);
+ liquid_alternative_flowing = deSerializeString16(is);
+ liquid_alternative_source = deSerializeString16(is);
liquid_viscosity = readU8(is);
liquid_renewable = readU8(is);
- light_source = readU8(is);
- damage_per_second = readU32(is);
+ liquid_range = readU8(is);
+ drowning = readU8(is);
+ floodable = readU8(is);
+
+ // node boxes
node_box.deSerialize(is);
selection_box.deSerialize(is);
+ collision_box.deSerialize(is);
+
+ // sounds
+ sound_footstep.deSerialize(is, version);
+ sound_dig.deSerialize(is, version);
+ sound_dug.deSerialize(is, version);
+
+ // read legacy properties
legacy_facedir_simple = readU8(is);
legacy_wallmounted = readU8(is);
- deSerializeSimpleSoundSpec(sound_footstep, is);
- deSerializeSimpleSoundSpec(sound_dig, is);
- deSerializeSimpleSoundSpec(sound_dug, is);
- // If you add anything here, insert it primarily inside the try-catch
- // block to not need to increase the version.
- try{
- // Stuff below should be moved to correct place in a version that
- // otherwise changes the protocol version
- }catch(SerializationError &e) {};
-}
-/*
- CNodeDefManager
-*/
+ try {
+ node_dig_prediction = deSerializeString16(is);
-class CNodeDefManager: public IWritableNodeDefManager
+ u8 tmp = readU8(is);
+ if (is.eof()) /* readU8 doesn't throw exceptions so we have to do this */
+ throw SerializationError("");
+ leveled_max = tmp;
+
+ tmp = readU8(is);
+ if (is.eof())
+ throw SerializationError("");
+ alpha = static_cast<enum AlphaMode>(tmp);
+ } catch(SerializationError &e) {};
+}
+
+#ifndef SERVER
+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)
{
-public:
- void clear()
- {
- m_name_id_mapping.clear();
- m_name_id_mapping_with_aliases.clear();
+ layer->shader_id = shader_id;
+ layer->texture = tsrc->getTextureForMesh(tiledef.name, &layer->texture_id);
+ layer->material_type = material_type;
- for(u16 i=0; i<=MAX_CONTENT; i++)
- {
- ContentFeatures &f = m_content_features[i];
- f.reset(); // Reset to defaults
- }
-
- // 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;
- // Insert directly into containers
- content_t c = CONTENT_AIR;
- m_content_features[c] = f;
- addNameIdMapping(c, f.name);
+ 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;
+ }
+
+ 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<FrameSpec>();
}
- // 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;
- // A way to remove accidental CONTENT_IGNOREs
- f.buildable_to = true;
- // Insert directly into containers
- content_t c = CONTENT_IGNORE;
- m_content_features[c] = f;
- addNameIdMapping(c, f.name);
+ layer->frames->resize(frame_count);
+
+ for (int i = 0; i < frame_count; i++) {
+
+ FrameSpec frame;
+
+ os.str("");
+ os << tiledef.name;
+ tiledef.animation.getTextureModifer(os,
+ layer->texture->getOriginalSize(), i);
+
+ 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;
}
}
- // CONTENT_IGNORE = not found
- content_t getFreeId()
- {
- for(u32 i=0; i<=0xffff; i++){
- const ContentFeatures &f = m_content_features[i];
- if(f.name == "")
- return i;
+}
+
+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<std::string> seen;
+
+ for (int i = 0; i < length; i++) {
+ if (seen.find(tiles[i].name) != seen.end())
+ continue;
+ seen.insert(tiles[i].name);
+
+ // 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<s32>(0, 0), texture->getOriginalSize());
+ if (!image)
+ continue;
+ core::dimension2d<u32> 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;
+ }
+ }
}
- return CONTENT_IGNORE;
+
+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;
}
- CNodeDefManager()
- {
- clear();
+ return false;
+}
+
+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";
}
- virtual ~CNodeDefManager()
- {
+ // 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;
}
- virtual IWritableNodeDefManager* clone()
- {
- CNodeDefManager *mgr = new CNodeDefManager();
- for(u16 i=0; i<=MAX_CONTENT; i++)
- {
- mgr->set(i, get(i));
+
+ 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);
}
- return mgr;
+ break;
+ case NDT_TORCHLIKE:
+ case NDT_SIGNLIKE:
+ case NDT_FENCELIKE:
+ case NDT_RAILLIKE:
+ solidness = 0;
+ break;
+ case NDT_PLANTLIKE_ROOTED:
+ solidness = 2;
+ break;
}
- virtual const ContentFeatures& get(content_t c) const
- {
- assert(c <= MAX_CONTENT);
- return m_content_features[c];
+
+ 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;
+ }
}
- virtual const ContentFeatures& get(const MapNode &n) const
- {
- return get(n.getContent());
+
+ 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);
}
- virtual bool getId(const std::string &name, content_t &result) const
- {
- std::map<std::string, content_t>::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;
+
+ 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;
}
- virtual content_t getId(const std::string &name) const
- {
- content_t id = CONTENT_IGNORE;
- getId(name, id);
- return id;
+ 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)
+ 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);
+ }
}
- virtual void getIds(const std::string &name, std::set<content_t> &result)
- const
- {
- if(name.substr(0,6) != "group:"){
- content_t id = CONTENT_IGNORE;
- if(getId(name, id))
- result.insert(id);
- return;
+
+ //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);
}
- std::string group = name.substr(6);
- for(u16 id=0; id<=MAX_CONTENT; id++)
- {
- const ContentFeatures &f = m_content_features[id];
- if(f.name == "") // Quickly discard undefined nodes
- continue;
- if(itemgroup_get(f.groups, group) != 0)
- result.insert(id);
+ } 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);
}
- virtual const ContentFeatures& get(const std::string &name) const
- {
- content_t id = CONTENT_IGNORE;
- getId(name, id);
- return get(id);
- }
- // IWritableNodeDefManager
- virtual void set(content_t c, const ContentFeatures &def)
- {
- verbosestream<<"registerNode: registering content id \""<<c
- <<"\": name=\""<<def.name<<"\""<<std::endl;
- assert(c <= MAX_CONTENT);
- // Don't allow redefining CONTENT_IGNORE (but allow air)
- if(def.name == "ignore" || c == CONTENT_IGNORE){
- infostream<<"registerNode: WARNING: Ignoring "
- <<"CONTENT_IGNORE redefinition"<<std::endl;
- return;
- }
- // Check that the special contents are not redefined as different id
- // because it would mess up everything
- if((def.name == "ignore" && c != CONTENT_IGNORE) ||
- (def.name == "air" && c != CONTENT_AIR)){
- errorstream<<"registerNode: IGNORING ERROR: "
- <<"trying to register built-in type \""
- <<def.name<<"\" as different id"<<std::endl;
- return;
+}
+#endif
+
+/*
+ NodeDefManager
+*/
+
+
+
+
+NodeDefManager::NodeDefManager()
+{
+ clear();
+}
+
+
+NodeDefManager::~NodeDefManager()
+{
+#ifndef SERVER
+ for (ContentFeatures &f : m_content_features) {
+ for (auto &j : f.mesh_ptr) {
+ if (j)
+ j->drop();
}
- m_content_features[c] = def;
- if(def.name != "")
- addNameIdMapping(c, def.name);
}
- virtual content_t set(const std::string &name,
- const ContentFeatures &def)
+#endif
+}
+
+
+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();
+
+ 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
{
- assert(name == def.name);
- u16 id = CONTENT_IGNORE;
- bool found = m_name_id_mapping.getId(name, id); // ignore aliases
- if(!found){
- // Get some id
- id = getFreeId();
- if(id == CONTENT_IGNORE)
- return CONTENT_IGNORE;
- if(name != "")
- addNameIdMapping(id, name);
- }
- set(id, def);
- return id;
+ ContentFeatures f;
+ f.name = "unknown";
+ // Insert directly into containers
+ content_t c = CONTENT_UNKNOWN;
+ m_content_features[c] = f;
+ addNameIdMapping(c, f.name);
}
- virtual content_t allocateDummy(const std::string &name)
+
+ // Set CONTENT_AIR
{
- assert(name != "");
ContentFeatures f;
- f.name = name;
- return set(name, 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.floodable = 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 void updateAliases(IItemDefManager *idef)
+
+ // Set CONTENT_IGNORE
{
- std::set<std::string> all = idef->getAll();
- m_name_id_mapping_with_aliases.clear();
- for(std::set<std::string>::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));
- }
+ 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);
+ }
+}
+
+
+bool NodeDefManager::getId(const std::string &name, content_t &result) const
+{
+ std::unordered_map<std::string, content_t>::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 NodeDefManager::getId(const std::string &name) const
+{
+ content_t id = CONTENT_IGNORE;
+ getId(name, id);
+ return id;
+}
+
+
+bool NodeDefManager::getIds(const std::string &name,
+ std::vector<content_t> &result) const
+{
+ //TimeTaker t("getIds", NULL, PRECISION_MICRO);
+ if (name.substr(0,6) != "group:") {
+ content_t id = CONTENT_IGNORE;
+ bool exists = getId(name, id);
+ if (exists)
+ result.push_back(id);
+ return exists;
+ }
+ std::string group = name.substr(6);
+
+ std::unordered_map<std::string, std::vector<content_t>>::const_iterator
+ i = m_group_to_items.find(group);
+ if (i == m_group_to_items.end())
+ return true;
+
+ const std::vector<content_t> &items = i->second;
+ result.insert(result.end(), items.begin(), items.end());
+ //printf("getIds: %dus\n", t.stop());
+ return true;
+}
+
+
+const ContentFeatures& NodeDefManager::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 NodeDefManager::allocateId()
+{
+ for (content_t id = m_next_id;
+ id >= m_next_id; // overflow?
+ ++id) {
+ while (id >= m_content_features.size()) {
+ m_content_features.emplace_back();
+ }
+ const ContentFeatures &f = m_content_features[id];
+ if (f.name.empty()) {
+ m_next_id = id + 1;
+ return id;
}
}
- virtual void updateTextures(ITextureSource *tsrc)
- {
-#ifndef SERVER
- infostream<<"CNodeDefManager::updateTextures(): Updating "
- <<"textures in node definitions"<<std::endl;
-
- 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");
-
- for(u16 i=0; i<=MAX_CONTENT; i++)
- {
- ContentFeatures *f = &m_content_features[i];
-
- // 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_block.png";
- }
+ // If we arrive here, an overflow occurred in id.
+ // That means no ID was found
+ return CONTENT_IGNORE;
+}
- bool is_liquid = false;
- 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_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");
- }
- }
- break;
- case NDT_TORCHLIKE:
- case NDT_SIGNLIKE:
- case NDT_PLANTLIKE:
- case NDT_FENCELIKE:
- case NDT_RAILLIKE:
- case NDT_NODEBOX:
- f->solidness = 0;
- break;
- }
- u8 material_type = 0;
- if(is_liquid){
- if(f->alpha == 255)
- material_type = TILE_MATERIAL_LIQUID_OPAQUE;
- else
- material_type = TILE_MATERIAL_LIQUID_TRANSPARENT;
- } else{
- material_type = TILE_MATERIAL_BASIC;
- }
+/*!
+ * 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<aabb3f> &boxes, aabb3f *box_union)
+{
+ for (const aabb3f &box : boxes) {
+ box_union->addInternalBox(box);
+ }
+}
+
- // Tiles (fill in f->tiles[])
- for(u16 j=0; j<6; j++){
- // Texture
- f->tiles[j].texture = tsrc->getTexture(tiledef[j].name);
- // 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 raw texture size to determine frame count by
- // aspect ratio
- video::ITexture *t = tsrc->getTextureRaw(tiledef[j].name);
- v2u32 size = t->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;
+/*!
+ * 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);
}
- // Special tiles (fill in f->special_tiles[])
- for(u16 j=0; j<CF_SPECIAL_COUNT; j++){
- // Texture
- f->special_tiles[j].texture =
- tsrc->getTexture(f->tiledef_special[j].name);
- // 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 raw texture size to determine frame count by
- // aspect ratio
- video::ITexture *t = tsrc->getTextureRaw(f->tiledef_special[j].name);
- v2u32 size = t->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;
- }
+ 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);
}
-#endif
}
- void serialize(std::ostream &os, u16 protocol_version)
- {
- writeU8(os, 1); // version
- u16 count = 0;
- std::ostringstream os2(std::ios::binary);
- for(u16 i=0; i<=MAX_CONTENT; i++)
- {
- if(i == CONTENT_IGNORE || i == CONTENT_AIR)
- continue;
- 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<<serializeString(wrapper_os.str());
- count++;
+}
+
+
+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<content_t> &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 NodeDefManager::set(const std::string &name, const ContentFeatures &def)
+{
+ // Pre-conditions
+ assert(name != "");
+ assert(name != "ignore");
+ assert(name == def.name);
+
+ content_t id = CONTENT_IGNORE;
+ if (!m_name_id_mapping.getId(name, id)) { // ignore aliases
+ // Get new id
+ id = allocateId();
+ if (id == CONTENT_IGNORE) {
+ warningstream << "NodeDefManager: Absolute "
+ "limit reached" << std::endl;
+ return CONTENT_IGNORE;
}
- writeU16(os, count);
- os<<serializeLongString(os2.str());
+ assert(id != CONTENT_IGNORE);
+ addNameIdMapping(id, name);
}
- 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);
- for(u16 n=0; n<count; n++){
- u16 i = readU16(is2);
- if(i > MAX_CONTENT){
- errorstream<<"ContentFeatures::deSerialize(): "
- <<"Too large content id: "<<i<<std::endl;
- continue;
- }
- /*// Do not deserialize special types
- if(i == CONTENT_IGNORE || i == CONTENT_AIR)
- continue;*/
- ContentFeatures *f = &m_content_features[i];
- // Read it from the string wrapper
- std::string wrapper = deSerializeString(is2);
- std::istringstream wrapper_is(wrapper, std::ios::binary);
- f->deSerialize(wrapper_is);
- verbosestream<<"deserialized "<<f->name<<std::endl;
- if(f->name != "")
- addNameIdMapping(i, f->name);
+
+ // If there is already ContentFeatures registered for this id, clear old groups
+ if (id < m_content_features.size())
+ eraseIdFromGroups(id);
+
+ m_content_features[id] = def;
+ verbosestream << "NodeDefManager: registering content id \"" << id
+ << "\": name=\"" << def.name << "\""<<std::endl;
+
+ getNodeBoxUnion(def.selection_box, def, &m_selection_box_union);
+ fixSelectionBoxIntUnion();
+
+ // Add this content to the list of all groups it belongs to
+ 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 NodeDefManager::allocateDummy(const std::string &name)
+{
+ assert(name != ""); // Pre-condition
+ ContentFeatures f;
+ f.name = name;
+ return set(name, f);
+}
+
+
+void NodeDefManager::removeNode(const std::string &name)
+{
+ // 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<std::string> all;
+ idef->getAll(all);
+ m_name_id_mapping_with_aliases.clear();
+ 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(
+ std::make_pair(name, id));
}
}
-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));
+}
+
+void NodeDefManager::applyTextureOverrides(const std::vector<TextureOverride> &overrides)
+{
+ infostream << "NodeDefManager::applyTextureOverrides(): Applying "
+ "overrides to textures" << std::endl;
+
+ for (const TextureOverride& texture_override : overrides) {
+ content_t id;
+ if (!getId(texture_override.id, id))
+ continue; // Ignore unknown node
+
+ ContentFeatures &nodedef = m_content_features[id];
+
+ // Override tiles
+ if (texture_override.hasTarget(OverrideTarget::TOP))
+ nodedef.tiledef[0].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::BOTTOM))
+ nodedef.tiledef[1].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::RIGHT))
+ nodedef.tiledef[2].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::LEFT))
+ nodedef.tiledef[3].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::BACK))
+ nodedef.tiledef[4].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::FRONT))
+ nodedef.tiledef[5].name = texture_override.texture;
+
+
+ // Override special tiles, if applicable
+ if (texture_override.hasTarget(OverrideTarget::SPECIAL_1))
+ nodedef.tiledef_special[0].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::SPECIAL_2))
+ nodedef.tiledef_special[1].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::SPECIAL_3))
+ nodedef.tiledef_special[2].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::SPECIAL_4))
+ nodedef.tiledef_special[3].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::SPECIAL_5))
+ nodedef.tiledef_special[4].name = texture_override.texture;
+
+ if (texture_override.hasTarget(OverrideTarget::SPECIAL_6))
+ nodedef.tiledef_special[5].name = texture_override.texture;
}
-private:
- // Features indexed by id
- ContentFeatures m_content_features[MAX_CONTENT+1];
- // 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<std::string, content_t> m_name_id_mapping_with_aliases;
-};
+}
-IWritableNodeDefManager* createNodeDefManager()
+void NodeDefManager::updateTextures(IGameDef *gamedef,
+ void (*progress_callback)(void *progress_args, u32 progress, u32 max_progress),
+ void *progress_callback_args)
{
- return new CNodeDefManager();
+#ifndef SERVER
+ infostream << "NodeDefManager::updateTextures(): Updating "
+ "textures in node definitions" << std::endl;
+
+ Client *client = (Client *)gamedef;
+ ITextureSource *tsrc = client->tsrc();
+ IShaderSource *shdsrc = client->getShaderSource();
+ scene::IMeshManipulator *meshmanip =
+ RenderingEngine::get_scene_manager()->getMeshManipulator();
+ TextureSettings tsettings;
+ tsettings.readSettings();
+
+ u32 size = m_content_features.size();
+
+ for (u32 i = 0; i < size; i++) {
+ ContentFeatures *f = &(m_content_features[i]);
+ f->updateTextures(tsrc, shdsrc, meshmanip, client, tsettings);
+ progress_callback(progress_callback_args, i, size);
+ }
+#endif
}
-/*
- Serialization of old ContentFeatures formats
-*/
+void NodeDefManager::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.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<<serializeString16(wrapper_os.str());
+
+ // must not overflow
+ u16 next = count + 1;
+ FATAL_ERROR_IF(next < count, "Overflow");
+ count++;
+ }
+ writeU16(os, count);
+ os << serializeString32(os2.str());
+}
-void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version)
+
+void NodeDefManager::deSerialize(std::istream &is)
{
- if(protocol_version == 13)
- {
- writeU8(os, 5); // version
- os<<serializeString(name);
- writeU16(os, groups.size());
- for(ItemGroupList::const_iterator
- i = groups.begin(); i != groups.end(); i++){
- os<<serializeString(i->first);
- writeS16(os, i->second);
+ clear();
+ int version = readU8(is);
+ if (version != 1)
+ throw SerializationError("unsupported NodeDefinitionManager version");
+ u16 count = readU16(is);
+ std::istringstream is2(deSerializeString32(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 = deSerializeString16(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) {
+ warningstream << "NodeDefManager::deSerialize(): "
+ "not changing builtin node " << i << std::endl;
+ continue;
}
- writeU8(os, drawtype);
- writeF1000(os, visual_scale);
- writeU8(os, 6);
- for(u32 i=0; i<6; i++)
- tiledef[i].serialize(os);
- writeU8(os, CF_SPECIAL_COUNT);
- for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
- tiledef_special[i].serialize(os);
+ if (f.name.empty()) {
+ warningstream << "NodeDefManager::deSerialize(): "
+ "received empty name" << std::endl;
+ continue;
}
- 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<<serializeString(""); // legacy: used to be metadata_name
- writeU8(os, liquid_type);
- os<<serializeString(liquid_alternative_flowing);
- os<<serializeString(liquid_alternative_source);
- writeU8(os, liquid_viscosity);
- writeU8(os, light_source);
- writeU32(os, damage_per_second);
- node_box.serialize(os);
- selection_box.serialize(os);
- writeU8(os, legacy_facedir_simple);
- writeU8(os, legacy_wallmounted);
- serializeSimpleSoundSpec(sound_footstep, os);
- serializeSimpleSoundSpec(sound_dig, os);
- serializeSimpleSoundSpec(sound_dug, os);
+
+ // Ignore aliases
+ u16 existing_id;
+ if (m_name_id_mapping.getId(f.name, existing_id) && i != existing_id) {
+ warningstream << "NodeDefManager::deSerialize(): "
+ "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);
+ TRACESTREAM(<< "NodeDef: deserialized " << f.name << std::endl);
+
+ getNodeBoxUnion(f.selection_box, f, &m_selection_box_union);
+ fixSelectionBoxIntUnion();
}
+
+ // Since liquid_alternative_flowing_id and liquid_alternative_source_id
+ // are not sent, resolve them client-side too.
+ resolveCrossrefs();
+}
+
+
+void NodeDefManager::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));
+}
+
+
+NodeDefManager *createNodeDefManager()
+{
+ return new NodeDefManager();
+}
+
+
+void NodeDefManager::pendNodeResolve(NodeResolver *nr) const
+{
+ nr->m_ndef = this;
+ if (m_node_registration_complete)
+ nr->nodeResolveInternal();
else
- {
- throw SerializationError("ContentFeatures::serialize(): Unsupported version requested");
+ m_pending_resolve_callbacks.push_back(nr);
+}
+
+
+bool NodeDefManager::cancelNodeResolveCallback(NodeResolver *nr) const
+{
+ 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 ContentFeatures::deSerializeOld(std::istream &is, int version)
+
+void NodeDefManager::runNodeResolveCallbacks()
{
- if(version == 5) // In PROTOCOL_VERSION 13
- {
- name = deSerializeString(is);
- groups.clear();
- u32 groups_size = readU16(is);
- for(u32 i=0; i<groups_size; i++){
- std::string name = deSerializeString(is);
- int value = readS16(is);
- groups[name] = value;
+ 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 NodeDefManager::resetNodeResolveState()
+{
+ m_node_registration_complete = false;
+ m_pending_resolve_callbacks.clear();
+}
+
+static void removeDupes(std::vector<content_t> &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;
}
- drawtype = (enum NodeDrawType)readU8(is);
- visual_scale = readF1000(is);
- if(readU8(is) != 6)
- throw SerializationError("unsupported tile count");
- for(u32 i=0; i<6; i++)
- tiledef[i].deSerialize(is);
- if(readU8(is) != CF_SPECIAL_COUNT)
- throw SerializationError("unsupported CF_SPECIAL_COUNT");
- for(u32 i=0; i<CF_SPECIAL_COUNT; i++)
- tiledef_special[i].deSerialize(is);
- alpha = readU8(is);
- post_effect_color.setAlpha(readU8(is));
- post_effect_color.setRed(readU8(is));
- post_effect_color.setGreen(readU8(is));
- post_effect_color.setBlue(readU8(is));
- param_type = (enum ContentParamType)readU8(is);
- param_type_2 = (enum ContentParamType2)readU8(is);
- is_ground_content = readU8(is);
- light_propagates = readU8(is);
- sunlight_propagates = readU8(is);
- walkable = readU8(is);
- pointable = readU8(is);
- diggable = readU8(is);
- climbable = readU8(is);
- buildable_to = readU8(is);
- deSerializeString(is); // legacy: used to be metadata_name
- liquid_type = (enum LiquidType)readU8(is);
- liquid_alternative_flowing = deSerializeString(is);
- liquid_alternative_source = deSerializeString(is);
- liquid_viscosity = readU8(is);
- light_source = readU8(is);
- damage_per_second = readU32(is);
- node_box.deSerialize(is);
- selection_box.deSerialize(is);
- legacy_facedir_simple = readU8(is);
- legacy_wallmounted = readU8(is);
- deSerializeSimpleSoundSpec(sound_footstep, is);
- deSerializeSimpleSoundSpec(sound_dig, is);
- deSerializeSimpleSoundSpec(sound_dug, is);
+ 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);
}
- else
- {
- throw SerializationError("unsupported ContentFeatures version");
+}
+
+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
+////
+
+NodeResolver::NodeResolver()
+{
+ m_nodenames.reserve(16);
+ m_nnlistsizes.reserve(4);
+}
+
+
+NodeResolver::~NodeResolver()
+{
+ if (!m_resolve_done && m_ndef)
+ m_ndef->cancelNodeResolveCallback(this);
+}
+
+
+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;
+ 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, bool error_on_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.empty()) {
+ name = node_alt;
+ success = m_ndef->getId(name, c);
+ }
+
+ if (!success) {
+ if (error_on_fallback)
+ errorstream << "NodeResolver: failed to resolve node name '" << name
+ << "'." << std::endl;
+ c = c_fallback;
+ }
+
+ *result_out = c;
+ return success;
}
+
+bool NodeResolver::getIdsFromNrBacklog(std::vector<content_t> *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 {
+ m_ndef->getIds(name, *result_out);
+ }
+ }
+
+ return success;
+}
projects / minetest.git / blobdiff