#include "itemdef.h"
#ifndef SERVER
-#include "mesh.h"
-#include "shader.h"
-#include "client.h"
+#include "client/mesh.h"
+#include "client/shader.h"
+#include "client/client.h"
#include "client/renderingengine.h"
#include "client/tile.h"
#include <IMeshManipulator.h>
#include "mapnode.h"
#include <fstream> // Used in applyTextureOverrides()
#include <algorithm>
+#include <cmath>
/*
NodeBox
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
{
// Protocol >= 36
- int version = 4;
+ const u8 version = 6;
writeU8(os, version);
switch (type) {
writeU16(os, fixed.size());
for (const aabb3f &nodebox : fixed) {
- writeV3F1000(os, nodebox.MinEdge);
- writeV3F1000(os, nodebox.MaxEdge);
+ writeV3F32(os, nodebox.MinEdge);
+ writeV3F32(os, nodebox.MaxEdge);
}
break;
case NODEBOX_WALLMOUNTED:
writeU8(os, type);
- 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);
+ 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)) { \
- writeV3F1000(os, i.MinEdge); \
- writeV3F1000(os, i.MaxEdge); \
+ writeV3F32(os, i.MinEdge); \
+ writeV3F32(os, i.MaxEdge); \
};
WRITEBOX(fixed);
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);
void NodeBox::deSerialize(std::istream &is)
{
int version = readU8(is);
- if (version < 4)
+ if (version < 6)
throw SerializationError("unsupported NodeBox version");
reset();
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)
{
count = readU16(is); \
(box).reserve(count); \
while (count--) { \
- v3f min = readV3F1000(is); \
- v3f max = readV3F1000(is); \
+ v3f min = readV3F32(is); \
+ v3f max = readV3F32(is); \
(box).emplace_back(min, max); }; }
u16 count;
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);
}
}
align_style = ALIGN_STYLE_NODE;
}
-
-/*
- SimpleSoundSpec serialization
-*/
-
-static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss,
- std::ostream &os, u8 version)
-{
- os<<serializeString(ss.name);
- writeF1000(os, ss.gain);
- writeF1000(os, ss.pitch);
-}
-static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss,
- std::istream &is, u8 version)
-{
- ss.name = deSerializeString(is);
- ss.gain = readF1000(is);
- ss.pitch = readF1000(is);
-}
-
void TextureSettings::readSettings()
{
connected_glass = g_settings->getBool("connected_glass");
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
{
- // protocol_version >= 36
- u8 version = 12;
+ const u8 version = CONTENTFEATURES_VERSION;
writeU8(os, version);
// general
// visual
writeU8(os, drawtype);
os << serializeString(mesh);
- writeF1000(os, visual_scale);
+ writeF32(os, visual_scale);
writeU8(os, 6);
for (const TileDef &td : tiledef)
td.serialize(os, protocol_version);
writeU16(os, connects_to_ids.size());
for (u16 connects_to_id : connects_to_ids)
writeU16(os, connects_to_id);
- writeU8(os, post_effect_color.getAlpha());
- writeU8(os, post_effect_color.getRed());
- writeU8(os, post_effect_color.getGreen());
- writeU8(os, post_effect_color.getBlue());
+ writeARGB8(os, post_effect_color);
writeU8(os, leveled);
// lighting
collision_box.serialize(os, protocol_version);
// sound
- serializeSimpleSoundSpec(sound_footstep, os, version);
- serializeSimpleSoundSpec(sound_dig, os, version);
- serializeSimpleSoundSpec(sound_dug, os, version);
+ sound_footstep.serialize(os, version);
+ sound_dig.serialize(os, version);
+ sound_dug.serialize(os, version);
// legacy
writeU8(os, legacy_facedir_simple);
void ContentFeatures::deSerialize(std::istream &is)
{
// version detection
- int version = readU8(is);
- if (version < 12)
+ const u8 version = readU8(is);
+ if (version < CONTENTFEATURES_VERSION)
throw SerializationError("unsupported ContentFeatures version");
// general
// visual
drawtype = (enum NodeDrawType) readU8(is);
mesh = deSerializeString(is);
- visual_scale = readF1000(is);
+ visual_scale = readF32(is);
if (readU8(is) != 6)
throw SerializationError("unsupported tile count");
for (TileDef &td : tiledef)
connects_to_ids.clear();
for (u16 i = 0; i < connects_to_size; i++)
connects_to_ids.push_back(readU16(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));
+ post_effect_color = readARGB8(is);
leveled = readU8(is);
// lighting-related
collision_box.deSerialize(is);
// sounds
- deSerializeSimpleSoundSpec(sound_footstep, is, version);
- deSerializeSimpleSoundSpec(sound_dig, is, version);
- deSerializeSimpleSoundSpec(sound_dug, is, version);
+ sound_footstep.deSerialize(is, version);
+ sound_dig.deSerialize(is, version);
+ sound_dug.deSerialize(is, version);
// read legacy properties
legacy_facedir_simple = readU8(is);
material_type = TILE_MATERIAL_WAVING_PLANTS;
else if (waving == 2)
material_type = TILE_MATERIAL_WAVING_LEAVES;
+ else if (waving == 3)
+ material_type = TILE_MATERIAL_WAVING_LIQUID_BASIC;
break;
case NDT_TORCHLIKE:
case NDT_SIGNLIKE:
correctAlpha(tdef, 6);
correctAlpha(tdef_overlay, 6);
correctAlpha(tdef_spec, CF_SPECIAL_COUNT);
- material_type = (alpha == 255) ?
- TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT;
+
+ if (waving == 3) {
+ material_type = (alpha == 255) ? TILE_MATERIAL_WAVING_LIQUID_OPAQUE :
+ TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT;
+ } else {
+ material_type = (alpha == 255) ? TILE_MATERIAL_LIQUID_OPAQUE :
+ TILE_MATERIAL_LIQUID_TRANSPARENT;
+ }
}
u32 tile_shader = shdsrc->getShader("nodes_shader", material_type, drawtype);
#endif
/*
- CNodeDefManager
+ NodeDefManager
*/
-class CNodeDefManager: public IWritableNodeDefManager {
-public:
- CNodeDefManager();
- virtual ~CNodeDefManager();
- void clear();
-
- 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 bool getIds(const std::string &name, std::vector<content_t> &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 removeNode(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 void setNodeRegistrationStatus(bool completed);
-
- virtual void pendNodeResolve(NodeResolver *nr);
- virtual bool cancelNodeResolveCallback(NodeResolver *nr);
- virtual void runNodeResolveCallbacks();
- virtual void resetNodeResolveState();
- virtual void mapNodeboxConnections();
- virtual bool nodeboxConnects(MapNode from, MapNode to, u8 connect_face);
- virtual core::aabbox3d<s16> getSelectionBoxIntUnion() const
- {
- return m_selection_box_int_union;
- }
-
-private:
- void addNameIdMapping(content_t i, std::string name);
- /*!
- * Recalculates m_selection_box_int_union based on
- * m_selection_box_union.
- */
- void fixSelectionBoxIntUnion();
-
- // Features indexed by id
- std::vector<ContentFeatures> m_content_features;
-
- // A mapping for fast converting back and forth between names and ids
- NameIdMapping m_name_id_mapping;
-
- // Like m_name_id_mapping, but only from names to ids, and includes
- // item aliases too. Updated by updateAliases()
- // Note: Not serialized.
-
- std::unordered_map<std::string, content_t> m_name_id_mapping_with_aliases;
-
- // A mapping from groups to a vector of content_ts that belong to it.
- // Necessary for a direct lookup in getIds().
- // Note: Not serialized.
- std::unordered_map<std::string, std::vector<content_t>> m_group_to_items;
- // Next possibly free id
- content_t m_next_id;
- // NodeResolvers to callback once node registration has ended
- std::vector<NodeResolver *> m_pending_resolve_callbacks;
- // True when all nodes have been registered
- bool m_node_registration_complete;
-
- //! The union of all nodes' selection boxes.
- aabb3f m_selection_box_union;
- /*!
- * The smallest box in node coordinates that
- * contains all nodes' selection boxes.
- */
- core::aabbox3d<s16> m_selection_box_int_union;
-};
-
-
-CNodeDefManager::CNodeDefManager()
+NodeDefManager::NodeDefManager()
{
clear();
}
-CNodeDefManager::~CNodeDefManager()
+NodeDefManager::~NodeDefManager()
{
#ifndef SERVER
for (ContentFeatures &f : m_content_features) {
}
-void CNodeDefManager::clear()
+void NodeDefManager::clear()
{
m_content_features.clear();
m_name_id_mapping.clear();
}
-inline const ContentFeatures& CNodeDefManager::get(content_t c) const
-{
- return c < m_content_features.size()
- ? m_content_features[c] : m_content_features[CONTENT_UNKNOWN];
-}
-
-
-inline const ContentFeatures& CNodeDefManager::get(const MapNode &n) const
-{
- return get(n.getContent());
-}
-
-
-bool CNodeDefManager::getId(const std::string &name, content_t &result) const
+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);
}
-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);
}
-bool CNodeDefManager::getIds(const std::string &name,
+bool NodeDefManager::getIds(const std::string &name,
std::vector<content_t> &result) const
{
//TimeTaker t("getIds", NULL, PRECISION_MICRO);
}
-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);
// 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?
}
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.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: {
}
-inline void CNodeDefManager::fixSelectionBoxIntUnion()
+inline void NodeDefManager::fixSelectionBoxIntUnion()
{
m_selection_box_int_union.MinEdge.X = floorf(
m_selection_box_union.MinEdge.X / 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 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"<<std::endl;
- return CONTENT_IGNORE;
- }
-
content_t id = CONTENT_IGNORE;
if (!m_name_id_mapping.getId(name, id)) { // ignore aliases
// Get new id
assert(id != CONTENT_IGNORE);
addNameIdMapping(id, 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
- // FIXME: This should remove a node from groups it no longer
- // belongs to when a node is re-registered
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;
}
-void CNodeDefManager::removeNode(const std::string &name)
+void NodeDefManager::removeNode(const std::string &name)
{
// Pre-condition
assert(name != "");
m_name_id_mapping_with_aliases.erase(name);
}
- // Erase node content from all groups it belongs to
- for (std::unordered_map<std::string, std::vector<content_t>>::iterator iter_groups =
- m_group_to_items.begin(); iter_groups != m_group_to_items.end();) {
- std::vector<content_t> &items = iter_groups->second;
- items.erase(std::remove(items.begin(), items.end(), id), items.end());
-
- // Check if group is empty
- if (items.empty())
- m_group_to_items.erase(iter_groups++);
- else
- ++iter_groups;
- }
+ eraseIdFromGroups(id);
}
-void CNodeDefManager::updateAliases(IItemDefManager *idef)
+void NodeDefManager::updateAliases(IItemDefManager *idef)
{
std::set<std::string> all;
idef->getAll(all);
}
}
-void CNodeDefManager::applyTextureOverrides(const std::string &override_filepath)
+void NodeDefManager::applyTextureOverrides(const std::string &override_filepath)
{
- infostream << "CNodeDefManager::applyTextureOverrides(): Applying "
+ infostream << "NodeDefManager::applyTextureOverrides(): Applying "
"overrides to textures from " << override_filepath << std::endl;
std::ifstream infile(override_filepath.c_str());
int line_c = 0;
while (std::getline(infile, line)) {
line_c++;
- if (trim(line).empty())
+ // Also trim '\r' on DOS-style files
+ line = trim(line);
+ if (line.empty())
continue;
+
std::vector<std::string> splitted = str_split(line, ' ');
if (splitted.size() != 3) {
errorstream << override_filepath
}
}
-void CNodeDefManager::updateTextures(IGameDef *gamedef,
+void NodeDefManager::updateTextures(IGameDef *gamedef,
void (*progress_callback)(void *progress_args, u32 progress, u32 max_progress),
void *progress_callback_args)
{
#ifndef SERVER
- infostream << "CNodeDefManager::updateTextures(): Updating "
+ infostream << "NodeDefManager::updateTextures(): Updating "
"textures in node definitions" << std::endl;
Client *client = (Client *)gamedef;
#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;
}
-void CNodeDefManager::deSerialize(std::istream &is)
+void NodeDefManager::deSerialize(std::istream &is)
{
clear();
int version = readU8(is);
}
-void CNodeDefManager::addNameIdMapping(content_t i, std::string name)
+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));
}
-IWritableNodeDefManager *createNodeDefManager()
-{
- return new CNodeDefManager();
-}
-
-inline void CNodeDefManager::setNodeRegistrationStatus(bool completed)
+NodeDefManager *createNodeDefManager()
{
- m_node_registration_complete = completed;
+ return new NodeDefManager();
}
-void CNodeDefManager::pendNodeResolve(NodeResolver *nr)
+void NodeDefManager::pendNodeResolve(NodeResolver *nr) const
{
nr->m_ndef = this;
if (m_node_registration_complete)
}
-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++) {
}
-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];
}
-void CNodeDefManager::resetNodeResolveState()
+void NodeDefManager::resetNodeResolveState()
{
m_node_registration_complete = false;
m_pending_resolve_callbacks.clear();
}
-void CNodeDefManager::mapNodeboxConnections()
+void NodeDefManager::mapNodeboxConnections()
{
for (ContentFeatures &f : m_content_features) {
if (f.drawtype != NDT_NODEBOX || f.node_box.type != NODEBOX_CONNECTED)
}
}
-bool CNodeDefManager::nodeboxConnects(MapNode from, MapNode to, u8 connect_face)
+bool NodeDefManager::nodeboxConnects(MapNode from, MapNode to,
+ u8 connect_face) const
{
const ContentFeatures &f1 = get(from);
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;
}
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;
}