X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapnode.cpp;h=3a12360f3c8b5ee7dcb2948d8fb5ed0e63a59d9f;hb=617d94c8038e3ff035eaeef7ccdfa4f442feb873;hp=bfadbeac5ddbe919dac889322be71e23d62426b3;hpb=157a4cf18cb9c098f465b8baecd7d2cd5705f2dd;p=dragonfireclient.git diff --git a/src/mapnode.cpp b/src/mapnode.cpp index bfadbeac5..3a12360f3 100644 --- a/src/mapnode.cpp +++ b/src/mapnode.cpp @@ -1,30 +1,44 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include "common_irrlicht.h" +#include "irrlichttypes_extrabloated.h" #include "mapnode.h" #include "porting.h" -#include -#include "main.h" // For g_settings #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 + +static const Rotation wallmounted_to_rot[] = { + ROTATE_0, ROTATE_180, ROTATE_90, ROTATE_270 +}; + +static const u8 rot_to_wallmounted[] = { + 2, 4, 3, 5 +}; + /* MapNode @@ -37,17 +51,24 @@ MapNode::MapNode(INodeDefManager *ndef, const std::string &name, { content_t id = CONTENT_IGNORE; ndef->getId(name, id); + param0 = id; param1 = a_param1; param2 = a_param2; - // Set content (param0 and (param2&0xf0)) after other params - // because this needs to override part of param2 - setContent(id); } -void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr) +void MapNode::getColor(const ContentFeatures &f, video::SColor *color) const +{ + if (f.palette) { + *color = (*f.palette)[param2]; + return; + } + *color = f.color; +} + +void MapNode::setLight(enum LightBank bank, u8 a_light, const ContentFeatures &f) { // 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) { @@ -60,26 +81,55 @@ void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr param1 |= (a_light & 0x0f)<<4; } else - assert(0); + assert("Invalid light bank" == NULL); +} + +void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr) +{ + setLight(bank, a_light, nodemgr->get(*this)); +} + +bool MapNode::isLightDayNightEq(INodeDefManager *nodemgr) const +{ + const ContentFeatures &f = nodemgr->get(*this); + bool isEqual; + + if (f.param_type == CPT_LIGHT) { + u8 day = MYMAX(f.light_source, param1 & 0x0f); + u8 night = MYMAX(f.light_source, (param1 >> 4) & 0x0f); + isEqual = day == night; + } else { + isEqual = true; + } + + return isEqual; } u8 MapNode::getLight(enum LightBank bank, INodeDefManager *nodemgr) const { // Select the brightest of [light source, propagated light] const ContentFeatures &f = nodemgr->get(*this); - u8 light = 0; + + u8 light; if(f.param_type == CPT_LIGHT) - { - if(bank == LIGHTBANK_DAY) - light = param1 & 0x0f; - else if(bank == LIGHTBANK_NIGHT) - light = (param1>>4)&0x0f; - else - assert(0); - } - if(f.light_source > light) - light = f.light_source; - return light; + light = bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f; + else + light = 0; + + return MYMAX(f.light_source, light); +} + +u8 MapNode::getLightRaw(enum LightBank bank, const ContentFeatures &f) const +{ + if(f.param_type == CPT_LIGHT) + return bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f; + return 0; +} + +u8 MapNode::getLightNoChecks(enum LightBank bank, const ContentFeatures *f) const +{ + return MYMAX(f->light_source, + bank == LIGHTBANK_DAY ? param1 & 0x0f : (param1 >> 4) & 0x0f); } bool MapNode::getLightBanks(u8 &lightday, u8 &lightnight, INodeDefManager *nodemgr) const @@ -103,18 +153,23 @@ 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(INodeDefManager *nodemgr, bool allow_wallmounted) const { const ContentFeatures &f = nodemgr->get(*this); - if(f.param_type_2 == CPT2_FACEDIR) - return getParam2() & 0x03; + 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 { 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; return 0; } @@ -132,98 +187,565 @@ v3s16 MapNode::getWallMountedDir(INodeDefManager *nodemgr) const } } +void MapNode::rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot) +{ + ContentParamType2 cpt2 = nodemgr->get(*this).param_type_2; + + 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; + + Rotation oldrot = wallmounted_to_rot[wmountface - 2]; + param2 &= ~7; + param2 |= rot_to_wallmounted[(oldrot - rot) & 3]; + } +} + +void transformNodeBox(const MapNode &n, const NodeBox &nodebox, + INodeDefManager *nodemgr, std::vector *p_boxes, u8 neighbors = 0) +{ + std::vector &boxes = *p_boxes; + + if (nodebox.type == NODEBOX_FIXED || nodebox.type == NODEBOX_LEVELED) { + const std::vector &fixed = nodebox.fixed; + int facedir = n.getFaceDir(nodemgr, true); + u8 axisdir = facedir>>2; + facedir&=0x03; + for (aabb3f box : fixed) { + if (nodebox.type == NODEBOX_LEVELED) + box.MaxEdge.Y = (-0.5f + n.getLevel(nodemgr) / 64.0f) * BS; + + switch (axisdir) { + case 0: + if(facedir == 1) + { + box.MinEdge.rotateXZBy(-90); + box.MaxEdge.rotateXZBy(-90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXZBy(180); + box.MaxEdge.rotateXZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXZBy(90); + box.MaxEdge.rotateXZBy(90); + } + break; + case 1: // z+ + box.MinEdge.rotateYZBy(90); + box.MaxEdge.rotateYZBy(90); + if(facedir == 1) + { + box.MinEdge.rotateXYBy(90); + box.MaxEdge.rotateXYBy(90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXYBy(180); + box.MaxEdge.rotateXYBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXYBy(-90); + box.MaxEdge.rotateXYBy(-90); + } + break; + case 2: //z- + box.MinEdge.rotateYZBy(-90); + box.MaxEdge.rotateYZBy(-90); + if(facedir == 1) + { + box.MinEdge.rotateXYBy(-90); + box.MaxEdge.rotateXYBy(-90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXYBy(180); + box.MaxEdge.rotateXYBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXYBy(90); + box.MaxEdge.rotateXYBy(90); + } + break; + case 3: //x+ + box.MinEdge.rotateXYBy(-90); + box.MaxEdge.rotateXYBy(-90); + if(facedir == 1) + { + box.MinEdge.rotateYZBy(90); + box.MaxEdge.rotateYZBy(90); + } + else if(facedir == 2) + { + box.MinEdge.rotateYZBy(180); + box.MaxEdge.rotateYZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateYZBy(-90); + box.MaxEdge.rotateYZBy(-90); + } + break; + case 4: //x- + box.MinEdge.rotateXYBy(90); + box.MaxEdge.rotateXYBy(90); + if(facedir == 1) + { + box.MinEdge.rotateYZBy(-90); + box.MaxEdge.rotateYZBy(-90); + } + else if(facedir == 2) + { + box.MinEdge.rotateYZBy(180); + box.MaxEdge.rotateYZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateYZBy(90); + box.MaxEdge.rotateYZBy(90); + } + break; + case 5: + box.MinEdge.rotateXYBy(-180); + box.MaxEdge.rotateXYBy(-180); + if(facedir == 1) + { + box.MinEdge.rotateXZBy(90); + box.MaxEdge.rotateXZBy(90); + } + else if(facedir == 2) + { + box.MinEdge.rotateXZBy(180); + box.MaxEdge.rotateXZBy(180); + } + else if(facedir == 3) + { + box.MinEdge.rotateXZBy(-90); + box.MaxEdge.rotateXZBy(-90); + } + break; + default: + break; + } + box.repair(); + boxes.push_back(box); + } + } + else if(nodebox.type == NODEBOX_WALLMOUNTED) + { + v3s16 dir = n.getWallMountedDir(nodemgr); + + // top + if(dir == v3s16(0,1,0)) + { + boxes.push_back(nodebox.wall_top); + } + // bottom + else if(dir == v3s16(0,-1,0)) + { + boxes.push_back(nodebox.wall_bottom); + } + // side + else + { + v3f vertices[2] = + { + nodebox.wall_side.MinEdge, + nodebox.wall_side.MaxEdge + }; + + for (v3f &vertex : vertices) { + if(dir == v3s16(-1,0,0)) + vertex.rotateXZBy(0); + if(dir == v3s16(1,0,0)) + vertex.rotateXZBy(180); + if(dir == v3s16(0,0,-1)) + vertex.rotateXZBy(90); + if(dir == v3s16(0,0,1)) + vertex.rotateXZBy(-90); + } + + aabb3f box = aabb3f(vertices[0]); + box.addInternalPoint(vertices[1]); + boxes.push_back(box); + } + } + else if (nodebox.type == NODEBOX_CONNECTED) + { + size_t boxes_size = boxes.size(); + boxes_size += nodebox.fixed.size(); + if (neighbors & 1) + boxes_size += nodebox.connect_top.size(); + else + boxes_size += nodebox.disconnected_top.size(); + + if (neighbors & 2) + boxes_size += nodebox.connect_bottom.size(); + else + boxes_size += nodebox.disconnected_bottom.size(); + + if (neighbors & 4) + boxes_size += nodebox.connect_front.size(); + else + boxes_size += nodebox.disconnected_front.size(); + + if (neighbors & 8) + boxes_size += nodebox.connect_left.size(); + else + boxes_size += nodebox.disconnected_left.size(); + + if (neighbors & 16) + boxes_size += nodebox.connect_back.size(); + else + boxes_size += nodebox.disconnected_back.size(); + + if (neighbors & 32) + boxes_size += nodebox.connect_right.size(); + else + boxes_size += nodebox.disconnected_right.size(); + + if (neighbors == 0) + boxes_size += nodebox.disconnected.size(); + + if (neighbors < 4) + boxes_size += nodebox.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(nodebox.connect_top); + } else { + BOXESPUSHBACK(nodebox.disconnected_top); + } + + if (neighbors & 2) { + BOXESPUSHBACK(nodebox.connect_bottom); + } else { + BOXESPUSHBACK(nodebox.disconnected_bottom); + } + + if (neighbors & 4) { + BOXESPUSHBACK(nodebox.connect_front); + } else { + BOXESPUSHBACK(nodebox.disconnected_front); + } + + if (neighbors & 8) { + BOXESPUSHBACK(nodebox.connect_left); + } else { + BOXESPUSHBACK(nodebox.disconnected_left); + } + + if (neighbors & 16) { + BOXESPUSHBACK(nodebox.connect_back); + } else { + BOXESPUSHBACK(nodebox.disconnected_back); + } + + if (neighbors & 32) { + BOXESPUSHBACK(nodebox.connect_right); + } else { + BOXESPUSHBACK(nodebox.disconnected_right); + } + + if (neighbors == 0) { + BOXESPUSHBACK(nodebox.disconnected); + } + + if (neighbors < 4) { + BOXESPUSHBACK(nodebox.disconnected_sides); + } + + } + else // NODEBOX_REGULAR + { + boxes.emplace_back(-BS/2,-BS/2,-BS/2,BS/2,BS/2,BS/2); + } +} + +static inline void getNeighborConnectingFace( + const v3s16 &p, INodeDefManager *nodedef, + Map *map, MapNode n, u8 bitmask, u8 *neighbors) +{ + MapNode n2 = map->getNodeNoEx(p); + if (nodedef->nodeboxConnects(n, n2, bitmask)) + *neighbors |= bitmask; +} + +u8 MapNode::getNeighbors(v3s16 p, Map *map) +{ + INodeDefManager *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(INodeDefManager *nodemgr, std::vector *boxes, u8 neighbors) +{ + const ContentFeatures &f = nodemgr->get(*this); + transformNodeBox(*this, f.node_box, nodemgr, boxes, neighbors); +} + +void MapNode::getCollisionBoxes(INodeDefManager *nodemgr, std::vector *boxes, u8 neighbors) +{ + const ContentFeatures &f = nodemgr->get(*this); + if (f.collision_box.fixed.empty()) + transformNodeBox(*this, f.node_box, nodemgr, boxes, neighbors); + else + transformNodeBox(*this, f.collision_box, nodemgr, boxes, neighbors); +} + +void MapNode::getSelectionBoxes(INodeDefManager *nodemgr, std::vector *boxes, u8 neighbors) +{ + const ContentFeatures &f = nodemgr->get(*this); + transformNodeBox(*this, f.selection_box, nodemgr, boxes, neighbors); +} + +u8 MapNode::getMaxLevel(INodeDefManager *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 0; +} + +u8 MapNode::getLevel(INodeDefManager *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_SOURCE) + return LIQUID_LEVEL_SOURCE; + if (f.param_type_2 == CPT2_FLOWINGLIQUID) + 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) + return level; + if(f.leveled > LEVELED_MAX) + return LEVELED_MAX; + return f.leveled; //default + } + return 0; +} + +u8 MapNode::setLevel(INodeDefManager *nodemgr, s8 level) +{ + u8 rest = 0; + if (level < 1) { + setContent(CONTENT_AIR); + return 0; + } + const ContentFeatures &f = nodemgr->get(*this); + if (f.param_type_2 == CPT2_FLOWINGLIQUID + || f.liquid_type == LIQUID_FLOWING + || f.liquid_type == LIQUID_SOURCE) { + if (level >= LIQUID_LEVEL_SOURCE) { + rest = level - LIQUID_LEVEL_SOURCE; + setContent(nodemgr->getId(f.liquid_alternative_source)); + } else { + setContent(nodemgr->getId(f.liquid_alternative_flowing)); + setParam2(level & LIQUID_LEVEL_MASK); + } + } else if (f.leveled || f.param_type_2 == CPT2_LEVELED) { + if (level > LEVELED_MAX) { + rest = level - LEVELED_MAX; + level = LEVELED_MAX; + } + setParam2(level & LEVELED_MASK); + } + return rest; +} +u8 MapNode::addLevel(INodeDefManager *nodemgr, s8 add) +{ + s8 level = getLevel(nodemgr); + if (add == 0) level = 1; + level += add; + return setLevel(nodemgr, level); +} 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) return 3; + + return 4; } void MapNode::serialize(u8 *dest, u8 version) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); - if(version <= 21) - { - serialize_pre22(dest, version); - return; - } + // 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) + throw SerializationError("MapNode::serialize: serialization to " + "version < 24 not possible"); - writeU8(dest+0, param0); - writeU8(dest+1, param1); - writeU8(dest+2, param2); + writeU16(dest+0, param0); + writeU8(dest+2, param1); + writeU8(dest+3, param2); } void MapNode::deSerialize(u8 *source, u8 version) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); - + if(version <= 21) { deSerialize_pre22(source, version); return; } - param0 = readU8(source+0); - param1 = readU8(source+1); - param2 = readU8(source+2); + if(version >= 24){ + param0 = readU16(source+0); + param1 = readU8(source+2); + param2 = readU8(source+3); + }else{ + param0 = readU8(source+0); + param1 = readU8(source+1); + param2 = readU8(source+2); + if(param0 > 0x7F){ + param0 |= ((param2&0xF0)<<4); + param2 &= 0x0F; + } + } } void MapNode::serializeBulk(std::ostream &os, int version, const MapNode *nodes, u32 nodecount, u8 content_width, u8 params_width, bool compressed) { - if(!ser_ver_supported(version)) + if (!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapNode format not supported"); - assert(version >= 22); - assert(content_width == 1); - assert(params_width == 2); + sanity_check(content_width == 2); + sanity_check(params_width == 2); - SharedBuffer databuf(nodecount * (content_width + params_width)); + // 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) + throw SerializationError("MapNode::serializeBulk: serialization to " + "version < 24 not possible"); - // Serialize content - if(content_width == 1) - { - for(u32 i=0; i= 22); - assert(content_width == 1); - assert(params_width == 2); + if (version < 22 + || (content_width != 1 && content_width != 2) + || params_width != 2) + FATAL_ERROR("Deserialize bulk node data error"); // Uncompress or read data u32 len = nodecount * (content_width + params_width); @@ -265,12 +788,11 @@ void MapNode::deSerializeBulk(std::istream &is, int version, for(u32 i=0; i 0x7F){ + nodes[i].param0 <<= 4; + nodes[i].param0 |= (nodes[i].param2&0xF0)>>4; + nodes[i].param2 &= 0x0F; + } + } } - else + else if(content_width == 2) { - dest[0] = actual_content; - dest[1] = n_foreign.param1; - dest[2] = n_foreign.param2; + for(u32 i=0; i 0x7f){ + param0 <<= 4; + param0 |= (param2&0xf0)>>4; + param2 &= 0x0f; + } } - + // Convert special values from old version to new if(version <= 19) { @@ -353,115 +860,3 @@ void MapNode::deSerialize_pre22(u8 *source, u8 version) // Translate to our known version *this = mapnode_translate_to_internal(*this, version); } - - -#ifndef SERVER - -/* - Nodes make a face if contents differ and solidness differs. - Return value: - 0: No face - 1: Face uses m1's content - 2: Face uses m2's content - equivalent: Whether the blocks share the same face (eg. water and glass) - - TODO: Add 3: Both faces drawn with backface culling, remove equivalent -*/ -u8 face_contents(content_t m1, content_t m2, bool *equivalent, - INodeDefManager *nodemgr) -{ - *equivalent = false; - - if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE) - return 0; - - bool contents_differ = (m1 != m2); - - const ContentFeatures &f1 = nodemgr->get(m1); - const ContentFeatures &f2 = nodemgr->get(m2); - - // Contents don't differ for different forms of same liquid - if(f1.sameLiquid(f2)) - contents_differ = false; - - u8 c1 = f1.solidness; - u8 c2 = f2.solidness; - - bool solidness_differs = (c1 != c2); - bool makes_face = contents_differ && solidness_differs; - - if(makes_face == false) - return 0; - - if(c1 == 0) - c1 = f1.visual_solidness; - if(c2 == 0) - c2 = f2.visual_solidness; - - if(c1 == c2){ - *equivalent = true; - // If same solidness, liquid takes precense - if(f1.isLiquid()) - return 1; - if(f2.isLiquid()) - return 2; - } - - if(c1 > c2) - return 1; - else - return 2; -} - -/* - Gets lighting value at face of node - - Parameters must consist of air and !air. - Order doesn't matter. - - If either of the nodes doesn't exist, light is 0. - - parameters: - daynight_ratio: 0...1000 - n: getNode(p) (uses only the lighting value) - n2: getNode(p + face_dir) (uses only the lighting value) - face_dir: axis oriented unit vector from p to p2 - - returns encoded light value. -*/ -u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2, - v3s16 face_dir, INodeDefManager *nodemgr) -{ - try{ - u8 light; - u8 l1 = n.getLightBlend(daynight_ratio, nodemgr); - u8 l2 = n2.getLightBlend(daynight_ratio, nodemgr); - if(l1 > l2) - light = l1; - else - light = l2; - - // Make some nice difference to different sides - - // This makes light come from a corner - /*if(face_dir.X == 1 || face_dir.Z == 1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.X == -1 || face_dir.Z == -1) - light = diminish_light(light);*/ - - // All neighboring faces have different shade (like in minecraft) - if(face_dir.X == 1 || face_dir.X == -1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.Z == 1 || face_dir.Z == -1) - light = diminish_light(light); - - return light; - } - catch(InvalidPositionException &e) - { - return 0; - } -} - -#endif -