Improve getPointedThing() (#4346)

* Improved getPointedThing()

The new algorithm checks every node exactly once.
Now the point and normal vector of the collision is also returned in the
PointedThing (currently they are not used outside of the function).
Now the CNodeDefManager keeps the union of all possible nodeboxes, so
the raycast won't miss any nodes. Also if there are only small
nodeboxes, getPointedThing() is exceptionally fast.
Also adds unit test for VoxelLineIterator.

* Cleanup, code move

This commit moves getPointedThing() and
Client::getSelectedActiveObject() to ClientEnvironment.
The map nodes now can decide which neighbors they are connecting to
(MapNode::getNeighbors()).

src/CMakeLists.txt

@@ -447,6 +447,7 @@ set(common_SRCS
 	quicktune.cpp
 	reflowscan.cpp
 	remoteplayer.cpp
+	raycast.cpp
 	rollback.cpp
 	rollback_interface.cpp
 	serialization.cpp

src/client.cpp

@@ -53,6 +53,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "database-sqlite3.h"
 #include "serialization.h"
 #include "guiscalingfilter.h"
+#include "raycast.h"
 
 extern gui::IGUIEnvironment* guienv;
 
@@ -1500,44 +1501,6 @@ void Client::inventoryAction(InventoryAction *a)
 	delete a;
 }
 
-ClientActiveObject * Client::getSelectedActiveObject(
-		f32 max_d,
-		v3f from_pos_f_on_map,
-		core::line3d<f32> shootline_on_map
-	)
-{
-	std::vector<DistanceSortedActiveObject> objects;
-
-	m_env.getActiveObjects(from_pos_f_on_map, max_d, objects);
-
-	// Sort them.
-	// After this, the closest object is the first in the array.
-	std::sort(objects.begin(), objects.end());
-
-	for(unsigned int i=0; i<objects.size(); i++)
-	{
-		ClientActiveObject *obj = objects[i].obj;
-
-		aabb3f *selection_box = obj->getSelectionBox();
-		if(selection_box == NULL)
-			continue;
-
-		v3f pos = obj->getPosition();
-
-		aabb3f offsetted_box(
-				selection_box->MinEdge + pos,
-				selection_box->MaxEdge + pos
-		);
-
-		if(offsetted_box.intersectsWithLine(shootline_on_map))
-		{
-			return obj;
-		}
-	}
-
-	return NULL;
-}
-
 float Client::getAnimationTime()
 {
 	return m_animation_time;

src/client.h

@@ -445,14 +445,6 @@ public:
 	Inventory* getInventory(const InventoryLocation &loc);
 	void inventoryAction(InventoryAction *a);
 
-	// Gets closest object pointed by the shootline
-	// Returns NULL if not found
-	ClientActiveObject * getSelectedActiveObject(
-			f32 max_d,
-			v3f from_pos_f_on_map,
-			core::line3d<f32> shootline_on_map
-	);
-
 	const std::list<std::string> &getConnectedPlayerNames()
 	{
 		return m_env.getPlayerNames();

src/clientmap.cpp

@@ -172,8 +172,6 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 	ScopeProfiler sp(g_profiler, "CM::updateDrawList()", SPT_AVG);
 	g_profiler->add("CM::updateDrawList() count", 1);
 
-	INodeDefManager *nodemgr = m_gamedef->ndef();
-
 	for (std::map<v3s16, MapBlock*>::iterator i = m_drawlist.begin();
 			i != m_drawlist.end(); ++i) {
 		MapBlock *block = i->second;
@@ -219,7 +217,7 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 	if (g_settings->getBool("free_move")) {
 		MapNode n = getNodeNoEx(cam_pos_nodes);
 		if (n.getContent() == CONTENT_IGNORE ||
-				nodemgr->get(n).solidness == 2)
+				m_nodedef->get(n).solidness == 2)
 			occlusion_culling_enabled = false;
 	}
 
@@ -297,23 +295,23 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 			if (occlusion_culling_enabled &&
 					// For the central point of the mapblock 'endoff' can be halved
 					isOccluded(this, spn, cpn,
-						step, stepfac, startoff, endoff / 2.0f, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff / 2.0f, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(bs2,bs2,bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(bs2,bs2,-bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(bs2,-bs2,bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(bs2,-bs2,-bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(-bs2,bs2,bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(-bs2,bs2,-bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(-bs2,-bs2,bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr) &&
+						step, stepfac, startoff, endoff, needed_count, m_nodedef) &&
 					isOccluded(this, spn, cpn + v3s16(-bs2,-bs2,-bs2),
-						step, stepfac, startoff, endoff, needed_count, nodemgr)) {
+						step, stepfac, startoff, endoff, needed_count, m_nodedef)) {
 				blocks_occlusion_culled++;
 				continue;
 			}
@@ -656,7 +654,6 @@ int ClientMap::getBackgroundBrightness(float max_d, u32 daylight_factor,
 		int oldvalue, bool *sunlight_seen_result)
 {
 	const bool debugprint = false;
-	INodeDefManager *ndef = m_gamedef->ndef();
 	static v3f z_directions[50] = {
 		v3f(-100, 0, 0)
 	};
@@ -694,7 +691,7 @@ int ClientMap::getBackgroundBrightness(float max_d, u32 daylight_factor,
 		float off = step * z_offsets[i];
 		bool sunlight_seen_now = false;
 		bool ok = getVisibleBrightness(this, m_camera_position, dir,
-				step, 1.0, max_d*0.6+off, max_d, ndef, daylight_factor,
+				step, 1.0, max_d*0.6+off, max_d, m_nodedef, daylight_factor,
 				sunlight_min_d,
 				&br, &sunlight_seen_now);
 		if(sunlight_seen_now)
@@ -734,8 +731,8 @@ int ClientMap::getBackgroundBrightness(float max_d, u32 daylight_factor,
 	int ret = 0;
 	if(brightness_count == 0){
 		MapNode n = getNodeNoEx(floatToInt(m_camera_position, BS));
-		if(ndef->get(n).param_type == CPT_LIGHT){
+		if(m_nodedef->get(n).param_type == CPT_LIGHT){
-			ret = decode_light(n.getLightBlend(daylight_factor, ndef));
+			ret = decode_light(n.getLightBlend(daylight_factor, m_nodedef));
 		} else {
 			ret = oldvalue;
 		}
@@ -758,8 +755,6 @@ int ClientMap::getBackgroundBrightness(float max_d, u32 daylight_factor,
 
 void ClientMap::renderPostFx(CameraMode cam_mode)
 {
-	INodeDefManager *nodemgr = m_gamedef->ndef();
-
 	// Sadly ISceneManager has no "post effects" render pass, in that case we
 	// could just register for that and handle it in renderMap().
 
@@ -768,7 +763,7 @@ void ClientMap::renderPostFx(CameraMode cam_mode)
 	// - If the player is in a solid node, make everything black.
 	// - If the player is in liquid, draw a semi-transparent overlay.
 	// - Do not if player is in third person mode
-	const ContentFeatures& features = nodemgr->get(n);
+	const ContentFeatures& features = m_nodedef->get(n);
 	video::SColor post_effect_color = features.post_effect_color;
 	if(features.solidness == 2 && !(g_settings->getBool("noclip") &&
 			m_gamedef->checkLocalPrivilege("noclip")) &&

src/environment.cpp

@@ -43,8 +43,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "daynightratio.h"
 #include "map.h"
 #include "emerge.h"
+#include "raycast.h"
+#include "voxelalgorithms.h"
 #include "util/serialize.h"
 #include "util/basic_macros.h"
+#include "util/pointedthing.h"
 #include "threading/mutex_auto_lock.h"
 
 #define LBM_NAME_ALLOWED_CHARS "abcdefghijklmnopqrstuvwxyz0123456789_:"
@@ -2848,4 +2851,242 @@ ClientEnvEvent ClientEnvironment::getClientEvent()
 	return event;
 }
 
+ClientActiveObject * ClientEnvironment::getSelectedActiveObject(
+	const core::line3d<f32> &shootline_on_map, v3f *intersection_point,
+	v3s16 *intersection_normal)
+{
+	std::vector<DistanceSortedActiveObject> objects;
+	getActiveObjects(shootline_on_map.start,
+		shootline_on_map.getLength() + 3, objects);
+	const v3f line_vector = shootline_on_map.getVector();
+
+	// Sort them.
+	// After this, the closest object is the first in the array.
+	std::sort(objects.begin(), objects.end());
+
+	/* Because objects can have different nodebox sizes,
+	 * the object whose center is the nearest isn't necessarily
+	 * the closest one. If an object is found, don't stop
+	 * immediately. */
+
+	f32 d_min = shootline_on_map.getLength();
+	ClientActiveObject *nearest_obj = NULL;
+	for (u32 i = 0; i < objects.size(); i++) {
+		ClientActiveObject *obj = objects[i].obj;
+
+		aabb3f *selection_box = obj->getSelectionBox();
+		if (selection_box == NULL)
+			continue;
+
+		v3f pos = obj->getPosition();
+
+		aabb3f offsetted_box(selection_box->MinEdge + pos,
+			selection_box->MaxEdge + pos);
+
+		if (offsetted_box.getCenter().getDistanceFrom(
+				shootline_on_map.start) > d_min + 9.6f*BS) {
+			// Probably there is no active object that has bigger nodebox than
+			// (-5.5,-5.5,-5.5,5.5,5.5,5.5)
+			// 9.6 > 5.5*sqrt(3)
+			break;
+		}
+
+		v3f current_intersection;
+		v3s16 current_normal;
+		if (boxLineCollision(offsetted_box, shootline_on_map.start, line_vector,
+				&current_intersection, &current_normal)) {
+			f32 d_current = current_intersection.getDistanceFrom(
+				shootline_on_map.start);
+			if (d_current <= d_min) {
+				d_min = d_current;
+				nearest_obj = obj;
+				*intersection_point = current_intersection;
+				*intersection_normal = current_normal;
+			}
+		}
+	}
+
+	return nearest_obj;
+}
+
+/*
+	Check if a node is pointable
+*/
+static inline bool isPointableNode(const MapNode &n,
+	INodeDefManager *ndef, bool liquids_pointable)
+{
+	const ContentFeatures &features = ndef->get(n);
+	return features.pointable ||
+	       (liquids_pointable && features.isLiquid());
+}
+
+PointedThing ClientEnvironment::getPointedThing(
+	core::line3d<f32> shootline,
+	bool liquids_pointable,
+	bool look_for_object)
+{
+	PointedThing result;
+
+	INodeDefManager *nodedef = m_map->getNodeDefManager();
+
+	core::aabbox3d<s16> maximal_exceed = nodedef->getSelectionBoxIntUnion();
+	// The code needs to search these nodes
+	core::aabbox3d<s16> search_range(-maximal_exceed.MaxEdge,
+		-maximal_exceed.MinEdge);
+	// If a node is found, there might be a larger node behind.
+	// To find it, we have to go further.
+	s16 maximal_overcheck =
+		  std::max(abs(search_range.MinEdge.X), abs(search_range.MaxEdge.X))
+		+ std::max(abs(search_range.MinEdge.Y), abs(search_range.MaxEdge.Y))
+		+ std::max(abs(search_range.MinEdge.Z), abs(search_range.MaxEdge.Z));
+
+	const v3f original_vector = shootline.getVector();
+	const f32 original_length = original_vector.getLength();
+
+	f32 min_distance = original_length;
+
+	// First try to find an active object
+	if (look_for_object) {
+		ClientActiveObject *selected_object = getSelectedActiveObject(
+			shootline, &result.intersection_point,
+			&result.intersection_normal);
+
+		if (selected_object != NULL) {
+			min_distance =
+				(result.intersection_point - shootline.start).getLength();
+
+			result.type = POINTEDTHING_OBJECT;
+			result.object_id = selected_object->getId();
+		}
+	}
+
+	// Reduce shootline
+	if (original_length > 0) {
+		shootline.end = shootline.start
+			+ shootline.getVector() / original_length * min_distance;
+	}
+
+	// Try to find a node that is closer than the selected active
+	// object (if it exists).
+
+	voxalgo::VoxelLineIterator iterator(shootline.start / BS,
+		shootline.getVector() / BS);
+	v3s16 oldnode = iterator.m_current_node_pos;
+	// Indicates that a node was found.
+	bool is_node_found = false;
+	// If a node is found, it is possible that there's a node
+	// behind it with a large nodebox, so continue the search.
+	u16 node_foundcounter = 0;
+	// If a node is found, this is the center of the
+	// first nodebox the shootline meets.
+	v3f found_boxcenter(0, 0, 0);
+	// The untested nodes are in this range.
+	core::aabbox3d<s16> new_nodes;
+	while (true) {
+		// Test the nodes around the current node in search_range.
+		new_nodes = search_range;
+		new_nodes.MinEdge += iterator.m_current_node_pos;
+		new_nodes.MaxEdge += iterator.m_current_node_pos;
+
+		// Only check new nodes
+		v3s16 delta = iterator.m_current_node_pos - oldnode;
+		if (delta.X > 0)
+			new_nodes.MinEdge.X = new_nodes.MaxEdge.X;
+		else if (delta.X < 0)
+			new_nodes.MaxEdge.X = new_nodes.MinEdge.X;
+		else if (delta.Y > 0)
+			new_nodes.MinEdge.Y = new_nodes.MaxEdge.Y;
+		else if (delta.Y < 0)
+			new_nodes.MaxEdge.Y = new_nodes.MinEdge.Y;
+		else if (delta.Z > 0)
+			new_nodes.MinEdge.Z = new_nodes.MaxEdge.Z;
+		else if (delta.Z < 0)
+			new_nodes.MaxEdge.Z = new_nodes.MinEdge.Z;
+
+		// For each untested node
+		for (s16 x = new_nodes.MinEdge.X; x <= new_nodes.MaxEdge.X; x++) {
+		for (s16 y = new_nodes.MinEdge.Y; y <= new_nodes.MaxEdge.Y; y++) {
+		for (s16 z = new_nodes.MinEdge.Z; z <= new_nodes.MaxEdge.Z; z++) {
+		MapNode n;
+		v3s16 np(x, y, z);
+		bool is_valid_position;
+
+		n = m_map->getNodeNoEx(np, &is_valid_position);
+		if (!(is_valid_position &&
+				isPointableNode(n, nodedef, liquids_pointable))) {
+			continue;
+		}
+		std::vector<aabb3f> boxes;
+		n.getSelectionBoxes(nodedef, &boxes,
+			n.getNeighbors(np, m_map));
+
+		v3f npf = intToFloat(np, BS);
+		for (std::vector<aabb3f>::const_iterator i = boxes.begin();
+			i != boxes.end(); ++i) {
+			aabb3f box = *i;
+			box.MinEdge += npf;
+			box.MaxEdge += npf;
+			v3f intersection_point;
+			v3s16 intersection_normal;
+			if (!boxLineCollision(box, shootline.start, shootline.getVector(),
+					&intersection_point, &intersection_normal)) {
+				continue;
+			}
+			f32 distance = (intersection_point - shootline.start).getLength();
+			if (distance >= min_distance) {
+				continue;
+			}
+			result.type = POINTEDTHING_NODE;
+			result.node_undersurface = np;
+			result.intersection_point = intersection_point;
+			result.intersection_normal = intersection_normal;
+			found_boxcenter = box.getCenter();
+			min_distance = distance;
+			is_node_found = true;
+		}
+		}
+		}
+		}
+		if (is_node_found) {
+			node_foundcounter++;
+			if (node_foundcounter > maximal_overcheck) {
+				break;
+			}
+		}
+		// Next node
+		if (iterator.hasNext()) {
+			oldnode = iterator.m_current_node_pos;
+			iterator.next();
+		} else {
+			break;
+		}
+	}
+
+	if (is_node_found) {
+		// Set undersurface and abovesurface nodes
+		f32 d = 0.002 * BS;
+		v3f fake_intersection = result.intersection_point;
+		// Move intersection towards its source block.
+		if (fake_intersection.X < found_boxcenter.X)
+			fake_intersection.X += d;
+		else
+			fake_intersection.X -= d;
+
+		if (fake_intersection.Y < found_boxcenter.Y)
+			fake_intersection.Y += d;
+		else
+			fake_intersection.Y -= d;
+
+		if (fake_intersection.Z < found_boxcenter.Z)
+			fake_intersection.Z += d;
+		else
+			fake_intersection.Z -= d;
+
+		result.node_real_undersurface = floatToInt(fake_intersection, BS);
+		result.node_abovesurface = result.node_real_undersurface
+			+ result.intersection_normal;
+	}
+	return result;
+}
+
 #endif // #ifndef SERVER

src/environment.h

@@ -55,6 +55,7 @@ class GameScripting;
 class Player;
 class RemotePlayer;
 class PlayerSAO;
+class PointedThing;
 
 class Environment
 {
@@ -627,6 +628,41 @@ public:
 	// Get event from queue. CEE_NONE is returned if queue is empty.
 	ClientEnvEvent getClientEvent();
 
+	/*!
+	 * Gets closest object pointed by the shootline.
+	 * Returns NULL if not found.
+	 *
+	 * \param[in]  shootline_on_map    the shootline for
+	 * the test in world coordinates
+	 * \param[out] intersection_point  the first point where
+	 * the shootline meets the object. Valid only if
+	 * not NULL is returned.
+	 * \param[out] intersection_normal the normal vector of
+	 * the intersection, pointing outwards. Zero vector if
+	 * the shootline starts in an active object.
+	 * Valid only if not NULL is returned.
+	 */
+	ClientActiveObject * getSelectedActiveObject(
+		const core::line3d<f32> &shootline_on_map,
+		v3f *intersection_point,
+		v3s16 *intersection_normal
+	);
+
+	/*!
+	 * Performs a raycast on the world.
+	 * Returns the first thing the shootline meets.
+	 *
+	 * @param[in]  shootline         the shootline, starting from
+	 * the camera position. This also gives the maximal distance
+	 * of the search.
+	 * @param[in]  liquids_pointable if false, liquids are ignored
+	 * @param[in]  look_for_object   if false, objects are ignored
+	 */
+	PointedThing getPointedThing(
+		core::line3d<f32> shootline,
+		bool liquids_pointable,
+		bool look_for_object);
+
 	u16 attachement_parent_ids[USHRT_MAX + 1];
 
 	const std::list<std::string> &getPlayerNames() { return m_player_names; }

src/game.cpp

@@ -265,271 +265,6 @@ public:
 	Client *m_client;
 };
 
-/*
-	Check if a node is pointable
-*/
-inline bool isPointableNode(const MapNode &n,
-			    Client *client, bool liquids_pointable)
-{
-	const ContentFeatures &features = client->getNodeDefManager()->get(n);
-	return features.pointable ||
-	       (liquids_pointable && features.isLiquid());
-}
-
-static inline void getNeighborConnectingFace(v3s16 p, INodeDefManager *nodedef,
-		ClientMap *map, MapNode n, u8 bitmask, u8 *neighbors)
-{
-	MapNode n2 = map->getNodeNoEx(p);
-	if (nodedef->nodeboxConnects(n, n2, bitmask))
-		*neighbors |= bitmask;
-}
-
-static inline u8 getNeighbors(v3s16 p, INodeDefManager *nodedef, ClientMap *map, MapNode n)
-{
-	u8 neighbors = 0;
-	const ContentFeatures &f = nodedef->get(n);
-	// 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, n, 1, &neighbors);
-
-		p2 = p;
-		p2.Y--;
-		getNeighborConnectingFace(p2, nodedef, map, n, 2, &neighbors);
-
-		p2 = p;
-		p2.Z--;
-		getNeighborConnectingFace(p2, nodedef, map, n, 4, &neighbors);
-
-		p2 = p;
-		p2.X--;
-		getNeighborConnectingFace(p2, nodedef, map, n, 8, &neighbors);
-
-		p2 = p;
-		p2.Z++;
-		getNeighborConnectingFace(p2, nodedef, map, n, 16, &neighbors);
-
-		p2 = p;
-		p2.X++;
-		getNeighborConnectingFace(p2, nodedef, map, n, 32, &neighbors);
-	}
-
-	return neighbors;
-}
-
-/*
-	Find what the player is pointing at
-*/
-PointedThing getPointedThing(Client *client, Hud *hud, const v3f &player_position,
-		const v3f &camera_direction, const v3f &camera_position,
-		core::line3d<f32> shootline, f32 d, bool liquids_pointable,
-		bool look_for_object, const v3s16 &camera_offset,
-		ClientActiveObject *&selected_object)
-{
-	PointedThing result;
-
-	std::vector<aabb3f> *selectionboxes = hud->getSelectionBoxes();
-	selectionboxes->clear();
-	static const bool show_entity_selectionbox = g_settings->getBool("show_entity_selectionbox");
-
-	selected_object = NULL;
-
-	INodeDefManager *nodedef = client->getNodeDefManager();
-	ClientMap &map = client->getEnv().getClientMap();
-
-	f32 min_distance = BS * 1001;
-
-	// First try to find a pointed at active object
-	if (look_for_object) {
-		selected_object = client->getSelectedActiveObject(d * BS,
-				  camera_position, shootline);
-
-		if (selected_object != NULL) {
-			if (show_entity_selectionbox &&
-					selected_object->doShowSelectionBox()) {
-				aabb3f *selection_box = selected_object->getSelectionBox();
-				// Box should exist because object was
-				// returned in the first place
-				assert(selection_box);
-
-				v3f pos = selected_object->getPosition();
-				selectionboxes->push_back(aabb3f(
-					selection_box->MinEdge, selection_box->MaxEdge));
-				hud->setSelectionPos(pos, camera_offset);
-			}
-
-			min_distance = (selected_object->getPosition() - camera_position).getLength();
-
-			hud->setSelectedFaceNormal(v3f(0.0, 0.0, 0.0));
-			result.type = POINTEDTHING_OBJECT;
-			result.object_id = selected_object->getId();
-		}
-	}
-
-	// That didn't work, try to find a pointed at node
-
-	v3s16 pos_i = floatToInt(player_position, BS);
-
-	/*infostream<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"
-			<<std::endl;*/
-
-	s16 a = d;
-	s16 ystart = pos_i.Y - (camera_direction.Y < 0 ? a : 1);
-	s16 zstart = pos_i.Z - (camera_direction.Z < 0 ? a : 1);
-	s16 xstart = pos_i.X - (camera_direction.X < 0 ? a : 1);
-	s16 yend = pos_i.Y + 1 + (camera_direction.Y > 0 ? a : 1);
-	s16 zend = pos_i.Z + (camera_direction.Z > 0 ? a : 1);
-	s16 xend = pos_i.X + (camera_direction.X > 0 ? a : 1);
-
-	// Prevent signed number overflow
-	if (yend == 32767)
-		yend = 32766;
-
-	if (zend == 32767)
-		zend = 32766;
-
-	if (xend == 32767)
-		xend = 32766;
-
-	v3s16 pointed_pos(0, 0, 0);
-
-	for (s16 y = ystart; y <= yend; y++) {
-		for (s16 z = zstart; z <= zend; z++) {
-			for (s16 x = xstart; x <= xend; x++) {
-				MapNode n;
-				bool is_valid_position;
-				v3s16 p(x, y, z);
-
-				n = map.getNodeNoEx(p, &is_valid_position);
-				if (!is_valid_position) {
-					continue;
-				}
-				if (!isPointableNode(n, client, liquids_pointable)) {
-					continue;
-				}
-
-				std::vector<aabb3f> boxes;
-				n.getSelectionBoxes(nodedef, &boxes, getNeighbors(p, nodedef, &map, n));
-
-				v3s16 np(x, y, z);
-				v3f npf = intToFloat(np, BS);
-				for (std::vector<aabb3f>::const_iterator
-						i = boxes.begin();
-						i != boxes.end(); ++i) {
-					aabb3f box = *i;
-					box.MinEdge += npf;
-					box.MaxEdge += npf;
-
-					v3f centerpoint = box.getCenter();
-					f32 distance = (centerpoint - camera_position).getLength();
-					if (distance >= min_distance) {
-						continue;
-					}
-					if (!box.intersectsWithLine(shootline)) {
-						continue;
-					}
-					result.type = POINTEDTHING_NODE;
-					min_distance = distance;
-					pointed_pos = np;
-				}
-			}
-		}
-	}
-
-	if (result.type == POINTEDTHING_NODE) {
-		f32 d = 0.001 * BS;
-		MapNode n = map.getNodeNoEx(pointed_pos);
-		v3f npf = intToFloat(pointed_pos, BS);
-		std::vector<aabb3f> boxes;
-		n.getSelectionBoxes(nodedef, &boxes, getNeighbors(pointed_pos, nodedef, &map, n));
-		f32 face_min_distance = 1000 * BS;
-		for (std::vector<aabb3f>::const_iterator
-				i = boxes.begin();
-				i != boxes.end(); ++i) {
-			aabb3f box = *i;
-			box.MinEdge += npf;
-			box.MaxEdge += npf;
-			for (u16 j = 0; j < 6; j++) {
-				v3s16 facedir = g_6dirs[j];
-				aabb3f facebox = box;
-				if (facedir.X > 0) {
-					facebox.MinEdge.X = facebox.MaxEdge.X - d;
-				} else if (facedir.X < 0) {
-					facebox.MaxEdge.X = facebox.MinEdge.X + d;
-				} else if (facedir.Y > 0) {
-					facebox.MinEdge.Y = facebox.MaxEdge.Y - d;
-				} else if (facedir.Y < 0) {
-					facebox.MaxEdge.Y = facebox.MinEdge.Y + d;
-				} else if (facedir.Z > 0) {
-					facebox.MinEdge.Z = facebox.MaxEdge.Z - d;
-				} else if (facedir.Z < 0) {
-					facebox.MaxEdge.Z = facebox.MinEdge.Z + d;
-				}
-				v3f centerpoint = facebox.getCenter();
-				f32 distance = (centerpoint - camera_position).getLength();
-				if (distance >= face_min_distance)
-					continue;
-				if (!facebox.intersectsWithLine(shootline))
-					continue;
-				result.node_abovesurface = pointed_pos + facedir;
-				hud->setSelectedFaceNormal(v3f(facedir.X, facedir.Y, facedir.Z));
-				face_min_distance = distance;
-			}
-		}
-		selectionboxes->clear();
-		for (std::vector<aabb3f>::const_iterator
-				i = boxes.begin();
-				i != boxes.end(); ++i) {
-			aabb3f box = *i;
-			box.MinEdge += v3f(-d, -d, -d);
-			box.MaxEdge += v3f(d, d, d);
-			selectionboxes->push_back(box);
-		}
-		hud->setSelectionPos(intToFloat(pointed_pos, BS), camera_offset);
-		result.node_undersurface = pointed_pos;
-	}
-
-	// Update selection mesh light level and vertex colors
-	if (selectionboxes->size() > 0) {
-		v3f pf = hud->getSelectionPos();
-		v3s16 p = floatToInt(pf, BS);
-
-		// Get selection mesh light level
-		MapNode n = map.getNodeNoEx(p);
-		u16 node_light = getInteriorLight(n, -1, nodedef);
-		u16 light_level = node_light;
-
-		for (u8 i = 0; i < 6; i++) {
-			n = map.getNodeNoEx(p + g_6dirs[i]);
-			node_light = getInteriorLight(n, -1, nodedef);
-			if (node_light > light_level)
-				light_level = node_light;
-		}
-
-		video::SColor c = MapBlock_LightColor(255, light_level, 0);
-		u8 day = c.getRed();
-		u8 night = c.getGreen();
-		u32 daynight_ratio = client->getEnv().getDayNightRatio();
-		finalColorBlend(c, day, night, daynight_ratio);
-
-		// Modify final color a bit with time
-		u32 timer = porting::getTimeMs() % 5000;
-		float timerf = (float)(irr::core::PI * ((timer / 2500.0) - 0.5));
-		float sin_r = 0.08 * sin(timerf);
-		float sin_g = 0.08 * sin(timerf + irr::core::PI * 0.5);
-		float sin_b = 0.08 * sin(timerf + irr::core::PI);
-		c.setRed(core::clamp(core::round32(c.getRed() * (0.8 + sin_r)), 0, 255));
-		c.setGreen(core::clamp(core::round32(c.getGreen() * (0.8 + sin_g)), 0, 255));
-		c.setBlue(core::clamp(core::round32(c.getBlue() * (0.8 + sin_b)), 0, 255));
-
-		// Set mesh final color
-		hud->setSelectionMeshColor(c);
-	}
-	return result;
-}
-
 /* Profiler display */
 
 void update_profiler_gui(gui::IGUIStaticText *guitext_profiler, FontEngine *fe,
@@ -1668,6 +1403,23 @@ protected:
 	void updateSound(f32 dtime);
 	void processPlayerInteraction(GameRunData *runData, f32 dtime, bool show_hud,
 			bool show_debug);
+	/*!
+	 * Returns the object or node the player is pointing at.
+	 * Also updates the selected thing in the Hud.
+	 *
+	 * @param[in]  shootline         the shootline, starting from
+	 * the camera position. This also gives the maximal distance
+	 * of the search.
+	 * @param[in]  liquids_pointable if false, liquids are ignored
+	 * @param[in]  look_for_object   if false, objects are ignored
+	 * @param[in]  camera_offset     offset of the camera
+	 * @param[out] selected_object   the selected object or
+	 * NULL if not found
+	 */
+	PointedThing updatePointedThing(
+			const core::line3d<f32> &shootline, bool liquids_pointable,
+			bool look_for_object, const v3s16 &camera_offset,
+			ClientActiveObject *&selected_object);
 	void handlePointingAtNothing(GameRunData *runData, const ItemStack &playerItem);
 	void handlePointingAtNode(GameRunData *runData,
 			const PointedThing &pointed, const ItemDefinition &playeritem_def,
@@ -3823,14 +3575,11 @@ void Game::processPlayerInteraction(GameRunData *runData,
 	core::line3d<f32> shootline;
 
 	if (camera->getCameraMode() != CAMERA_MODE_THIRD_FRONT) {
-
 		shootline = core::line3d<f32>(camera_position,
-						camera_position + camera_direction * BS * (d + 1));
+			camera_position + camera_direction * BS * d);
-
 	} else {
 	    // prevent player pointing anything in front-view
-		if (camera->getCameraMode() == CAMERA_MODE_THIRD_FRONT)
+		shootline = core::line3d<f32>(camera_position,camera_position);
-			shootline = core::line3d<f32>(0, 0, 0, 0, 0, 0);
 	}
 
 #ifdef HAVE_TOUCHSCREENGUI
@@ -3843,10 +3592,7 @@ void Game::processPlayerInteraction(GameRunData *runData,
 
 #endif
 
-	PointedThing pointed = getPointedThing(
+	PointedThing pointed = updatePointedThing(shootline,
-			// input
-			client, hud, player_position, camera_direction,
-			camera_position, shootline, d,
 			playeritem_def.liquids_pointable,
 			!runData->ldown_for_dig,
 			camera_offset,
@@ -3940,6 +3686,104 @@ void Game::processPlayerInteraction(GameRunData *runData,
 }
 
 
+PointedThing Game::updatePointedThing(
+	const core::line3d<f32> &shootline,
+	bool liquids_pointable,
+	bool look_for_object,
+	const v3s16 &camera_offset,
+	ClientActiveObject *&selected_object)
+{
+	std::vector<aabb3f> *selectionboxes = hud->getSelectionBoxes();
+	selectionboxes->clear();
+	static const bool show_entity_selectionbox = g_settings->getBool(
+		"show_entity_selectionbox");
+
+	ClientMap &map = client->getEnv().getClientMap();
+	INodeDefManager *nodedef=client->getNodeDefManager();
+
+	selected_object = NULL;
+
+	PointedThing result=client->getEnv().getPointedThing(
+		shootline, liquids_pointable, look_for_object);
+	if (result.type == POINTEDTHING_OBJECT) {
+		selected_object = client->getEnv().getActiveObject(result.object_id);
+		if (show_entity_selectionbox && selected_object->doShowSelectionBox()) {
+			aabb3f *selection_box = selected_object->getSelectionBox();
+
+			// Box should exist because object was
+			// returned in the first place
+
+			assert(selection_box);
+
+			v3f pos = selected_object->getPosition();
+			selectionboxes->push_back(aabb3f(
+				selection_box->MinEdge, selection_box->MaxEdge));
+			selectionboxes->push_back(
+				aabb3f(selection_box->MinEdge, selection_box->MaxEdge));
+			hud->setSelectionPos(pos, camera_offset);
+		}
+	} else if (result.type == POINTEDTHING_NODE) {
+		// Update selection boxes
+		MapNode n = map.getNodeNoEx(result.node_undersurface);
+		std::vector<aabb3f> boxes;
+		n.getSelectionBoxes(nodedef, &boxes,
+			n.getNeighbors(result.node_undersurface, &map));
+
+		f32 d = 0.002 * BS;
+		for (std::vector<aabb3f>::const_iterator i = boxes.begin();
+			i != boxes.end(); ++i) {
+			aabb3f box = *i;
+			box.MinEdge -= v3f(d, d, d);
+			box.MaxEdge += v3f(d, d, d);
+			selectionboxes->push_back(box);
+		}
+		hud->setSelectionPos(intToFloat(result.node_undersurface, BS),
+			camera_offset);
+	}
+
+	// Update selection mesh light level and vertex colors
+	if (selectionboxes->size() > 0) {
+		v3f pf = hud->getSelectionPos();
+		v3s16 p = floatToInt(pf, BS);
+
+		// Get selection mesh light level
+		MapNode n = map.getNodeNoEx(p);
+		u16 node_light = getInteriorLight(n, -1, nodedef);
+		u16 light_level = node_light;
+
+		for (u8 i = 0; i < 6; i++) {
+			n = map.getNodeNoEx(p + g_6dirs[i]);
+			node_light = getInteriorLight(n, -1, nodedef);
+			if (node_light > light_level)
+				light_level = node_light;
+		}
+
+		video::SColor c = MapBlock_LightColor(255, light_level, 0);
+		u8 day = c.getRed();
+		u8 night = c.getGreen();
+		u32 daynight_ratio = client->getEnv().getDayNightRatio();
+		finalColorBlend(c, day, night, daynight_ratio);
+
+		// Modify final color a bit with time
+		u32 timer = porting::getTimeMs() % 5000;
+		float timerf = (float) (irr::core::PI * ((timer / 2500.0) - 0.5));
+		float sin_r = 0.08 * sin(timerf);
+		float sin_g = 0.08 * sin(timerf + irr::core::PI * 0.5);
+		float sin_b = 0.08 * sin(timerf + irr::core::PI);
+		c.setRed(
+			core::clamp(core::round32(c.getRed() * (0.8 + sin_r)), 0, 255));
+		c.setGreen(
+			core::clamp(core::round32(c.getGreen() * (0.8 + sin_g)), 0, 255));
+		c.setBlue(
+			core::clamp(core::round32(c.getBlue() * (0.8 + sin_b)), 0, 255));
+
+		// Set mesh final color
+		hud->setSelectionMeshColor(c);
+	}
+	return result;
+}
+
+
 void Game::handlePointingAtNothing(GameRunData *runData, const ItemStack &playerItem)
 {
 	infostream << "Right Clicked in Air" << std::endl;

src/map.cpp

@@ -66,6 +66,7 @@ Map::Map(std::ostream &dout, IGameDef *gamedef):
 	m_dout(dout),
 	m_gamedef(gamedef),
 	m_sector_cache(NULL),
+	m_nodedef(gamedef->ndef()),
 	m_transforming_liquid_loop_count_multiplier(1.0f),
 	m_unprocessed_count(0),
 	m_inc_trending_up_start_time(0),
@@ -227,7 +228,7 @@ void Map::setNode(v3s16 p, MapNode & n)
 		bool temp_bool;
 		errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
 				<<" while trying to replace \""
-				<<m_gamedef->ndef()->get(block->getNodeNoCheck(relpos, &temp_bool)).name
+				<<m_nodedef->get(block->getNodeNoCheck(relpos, &temp_bool)).name
 				<<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
 		debug_stacks_print_to(infostream);
 		return;
@@ -257,8 +258,6 @@ void Map::unspreadLight(enum LightBank bank,
 		std::set<v3s16> & light_sources,
 		std::map<v3s16, MapBlock*>  & modified_blocks)
 {
-	INodeDefManager *nodemgr = m_gamedef->ndef();
-
 	v3s16 dirs[6] = {
 		v3s16(0,0,1), // back
 		v3s16(0,1,0), // top
@@ -353,20 +352,20 @@ void Map::unspreadLight(enum LightBank bank,
 				If the neighbor is dimmer than what was specified
 				as oldlight (the light of the previous node)
 			*/
-			if(n2.getLight(bank, nodemgr) < oldlight)
+			if(n2.getLight(bank, m_nodedef) < oldlight)
 			{
 				/*
 					And the neighbor is transparent and it has some light
 				*/
-				if(nodemgr->get(n2).light_propagates
+				if(m_nodedef->get(n2).light_propagates
-						&& n2.getLight(bank, nodemgr) != 0)
+						&& n2.getLight(bank, m_nodedef) != 0)
 				{
 					/*
 						Set light to 0 and add to queue
 					*/
 
-					u8 current_light = n2.getLight(bank, nodemgr);
+					u8 current_light = n2.getLight(bank, m_nodedef);
-					n2.setLight(bank, 0, nodemgr);
+					n2.setLight(bank, 0, m_nodedef);
 					block->setNode(relpos, n2);
 
 					unlighted_nodes[n2pos] = current_light;
@@ -421,8 +420,6 @@ void Map::spreadLight(enum LightBank bank,
 		std::set<v3s16> & from_nodes,
 		std::map<v3s16, MapBlock*> & modified_blocks)
 {
-	INodeDefManager *nodemgr = m_gamedef->ndef();
-
 	const v3s16 dirs[6] = {
 		v3s16(0,0,1), // back
 		v3s16(0,1,0), // top
@@ -476,7 +473,7 @@ void Map::spreadLight(enum LightBank bank,
 		bool is_valid_position;
 		MapNode n = block->getNode(relpos, &is_valid_position);
 
-		u8 oldlight = is_valid_position ? n.getLight(bank, nodemgr) : 0;
+		u8 oldlight = is_valid_position ? n.getLight(bank, m_nodedef) : 0;
 		u8 newlight = diminish_light(oldlight);
 
 		// Loop through 6 neighbors
@@ -512,7 +509,7 @@ void Map::spreadLight(enum LightBank bank,
 				If the neighbor is brighter than the current node,
 				add to list (it will light up this node on its turn)
 			*/
-			if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight))
+			if(n2.getLight(bank, m_nodedef) > undiminish_light(oldlight))
 			{
 				lighted_nodes.insert(n2pos);
 				changed = true;
@@ -521,11 +518,11 @@ void Map::spreadLight(enum LightBank bank,
 				If the neighbor is dimmer than how much light this node
 				would spread on it, add to list
 			*/
-			if(n2.getLight(bank, nodemgr) < newlight)
+			if(n2.getLight(bank, m_nodedef) < newlight)
 			{
-				if(nodemgr->get(n2).light_propagates)
+				if(m_nodedef->get(n2).light_propagates)
 				{
-					n2.setLight(bank, newlight, nodemgr);
+					n2.setLight(bank, newlight, m_nodedef);
 					block->setNode(relpos, n2);
 					lighted_nodes.insert(n2pos);
 					changed = true;
@@ -558,8 +555,6 @@ void Map::updateLighting(enum LightBank bank,
 		std::map<v3s16, MapBlock*> & a_blocks,
 		std::map<v3s16, MapBlock*> & modified_blocks)
 {
-	INodeDefManager *nodemgr = m_gamedef->ndef();
-
 	/*m_dout<<"Map::updateLighting(): "
 			<<a_blocks.size()<<" blocks."<<std::endl;*/
 
@@ -614,12 +609,12 @@ void Map::updateLighting(enum LightBank bank,
 							<<std::endl;
 					continue;
 				}
-				u8 oldlight = n.getLight(bank, nodemgr);
+				u8 oldlight = n.getLight(bank, m_nodedef);
-				n.setLight(bank, 0, nodemgr);
+				n.setLight(bank, 0, m_nodedef);
 				block->setNode(p, n);
 
 				// If node sources light, add to list
-				u8 source = nodemgr->get(n).light_source;
+				u8 source = m_nodedef->get(n).light_source;
 				if(source != 0)
 					light_sources.insert(p + posnodes);
 
@@ -810,8 +805,6 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 		std::map<v3s16, MapBlock*> &modified_blocks,
 		bool remove_metadata)
 {
-	INodeDefManager *ndef = m_gamedef->ndef();
-
 	// Collect old node for rollback
 	RollbackNode rollback_oldnode(this, p, m_gamedef);
 
@@ -825,14 +818,14 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 
 	// Set the node on the map
 	// Ignore light (because calling voxalgo::update_lighting_nodes)
-	n.setLight(LIGHTBANK_DAY, 0, ndef);
+	n.setLight(LIGHTBANK_DAY, 0, m_nodedef);
-	n.setLight(LIGHTBANK_NIGHT, 0, ndef);
+	n.setLight(LIGHTBANK_NIGHT, 0, m_nodedef);
 	setNode(p, n);
 
 	// Update lighting
 	std::vector<std::pair<v3s16, MapNode> > oldnodes;
 	oldnodes.push_back(std::pair<v3s16, MapNode>(p, oldnode));
-	voxalgo::update_lighting_nodes(this, ndef, oldnodes, modified_blocks);
+	voxalgo::update_lighting_nodes(this, m_nodedef, oldnodes, modified_blocks);
 
 	for(std::map<v3s16, MapBlock*>::iterator
 			i = modified_blocks.begin();
@@ -869,11 +862,10 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n,
 
 		bool is_valid_position;
 		MapNode n2 = getNodeNoEx(p2, &is_valid_position);
-		if(is_valid_position
+		if(is_valid_position &&
-				&& (ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR))
+				(m_nodedef->get(n2).isLiquid() ||
-		{
+				n2.getContent() == CONTENT_AIR))
 			m_transforming_liquid.push_back(p2);
-		}
 	}
 }
 
@@ -1213,9 +1205,6 @@ s32 Map::transforming_liquid_size() {
 
 void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 {
-
-	INodeDefManager *nodemgr = m_gamedef->ndef();
-
 	DSTACK(FUNCTION_NAME);
 	//TimeTaker timer("transformLiquids()");
 
@@ -1275,12 +1264,12 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 		// The node which will be placed there if liquid
 		// can't flow into this node.
 		content_t floodable_node = CONTENT_AIR;
-		const ContentFeatures &cf = nodemgr->get(n0);
+		const ContentFeatures &cf = m_nodedef->get(n0);
 		LiquidType liquid_type = cf.liquid_type;
 		switch (liquid_type) {
 			case LIQUID_SOURCE:
 				liquid_level = LIQUID_LEVEL_SOURCE;
-				liquid_kind = nodemgr->getId(cf.liquid_alternative_flowing);
+				liquid_kind = m_nodedef->getId(cf.liquid_alternative_flowing);
 				break;
 			case LIQUID_FLOWING:
 				liquid_level = (n0.param2 & LIQUID_LEVEL_MASK);
@@ -1322,8 +1311,8 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 			}
 			v3s16 npos = p0 + dirs[i];
 			NodeNeighbor nb(getNodeNoEx(npos), nt, npos);
-			const ContentFeatures &cfnb = nodemgr->get(nb.n);
+			const ContentFeatures &cfnb = m_nodedef->get(nb.n);
-			switch (nodemgr->get(nb.n.getContent()).liquid_type) {
+			switch (m_nodedef->get(nb.n.getContent()).liquid_type) {
 				case LIQUID_NONE:
 					if (cfnb.floodable) {
 						airs[num_airs++] = nb;
@@ -1351,8 +1340,8 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 				case LIQUID_SOURCE:
 					// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
 					if (liquid_kind == CONTENT_AIR)
-						liquid_kind = nodemgr->getId(cfnb.liquid_alternative_flowing);
+						liquid_kind = m_nodedef->getId(cfnb.liquid_alternative_flowing);
-					if (nodemgr->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
+					if (m_nodedef->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
 						neutrals[num_neutrals++] = nb;
 					} else {
 						// Do not count bottom source, it will screw things up
@@ -1363,8 +1352,8 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 				case LIQUID_FLOWING:
 					// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
 					if (liquid_kind == CONTENT_AIR)
-						liquid_kind = nodemgr->getId(cfnb.liquid_alternative_flowing);
+						liquid_kind = m_nodedef->getId(cfnb.liquid_alternative_flowing);
-					if (nodemgr->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
+					if (m_nodedef->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
 						neutrals[num_neutrals++] = nb;
 					} else {
 						flows[num_flows++] = nb;
@@ -1382,15 +1371,15 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 		s8 new_node_level = -1;
 		s8 max_node_level = -1;
 
-		u8 range = nodemgr->get(liquid_kind).liquid_range;
+		u8 range = m_nodedef->get(liquid_kind).liquid_range;
 		if (range > LIQUID_LEVEL_MAX + 1)
 			range = LIQUID_LEVEL_MAX + 1;
 
-		if ((num_sources >= 2 && nodemgr->get(liquid_kind).liquid_renewable) || liquid_type == LIQUID_SOURCE) {
+		if ((num_sources >= 2 && m_nodedef->get(liquid_kind).liquid_renewable) || liquid_type == LIQUID_SOURCE) {
 			// liquid_kind will be set to either the flowing alternative of the node (if it's a liquid)
 			// or the flowing alternative of the first of the surrounding sources (if it's air), so
 			// it's perfectly safe to use liquid_kind here to determine the new node content.
-			new_node_content = nodemgr->getId(nodemgr->get(liquid_kind).liquid_alternative_source);
+			new_node_content = m_nodedef->getId(m_nodedef->get(liquid_kind).liquid_alternative_source);
 		} else if (num_sources >= 1 && sources[0].t != NEIGHBOR_LOWER) {
 			// liquid_kind is set properly, see above
 			max_node_level = new_node_level = LIQUID_LEVEL_MAX;
@@ -1427,7 +1416,7 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 				}
 			}
 
-			u8 viscosity = nodemgr->get(liquid_kind).liquid_viscosity;
+			u8 viscosity = m_nodedef->get(liquid_kind).liquid_viscosity;
 			if (viscosity > 1 && max_node_level != liquid_level) {
 				// amount to gain, limited by viscosity
 				// must be at least 1 in absolute value
@@ -1455,7 +1444,7 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 			check if anything has changed. if not, just continue with the next node.
 		 */
 		if (new_node_content == n0.getContent() &&
-				(nodemgr->get(n0.getContent()).liquid_type != LIQUID_FLOWING ||
+				(m_nodedef->get(n0.getContent()).liquid_type != LIQUID_FLOWING ||
 				((n0.param2 & LIQUID_LEVEL_MASK) == (u8)new_node_level &&
 				((n0.param2 & LIQUID_FLOW_DOWN_MASK) == LIQUID_FLOW_DOWN_MASK)
 				== flowing_down)))
@@ -1467,7 +1456,7 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 		 */
 		MapNode n00 = n0;
 		//bool flow_down_enabled = (flowing_down && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK));
-		if (nodemgr->get(new_node_content).liquid_type == LIQUID_FLOWING) {
+		if (m_nodedef->get(new_node_content).liquid_type == LIQUID_FLOWING) {
 			// set level to last 3 bits, flowing down bit to 4th bit
 			n0.param2 = (flowing_down ? LIQUID_FLOW_DOWN_MASK : 0x00) | (new_node_level & LIQUID_LEVEL_MASK);
 		} else {
@@ -1477,8 +1466,8 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 		n0.setContent(new_node_content);
 
 		// Ignore light (because calling voxalgo::update_lighting_nodes)
-		n0.setLight(LIGHTBANK_DAY, 0, nodemgr);
+		n0.setLight(LIGHTBANK_DAY, 0, m_nodedef);
-		n0.setLight(LIGHTBANK_NIGHT, 0, nodemgr);
+		n0.setLight(LIGHTBANK_NIGHT, 0, m_nodedef);
 
 		// Find out whether there is a suspect for this action
 		std::string suspect;
@@ -1512,7 +1501,7 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 		/*
 			enqueue neighbors for update if neccessary
 		 */
-		switch (nodemgr->get(n0.getContent()).liquid_type) {
+		switch (m_nodedef->get(n0.getContent()).liquid_type) {
 			case LIQUID_SOURCE:
 			case LIQUID_FLOWING:
 				// make sure source flows into all neighboring nodes
@@ -1535,7 +1524,7 @@ void Map::transformLiquids(std::map<v3s16, MapBlock*> &modified_blocks)
 	for (std::deque<v3s16>::iterator iter = must_reflow.begin(); iter != must_reflow.end(); ++iter)
 		m_transforming_liquid.push_back(*iter);
 
-	voxalgo::update_lighting_nodes(this, nodemgr, changed_nodes, modified_blocks);
+	voxalgo::update_lighting_nodes(this, m_nodedef, changed_nodes, modified_blocks);
 
 
 	/* ----------------------------------------------------------------------
@@ -1900,7 +1889,7 @@ bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data)
 	data->blockpos_min = bpmin;
 	data->blockpos_max = bpmax;
 	data->blockpos_requested = blockpos;
-	data->nodedef = m_gamedef->ndef();
+	data->nodedef = m_nodedef;
 
 	/*
 		Create the whole area of this and the neighboring blocks

src/map.h

@@ -193,6 +193,8 @@ public:
 	virtual MapBlock * emergeBlock(v3s16 p, bool create_blank=true)
 	{ return getBlockNoCreateNoEx(p); }
 
+	inline INodeDefManager * getNodeDefManager() { return m_nodedef; }
+
 	// Returns InvalidPositionException if not found
 	bool isNodeUnderground(v3s16 p);
 
@@ -346,6 +348,9 @@ protected:
 	// Queued transforming water nodes
 	UniqueQueue<v3s16> m_transforming_liquid;
 
+	// This stores the properties of the nodes on the map.
+	INodeDefManager *m_nodedef;
+
 private:
 	f32 m_transforming_liquid_loop_count_multiplier;
 	u32 m_unprocessed_count;

src/mapnode.cpp

@@ -21,6 +21,7 @@ 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"
@@ -453,6 +454,51 @@ void transformNodeBox(const MapNode &n, const NodeBox &nodebox,
 	}
 }
 
+static inline void getNeighborConnectingFace(
+	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<aabb3f> *boxes, u8 neighbors)
 {
 	const ContentFeatures &f = nodemgr->get(*this);

src/mapnode.h

@@ -28,6 +28,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <vector>
 
 class INodeDefManager;
+class Map;
 
 /*
 	Naming scheme:
@@ -246,6 +247,13 @@ struct MapNode
 
 	void rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot);
 
+	/*!
+	 * Checks which neighbors does this node connect to.
+	 *
+	 * \param p coordinates of the node
+	 */
+	u8 getNeighbors(v3s16 p, Map *map);
+
 	/*
 		Gets list of node boxes (used for rendering (NDT_NODEBOX))
 	*/

src/nodedef.cpp

@@ -790,9 +790,18 @@ public:
 	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;
@@ -819,6 +828,14 @@ private:
 
 	// 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;
 };
 
 
@@ -849,6 +866,8 @@ void CNodeDefManager::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();
 
@@ -1007,6 +1026,123 @@ content_t CNodeDefManager::allocateId()
 }
 
 
+/*!
+ * 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 (std::vector<aabb3f>::const_iterator it = boxes.begin();
+			it != boxes.end(); ++it) {
+		box_union->addInternalBox(*it);
+	}
+}
+
+
+/*!
+ * 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) {
+				// 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 (int i = 0; i < 6; i++) {
+					if (max < coords[i]) {
+						max = coords[i];
+					}
+				}
+				// 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);
+			}
+			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 (int i = 0; i < 4; i++) {
+				if (max < coords[i]) {
+					max = coords[i];
+				}
+			}
+			// 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);
+			break;
+		}
+		default: {
+			// NODEBOX_REGULAR
+			box_union->addInternalPoint(-BS / 2, -BS / 2, -BS / 2);
+			box_union->addInternalPoint(+BS / 2, +BS / 2, +BS / 2);
+		}
+	}
+}
+
+
+inline void CNodeDefManager::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);
+}
+
+
 // IWritableNodeDefManager
 content_t CNodeDefManager::set(const std::string &name, const ContentFeatures &def)
 {
@@ -1037,6 +1173,8 @@ content_t CNodeDefManager::set(const std::string &name, const ContentFeatures &d
 	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
@@ -1266,6 +1404,9 @@ void CNodeDefManager::deSerialize(std::istream &is)
 		m_content_features[i] = f;
 		addNameIdMapping(i, f.name);
 		verbosestream << "deserialized " << f.name << std::endl;
+
+		getNodeBoxUnion(f.selection_box, f, &m_selection_box_union);
+		fixSelectionBoxIntUnion();
 	}
 }
 

src/nodedef.h

@@ -349,6 +349,11 @@ public:
 	virtual void pendNodeResolve(NodeResolver *nr)=0;
 	virtual bool cancelNodeResolveCallback(NodeResolver *nr)=0;
 	virtual bool nodeboxConnects(const MapNode from, const MapNode to, u8 connect_face)=0;
+	/*!
+	 * Returns the smallest box in node coordinates that
+	 * contains all nodes' selection boxes.
+	 */
+	virtual core::aabbox3d<s16> getSelectionBoxIntUnion() const=0;
 };
 
 class IWritableNodeDefManager : public INodeDefManager {
@@ -406,6 +411,7 @@ public:
 	virtual void runNodeResolveCallbacks()=0;
 	virtual void resetNodeResolveState()=0;
 	virtual void mapNodeboxConnections()=0;
+	virtual core::aabbox3d<s16> getSelectionBoxIntUnion() const=0;
 };
 
 IWritableNodeDefManager *createNodeDefManager();

src/raycast.cpp

@@ -0,0 +1,89 @@
+/*
+Minetest
+Copyright (C) 2016 juhdanad, Daniel Juhasz <juhdanad@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
+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 Lesser General Public License for more details.
+
+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 "irr_v3d.h"
+#include "irr_aabb3d.h"
+
+bool boxLineCollision(const aabb3f &box, const v3f &start,
+		const v3f &dir, v3f *collision_point, v3s16 *collision_normal) {
+	if (box.isPointInside(start)) {
+		*collision_point = start;
+		collision_normal->set(0, 0, 0);
+		return true;
+	}
+	float m = 0;
+
+	// Test X collision
+	if (dir.X != 0) {
+		if (dir.X > 0)
+			m = (box.MinEdge.X - start.X) / dir.X;
+		else
+			m = (box.MaxEdge.X - start.X) / dir.X;
+
+		if (m >= 0 && m <= 1) {
+			*collision_point = start + dir * m;
+			if ((collision_point->Y >= box.MinEdge.Y)
+					&& (collision_point->Y <= box.MaxEdge.Y)
+					&& (collision_point->Z >= box.MinEdge.Z)
+					&& (collision_point->Z <= box.MaxEdge.Z)) {
+				collision_normal->set((dir.X > 0) ? -1 : 1, 0, 0);
+				return true;
+			}
+		}
+	}
+
+	// Test Y collision
+	if (dir.Y != 0) {
+		if (dir.Y > 0)
+			m = (box.MinEdge.Y - start.Y) / dir.Y;
+		else
+			m = (box.MaxEdge.Y - start.Y) / dir.Y;
+
+		if (m >= 0 && m <= 1) {
+			*collision_point = start + dir * m;
+			if ((collision_point->X >= box.MinEdge.X)
+					&& (collision_point->X <= box.MaxEdge.X)
+					&& (collision_point->Z >= box.MinEdge.Z)
+					&& (collision_point->Z <= box.MaxEdge.Z)) {
+				collision_normal->set(0, (dir.Y > 0) ? -1 : 1, 0);
+				return true;
+			}
+		}
+	}
+
+	// Test Z collision
+	if (dir.Z != 0) {
+		if (dir.Z > 0)
+			m = (box.MinEdge.Z - start.Z) / dir.Z;
+		else
+			m = (box.MaxEdge.Z - start.Z) / dir.Z;
+
+		if (m >= 0 && m <= 1) {
+			*collision_point = start + dir * m;
+			if ((collision_point->X >= box.MinEdge.X)
+					&& (collision_point->X <= box.MaxEdge.X)
+					&& (collision_point->Y >= box.MinEdge.Y)
+					&& (collision_point->Y <= box.MaxEdge.Y)) {
+				collision_normal->set(0, 0, (dir.Z > 0) ? -1 : 1);
+				return true;
+			}
+		}
+	}
+	return false;
+}

src/raycast.h

@@ -0,0 +1,38 @@
+/*
+Minetest
+Copyright (C) 2016 juhdanad, Daniel Juhasz <juhdanad@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
+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 Lesser General Public License for more details.
+
+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.
+*/
+
+#ifndef SRC_RAYCAST_H_
+#define SRC_RAYCAST_H_
+
+
+/*!
+ * Checks if a line and a box intersects.
+ * @param[in]  box              box to test collision
+ * @param[in]  start            starting point of the line
+ * @param[in]  dir              direction and length of the line
+ * @param[out] collision_point  first point of the collision
+ * @param[out] collision_normal normal vector at the collision, points
+ * outwards of the surface. If start is in the box, zero vector.
+ * @returns true if a collision point was found
+ */
+bool boxLineCollision(const aabb3f &box, const v3f &start, const v3f &dir,
+	v3f *collision_point, v3s16 *collision_normal);
+
+
+#endif /* SRC_RAYCAST_H_ */

src/unittest/test_voxelalgorithms.cpp

@@ -21,6 +21,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "gamedef.h"
 #include "voxelalgorithms.h"
+#include "util/numeric.h"
 
 class TestVoxelAlgorithms : public TestBase {
 public:
@@ -31,6 +32,7 @@ public:
 
 	void testPropogateSunlight(INodeDefManager *ndef);
 	void testClearLightAndCollectSources(INodeDefManager *ndef);
+	void testVoxelLineIterator(INodeDefManager *ndef);
 };
 
 static TestVoxelAlgorithms g_test_instance;
@@ -41,6 +43,7 @@ void TestVoxelAlgorithms::runTests(IGameDef *gamedef)
 
 	TEST(testPropogateSunlight, ndef);
 	TEST(testClearLightAndCollectSources, ndef);
+	TEST(testVoxelLineIterator, ndef);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -202,3 +205,59 @@ void TestVoxelAlgorithms::testClearLightAndCollectSources(INodeDefManager *ndef)
 		UASSERT(unlight_from.size() == 1);
 	}
 }
+
+void TestVoxelAlgorithms::testVoxelLineIterator(INodeDefManager *ndef)
+{
+	// Test some lines
+	// Do not test lines that start or end on the border of
+	// two voxels as rounding errors can make the test fail!
+	std::vector<core::line3d<f32> > lines;
+	for (f32 x = -9.1; x < 9; x += 3.124) {
+	for (f32 y = -9.2; y < 9; y += 3.123) {
+	for (f32 z = -9.3; z < 9; z += 3.122) {
+		lines.push_back(core::line3d<f32>(-x, -y, -z, x, y, z));
+	}
+	}
+	}
+	lines.push_back(core::line3d<f32>(0, 0, 0, 0, 0, 0));
+	// Test every line
+	std::vector<core::line3d<f32> >::iterator it = lines.begin();
+	for (; it < lines.end(); it++) {
+		core::line3d<f32> l = *it;
+
+		// Initialize test
+		voxalgo::VoxelLineIterator iterator(l.start, l.getVector());
+
+		//Test the first voxel
+		v3s16 start_voxel = floatToInt(l.start, 1);
+		UASSERT(iterator.m_current_node_pos == start_voxel);
+
+		// Values for testing
+		v3s16 end_voxel = floatToInt(l.end, 1);
+		v3s16 voxel_vector = end_voxel - start_voxel;
+		int nodecount = abs(voxel_vector.X) + abs(voxel_vector.Y)
+			+ abs(voxel_vector.Z);
+		int actual_nodecount = 0;
+		v3s16 old_voxel = iterator.m_current_node_pos;
+
+		while (iterator.hasNext()) {
+			iterator.next();
+			actual_nodecount++;
+			v3s16 new_voxel = iterator.m_current_node_pos;
+			// This must be a neighbor of the old voxel
+			UASSERTEQ(f32, (new_voxel - old_voxel).getLengthSQ(), 1);
+			// The line must intersect with the voxel
+			v3f voxel_center = intToFloat(iterator.m_current_node_pos, 1);
+			aabb3f box(voxel_center - v3f(0.5, 0.5, 0.5),
+				voxel_center + v3f(0.5, 0.5, 0.5));
+			UASSERT(box.intersectsWithLine(l));
+			// Update old voxel
+			old_voxel = new_voxel;
+		}
+
+		// Test last node
+		UASSERT(iterator.m_current_node_pos == end_voxel);
+		// Test node count
+		UASSERTEQ(int, actual_nodecount, nodecount);
+	}
+}

src/util/pointedthing.cpp

@@ -27,29 +27,25 @@ PointedThing::PointedThing():
 	type(POINTEDTHING_NOTHING),
 	node_undersurface(0,0,0),
 	node_abovesurface(0,0,0),
+	node_real_undersurface(0,0,0),
+	intersection_point(0,0,0),
+	intersection_normal(0,0,0),
 	object_id(-1)
 {}
 
 std::string PointedThing::dump() const
 {
 	std::ostringstream os(std::ios::binary);
-	if(type == POINTEDTHING_NOTHING)
+	if (type == POINTEDTHING_NOTHING) {
-	{
 		os<<"[nothing]";
-	}
+	} else if (type == POINTEDTHING_NODE) {
-	else if(type == POINTEDTHING_NODE)
-	{
 		const v3s16 &u = node_undersurface;
 		const v3s16 &a = node_abovesurface;
 		os<<"[node under="<<u.X<<","<<u.Y<<","<<u.Z
 			<< " above="<<a.X<<","<<a.Y<<","<<a.Z<<"]";
-	}
+	} else if (type == POINTEDTHING_OBJECT) {
-	else if(type == POINTEDTHING_OBJECT)
-	{
 		os<<"[object "<<object_id<<"]";
-	}
+	} else {
-	else
-	{
 		os<<"[unknown PointedThing]";
 	}
 	return os.str();
@@ -59,61 +55,56 @@ void PointedThing::serialize(std::ostream &os) const
 {
 	writeU8(os, 0); // version
 	writeU8(os, (u8)type);
-	if(type == POINTEDTHING_NOTHING)
+	switch (type) {
-	{
+	case POINTEDTHING_NOTHING:
-		// nothing
+		break;
-	}
+	case POINTEDTHING_NODE:
-	else if(type == POINTEDTHING_NODE)
-	{
 		writeV3S16(os, node_undersurface);
 		writeV3S16(os, node_abovesurface);
-	}
+		break;
-	else if(type == POINTEDTHING_OBJECT)
+	case POINTEDTHING_OBJECT:
-	{
 		writeS16(os, object_id);
+		break;
 	}
 }
 
 void PointedThing::deSerialize(std::istream &is)
 {
 	int version = readU8(is);
-	if(version != 0) throw SerializationError(
+	if (version != 0) throw SerializationError(
 			"unsupported PointedThing version");
 	type = (PointedThingType) readU8(is);
-	if(type == POINTEDTHING_NOTHING)
+	switch (type) {
-	{
+	case POINTEDTHING_NOTHING:
-		// nothing
+		break;
-	}
+	case POINTEDTHING_NODE:
-	else if(type == POINTEDTHING_NODE)
-	{
 		node_undersurface = readV3S16(is);
 		node_abovesurface = readV3S16(is);
-	}
+		break;
-	else if(type == POINTEDTHING_OBJECT)
+	case POINTEDTHING_OBJECT:
-	{
 		object_id = readS16(is);
-	}
+		break;
-	else
+	default:
-	{
+		throw SerializationError("unsupported PointedThingType");
-		throw SerializationError(
-			"unsupported PointedThingType");
 	}
 }
 
 bool PointedThing::operator==(const PointedThing &pt2) const
 {
-	if(type != pt2.type)
+	if (type != pt2.type)
-		return false;
-	if(type == POINTEDTHING_NODE)
 	{
-		if(node_undersurface != pt2.node_undersurface)
+		return false;
-			return false;
+	}
-		if(node_abovesurface != pt2.node_abovesurface)
+	if (type == POINTEDTHING_NODE)
+	{
+		if ((node_undersurface != pt2.node_undersurface)
+				|| (node_abovesurface != pt2.node_abovesurface)
+				|| (node_real_undersurface != pt2.node_real_undersurface))
 			return false;
 	}
-	else if(type == POINTEDTHING_OBJECT)
+	else if (type == POINTEDTHING_OBJECT)
 	{
-		if(object_id != pt2.object_id)
+		if (object_id != pt2.object_id)
 			return false;
 	}
 	return true;

src/util/pointedthing.h

@@ -32,17 +32,57 @@ enum PointedThingType
 	POINTEDTHING_OBJECT
 };
 
+//! An active object or node which is selected by a ray on the map.
 struct PointedThing
 {
+	//! The type of the pointed object.
 	PointedThingType type;
+	/*!
+	 * Only valid if type is POINTEDTHING_NODE.
+	 * The coordinates of the node which owns the
+	 * nodebox that the ray hits first.
+	 * This may differ from node_real_undersurface if
+	 * a nodebox exceeds the limits of its node.
+	 */
 	v3s16 node_undersurface;
+	/*!
+	 * Only valid if type is POINTEDTHING_NODE.
+	 * The coordinates of the last node the ray intersects
+	 * before node_undersurface. Same as node_undersurface
+	 * if the ray starts in a nodebox.
+	 */
 	v3s16 node_abovesurface;
+	/*!
+	 * Only valid if type is POINTEDTHING_NODE.
+	 * The coordinates of the node which contains the
+	 * point of the collision and the nodebox of the node.
+	 */
+	v3s16 node_real_undersurface;
+	/*!
+	 * Only valid if type isn't POINTEDTHING_NONE.
+	 * First intersection point of the ray and the nodebox.
+	 */
+	v3f intersection_point;
+	/*!
+	 * Only valid if type isn't POINTEDTHING_NONE.
+	 * Normal vector of the intersection.
+	 * This is perpendicular to the face the ray hits,
+	 * points outside of the box and it's length is 1.
+	 */
+	v3s16 intersection_normal;
+	/*!
+	 * Only valid if type is POINTEDTHING_OBJECT.
+	 * The ID of the object the ray hit.
+	 */
 	s16 object_id;
 
 	PointedThing();
 	std::string dump() const;
 	void serialize(std::ostream &os) const;
 	void deSerialize(std::istream &is);
+	/*!
+	 * This function ignores the intersection point and normal.
+	 */
 	bool operator==(const PointedThing &pt2) const;
 	bool operator!=(const PointedThing &pt2) const;
 };

src/voxelalgorithms.cpp

@@ -747,5 +747,73 @@ void update_lighting_nodes(Map *map, INodeDefManager *ndef,
 	}
 }
 
+VoxelLineIterator::VoxelLineIterator(
+	const v3f &start_position,
+	const v3f &line_vector) :
+	m_start_position(start_position),
+	m_line_vector(line_vector),
+	m_next_intersection_multi(10000.0f, 10000.0f, 10000.0f),
+	m_intersection_multi_inc(10000.0f, 10000.0f, 10000.0f),
+	m_step_directions(1.0f, 1.0f, 1.0f)
+{
+	m_current_node_pos = floatToInt(m_start_position, 1);
+
+	if (m_line_vector.X > 0) {
+		m_next_intersection_multi.X = (floorf(m_start_position.X - 0.5) + 1.5
+			- m_start_position.X) / m_line_vector.X;
+		m_intersection_multi_inc.X = 1 / m_line_vector.X;
+	} else if (m_line_vector.X < 0) {
+		m_next_intersection_multi.X = (floorf(m_start_position.X - 0.5)
+			- m_start_position.X + 0.5) / m_line_vector.X;
+		m_intersection_multi_inc.X = -1 / m_line_vector.X;
+		m_step_directions.X = -1;
+	}
+
+	if (m_line_vector.Y > 0) {
+		m_next_intersection_multi.Y = (floorf(m_start_position.Y - 0.5) + 1.5
+			- m_start_position.Y) / m_line_vector.Y;
+		m_intersection_multi_inc.Y = 1 / m_line_vector.Y;
+	} else if (m_line_vector.Y < 0) {
+		m_next_intersection_multi.Y = (floorf(m_start_position.Y - 0.5)
+			- m_start_position.Y + 0.5) / m_line_vector.Y;
+		m_intersection_multi_inc.Y = -1 / m_line_vector.Y;
+		m_step_directions.Y = -1;
+	}
+
+	if (m_line_vector.Z > 0) {
+		m_next_intersection_multi.Z = (floorf(m_start_position.Z - 0.5) + 1.5
+			- m_start_position.Z) / m_line_vector.Z;
+		m_intersection_multi_inc.Z = 1 / m_line_vector.Z;
+	} else if (m_line_vector.Z < 0) {
+		m_next_intersection_multi.Z = (floorf(m_start_position.Z - 0.5)
+			- m_start_position.Z + 0.5) / m_line_vector.Z;
+		m_intersection_multi_inc.Z = -1 / m_line_vector.Z;
+		m_step_directions.Z = -1;
+	}
+
+	m_has_next = (m_next_intersection_multi.X <= 1)
+		|| (m_next_intersection_multi.Y <= 1)
+		|| (m_next_intersection_multi.Z <= 1);
+}
+
+void VoxelLineIterator::next()
+{
+	if ((m_next_intersection_multi.X < m_next_intersection_multi.Y)
+			&& (m_next_intersection_multi.X < m_next_intersection_multi.Z)) {
+		m_next_intersection_multi.X += m_intersection_multi_inc.X;
+		m_current_node_pos.X += m_step_directions.X;
+	} else if ((m_next_intersection_multi.Y < m_next_intersection_multi.Z)) {
+		m_next_intersection_multi.Y += m_intersection_multi_inc.Y;
+		m_current_node_pos.Y += m_step_directions.Y;
+	} else {
+		m_next_intersection_multi.Z += m_intersection_multi_inc.Z;
+		m_current_node_pos.Z += m_step_directions.Z;
+	}
+
+	m_has_next = (m_next_intersection_multi.X <= 1)
+			|| (m_next_intersection_multi.Y <= 1)
+			|| (m_next_intersection_multi.Z <= 1);
+}
+
 } // namespace voxalgo
 

src/voxelalgorithms.h

@@ -73,7 +73,68 @@ void update_lighting_nodes(
 	std::vector<std::pair<v3s16, MapNode> > &oldnodes,
 	std::map<v3s16, MapBlock*> &modified_blocks);
 
+/*!
+ * This class iterates trough voxels that intersect with
+ * a line. The collision detection does not see nodeboxes,
+ * every voxel is a cube and is returned.
+ * This iterator steps to all nodes exactly once.
+ */
+struct VoxelLineIterator
+{
+public:
+	//! Starting position of the line in world coordinates.
+	v3f m_start_position;
+	//! Direction and length of the line in world coordinates.
+	v3f m_line_vector;
+	/*!
+	 * Each component stores the next smallest positive number, by
+	 * which multiplying the line's vector gives a vector that ends
+	 * on the intersection of two nodes.
+	 */
+	v3f m_next_intersection_multi;
+	/*!
+	 * Each component stores the smallest positive number, by which
+	 * m_next_intersection_multi's components can be increased.
+	 */
+	v3f m_intersection_multi_inc;
+	/*!
+	 * Direction of the line. Each component can be -1 or 1 (if a
+	 * component of the line's vector is 0, then there will be 1).
+	 */
+	v3s16 m_step_directions;
+	//! Position of the current node.
+	v3s16 m_current_node_pos;
+	//! If true, the next node will intersect the line, too.
+	bool m_has_next;
+
+	/*!
+	 * Creates a voxel line iterator with the given line.
+	 * @param start_position starting point of the line
+	 * in voxel coordinates
+	 * @param line_vector    length and direction of the
+	 * line in voxel coordinates. start_position+line_vector
+	 * is the end of the line
+	 */
+	VoxelLineIterator(const v3f &start_position,const v3f &line_vector);
+
+	/*!
+	 * Steps to the next voxel.
+	 * Updates m_current_node_pos and
+	 * m_previous_node_pos.
+	 * Note that it works even if hasNext() is false,
+	 * continuing the line as a ray.
+	 */
+	void next();
+
+	/*!
+	 * Returns true if the next voxel intersects the given line.
+	 */
+	inline bool hasNext() const { return m_has_next; }
+};
+
 } // namespace voxalgo
 
+
+
 #endif