Fix Android build, but there is a remaining linking issue in guiConfirmRegistration

[oweals/minetest.git] / src / mapnode.cpp

diff --git a/src/mapnode.cpp b/src/mapnode.cpp
index 9b6a39e1bd2f23d996ac975ff94c99d9bb65912c..ffba2f599d501671c3608768f8a680b02b423c91 100644 (file)
--- a/src/mapnode.cpp
+++ b/src/mapnode.cpp
@@ -26,6 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "serialization.h" // For ser_ver_supported
 #include "util/serialize.h"
 #include "log.h"
+#include "util/directiontables.h"
 #include "util/numeric.h"
 #include <string>
 #include <sstream>
@@ -45,7 +46,7 @@ static const u8 rot_to_wallmounted[] = {
 
 // Create directly from a nodename
 // If name is unknown, sets CONTENT_IGNORE
-MapNode::MapNode(INodeDefManager *ndef, const std::string &name,
+MapNode::MapNode(const NodeDefManager *ndef, const std::string &name,
                u8 a_param1, u8 a_param2)
 {
        content_t id = CONTENT_IGNORE;
@@ -83,12 +84,13 @@ void MapNode::setLight(enum LightBank bank, u8 a_light, const ContentFeatures &f
                assert("Invalid light bank" == NULL);
 }
 
-void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr)
+void MapNode::setLight(enum LightBank bank, u8 a_light,
+       const NodeDefManager *nodemgr)
 {
        setLight(bank, a_light, nodemgr->get(*this));
 }
 
-bool MapNode::isLightDayNightEq(INodeDefManager *nodemgr) const
+bool MapNode::isLightDayNightEq(const NodeDefManager *nodemgr) const
 {
        const ContentFeatures &f = nodemgr->get(*this);
        bool isEqual;
@@ -104,7 +106,7 @@ bool MapNode::isLightDayNightEq(INodeDefManager *nodemgr) const
        return isEqual;
 }
 
-u8 MapNode::getLight(enum LightBank bank, INodeDefManager *nodemgr) const
+u8 MapNode::getLight(enum LightBank bank, const NodeDefManager *nodemgr) const
 {
        // Select the brightest of [light source, propagated light]
        const ContentFeatures &f = nodemgr->get(*this);
@@ -131,7 +133,8 @@ u8 MapNode::getLightNoChecks(enum LightBank bank, const ContentFeatures *f) cons
                     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);
@@ -152,16 +155,20 @@ 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 ||
                        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 ||
@@ -170,7 +177,7 @@ u8 MapNode::getWallMounted(INodeDefManager *nodemgr) const
        return 0;
 }
 
-v3s16 MapNode::getWallMountedDir(INodeDefManager *nodemgr) const
+v3s16 MapNode::getWallMountedDir(const NodeDefManager *nodemgr) const
 {
        switch(getWallMounted(nodemgr))
        {
@@ -183,7 +190,7 @@ v3s16 MapNode::getWallMountedDir(INodeDefManager *nodemgr) const
        }
 }
 
-void MapNode::rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot)
+void MapNode::rotateAlongYAxis(const NodeDefManager *nodemgr, Rotation rot)
 {
        ContentParamType2 cpt2 = nodemgr->get(*this).param_type_2;
 
@@ -240,19 +247,19 @@ void MapNode::rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot)
 }
 
 void transformNodeBox(const MapNode &n, const NodeBox &nodebox,
-               INodeDefManager *nodemgr, std::vector<aabb3f> *p_boxes, u8 neighbors = 0)
+       const NodeDefManager *nodemgr, std::vector<aabb3f> *p_boxes,
+       u8 neighbors = 0)
 {
        std::vector<aabb3f> &boxes = *p_boxes;
 
        if (nodebox.type == NODEBOX_FIXED || nodebox.type == NODEBOX_LEVELED) {
                const std::vector<aabb3f> &fixed = nodebox.fixed;
-               int facedir = n.getFaceDir(nodemgr);
+               int facedir = n.getFaceDir(nodemgr, true);
                u8 axisdir = facedir>>2;
                facedir&=0x03;
                for (aabb3f box : fixed) {
-                       if (nodebox.type == NODEBOX_LEVELED) {
-                               box.MaxEdge.Y = -BS/2 + BS*((float)1/LEVELED_MAX) * n.getLevel(nodemgr);
-                       }
+                       if (nodebox.type == NODEBOX_LEVELED)
+                               box.MaxEdge.Y = (-0.5f + n.getLevel(nodemgr) / 64.0f) * BS;
 
                        switch (axisdir) {
                        case 0:
@@ -419,16 +426,40 @@ void transformNodeBox(const MapNode &n, const NodeBox &nodebox,
                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) \
@@ -439,18 +470,50 @@ void transformNodeBox(const MapNode &n, const NodeBox &nodebox,
 
                BOXESPUSHBACK(nodebox.fixed);
 
-               if (neighbors & 1)
+               if (neighbors & 1) {
                        BOXESPUSHBACK(nodebox.connect_top);
-               if (neighbors & 2)
+               } else {
+                       BOXESPUSHBACK(nodebox.disconnected_top);
+               }
+
+               if (neighbors & 2) {
                        BOXESPUSHBACK(nodebox.connect_bottom);
-               if (neighbors & 4)
+               } else {
+                       BOXESPUSHBACK(nodebox.disconnected_bottom);
+               }
+
+               if (neighbors & 4) {
                        BOXESPUSHBACK(nodebox.connect_front);
-               if (neighbors & 8)
+               } else {
+                       BOXESPUSHBACK(nodebox.disconnected_front);
+               }
+
+               if (neighbors & 8) {
                        BOXESPUSHBACK(nodebox.connect_left);
-               if (neighbors & 16)
+               } else {
+                       BOXESPUSHBACK(nodebox.disconnected_left);
+               }
+
+               if (neighbors & 16) {
                        BOXESPUSHBACK(nodebox.connect_back);
-               if (neighbors & 32)
+               } 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
        {
@@ -459,7 +522,7 @@ void transformNodeBox(const MapNode &n, const NodeBox &nodebox,
 }
 
 static inline void getNeighborConnectingFace(
-       const v3s16 &p, INodeDefManager *nodedef,
+       const v3s16 &p, const NodeDefManager *nodedef,
        Map *map, MapNode n, u8 bitmask, u8 *neighbors)
 {
        MapNode n2 = map->getNodeNoEx(p);
@@ -469,7 +532,7 @@ static inline void getNeighborConnectingFace(
 
 u8 MapNode::getNeighbors(v3s16 p, Map *map)
 {
-       INodeDefManager *nodedef=map->getNodeDefManager();
+       const NodeDefManager *nodedef = map->getNodeDefManager();
        u8 neighbors = 0;
        const ContentFeatures &f = nodedef->get(*this);
        // locate possible neighboring nodes to connect to
@@ -503,13 +566,15 @@ u8 MapNode::getNeighbors(v3s16 p, Map *map)
        return neighbors;
 }
 
-void MapNode::getNodeBoxes(INodeDefManager *nodemgr, std::vector<aabb3f> *boxes, u8 neighbors)
+void MapNode::getNodeBoxes(const NodeDefManager *nodemgr,
+       std::vector<aabb3f> *boxes, u8 neighbors)
 {
        const ContentFeatures &f = nodemgr->get(*this);
        transformNodeBox(*this, f.node_box, nodemgr, boxes, neighbors);
 }
 
-void MapNode::getCollisionBoxes(INodeDefManager *nodemgr, std::vector<aabb3f> *boxes, u8 neighbors)
+void MapNode::getCollisionBoxes(const NodeDefManager *nodemgr,
+       std::vector<aabb3f> *boxes, u8 neighbors)
 {
        const ContentFeatures &f = nodemgr->get(*this);
        if (f.collision_box.fixed.empty())
@@ -518,13 +583,14 @@ void MapNode::getCollisionBoxes(INodeDefManager *nodemgr, std::vector<aabb3f> *b
                transformNodeBox(*this, f.collision_box, nodemgr, boxes, neighbors);
 }
 
-void MapNode::getSelectionBoxes(INodeDefManager *nodemgr, std::vector<aabb3f> *boxes, u8 neighbors)
+void MapNode::getSelectionBoxes(const NodeDefManager *nodemgr,
+       std::vector<aabb3f> *boxes, u8 neighbors)
 {
        const ContentFeatures &f = nodemgr->get(*this);
        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 ==
@@ -535,7 +601,7 @@ u8 MapNode::getMaxLevel(INodeDefManager *nodemgr) const
        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 ==
@@ -556,7 +622,7 @@ u8 MapNode::getLevel(INodeDefManager *nodemgr) const
        return 0;
 }
 
-u8 MapNode::setLevel(INodeDefManager *nodemgr, s8 level)
+u8 MapNode::setLevel(const NodeDefManager *nodemgr, s8 level)
 {
        u8 rest = 0;
        if (level < 1) {
@@ -584,7 +650,7 @@ u8 MapNode::setLevel(INodeDefManager *nodemgr, s8 level)
        return rest;
 }
 
-u8 MapNode::addLevel(INodeDefManager *nodemgr, s8 add)
+u8 MapNode::addLevel(const NodeDefManager *nodemgr, s8 add)
 {
        s8 level = getLevel(nodemgr);
        if (add == 0) level = 1;