far clean

src/client/clientmap.cpp

@@ -1138,11 +1138,8 @@ void ClientMap::updateDrawListFm(float dtime, unsigned int max_cycle_ms)
 				continue;
 
 			{
-				const auto fmesh_step = getFarStep(
-						m_control, getNodeBlockPos(far_blocks_last_cam_pos), bp);
-				blocks_skip_farmesh.emplace(
-						getFarActual(bp, getNodeBlockPos(far_blocks_last_cam_pos),
-								fmesh_step, m_control));
+				blocks_skip_farmesh.emplace(getFarActualBlockPos(
+						bp, getNodeBlockPos(far_blocks_last_cam_pos), m_control));
 			}
 
 			if (mesh) {
@@ -1177,8 +1174,7 @@ void ClientMap::updateDrawListFm(float dtime, unsigned int max_cycle_ms)
 		const auto lock = m_far_blocks.lock_unique_rec();
 		for (auto it = m_far_blocks.begin(); it != m_far_blocks.end();) {
 			const auto &block = it->second;
-			if (far_iteration_clean  &&
-					block->far_iteration < far_iteration_clean) {
+			if (far_iteration_clean && block->far_iteration < far_iteration_clean) {
 				m_far_blocks_delete.emplace_back(block);
 				it = m_far_blocks.erase(it);
 			} else if (block->far_iteration >= far_iteration_use) {

src/client/fm_client.cpp

@@ -295,14 +295,11 @@ void Client::handleCommand_BlockDataFm(NetworkPacket *pkt)
 		++m_new_farmeshes;
 
 		//todo: step ordered thread pool
-		mesh_thread_pool.enqueue([this, block]() mutable {
+		mesh_thread_pool.enqueue([this, block, step]() mutable {
 			auto &client_map = getEnv().getClientMap();
 			const auto &control = client_map.getControl();
 			const auto bpos = block->getPos();
-			const auto fmesh_step_ = getFarStep(control,
-					getNodeBlockPos(client_map.far_blocks_last_cam_pos), block->getPos());
-			if (!inFarGrid(block->getPos(),
-						getNodeBlockPos(client_map.far_blocks_last_cam_pos), fmesh_step_,
+			if (!inFarGrid(bpos, getNodeBlockPos(client_map.far_blocks_last_cam_pos),
 						control)) {
 				return;
 			}

src/client/fm_far_container.cpp

@@ -22,15 +22,15 @@ thread_local std::pair<block_step_t, v3bpos_t> block_cache_p;
 const MapNode &FarContainer::getNodeRefUnsafe(const v3pos_t &pos)
 {
 	const auto bpos = getNodeBlockPos(pos);
-	const auto player_bpos =
-			getNodeBlockPos(m_client->getEnv().getClientMap().far_blocks_last_cam_pos);
-	const auto step =
-			getFarStep(m_client->getEnv().getClientMap().getControl(), player_bpos, bpos);
-	//const auto &shift = step; // + cell_size_pow;
-	//const v3bpos_t bpos_aligned((bpos.X >> shift) << shift, (bpos.Y >> shift) << shift, (bpos.Z >> shift) << shift);
-	const v3bpos_t bpos_aligned = getFarActual(
-			bpos, player_bpos, step, m_client->getEnv().getClientMap().getControl());
-
+	auto &client_map = m_client->getEnv().getClientMap();
+	const auto player_bpos = getNodeBlockPos(client_map.far_blocks_last_cam_pos);
+	const auto &control = client_map.getControl();
+	const auto step = getFarStep(control, player_bpos, bpos
+			//	, 0
+	);
+	const v3bpos_t bpos_aligned = getFarActualBlockPos(bpos, player_bpos, control
+			//	, 0
+	);
 	MapBlockPtr block;
 	const auto step_block_pos = std::make_pair(step, bpos_aligned);
 	if (block_cache && step_block_pos == block_cache_p) {
@@ -38,18 +38,18 @@ const MapNode &FarContainer::getNodeRefUnsafe(const v3pos_t &pos)
 	}
 
 	if (!block && step < FARMESH_STEP_MAX) {
-		const auto &storage = m_client->getEnv().getClientMap().far_blocks_storage[step];
+		const auto &storage = client_map.far_blocks_storage[step];
 		block = storage.get(bpos_aligned).block;
 	}
 
-	const auto loadBlock = [this](const auto &bpos, const auto step) -> MapBlockPtr {
+	const auto loadBlock = [this, &client_map](
+								   const auto &bpos, const auto step) -> MapBlockPtr {
 		auto *dbase =
 				GetFarDatabase({}, m_client->far_dbases, m_client->m_world_path, step);
 		if (!dbase) {
 			return {};
 		}
-		MapBlockPtr block =
-				m_client->getEnv().getClientMap().createBlankBlockNoInsert(bpos);
+		MapBlockPtr block = client_map.createBlankBlockNoInsert(bpos);
 
 		std::string blob;
 		dbase->loadBlock(bpos, &blob);
@@ -89,7 +89,7 @@ const MapNode &FarContainer::getNodeRefUnsafe(const v3pos_t &pos)
 		block_cache_p = step_block_pos;
 		block_cache = block;
 
-		v3pos_t relpos = pos - bpos_aligned * MAP_BLOCKSIZE;
+		const v3pos_t relpos = pos - bpos_aligned * MAP_BLOCKSIZE;
 
 		const auto &relpos_shift = step;
 		const auto relpos_shifted = v3pos_t(relpos.X >> relpos_shift,

src/client/fm_farmesh.cpp

@@ -54,7 +54,8 @@ const v3opos_t g_6dirso[6] = {
 		v3opos_t(0, 1, 0),	// top
 };
 
-void FarMesh::makeFarBlock(const v3bpos_t &blockpos, block_step_t step, bool bnear)
+void FarMesh::makeFarBlock(const v3bpos_t &blockpos, block_step_t step, bool bnear,
+		std::optional<v3bpos_t> blockpos_actual_optional)
 {
 	g_profiler->add("Client: Farmesh make", 1);
 
@@ -62,9 +63,10 @@ void FarMesh::makeFarBlock(const v3bpos_t &blockpos, block_step_t step, bool bne
 	//const auto &draw_control = client_map.getControl();
 	const auto &draw_control = *m_control;
 	const auto blockpos_actual =
-			bnear ? blockpos
-				  : getFarActual(blockpos, getNodeBlockPos(m_camera_pos_aligned), step,
-							draw_control);
+			blockpos_actual_optional.has_value() ? blockpos_actual_optional.value()
+			: bnear								 ? blockpos
+												 : getFarActualBlockPos(blockpos,
+														   getNodeBlockPos(m_camera_pos_aligned), draw_control);
 	auto &far_blocks = //near ? m_client->getEnv().getClientMap().m_far_near_blocks :
 			client_map.m_far_blocks;
 	if (const auto it = client_map.far_blocks_storage[step].find(blockpos_actual);
@@ -134,9 +136,9 @@ void FarMesh::makeFarBlocks(const v3bpos_t &blockpos, block_step_t step)
 
 	// TODO: fix finding correct near blocks respecting their steps and enable:
 
-	const static auto pfar = std::vector<v3pos_t>{
-			v3pos_t(0, 0, 0), // self
-	};
+	//const static auto pfar = std::vector<v3pos_t>{
+	//		v3pos_t(0, 0, 0), // self
+	//};
 	const static auto pnear = std::vector<v3pos_t>{
 			v3pos_t(0, 0, 0),  // self
 			v3pos_t(0, 0, 1),  // back
@@ -147,15 +149,15 @@ void FarMesh::makeFarBlocks(const v3bpos_t &blockpos, block_step_t step)
 			v3pos_t(0, -1, 0), // bottom
 	};
 	const auto &use_dirs = pnear;
-	const auto step_width = 1 << (step - 1);
+	const auto &control = *m_control;
+	const auto step_width = 1 << (step - 1 + control.cell_size_pow);
 	for (const auto &dir : use_dirs) {
 		const auto bpos_dir = blockpos + dir * step_width;
-		const auto &control = *m_control;
-		const auto bpos = getFarActual(
-				bpos_dir, getNodeBlockPos(m_camera_pos_aligned), step, control);
+		const auto bpos = getFarActualBlockPos(
+				bpos_dir, getNodeBlockPos(m_camera_pos_aligned), control);
 		const auto block_step_correct =
 				getFarStep(control, getNodeBlockPos(m_camera_pos_aligned), bpos);
-		makeFarBlock(bpos, block_step_correct);
+		makeFarBlock(bpos, block_step_correct, {}, bpos);
 	}
 }
 
@@ -278,7 +280,7 @@ int FarMesh::go_container()
 			g_settings->getU32("farmesh_all_changed");
 
 	runFarAll(cbpos, draw_control.cell_size_pow, draw_control.farmesh,
-			draw_control.farmesh_quality, 0,
+			draw_control.farmesh_quality_pow, 0,
 			[this, &cbpos](const v3bpos_t &bpos, const bpos_t &size) -> bool {
 				const block_step_t step = rangeToStep(size);
 
@@ -298,7 +300,7 @@ int FarMesh::go_container()
 				const auto contains = it != step_blocks.end() && it->second.block;
 
 				if (contains) {
-					makeFarBlock(bpos, step);
+					makeFarBlock(bpos, step, {}, bpos);
 				}
 
 				return false;
@@ -322,7 +324,7 @@ int FarMesh::go_flat()
 	// todo: maybe save blocks while cam pos not changed
 	std::array<std::unordered_set<v3bpos_t>, FARMESH_STEP_MAX> blocks;
 	runFarAll(cbpos, draw_control.cell_size_pow, draw_control.farmesh,
-			draw_control.farmesh_quality, cbpos.Y ?: 1,
+			draw_control.farmesh_quality_pow, cbpos.Y ?: 1,
 			[this, &draw_control, &blocks](
 					const v3bpos_t &bpos, const bpos_t &size) -> bool {
 				for (const auto &add : {
@@ -350,6 +352,9 @@ int FarMesh::go_flat()
 			});
 
 	for (; last_step < blocks.size(); ++last_step) {
+		if (!last_step) {
+			continue;
+		}
 		for (const auto &bpos : blocks[last_step]) {
 			// just first suggestion
 			if (1 << (last_step + MAP_BLOCKP) > draw_control.farmesh &&

src/client/fm_farmesh.h

@@ -59,7 +59,8 @@ public:
 			v3pos_t m_camera_offset,
 			//float brightness,
 			int render_range, float speed);
-	void makeFarBlock(const v3bpos_t &blockpos, block_step_t step, bool bnear = false);
+	void makeFarBlock(const v3bpos_t &blockpos, block_step_t step, bool bnear = false,
+			std::optional<v3bpos_t> blockpos_actual = {});
 	void makeFarBlocks(const v3bpos_t &blockpos, block_step_t step);
 	//void makeFarBlocks(const v3bpos_t &blockpos);
 

src/client/hud.cpp

@@ -965,15 +965,13 @@ void Hud::drawBlockBounds()
 				const auto &mesh_step = block->far_step;
 				int g = 0;
 
-				if (!inFarGrid(blockPos, getNodeBlockPos(
-								client_map
-										.far_blocks_last_cam_pos), mesh_step,
-							client_map.getControl()))
-					{
-						// DUMP("Not in grid", blockPos,  block->far_step, mesh_step, block->getTimestamp(), client->getEnv() .getClientMap() .m_far_blocks_last_cam_pos);
-						// continue;
-						g+=50;
-					}
+				if (!inFarGrid(blockPos,
+							getNodeBlockPos(client_map.far_blocks_last_cam_pos),
+							client_map.getControl())) {
+					// DUMP("Not in grid", blockPos,  block->far_step, mesh_step, block->getTimestamp(), client->getEnv() .getClientMap() .m_far_blocks_last_cam_pos);
+					// continue;
+					g += 50;
+				}
 
 				int fscale = 1;
 				int lod_step = 0;

src/client/hud.h

@@ -37,11 +37,11 @@ public:
 	enum BlockBoundsMode
 	{
 		BLOCK_BOUNDS_OFF,
-		BLOCK_BOUNDS_CURRENT,
-		BLOCK_BOUNDS_NEAR,
 		BLOCK_BOUNDS_FAR_DRAWN,
 		BLOCK_BOUNDS_FAR_REQUEST,
 		BLOCK_BOUNDS_FAR_STORAGE,
+		BLOCK_BOUNDS_CURRENT,
+		BLOCK_BOUNDS_NEAR,
 		BLOCK_BOUNDS_MAX
 	} m_block_bounds_mode = BLOCK_BOUNDS_OFF;
 

src/fm_clientiface.cpp

@@ -617,13 +617,13 @@ uint32_t RemoteClient::SendFarBlocks(const int32_t uptime)
 			if (!player)
 				return 0;
 
-			auto *sao = player->getPlayerSAO();
+			const auto *sao = player->getPlayerSAO();
 			if (!sao)
 				return 0;
 
-			auto playerpos = sao->getBasePosition();
+			const auto playerpos = sao->getBasePosition();
 
-			auto cbpos = floatToInt(playerpos, BS * MAP_BLOCKSIZE);
+			const auto cbpos = floatToInt(playerpos, BS * MAP_BLOCKSIZE);
 
 			const auto cell_size = 1; // FMTODO from remoteclient
 			const auto cell_size_pow = rangeToStep(cell_size);
@@ -631,12 +631,12 @@ uint32_t RemoteClient::SendFarBlocks(const int32_t uptime)
 					g_settings->getU32("farmesh_all_changed");
 			const auto &use_farmesh_all_changed =
 					std::min(setting_farmesh_all_changed, farmesh_all_changed);
-			runFarAll(cbpos, cell_size_pow, farmesh, farmesh_quality, false,
+			runFarAll(cbpos, cell_size_pow, farmesh, rangeToStep(farmesh_quality), false,
 					[this, &ordered, &cbpos, &use_farmesh_all_changed](
 							const v3bpos_t &bpos, const bpos_t &size) -> bool {
 						if (!size) {
 							return false;
-						};
+						}
 
 						// TODO: use block center
 						const auto bdist = radius_box(cbpos, bpos);

src/fm_far_calc.cpp

@@ -70,9 +70,8 @@ block_step_t getLodStep(const MapDrawControl &draw_control,
 	return 0;
 };
 
-int rangeToStep(const int range)
+uint8_t 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;
 };
@@ -132,9 +131,9 @@ using tpos_t = int32_t;
 using v3tpos_t = v3s32;
 #endif
 bool inFarGrid(const v3bpos_t &blockpos, const v3bpos_t &playerblockpos,
-		block_step_t step, const MapDrawControl &draw_control)
+		const MapDrawControl &draw_control)
 {
-	const auto act = getFarActual(blockpos, playerblockpos, step, draw_control);
+	const auto act = getFarActualBlockPos(blockpos, playerblockpos, draw_control);
 	return act == blockpos;
 }
 
@@ -145,34 +144,32 @@ struct child_t
 };
 
 std::optional<child_t> find(const v3tpos_t &block_pos, const v3tpos_t &player_pos,
-		const child_t &child, const int cell_size_pow, uint16_t farmesh_quality,
+		const child_t &child, const int cell_size_pow, uint16_t farmesh_quality_pow,
 		uint16_t depth = 0)
 {
-	if (!(block_pos.X >= child.pos.X && block_pos.X < child.pos.X + child.size &&
-				block_pos.Y >= child.pos.Y && block_pos.Y < child.pos.Y + child.size &&
-				block_pos.Z >= child.pos.Z && block_pos.Z < child.pos.Z + child.size)) {
+	const auto sz = child.size << cell_size_pow;
+	if (!(block_pos.X >= child.pos.X && block_pos.X < child.pos.X + sz &&
+				block_pos.Y >= child.pos.Y && block_pos.Y < child.pos.Y + sz &&
+				block_pos.Z >= child.pos.Z && block_pos.Z < child.pos.Z + sz)) {
 		if (depth) {
 			return {};
 		} else {
 			return child;
 		}
 	}
+
 	if (child.size < (1 << (cell_size_pow))) {
 		return child;
 	}
 
-	auto distance =
-			std::max({std::abs((tpos_t)player_pos.X - child.pos.X - (child.size >> 1)),
-					std::abs((tpos_t)player_pos.Y - child.pos.Y - (child.size >> 1)),
-					std::abs((tpos_t)player_pos.Z - child.pos.Z - (child.size >> 1))});
-
-	if (farmesh_quality) {
-		distance /= farmesh_quality;
-	}
-	if (distance > child.size) {
-		return child;
-	}
 	const tpos_t childSize = child.size >> 1;
+	auto distance = std::max({std::abs((tpos_t)player_pos.X - (child.pos.X + childSize)),
+			std::abs((tpos_t)player_pos.Y - (child.pos.Y + childSize)),
+			std::abs((tpos_t)player_pos.Z - (child.pos.Z + childSize))});
+	const auto next_child_size = child.size << (1 + farmesh_quality_pow);
+	if (distance >= next_child_size) {
+		return child_t{.pos{child.pos}, .size{child.size >> cell_size_pow}};
+	}
 	for (const auto &child : {
 				 child_t{.pos{child.pos}, .size = childSize},
 				 child_t{.pos = v3tpos_t(
@@ -199,7 +196,7 @@ std::optional<child_t> find(const v3tpos_t &block_pos, const v3tpos_t &player_po
 		 }) {
 
 		if (const auto res = find(block_pos, player_pos, child, cell_size_pow,
-					farmesh_quality, depth + 1);
+					farmesh_quality_pow, depth + 1);
 				res) {
 			return res;
 		}
@@ -254,6 +251,7 @@ child_t tree_params_to_child(
 							(tree_params.tree_align_size >> 1)),
 			.size{tree_params.tree_size}};
 }
+
 block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos_t &ppos,
 		const v3bpos_t &blockpos, uint8_t cell_size_pow)
 {
@@ -264,7 +262,8 @@ block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos
 
 	const auto res = find(
 			{blockpos_aligned_cell.X, blockpos_aligned_cell.Y, blockpos_aligned_cell.Z},
-			{ppos.X, ppos.Y, ppos.Z}, start, cell_size_pow, draw_control.farmesh_quality);
+			{ppos.X, ppos.Y, ppos.Z}, start, cell_size_pow,
+			draw_control.farmesh_quality_pow);
 	if (res) {
 		/*
 #if !USE_POS32
@@ -289,23 +288,24 @@ block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos
 }
 
 block_step_t getFarStep(const MapDrawControl &draw_control, const v3bpos_t &ppos,
-		const v3bpos_t &blockpos)
+		const v3bpos_t &blockpos, const std::optional<uint8_t> &cell_size_pow)
 {
-	return getFarStepCellSize(draw_control, ppos, blockpos, draw_control.cell_size_pow);
+	return getFarStepCellSize(draw_control, ppos, blockpos,
+			cell_size_pow.value_or(draw_control.cell_size_pow));
 }
 
-v3bpos_t getFarActual(const v3bpos_t &blockpos, const v3bpos_t &ppos, block_step_t step,
+v3bpos_t getFarActualBlockPos(const v3bpos_t &blockpos,
+		const v3bpos_t &ppos, //block_step_t step,
 		const MapDrawControl &draw_control, const std::optional<uint8_t> &cell_size_pow)
 {
-	const auto blockpos_aligned_cell =
-			align_shift(blockpos, cell_size_pow.value_or(draw_control.cell_size_pow));
-	tree_params_t tree_params{.tree_pow{farmesh_to_tree_pow(draw_control.farmesh)}};
+	const auto blockpos_aligned_cell = blockpos;
+	const tree_params_t tree_params{.tree_pow{farmesh_to_tree_pow(draw_control.farmesh)}};
 	const auto start = tree_params_to_child(tree_params, ppos);
 	const auto res = find(
 			{blockpos_aligned_cell.X, blockpos_aligned_cell.Y, blockpos_aligned_cell.Z},
 			{ppos.X, ppos.Y, ppos.Z}, start,
 			cell_size_pow.value_or(draw_control.cell_size_pow),
-			draw_control.farmesh_quality);
+			draw_control.farmesh_quality_pow);
 
 	if (res) {
 #if USE_POS32
@@ -324,38 +324,38 @@ v3bpos_t getFarActual(const v3bpos_t &blockpos, const v3bpos_t &ppos, block_step
 		return v3bpos_t(res->pos.X, res->pos.Y, res->pos.Z);
 #endif
 	}
-	const auto ext_align = tree_params.external_pow; // + cell_size_pow;
-	return v3bpos_t((blockpos.X >> ext_align) << ext_align,
+	const auto &ext_align = tree_params.external_pow; // + cell_size_pow;
+	const v3bpos_t ret((blockpos.X >> ext_align) << ext_align,
 			(blockpos.Y >> ext_align) << ext_align,
 			(blockpos.Z >> ext_align) << ext_align);
+	return ret;
 }
 
 struct each_param_t
 {
 	const v3tpos_t &player_pos;
-	const int cell_size_pow;
-	const uint16_t farmesh_quality;
+	const uint8_t cell_size_pow;
+	const uint8_t farmesh_quality_pow;
 	const std::function<bool(const child_t &)> &func;
 	const bool two_d{false};
 };
 
 void each(const each_param_t &param, const child_t &child)
 {
-	auto distance = std::max({std::abs((tpos_t)param.player_pos.X - child.pos.X -
-									   (child.size >> 1)),
-			std::abs((tpos_t)param.player_pos.Y - child.pos.Y - (child.size >> 1)),
-			std::abs((tpos_t)param.player_pos.Z - child.pos.Z - (child.size >> 1))});
+	const tpos_t childSize = child.size >> 1;
+	auto distance =
+			std::max({std::abs((tpos_t)param.player_pos.X - child.pos.X - childSize),
+					std::abs((tpos_t)param.player_pos.Y - child.pos.Y - childSize),
+					std::abs((tpos_t)param.player_pos.Z - child.pos.Z - childSize)});
 
-	if (param.farmesh_quality) {
-		distance /= param.farmesh_quality;
-	}
-
-	if (distance > child.size) {
-		param.func(child);
+	const auto next_child_size = child.size << (1 + param.farmesh_quality_pow);
+	if (distance >= next_child_size) {
+		param.func(child_t{.pos{child.pos},
+				.size{child.size >> param.cell_size_pow}
+				});
 		return;
 	}
 
-	const tpos_t childSize = child.size >> 1;
 	uint8_t i{0};
 	for (const auto &child : {
 				 // first with unchanged Y for 2d
@@ -391,7 +391,9 @@ void each(const each_param_t &param, const child_t &child)
 		}
 
 		if (child.size < (1 << (param.cell_size_pow))) {
-			if (param.func(child)) {
+			if (param.func(child_t{.pos{child.pos},
+						.size{child.size >> param.cell_size_pow}}))
+			{
 				return;
 			}
 			continue;
@@ -402,7 +404,7 @@ void each(const each_param_t &param, const child_t &child)
 }
 
 void runFarAll(const v3bpos_t &ppos, uint8_t cell_size_pow, int farmesh,
-		uint8_t farmesh_quality, pos_t two_d,
+		uint8_t farmesh_quality_pow, pos_t two_d,
 		const std::function<bool(const v3bpos_t &, const bpos_t &)> &func)
 {
 
@@ -416,7 +418,7 @@ void runFarAll(const v3bpos_t &ppos, uint8_t cell_size_pow, int farmesh,
 
 	each({.player_pos{ppos.X, ppos.Y, ppos.Z},
 				 .cell_size_pow{cell_size_pow},
-				 .farmesh_quality{farmesh_quality},
+				 .farmesh_quality_pow{farmesh_quality_pow},
 				 .func{func_convert},
 				 .two_d{static_cast<bool>(two_d)}},
 			start);

src/fm_far_calc.h

@@ -47,17 +47,18 @@ block_step_t getLodStep(const MapDrawControl &draw_control,
 block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos_t &ppos,
 		const v3bpos_t &blockpos, uint8_t cell_size_pow);
 block_step_t getFarStep(const MapDrawControl &draw_control,
-		const v3bpos_t &playerblockpos, const v3bpos_t &block_pos);
+		const v3bpos_t &playerblockpos, const v3bpos_t &block_pos,
+		const std::optional<uint8_t> &cell_size_pow = {});
 block_step_t getFarStepBad(const MapDrawControl &draw_control,
 		const v3bpos_t &playerblockpos, const v3bpos_t &block_pos);
 bool inFarGrid(const v3bpos_t &blockpos, const v3bpos_t &playerblockpos,
-		block_step_t step, const MapDrawControl &draw_control);
-v3bpos_t getFarActual(const v3bpos_t &blockpos, const v3bpos_t &playerblockpos,
-		block_step_t step, const MapDrawControl &draw_control,
+		const MapDrawControl &draw_control);
+v3bpos_t getFarActualBlockPos(const v3bpos_t &blockpos, const v3bpos_t &playerblockpos,
+		const MapDrawControl &draw_control,
 		const std::optional<uint8_t> &cell_size_pow = {});
 v3bpos_t playerBlockAlign(
 		const MapDrawControl &draw_control, const v3bpos_t &playerblockpos);
 void runFarAll(const v3bpos_t &ppos, uint8_t cell_size_pow, int farmesh,
-		uint8_t farmesh_quality, pos_t two_d,
+		uint8_t farmesh_quality_pow, pos_t two_d,
 		const std::function<bool(const v3bpos_t &, const bpos_t &)> &func);
-int rangeToStep(const int range);
+uint8_t rangeToStep(const int range);