Various random code cleanups

src/client/client.cpp

@@ -1044,8 +1044,8 @@ void Client::Send(NetworkPacket* pkt)
 // Will fill up 12 + 12 + 4 + 4 + 4 + 1 + 1 + 1 + 4 + 4 bytes
 void writePlayerPos(LocalPlayer *myplayer, ClientMap *clientMap, NetworkPacket *pkt, bool camera_inverted)
 {
-	v3f pf           = myplayer->getPosition() * 100;
-	v3f sf           = myplayer->getSpeed() * 100;
+	v3s32 position   = v3s32::from(myplayer->getPosition() * 100);
+	v3s32 speed      = v3s32::from(myplayer->getSpeed() * 100);
 	s32 pitch        = myplayer->getPitch() * 100;
 	s32 yaw          = myplayer->getYaw() * 100;
 	u32 keyPressed   = myplayer->control.getKeysPressed();
@@ -1056,9 +1056,6 @@ void writePlayerPos(LocalPlayer *myplayer, ClientMap *clientMap, NetworkPacket *
 	f32 movement_speed = myplayer->control.movement_speed;
 	f32 movement_dir = myplayer->control.movement_direction;
 
-	v3s32 position(pf.X, pf.Y, pf.Z);
-	v3s32 speed(sf.X, sf.Y, sf.Z);
-
 	/*
 		Format:
 		[0] v3s32 position*100
@@ -1755,12 +1752,7 @@ void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server, bool
 
 void Client::addUpdateMeshTaskForNode(v3s16 nodepos, bool ack_to_server, bool urgent)
 {
-	{
-		v3s16 p = nodepos;
-		infostream<<"Client::addUpdateMeshTaskForNode(): "
-				<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
-				<<std::endl;
-	}
+	infostream << "Client::addUpdateMeshTaskForNode(): " << nodepos << std::endl;
 
 	v3s16 blockpos = getNodeBlockPos(nodepos);
 	v3s16 blockpos_relative = blockpos * MAP_BLOCKSIZE;

src/client/content_mapblock.cpp

@@ -121,7 +121,7 @@ void MapblockMeshGenerator::drawQuad(const TileSpec &tile, v3f *coords, const v3
 		v2f(1.0, vertical_tiling), v2f(0.0, vertical_tiling)};
 	video::S3DVertex vertices[4];
 	bool shade_face = !cur_node.f->light_source && (normal != v3s16(0, 0, 0));
-	v3f normal2(normal.X, normal.Y, normal.Z);
+	v3f normal2 = v3f::from(normal);
 	for (int j = 0; j < 4; j++) {
 		vertices[j].Pos = coords[j] + cur_node.origin;
 		vertices[j].Normal = normal2;

src/client/event_manager.h

@@ -33,7 +33,7 @@ public:
 
 	void put(MtEvent *e) override
 	{
-		std::map<MtEvent::Type, Dest>::iterator i = m_dest.find(e->getType());
+		auto i = m_dest.find(e->getType());
 		if (i != m_dest.end()) {
 			std::list<FuncSpec> &funcs = i->second.funcs;
 			for (FuncSpec &func : funcs) {
@@ -44,7 +44,7 @@ public:
 	}
 	void reg(MtEvent::Type type, event_receive_func f, void *data) override
 	{
-		std::map<MtEvent::Type, Dest>::iterator i = m_dest.find(type);
+		auto i = m_dest.find(type);
 		if (i != m_dest.end()) {
 			i->second.funcs.emplace_back(f, data);
 		} else {

src/client/game.cpp

@@ -3245,10 +3245,8 @@ PointedThing Game::updatePointedThing(
 		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;
+		f32 d = 0.002f * BS;
+		for (aabb3f box : boxes) {
 			box.MinEdge -= v3f(d, d, d);
 			box.MaxEdge += v3f(d, d, d);
 			selectionboxes->push_back(box);
@@ -3450,9 +3448,8 @@ bool Game::nodePlacement(const ItemDefinition &selected_def,
 			u8 predicted_param2 = dir.Y < 0 ? 1 : 0;
 			if (selected_def.wallmounted_rotate_vertical) {
 				bool rotate90 = false;
-				v3f fnodepos = v3f(neighborpos.X, neighborpos.Y, neighborpos.Z);
 				v3f ppos = client->getEnv().getLocalPlayer()->getPosition() / BS;
-				v3f pdir = fnodepos - ppos;
+				v3f pdir = v3f::from(neighborpos) - ppos;
 				switch (predicted_f.drawtype) {
 					case NDT_TORCHLIKE: {
 						rotate90 = !((pdir.X < 0 && pdir.Z > 0) ||

src/client/hud.cpp

@@ -965,8 +965,8 @@ void Hud::drawBlockBounds()
 		v3f pmax = v3f(x, y, 1 + radius) * MAP_BLOCKSIZE * BS;
 
 		driver->draw3DLine(
-			base_corner + v3f(pmin.X, pmin.Y, pmin.Z),
-			base_corner + v3f(pmax.X, pmax.Y, pmax.Z),
+			base_corner + pmin,
+			base_corner + pmax,
 			choose_color(block_pos.X, block_pos.Y)
 		);
 		driver->draw3DLine(

src/client/imagefilters.cpp

@@ -285,13 +285,13 @@ void imageScaleNNAA(video::IImage *src, const core::rect<s32> &srcrect, video::I
 		maxsx = minsx + sw / dim.Width;
 		maxsx = rangelim(maxsx, 0, sox + sw);
 		if (minsx > maxsx)
-			SWAP(double, minsx, maxsx);
+			std::swap(minsx, maxsx);
 		minsy = soy + (dy * sh / dim.Height);
 		minsy = rangelim(minsy, 0, soy + sh);
 		maxsy = minsy + sh / dim.Height;
 		maxsy = rangelim(maxsy, 0, soy + sh);
 		if (minsy > maxsy)
-			SWAP(double, minsy, maxsy);
+			std::swap(minsy, maxsy);
 
 		// Total area, and integral of r, g, b values over that area,
 		// initialized to zero, to be summed up in next loops.

src/client/mesh_generator_thread.cpp

@@ -145,8 +145,7 @@ QueuedMeshUpdate *MeshUpdateQueue::pop()
 		MutexAutoLock lock(m_mutex);
 
 		bool must_be_urgent = !m_urgents.empty();
-		for (std::vector<QueuedMeshUpdate*>::iterator i = m_queue.begin();
-				i != m_queue.end(); ++i) {
+		for (auto i = m_queue.begin(); i != m_queue.end(); ++i) {
 			QueuedMeshUpdate *q = *i;
 			if (must_be_urgent && m_urgents.count(q->p) == 0)
 				continue;
@@ -264,8 +263,8 @@ void MeshUpdateManager::updateBlock(Map *map, v3s16 p, bool ack_block_to_server,
 			g_settings->getBool("smooth_lighting")
 			&& !g_settings->getFlag("performance_tradeoffs");
 	if (!m_queue_in.addBlock(map, p, ack_block_to_server, urgent)) {
-		warningstream << "Update requested for non-existent block at ("
-				<< p.X << ", " << p.Y << ", " << p.Z << ")" << std::endl;
+		warningstream << "Update requested for non-existent block at "
+				<< p << std::endl;
 		return;
 	}
 	if (update_neighbors) {

src/client/minimap.cpp

@@ -78,15 +78,13 @@ void MinimapUpdateThread::doUpdate()
 	while (popBlockUpdate(&update)) {
 		if (update.data) {
 			// Swap two values in the map using single lookup
-			std::pair<std::map<v3s16, MinimapMapblock*>::iterator, bool>
-			    result = m_blocks_cache.insert(std::make_pair(update.pos, update.data));
+			auto result = m_blocks_cache.insert(std::make_pair(update.pos, update.data));
 			if (!result.second) {
 				delete result.first->second;
 				result.first->second = update.data;
 			}
 		} else {
-			std::map<v3s16, MinimapMapblock *>::iterator it;
-			it = m_blocks_cache.find(update.pos);
+			auto it = m_blocks_cache.find(update.pos);
 			if (it != m_blocks_cache.end()) {
 				delete it->second;
 				m_blocks_cache.erase(it);
@@ -124,8 +122,7 @@ void MinimapUpdateThread::getMap(v3s16 pos, s16 size, s16 height)
 	for (blockpos.Z = blockpos_min.Z; blockpos.Z <= blockpos_max.Z; ++blockpos.Z)
 	for (blockpos.Y = blockpos_min.Y; blockpos.Y <= blockpos_max.Y; ++blockpos.Y)
 	for (blockpos.X = blockpos_min.X; blockpos.X <= blockpos_max.X; ++blockpos.X) {
-		std::map<v3s16, MinimapMapblock *>::const_iterator pblock =
-			m_blocks_cache.find(blockpos);
+		auto pblock = m_blocks_cache.find(blockpos);
 		if (pblock == m_blocks_cache.end())
 			continue;
 		const MinimapMapblock &block = *pblock->second;
@@ -647,8 +644,7 @@ void Minimap::drawMinimap(core::rect<s32> rect)
 	f32 sin_angle = std::sin(m_angle * core::DEGTORAD);
 	f32 cos_angle = std::cos(m_angle * core::DEGTORAD);
 	s32 marker_size2 =  0.025 * (float)rect.getWidth();;
-	for (std::list<v2f>::const_iterator
-			i = m_active_markers.begin();
+	for (auto i = m_active_markers.begin();
 			i != m_active_markers.end(); ++i) {
 		v2f posf = *i;
 		if (data->minimap_shape_round) {

src/client/particles.cpp

@@ -193,7 +193,7 @@ void Particle::updateVertices(ClientEnvironment *env, video::SColor color)
 	video::S3DVertex *vertices = m_buffer->getVertices(m_index);
 
 	if (m_texture.tex != nullptr)
-		scale = m_texture.tex -> scale.blend(m_time / (m_expiration+0.1));
+		scale = m_texture.tex -> scale.blend(m_time / (m_expiration+0.1f));
 	else
 		scale = v2f(1.f, 1.f);
 
@@ -203,7 +203,7 @@ void Particle::updateVertices(ClientEnvironment *env, video::SColor color)
 		v2u32 framesize;
 		texcoord = m_p.animation.getTextureCoords(texsize, m_animation_frame);
 		m_p.animation.determineParams(texsize, NULL, NULL, &framesize);
-		framesize_f = v2f(framesize.X / (float) texsize.X, framesize.Y / (float) texsize.Y);
+		framesize_f = v2f::from(framesize) / v2f::from(texsize);
 
 		tx0 = m_texpos.X + texcoord.X;
 		tx1 = m_texpos.X + texcoord.X + framesize_f.X * m_texsize.X;

src/client/shadows/dynamicshadowsrender.cpp

@@ -177,14 +177,15 @@ void ShadowRenderer::removeNodeFromShadowList(scene::ISceneNode *node)
 	node->forEachMaterial([] (auto &mat) {
 		mat.setTexture(TEXTURE_LAYER_SHADOW, nullptr);
 	});
-	for (auto it = m_shadow_node_array.begin(); it != m_shadow_node_array.end();) {
-		if (it->node == node) {
-			it = m_shadow_node_array.erase(it);
-			break;
-		} else {
-			++it;
-		}
+
+	auto it = std::find(m_shadow_node_array.begin(), m_shadow_node_array.end(), node);
+	if (it == m_shadow_node_array.end()) {
+		infostream << "removeNodeFromShadowList: " << node << " not found" << std::endl;
+		return;
 	}
+	// swap with last, then remove
+	*it = m_shadow_node_array.back();
+	m_shadow_node_array.pop_back();
 }
 
 void ShadowRenderer::updateSMTextures()

src/client/shadows/dynamicshadowsrender.h

@@ -28,7 +28,8 @@ struct NodeToApply
 			E_SHADOW_MODE m = E_SHADOW_MODE::ESM_BOTH) :
 			node(n),
 			shadowMode(m){};
-	bool operator<(const NodeToApply &other) const { return node < other.node; };
+
+	bool operator==(scene::ISceneNode *n) const { return node == n; }
 
 	scene::ISceneNode *node;
 

src/client/wieldmesh.cpp

@@ -154,8 +154,7 @@ public:
 
 		int maxdim = MYMAX(dim.Width, dim.Height);
 
-		std::map<int, scene::IMesh*>::iterator
-			it = m_extrusion_meshes.lower_bound(maxdim);
+		auto it = m_extrusion_meshes.lower_bound(maxdim);
 
 		if (it == m_extrusion_meshes.end()) {
 			// no viable resolution found; use largest one