optimize

src/client/client.cpp

@@ -33,6 +33,7 @@ along with Freeminer.  If not, see <http://www.gnu.org/licenses/>.
 #include <string>
 #include "client.h"
 #include "client/fontengine.h"
+#include "fm_far_calc.h"
 #include "network/clientopcodes.h"
 #include "network/connection.h"
 #include "network/networkpacket.h"
@@ -181,9 +182,9 @@ Client::Client(
 	m_cache_save_interval = g_settings->getU16("server_map_save_interval");
 	m_mesh_grid = { g_settings->getU16("client_mesh_chunk") };
 	control.cell_size = m_mesh_grid.cell_size;
-	control.cell_size_pow =	log(control.cell_size) / log(2);
+	control.cell_size_pow =	rangeToStep(control.cell_size);
 	control.farmesh_quality = g_settings->getU16("farmesh_quality");
-	control.farmesh_quality_pow = log(control.farmesh_quality) / log(2);
+	control.farmesh_quality_pow = rangeToStep(control.farmesh_quality);
 	control.farmesh_stable = g_settings->getU16("farmesh_stable");
 	control.farmesh_all_changed = g_settings->getPos("farmesh_all_changed");
 }

src/client/fm_farmesh.cpp

@@ -280,7 +280,7 @@ int FarMesh::go_container()
 	runFarAll(cbpos, draw_control.cell_size_pow, draw_control.farmesh,
 			draw_control.farmesh_quality, 0,
 			[this, &cbpos](const v3bpos_t &bpos, const bpos_t &size) -> bool {
-				const block_step_t step = log(size) / log(2);
+				const block_step_t step = rangeToStep(size);
 
 				if (step >= FARMESH_STEP_MAX) {
 					return false;
@@ -445,7 +445,7 @@ int FarMesh::go_direction(const size_t dir_n)
 				break;
 			}
 
-			const int step_aligned_pow = ceil(log(step_width) / log(2)) - align_reduce;
+			const int step_aligned_pow =   rangeToStep(step_width) - align_reduce; // ceil ?
 			const auto pos_int = align_shift(
 					floatToInt(pos, BS), step_aligned_pow > 0 ? step_aligned_pow : 0);
 
@@ -487,7 +487,7 @@ int FarMesh::go_direction(const size_t dir_n)
 					//DUMP(actual_blockpos, blockpos, blocks);
 					//for (const auto bp : seven_blocks)
 					const bpos_t blocks =
-							pow(2, block_step + log(draw_control.cell_size) / log(2));
+							pow(2, block_step + rangeToStep(draw_control.cell_size);
 					//const bpos_t blocks =					pow(2, block_step);
 					DUMP("mis", actual_blockpos, blockpos, pos_int, block_step,
 							/*block_step_m1,*/ blocks);

src/emerge.cpp

@@ -812,7 +812,7 @@ void *EmergeThread::run()
 		runCompletionCallbacks(pos, action, bedata.callbacks);
 
 		if (block) {
-			//modified_blocks[pos] = block;
+			modified_blocks[pos] = block;
 		} else if (allow_gen) {
 			verbosestream<<"nothing generated at "<<pos<< " emerge action="<< action <<std::endl;
 		}

src/fm_clientiface.cpp

@@ -626,7 +626,7 @@ uint32_t RemoteClient::SendFarBlocks(const int32_t uptime)
 			auto cbpos = floatToInt(playerpos, BS * MAP_BLOCKSIZE);
 
 			const auto cell_size = 1; // FMTODO from remoteclient
-			const auto cell_size_pow = log(cell_size) / log(2);
+			const auto cell_size_pow = rangeToStep(cell_size);
 			thread_local static const s16 setting_farmesh_all_changed =
 					g_settings->getU32("farmesh_all_changed");
 			const auto &use_farmesh_all_changed =
@@ -644,7 +644,7 @@ uint32_t RemoteClient::SendFarBlocks(const int32_t uptime)
 							return false;
 						}
 
-						block_step_t step = log(size) / log(2);
+						block_step_t step = rangeToStep(size);
 						if (far_blocks_requested.size() < step) {
 							far_blocks_requested.resize(step);
 						}

src/fm_far_calc.cpp

@@ -22,6 +22,7 @@ along with Freeminer.  If not, see <http://www.gnu.org/licenses/>.
 #include "fm_far_calc.h"
 #include <cstdint>
 #include <optional>
+#include <bit>
 
 #include "client/clientmap.h"
 #include "irr_v3d.h"
@@ -69,6 +70,13 @@ block_step_t getLodStep(const MapDrawControl &draw_control,
 	return 0;
 };
 
+int rangeToStep(const int range)
+{
+	return log(range) / log(2);
+	const unsigned int r = static_cast<unsigned int>(range);
+	return r ? static_cast<int>(std::bit_width(r) - 1) : 0;
+};
+
 block_step_t getFarStepBad(const MapDrawControl &draw_control,
 		const v3bpos_t &playerblockpos, const v3bpos_t &blockpos)
 {
@@ -83,16 +91,16 @@ block_step_t getFarStepBad(const MapDrawControl &draw_control,
 	if (range <= 1)
 		return 1;
 
-	int skip = log(range) / log(2);
-	//skip += log(draw_control.cell_size) / log(2);
+	int skip = rangeToStep(range);
+	//skip += rangeToStep(draw_control.cell_size);
 	range = radius_box(v3pos_t((playerblockpos.X >> skip) << skip,
 							   (playerblockpos.Y >> skip) << skip,
 							   (playerblockpos.Z >> skip) << skip),
 			v3pos_t((blockpos.X >> skip) << skip, (blockpos.Y >> skip) << skip,
 					(blockpos.Z >> skip) << skip));
-	range >>= next_step + int(log(draw_control.cell_size) / log(2)); // TODO: configurable
+	range >>= next_step + rangeToStep(draw_control.cell_size); // TODO: configurable
 	if (range > 1) {
-		skip = log(range) / log(2);
+		skip = rangeToStep(range);
 	}
 	if (skip > FARMESH_STEP_MAX)
 		skip = FARMESH_STEP_MAX;
@@ -269,7 +277,7 @@ block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos
 			return {};
 #endif
 */
-		const auto step1 = int(log(res->size) / log(2));
+		const auto step1 = rangeToStep(res->size);
 		if (cell_size_pow >= step1) {
 			return 0;
 		}

src/fm_far_calc.h

@@ -60,3 +60,4 @@ v3bpos_t playerBlockAlign(
 void runFarAll(const v3bpos_t &ppos, uint8_t cell_size_pow, int farmesh,
 		uint8_t farmesh_quality, pos_t two_d,
 		const std::function<bool(const v3bpos_t &, const bpos_t &)> &func);
+int rangeToStep(const int range);