X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmapnode.cpp;h=42f020e7106b651eeca3ad4e4d3f7630cac56429;hb=1f39948bc3341af99a1a2dfc39e4b4164ab56f4c;hp=4afa91983b19917b8f2db9d7888f7838ce45dc52;hpb=9527984dbcfc0a6cc7aa0470430cb6c3aa4103ba;p=dragonfireclient.git diff --git a/src/mapnode.cpp b/src/mapnode.cpp index 4afa91983..42f020e71 100644 --- a/src/mapnode.cpp +++ b/src/mapnode.cpp @@ -21,10 +21,12 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "mapnode.h" #include "porting.h" #include "nodedef.h" +#include "map.h" #include "content_mapnode.h" // For mapnode_translate_*_internal #include "serialization.h" // For ser_ver_supported #include "util/serialize.h" #include "log.h" +#include "util/directiontables.h" #include "util/numeric.h" #include #include @@ -42,22 +44,19 @@ static const u8 rot_to_wallmounted[] = { MapNode */ -// Create directly from a nodename -// If name is unknown, sets CONTENT_IGNORE -MapNode::MapNode(INodeDefManager *ndef, const std::string &name, - u8 a_param1, u8 a_param2) +void MapNode::getColor(const ContentFeatures &f, video::SColor *color) const { - content_t id = CONTENT_IGNORE; - ndef->getId(name, id); - param0 = id; - param1 = a_param1; - param2 = a_param2; + if (f.palette) { + *color = (*f.palette)[param2]; + return; + } + *color = f.color; } -void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr) +void MapNode::setLight(LightBank bank, u8 a_light, const ContentFeatures &f) noexcept { // If node doesn't contain light data, ignore this - if(nodemgr->get(*this).param_type != CPT_LIGHT) + if(f.param_type != CPT_LIGHT) return; if(bank == LIGHTBANK_DAY) { @@ -73,7 +72,12 @@ void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr assert("Invalid light bank" == NULL); } -bool MapNode::isLightDayNightEq(INodeDefManager *nodemgr) const +void MapNode::setLight(LightBank bank, u8 a_light, const NodeDefManager *nodemgr) +{ + setLight(bank, a_light, nodemgr->get(*this)); +} + +bool MapNode::isLightDayNightEq(const NodeDefManager *nodemgr) const { const ContentFeatures &f = nodemgr->get(*this); bool isEqual; @@ -89,7 +93,7 @@ bool MapNode::isLightDayNightEq(INodeDefManager *nodemgr) const return isEqual; } -u8 MapNode::getLight(enum LightBank bank, INodeDefManager *nodemgr) const +u8 MapNode::getLight(LightBank bank, const NodeDefManager *nodemgr) const { // Select the brightest of [light source, propagated light] const ContentFeatures &f = nodemgr->get(*this); @@ -103,13 +107,21 @@ u8 MapNode::getLight(enum LightBank bank, INodeDefManager *nodemgr) const return MYMAX(f.light_source, light); } -u8 MapNode::getLightNoChecks(enum LightBank bank, const ContentFeatures *f) const +u8 MapNode::getLightRaw(LightBank bank, const ContentFeatures &f) const noexcept +{ + if(f.param_type == CPT_LIGHT) + return bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f; + return 0; +} + +u8 MapNode::getLightNoChecks(LightBank bank, const ContentFeatures *f) const noexcept { return MYMAX(f->light_source, bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f); } -bool MapNode::getLightBanks(u8 &lightday, u8 &lightnight, INodeDefManager *nodemgr) const +bool MapNode::getLightBanks(u8 &lightday, u8 &lightnight, + const NodeDefManager *nodemgr) const { // Select the brightest of [light source, propagated light] const ContentFeatures &f = nodemgr->get(*this); @@ -130,23 +142,34 @@ bool MapNode::getLightBanks(u8 &lightday, u8 &lightnight, INodeDefManager *nodem return f.param_type == CPT_LIGHT || f.light_source != 0; } -u8 MapNode::getFaceDir(INodeDefManager *nodemgr) const +u8 MapNode::getFaceDir(const NodeDefManager *nodemgr, + bool allow_wallmounted) const { const ContentFeatures &f = nodemgr->get(*this); - if(f.param_type_2 == CPT2_FACEDIR) + if (f.param_type_2 == CPT2_FACEDIR || + f.param_type_2 == CPT2_COLORED_FACEDIR) return (getParam2() & 0x1F) % 24; + if (allow_wallmounted && (f.param_type_2 == CPT2_WALLMOUNTED || + f.param_type_2 == CPT2_COLORED_WALLMOUNTED)) + return wallmounted_to_facedir[getParam2() & 0x07]; return 0; } -u8 MapNode::getWallMounted(INodeDefManager *nodemgr) const +u8 MapNode::getWallMounted(const NodeDefManager *nodemgr) const { const ContentFeatures &f = nodemgr->get(*this); - if(f.param_type_2 == CPT2_WALLMOUNTED) + if (f.param_type_2 == CPT2_WALLMOUNTED || + f.param_type_2 == CPT2_COLORED_WALLMOUNTED) { return getParam2() & 0x07; + } else if (f.drawtype == NDT_SIGNLIKE || f.drawtype == NDT_TORCHLIKE || + f.drawtype == NDT_PLANTLIKE || + f.drawtype == NDT_PLANTLIKE_ROOTED) { + return 1; + } return 0; } -v3s16 MapNode::getWallMountedDir(INodeDefManager *nodemgr) const +v3s16 MapNode::getWallMountedDir(const NodeDefManager *nodemgr) const { switch(getWallMounted(nodemgr)) { @@ -159,14 +182,62 @@ v3s16 MapNode::getWallMountedDir(INodeDefManager *nodemgr) const } } -void MapNode::rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot) { +u8 MapNode::getDegRotate(const NodeDefManager *nodemgr) const +{ + const ContentFeatures &f = nodemgr->get(*this); + if (f.param_type_2 == CPT2_DEGROTATE) + return getParam2() % 240; + if (f.param_type_2 == CPT2_COLORED_DEGROTATE) + return 10 * ((getParam2() & 0x1F) % 24); + return 0; +} + +void MapNode::rotateAlongYAxis(const NodeDefManager *nodemgr, Rotation rot) +{ ContentParamType2 cpt2 = nodemgr->get(*this).param_type_2; - if (cpt2 == CPT2_FACEDIR) { - u8 newrot = param2 & 3; - param2 &= ~3; - param2 |= (newrot + rot) & 3; - } else if (cpt2 == CPT2_WALLMOUNTED) { + if (cpt2 == CPT2_FACEDIR || cpt2 == CPT2_COLORED_FACEDIR) { + static const u8 rotate_facedir[24 * 4] = { + // Table value = rotated facedir + // Columns: 0, 90, 180, 270 degrees rotation around vertical axis + // Rotation is anticlockwise as seen from above (+Y) + + 0, 1, 2, 3, // Initial facedir 0 to 3 + 1, 2, 3, 0, + 2, 3, 0, 1, + 3, 0, 1, 2, + + 4, 13, 10, 19, // 4 to 7 + 5, 14, 11, 16, + 6, 15, 8, 17, + 7, 12, 9, 18, + + 8, 17, 6, 15, // 8 to 11 + 9, 18, 7, 12, + 10, 19, 4, 13, + 11, 16, 5, 14, + + 12, 9, 18, 7, // 12 to 15 + 13, 10, 19, 4, + 14, 11, 16, 5, + 15, 8, 17, 6, + + 16, 5, 14, 11, // 16 to 19 + 17, 6, 15, 8, + 18, 7, 12, 9, + 19, 4, 13, 10, + + 20, 23, 22, 21, // 20 to 23 + 21, 20, 23, 22, + 22, 21, 20, 23, + 23, 22, 21, 20 + }; + u8 facedir = (param2 & 31) % 24; + u8 index = facedir * 4 + rot; + param2 &= ~31; + param2 |= rotate_facedir[index]; + } else if (cpt2 == CPT2_WALLMOUNTED || + cpt2 == CPT2_COLORED_WALLMOUNTED) { u8 wmountface = (param2 & 7); if (wmountface <= 1) return; @@ -174,31 +245,38 @@ void MapNode::rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot) { Rotation oldrot = wallmounted_to_rot[wmountface - 2]; param2 &= ~7; param2 |= rot_to_wallmounted[(oldrot - rot) & 3]; + } else if (cpt2 == CPT2_DEGROTATE) { + int angle = param2; // in 1.5° + angle += 60 * rot; // don’t do that on u8 + angle %= 240; + param2 = angle; + } else if (cpt2 == CPT2_COLORED_DEGROTATE) { + int angle = param2 & 0x1F; // in 15° + int color = param2 & 0xE0; + angle += 6 * rot; + angle %= 24; + param2 = color | angle; } } -static std::vector transformNodeBox(const MapNode &n, - const NodeBox &nodebox, INodeDefManager *nodemgr) +void transformNodeBox(const MapNode &n, const NodeBox &nodebox, + const NodeDefManager *nodemgr, std::vector *p_boxes, + u8 neighbors = 0) { - std::vector boxes; - if(nodebox.type == NODEBOX_FIXED || nodebox.type == NODEBOX_LEVELED) - { - const std::vector &fixed = nodebox.fixed; - int facedir = n.getFaceDir(nodemgr); + std::vector &boxes = *p_boxes; + + if (nodebox.type == NODEBOX_FIXED || nodebox.type == NODEBOX_LEVELED) { + const auto &fixed = nodebox.fixed; + int facedir = n.getFaceDir(nodemgr, true); u8 axisdir = facedir>>2; facedir&=0x03; - for(std::vector::const_iterator - i = fixed.begin(); - i != fixed.end(); i++) - { - aabb3f box = *i; - if (nodebox.type == NODEBOX_LEVELED) { - box.MaxEdge.Y = -BS/2 + BS*((float)1/LEVELED_MAX) * n.getLevel(nodemgr); - } + boxes.reserve(boxes.size() + fixed.size()); + for (aabb3f box : fixed) { + if (nodebox.type == NODEBOX_LEVELED) + box.MaxEdge.Y = (-0.5f + n.getLevel(nodemgr) / 64.0f) * BS; - switch (axisdir) - { + switch (axisdir) { case 0: if(facedir == 1) { @@ -341,16 +419,15 @@ static std::vector transformNodeBox(const MapNode &n, nodebox.wall_side.MaxEdge }; - for(s32 i=0; i<2; i++) - { + for (v3f &vertex : vertices) { if(dir == v3s16(-1,0,0)) - vertices[i].rotateXZBy(0); + vertex.rotateXZBy(0); if(dir == v3s16(1,0,0)) - vertices[i].rotateXZBy(180); + vertex.rotateXZBy(180); if(dir == v3s16(0,0,-1)) - vertices[i].rotateXZBy(90); + vertex.rotateXZBy(90); if(dir == v3s16(0,0,1)) - vertices[i].rotateXZBy(-90); + vertex.rotateXZBy(-90); } aabb3f box = aabb3f(vertices[0]); @@ -358,46 +435,190 @@ static std::vector transformNodeBox(const MapNode &n, boxes.push_back(box); } } + else if (nodebox.type == NODEBOX_CONNECTED) + { + size_t boxes_size = boxes.size(); + boxes_size += nodebox.fixed.size(); + const auto &c = nodebox.getConnected(); + + if (neighbors & 1) + boxes_size += c.connect_top.size(); + else + boxes_size += c.disconnected_top.size(); + + if (neighbors & 2) + boxes_size += c.connect_bottom.size(); + else + boxes_size += c.disconnected_bottom.size(); + + if (neighbors & 4) + boxes_size += c.connect_front.size(); + else + boxes_size += c.disconnected_front.size(); + + if (neighbors & 8) + boxes_size += c.connect_left.size(); + else + boxes_size += c.disconnected_left.size(); + + if (neighbors & 16) + boxes_size += c.connect_back.size(); + else + boxes_size += c.disconnected_back.size(); + + if (neighbors & 32) + boxes_size += c.connect_right.size(); + else + boxes_size += c.disconnected_right.size(); + + if (neighbors == 0) + boxes_size += c.disconnected.size(); + + if (neighbors < 4) + boxes_size += c.disconnected_sides.size(); + + boxes.reserve(boxes_size); + +#define BOXESPUSHBACK(c) \ + for (std::vector::const_iterator \ + it = (c).begin(); \ + it != (c).end(); ++it) \ + (boxes).push_back(*it); + + BOXESPUSHBACK(nodebox.fixed); + + if (neighbors & 1) { + BOXESPUSHBACK(c.connect_top); + } else { + BOXESPUSHBACK(c.disconnected_top); + } + + if (neighbors & 2) { + BOXESPUSHBACK(c.connect_bottom); + } else { + BOXESPUSHBACK(c.disconnected_bottom); + } + + if (neighbors & 4) { + BOXESPUSHBACK(c.connect_front); + } else { + BOXESPUSHBACK(c.disconnected_front); + } + + if (neighbors & 8) { + BOXESPUSHBACK(c.connect_left); + } else { + BOXESPUSHBACK(c.disconnected_left); + } + + if (neighbors & 16) { + BOXESPUSHBACK(c.connect_back); + } else { + BOXESPUSHBACK(c.disconnected_back); + } + + if (neighbors & 32) { + BOXESPUSHBACK(c.connect_right); + } else { + BOXESPUSHBACK(c.disconnected_right); + } + + if (neighbors == 0) { + BOXESPUSHBACK(c.disconnected); + } + + if (neighbors < 4) { + BOXESPUSHBACK(c.disconnected_sides); + } + + } else // NODEBOX_REGULAR { - boxes.push_back(aabb3f(-BS/2,-BS/2,-BS/2,BS/2,BS/2,BS/2)); + boxes.emplace_back(-BS/2,-BS/2,-BS/2,BS/2,BS/2,BS/2); } - return boxes; } -std::vector MapNode::getNodeBoxes(INodeDefManager *nodemgr) const +static inline void getNeighborConnectingFace( + const v3s16 &p, const NodeDefManager *nodedef, + Map *map, MapNode n, u8 bitmask, u8 *neighbors) +{ + MapNode n2 = map->getNode(p); + if (nodedef->nodeboxConnects(n, n2, bitmask)) + *neighbors |= bitmask; +} + +u8 MapNode::getNeighbors(v3s16 p, Map *map) const +{ + const NodeDefManager *nodedef = map->getNodeDefManager(); + u8 neighbors = 0; + const ContentFeatures &f = nodedef->get(*this); + // locate possible neighboring nodes to connect to + if (f.drawtype == NDT_NODEBOX && f.node_box.type == NODEBOX_CONNECTED) { + v3s16 p2 = p; + + p2.Y++; + getNeighborConnectingFace(p2, nodedef, map, *this, 1, &neighbors); + + p2 = p; + p2.Y--; + getNeighborConnectingFace(p2, nodedef, map, *this, 2, &neighbors); + + p2 = p; + p2.Z--; + getNeighborConnectingFace(p2, nodedef, map, *this, 4, &neighbors); + + p2 = p; + p2.X--; + getNeighborConnectingFace(p2, nodedef, map, *this, 8, &neighbors); + + p2 = p; + p2.Z++; + getNeighborConnectingFace(p2, nodedef, map, *this, 16, &neighbors); + + p2 = p; + p2.X++; + getNeighborConnectingFace(p2, nodedef, map, *this, 32, &neighbors); + } + + return neighbors; +} + +void MapNode::getNodeBoxes(const NodeDefManager *nodemgr, + std::vector *boxes, u8 neighbors) const { const ContentFeatures &f = nodemgr->get(*this); - return transformNodeBox(*this, f.node_box, nodemgr); + transformNodeBox(*this, f.node_box, nodemgr, boxes, neighbors); } -std::vector MapNode::getCollisionBoxes(INodeDefManager *nodemgr) const +void MapNode::getCollisionBoxes(const NodeDefManager *nodemgr, + std::vector *boxes, u8 neighbors) const { const ContentFeatures &f = nodemgr->get(*this); if (f.collision_box.fixed.empty()) - return transformNodeBox(*this, f.node_box, nodemgr); + transformNodeBox(*this, f.node_box, nodemgr, boxes, neighbors); else - return transformNodeBox(*this, f.collision_box, nodemgr); + transformNodeBox(*this, f.collision_box, nodemgr, boxes, neighbors); } -std::vector MapNode::getSelectionBoxes(INodeDefManager *nodemgr) const +void MapNode::getSelectionBoxes(const NodeDefManager *nodemgr, + std::vector *boxes, u8 neighbors) const { const ContentFeatures &f = nodemgr->get(*this); - return transformNodeBox(*this, f.selection_box, nodemgr); + transformNodeBox(*this, f.selection_box, nodemgr, boxes, neighbors); } -u8 MapNode::getMaxLevel(INodeDefManager *nodemgr) const +u8 MapNode::getMaxLevel(const NodeDefManager *nodemgr) const { const ContentFeatures &f = nodemgr->get(*this); // todo: after update in all games leave only if (f.param_type_2 == if( f.liquid_type == LIQUID_FLOWING || f.param_type_2 == CPT2_FLOWINGLIQUID) return LIQUID_LEVEL_MAX; if(f.leveled || f.param_type_2 == CPT2_LEVELED) - return LEVELED_MAX; + return f.leveled_max; return 0; } -u8 MapNode::getLevel(INodeDefManager *nodemgr) const +u8 MapNode::getLevel(const NodeDefManager *nodemgr) const { const ContentFeatures &f = nodemgr->get(*this); // todo: after update in all games leave only if (f.param_type_2 == @@ -407,49 +628,52 @@ u8 MapNode::getLevel(INodeDefManager *nodemgr) const return getParam2() & LIQUID_LEVEL_MASK; if(f.liquid_type == LIQUID_FLOWING) // can remove if all param_type_2 setted return getParam2() & LIQUID_LEVEL_MASK; - if(f.leveled || f.param_type_2 == CPT2_LEVELED) { - u8 level = getParam2() & LEVELED_MASK; - if(level) + if (f.param_type_2 == CPT2_LEVELED) { + u8 level = getParam2() & LEVELED_MASK; + if (level) return level; - if(f.leveled > LEVELED_MAX) - return LEVELED_MAX; - return f.leveled; //default } - return 0; + // Return static value from nodedef if param2 isn't used for level + if (f.leveled > f.leveled_max) + return f.leveled_max; + return f.leveled; } -u8 MapNode::setLevel(INodeDefManager *nodemgr, s8 level) +s8 MapNode::setLevel(const NodeDefManager *nodemgr, s16 level) { - u8 rest = 0; - if (level < 1) { - setContent(CONTENT_AIR); - return 0; - } + s8 rest = 0; const ContentFeatures &f = nodemgr->get(*this); if (f.param_type_2 == CPT2_FLOWINGLIQUID - || f.liquid_type == LIQUID_FLOWING - || f.liquid_type == LIQUID_SOURCE) { + || f.liquid_type == LIQUID_FLOWING + || f.liquid_type == LIQUID_SOURCE) { + if (level <= 0) { // liquid can’t exist with zero level + setContent(CONTENT_AIR); + return 0; + } if (level >= LIQUID_LEVEL_SOURCE) { rest = level - LIQUID_LEVEL_SOURCE; - setContent(nodemgr->getId(f.liquid_alternative_source)); + setContent(f.liquid_alternative_source_id); + setParam2(0); } else { - setContent(nodemgr->getId(f.liquid_alternative_flowing)); - setParam2(level & LIQUID_LEVEL_MASK); + setContent(f.liquid_alternative_flowing_id); + setParam2((level & LIQUID_LEVEL_MASK) | (getParam2() & ~LIQUID_LEVEL_MASK)); } - } else if (f.leveled || f.param_type_2 == CPT2_LEVELED) { - if (level > LEVELED_MAX) { - rest = level - LEVELED_MAX; - level = LEVELED_MAX; + } else if (f.param_type_2 == CPT2_LEVELED) { + if (level < 0) { // zero means default for a leveled nodebox + rest = level; + level = 0; + } else if (level > f.leveled_max) { + rest = level - f.leveled_max; + level = f.leveled_max; } - setParam2(level & LEVELED_MASK); + setParam2((level & LEVELED_MASK) | (getParam2() & ~LEVELED_MASK)); } return rest; } -u8 MapNode::addLevel(INodeDefManager *nodemgr, s8 add) +s8 MapNode::addLevel(const NodeDefManager *nodemgr, s16 add) { - s8 level = getLevel(nodemgr); - if (add == 0) level = 1; + s16 level = getLevel(nodemgr); level += add; return setLevel(nodemgr, level); } @@ -459,16 +683,18 @@ u32 MapNode::serializedLength(u8 version) if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); - if(version == 0) + if (version == 0) return 1; - else if(version <= 9) + + if (version <= 9) return 2; - else if(version <= 23) + + if (version <= 23) return 3; - else - return 4; + + return 4; } -void MapNode::serialize(u8 *dest, u8 version) +void MapNode::serialize(u8 *dest, u8 version) const { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); @@ -508,11 +734,12 @@ void MapNode::deSerialize(u8 *source, u8 version) } } } -void MapNode::serializeBulk(std::ostream &os, int version, + +SharedBuffer MapNode::serializeBulk(int version, const MapNode *nodes, u32 nodecount, - u8 content_width, u8 params_width, bool compressed) + u8 content_width, u8 params_width) { - if(!ser_ver_supported(version)) + if (!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); sanity_check(content_width == 2); @@ -520,44 +747,28 @@ void MapNode::serializeBulk(std::ostream &os, int version, // Can't do this anymore; we have 16-bit dynamically allocated node IDs // in memory; conversion just won't work in this direction. - if(version < 24) + if (version < 24) throw SerializationError("MapNode::serializeBulk: serialization to " "version < 24 not possible"); SharedBuffer databuf(nodecount * (content_width + params_width)); - // Serialize content - for(u32 i=0; i databuf(len); - if(compressed) - { - std::ostringstream os(std::ios_base::binary); - decompressZlib(is, os); - std::string s = os.str(); - if(s.size() != len) - throw SerializationError("deSerializeBulkNodes: " - "decompress resulted in invalid size"); - memcpy(&databuf[0], s.c_str(), len); - } - else - { - is.read((char*) &databuf[0], len); - if(is.eof() || is.fail()) - throw SerializationError("deSerializeBulkNodes: " - "failed to read bulk node data"); - } + // read data + const u32 len = nodecount * (content_width + params_width); + Buffer databuf(len); + is.read(reinterpret_cast(*databuf), len); // Deserialize content if(content_width == 1) @@ -628,7 +823,7 @@ void MapNode::deSerializeBulk(std::istream &is, int version, /* Legacy serialization */ -void MapNode::deSerialize_pre22(u8 *source, u8 version) +void MapNode::deSerialize_pre22(const u8 *source, u8 version) { if(version <= 1) { @@ -656,7 +851,7 @@ void MapNode::deSerialize_pre22(u8 *source, u8 version) { // In these versions, CONTENT_IGNORE and CONTENT_AIR // are 255 and 254 - // Version 19 is fucked up with sometimes the old values and sometimes not + // Version 19 is messed up with sometimes the old values and sometimes not if(param0 == 255) param0 = CONTENT_IGNORE; else if(param0 == 254)