far cell

src/client/fm_client.cpp

@@ -183,7 +183,7 @@ void Client::createFarMesh(MapBlockPtr &block)
 		//const auto &m_camera_offset = m_camera->getOffset();
 		const auto &step = block->far_step;
 		MeshMakeData mdat(m_client->getNodeDefManager(),
-				MAP_BLOCKSIZE * m_client->getMeshGrid().cell_size, m_mesh_grid, 0, step,
+				MAP_BLOCKSIZE * m_mesh_grid.cell_size, m_mesh_grid, 0, step,
 				&m_client->far_container);
 		mdat.m_blockpos = blockpos_actual;
 		const auto mbmsh = std::make_shared<MapBlockMesh>(m_client, &mdat);

src/client/fm_far_container.cpp

@@ -25,12 +25,13 @@ const MapNode &FarContainer::getNodeRefUnsafe(const v3pos_t &pos)
 	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
+	const auto step = getFarStep(control, player_bpos, bpos, {}, true
 			//	, 0
 	);
+	const v3bpos_t bpos_aligned =
+			getFarActualBlockPos(bpos, player_bpos, control, {}, true
+					//	, 0
+			);
 	MapBlockPtr block;
 	const auto step_block_pos = std::make_pair(step, bpos_aligned);
 	if (block_cache && step_block_pos == block_cache_p) {

src/client/fm_farmesh.cpp

@@ -280,9 +280,9 @@ int FarMesh::go_container()
 			g_settings->getU32("farmesh_all_changed");
 
 	runFarAll(cbpos, draw_control.cell_size_pow, draw_control.farmesh,
-			draw_control.farmesh_quality_pow, 0,
-			[this, &cbpos](const v3bpos_t &bpos, const bpos_t &size) -> bool {
-				const block_step_t step = rangeToStep(size);
+			draw_control.farmesh_quality_pow, 0, false,
+			[this, &cbpos](const v3bpos_t &bpos, const bpos_t &size,
+					const block_step_t &step) -> bool {
 
 				if (step >= FARMESH_STEP_MAX) {
 					return false;
@@ -324,9 +324,9 @@ 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_pow, cbpos.Y ?: 1,
-			[this, &draw_control, &blocks](
-					const v3bpos_t &bpos, const bpos_t &size) -> bool {
+			draw_control.farmesh_quality_pow, cbpos.Y ?: 1, true,
+			[this, &draw_control, &blocks](const v3bpos_t &bpos, const bpos_t &size,
+					const block_step_t &step) -> bool {
 				for (const auto &add : {
 							 v2bpos_t(0, 0),
 							 v2bpos_t(0, size - 1),
@@ -342,7 +342,8 @@ int FarMesh::go_flat()
 								 MAP_BLOCKP;
 
 					const auto step_new = getFarStep(draw_control,
-							getNodeBlockPos(m_camera_pos_aligned), bpos_new);
+							getNodeBlockPos(m_camera_pos_aligned), bpos_new //, 0
+					);
 
 					if (step_new >= FARMESH_STEP_MAX)
 						continue;

src/client/hud.cpp

@@ -936,7 +936,7 @@ void Hud::drawBlockBounds()
 
 	// 3s16 pos = player->getStandingNodePos();
 
-	if (m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN) {
+	if (m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN || m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN_EACH) {
 		const auto offset = intToFloat(client->getCamera()->getOffset(), BS);
 
 		//s8 radius = m_block_bounds_mode == BLOCK_BOUNDS_NEAR ? 2 : 0;
@@ -946,14 +946,12 @@ void Hud::drawBlockBounds()
  		const auto & far_blocks = client_map.m_far_blocks;
 
 		if (const auto lock = far_blocks.try_lock_shared_rec(); lock->owns_lock()) {
-			for (const auto &[blockPos, block] :
-					far_blocks) {
+			for (const auto &[blockPos, block] : far_blocks) {
 				if (!block)
 					continue;
-				if (block->far_iteration <
-						client_map.far_iteration_use)
+				if (block->far_iteration < client_map.far_iteration_use)
 					continue;
-/*					
+				/*					
 				const auto mesh_step_ = getFarStep(
 						client->getEnv().getClientMap().getControl(),
 						getNodeBlockPos(
@@ -967,7 +965,8 @@ void Hud::drawBlockBounds()
 
 				if (!inFarGrid(blockPos,
 							getNodeBlockPos(client_map.far_blocks_last_cam_pos),
-							client_map.getControl())) {
+							client_map.getControl(),
+							m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN_EACH)) {
 					// DUMP("Not in grid", blockPos,  block->far_step, mesh_step, block->getTimestamp(), client->getEnv() .getClientMap() .m_far_blocks_last_cam_pos);
 					// continue;
 					g += 50;
@@ -986,14 +985,14 @@ void Hud::drawBlockBounds()
 					lod_step = mesh->lod_step;
 					far_step = mesh->far_step;
 				}
-				const aabb3f box(
-						oposToV3f(intToFloat((blockPos)*MAP_BLOCKSIZE, BS) - offset - halfNode + 1),
-						oposToV3f(intToFloat(
-								((blockPos)*MAP_BLOCKSIZE) + (MAP_BLOCKSIZE * fscale - fscale),
-								BS) -
-								offset + halfNode - 1));
+				const aabb3f box(oposToV3f(intToFloat((blockPos)*MAP_BLOCKSIZE, BS) -
+										   offset - halfNode + 1),
+						oposToV3f(intToFloat(((blockPos)*MAP_BLOCKSIZE) +
+													 (MAP_BLOCKSIZE * fscale - fscale),
+										  BS) -
+								  offset + halfNode - 1));
 				driver->draw3DBox(box, video::SColor(200 + b, 255 - lod_step * 10 + b,
-											   255 -g - far_step * 10, fscale * 20));
+											   255 - g - far_step * 10, fscale * 20));
 			}
 		}
 	} else if (m_block_bounds_mode == BLOCK_BOUNDS_FAR_REQUEST) {
@@ -1002,17 +1001,18 @@ void Hud::drawBlockBounds()
 		const auto &far_blocks = client->getEnv().getClientMap().m_far_blocks_ask;
 		{
 			for (const auto &[blockPos, step_ts] : far_blocks) {
-			    const auto &[mesh_step, ts] = step_ts;
-				int fscale = pow(2, mesh_step - 1);
-				int lod_step = 0;
-				int far_step = 0;
-				int b = 0;
-				const aabb3f box(
-						oposToV3f(intToFloat((blockPos)*MAP_BLOCKSIZE, BS) - offset - halfNode + 1),
-						oposToV3f(intToFloat(
-								((blockPos)*MAP_BLOCKSIZE) + (MAP_BLOCKSIZE << mesh_step ) - (1 << mesh_step), // - 1
-								BS) -
-								offset + halfNode - 1));
+				const auto &[mesh_step, ts] = step_ts;
+				const int fscale = pow(2, mesh_step - 1);
+				const int lod_step = 0;
+				const int far_step = 0;
+				const int b = 0;
+				const aabb3f box(oposToV3f(intToFloat((blockPos)*MAP_BLOCKSIZE, BS) -
+										   offset - halfNode + 1),
+						oposToV3f(intToFloat(((blockPos)*MAP_BLOCKSIZE) +
+													 (MAP_BLOCKSIZE << mesh_step) -
+													 (1 << mesh_step), // - 1
+										  BS) -
+								  offset + halfNode - 1));
 				driver->draw3DBox(box, video::SColor(200 + b, 255 - lod_step * 10 + b,
 											   255 - far_step * 10, fscale * 20));
 			}
@@ -1020,10 +1020,11 @@ void Hud::drawBlockBounds()
 	} else if (m_block_bounds_mode == Hud::BLOCK_BOUNDS_FAR_STORAGE) {
 		const auto offset = intToFloat(client->getCamera()->getOffset(), BS);
 		const auto halfNode = v3opos_t(BS, BS, BS) / 2.0f;
-		const auto &far_blocks = client->getEnv().getClientMap().far_blocks_storage;
+		const auto &far_blocks_storage =
+				client->getEnv().getClientMap().far_blocks_storage;
 
-		for (size_t step = 0; step < far_blocks.size(); ++step) {
-			const auto &blocks = far_blocks[step];
+		for (size_t step = 0; step < far_blocks_storage.size(); ++step) {
+			const auto &blocks = far_blocks_storage[step];
 			const auto mesh_step = step;
 			for (const auto &[blockPos, block_ts] : blocks) {
 				const auto &[block, ts] = block_ts;
@@ -1031,18 +1032,20 @@ void Hud::drawBlockBounds()
 					continue;
 				}
 				const auto has_mesh = !!block->getFarMesh(mesh_step);
-				int fscale = pow(2, mesh_step );
-				int lod_step = 0;
-				int far_step = 0;
-				int b = 0;
-				const aabb3f box(
-						oposToV3f(intToFloat((blockPos)*MAP_BLOCKSIZE, BS) - offset - halfNode + 1),
-						oposToV3f(intToFloat(
-								((blockPos)*MAP_BLOCKSIZE) + (MAP_BLOCKSIZE << (mesh_step) ) - (1 << mesh_step), ///// -1 ?
-								BS) -
-								offset + (halfNode - 1)));
-				driver->draw3DBox(box, video::SColor(200 + b, 255 - lod_step * 10 + b,
-											   255 - far_step * 10, fscale * 20 + 20*has_mesh));
+				const int fscale = pow(2, mesh_step);
+				const int lod_step = 0;
+				const int far_step = 0;
+				const int b = 0;
+				const aabb3f box(oposToV3f(intToFloat((blockPos)*MAP_BLOCKSIZE, BS) -
+										   offset - halfNode + 1),
+						oposToV3f(intToFloat(((blockPos)*MAP_BLOCKSIZE) +
+													 (MAP_BLOCKSIZE << (mesh_step)) -
+													 (1 << mesh_step), ///// -1 ?
+										  BS) -
+								  offset + (halfNode - 1)));
+				driver->draw3DBox(
+						box, video::SColor(200 + b, 255 - lod_step * 10 + b,
+									 255 - far_step * 10, fscale * 20 + 20 * has_mesh));
 			}
 		}
 	} else {

src/client/hud.h

@@ -38,6 +38,7 @@ public:
 	{
 		BLOCK_BOUNDS_OFF,
 		BLOCK_BOUNDS_FAR_DRAWN,
+		BLOCK_BOUNDS_FAR_DRAWN_EACH,
 		BLOCK_BOUNDS_FAR_REQUEST,
 		BLOCK_BOUNDS_FAR_STORAGE,
 		BLOCK_BOUNDS_CURRENT,

src/fm_clientiface.cpp

@@ -632,8 +632,10 @@ uint32_t RemoteClient::SendFarBlocks(const int32_t uptime)
 			const auto &use_farmesh_all_changed =
 					std::min(setting_farmesh_all_changed, farmesh_all_changed);
 			runFarAll(cbpos, cell_size_pow, farmesh, rangeToStep(farmesh_quality), false,
+					true,
 					[this, &ordered, &cbpos, &use_farmesh_all_changed](
-							const v3bpos_t &bpos, const bpos_t &size) -> bool {
+							const v3bpos_t &bpos, const bpos_t &size,
+							const block_step_t &step) -> bool {
 						if (!size) {
 							return false;
 						}
@@ -644,7 +646,7 @@ uint32_t RemoteClient::SendFarBlocks(const int32_t uptime)
 							return false;
 						}
 
-						block_step_t step = rangeToStep(size);
+						//block_step_t step = rangeToStep(size);
 						if (far_blocks_requested.size() < step) {
 							far_blocks_requested.resize(step);
 						}

src/fm_far_calc.cpp

@@ -40,8 +40,8 @@ block_step_t getLodStep(const MapDrawControl &draw_control,
 		}
 		*/
 
-		const auto cells = std::max<int>(draw_control.cell_size * 2,
-				draw_control.lodmesh / draw_control.cell_size);
+		const auto cells = std::max<int>(draw_control.cell_size << 1,
+				draw_control.lodmesh >> draw_control.cell_size_pow);
 		// for (int i = 8; i >= 0; --i) {
 		// 	if (range >= cells + draw_control.lodmesh * pow(2, i))
 		// 		return i;
@@ -97,7 +97,7 @@ block_step_t getFarStepBad(const MapDrawControl &draw_control,
 							   (playerblockpos.Z >> skip) << skip),
 			v3pos_t((blockpos.X >> skip) << skip, (blockpos.Y >> skip) << skip,
 					(blockpos.Z >> skip) << skip));
-	range >>= next_step + rangeToStep(draw_control.cell_size); // TODO: configurable
+	range >>= next_step + draw_control.cell_size_pow;
 	if (range > 1) {
 		skip = rangeToStep(range);
 	}
@@ -131,44 +131,68 @@ using tpos_t = int32_t;
 using v3tpos_t = v3s32;
 #endif
 bool inFarGrid(const v3bpos_t &blockpos, const v3bpos_t &playerblockpos,
-		const MapDrawControl &draw_control)
+		const MapDrawControl &draw_control, bool cell_each)
 {
-	const auto act = getFarActualBlockPos(blockpos, playerblockpos, draw_control);
+	const auto act =
+			getFarActualBlockPos(blockpos, playerblockpos, draw_control, {}, cell_each);
 	return act == blockpos;
 }
 
+struct find_param_t
+{
+	const v3tpos_t &block_pos;
+	const v3tpos_t &player_pos;
+	const uint8_t cell_size_pow;
+	const uint8_t farmesh_quality_pow;
+	const bool cell_size_each{0};
+};
+
 struct child_t
 {
 	v3tpos_t pos;
 	tpos_t size;
+	block_step_t step;
 };
 
-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_pow,
+std::optional<child_t> find(const find_param_t &param,
+		const child_t &child,
 		uint16_t depth = 0)
 {
-	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)) {
+	const auto make_result = [&param](const auto &child) {
+		return child_t{
+				.pos{child.pos},
+				.size{child.size >> (param.cell_size_each ? 0 : param.cell_size_pow)},
+				.step{rangeToStep(child.size)},
+		};
+	};
+
+	const auto sz = child.size; //<< param.cell_size_pow;
+	if (!(param.block_pos.X >= child.pos.X && param.block_pos.X < child.pos.X + sz &&
+				param.block_pos.Y >= child.pos.Y &&
+				param.block_pos.Y < child.pos.Y + sz &&
+				param.block_pos.Z >= child.pos.Z &&
+				param.block_pos.Z < child.pos.Z + sz)) {
 		if (depth) {
 			return {};
 		} else {
-			return child;
+			return make_result(child);
+
 		}
 	}
 
-	if (child.size < (1 << (cell_size_pow))) {
-		return child;
+	if (child.size < (1 << (param.cell_size_pow))) {
+		return make_result(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);
+	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))});
+	const auto next_child_size =
+			child.size << (1 + std::max(param.farmesh_quality_pow, param.cell_size_pow));
 	if (distance >= next_child_size) {
-		return child_t{.pos{child.pos}, .size{child.size >> cell_size_pow}};
+		return make_result(child);
 	}
 	for (const auto &child : {
 				 child_t{.pos{child.pos}, .size = childSize},
@@ -195,9 +219,7 @@ std::optional<child_t> find(const v3tpos_t &block_pos, const v3tpos_t &player_po
 						 .size = childSize},
 		 }) {
 
-		if (const auto res = find(block_pos, player_pos, child, cell_size_pow,
-					farmesh_quality_pow, depth + 1);
-				res) {
+		if (const auto res = find(param, child, depth + 1); res) {
 			return res;
 		}
 	}
@@ -253,17 +275,20 @@ child_t tree_params_to_child(
 }
 
 block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos_t &ppos,
-		const v3bpos_t &blockpos, uint8_t cell_size_pow)
+		const v3bpos_t &blockpos, uint8_t cell_size_pow, bool cell_each)
 {
 	const auto blockpos_aligned_cell = align_shift(blockpos, cell_size_pow);
 	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,
-			draw_control.farmesh_quality_pow);
+	const auto res = find({.block_pos{blockpos_aligned_cell.X, blockpos_aligned_cell.Y,
+								   blockpos_aligned_cell.Z},
+								  .player_pos{ppos.X, ppos.Y, ppos.Z},
+								  .cell_size_pow{cell_size_pow},
+								  .farmesh_quality_pow{draw_control.farmesh_quality_pow},
+								  .cell_size_each{cell_each}},
+			start);
 	if (res) {
 		/*
 #if !USE_POS32
@@ -276,36 +301,36 @@ block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos
 			return {};
 #endif
 */
-		const auto step1 = rangeToStep(res->size);
-		if (cell_size_pow >= step1) {
-			return 0;
-		}
-		const auto step = step1 - cell_size_pow;
-		return step;
+		return res->step;
 	}
 	return 0; // TODO! fix intersection with cell_size_pow
 			  //return external_pow; //+ draw_control.cell_size_pow;
 }
 
 block_step_t getFarStep(const MapDrawControl &draw_control, const v3bpos_t &ppos,
-		const v3bpos_t &blockpos, const std::optional<uint8_t> &cell_size_pow)
+		const v3bpos_t &blockpos, const std::optional<uint8_t> &cell_size_pow,
+		bool cell_each)
 {
 	return getFarStepCellSize(draw_control, ppos, blockpos,
-			cell_size_pow.value_or(draw_control.cell_size_pow));
+			cell_size_pow.value_or(draw_control.cell_size_pow), cell_each);
 }
 
 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 MapDrawControl &draw_control, const std::optional<uint8_t> &cell_size_pow,
+		bool cell_each)
 {
 	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_pow);
+			{.block_pos{blockpos_aligned_cell.X, blockpos_aligned_cell.Y,
+					 blockpos_aligned_cell.Z},
+					.player_pos{ppos.X, ppos.Y, ppos.Z},
+					.cell_size_pow{cell_size_pow.value_or(draw_control.cell_size_pow)},
+					.farmesh_quality_pow{draw_control.farmesh_quality_pow},
+					.cell_size_each{cell_each}},
+			start);
 
 	if (res) {
 #if USE_POS32
@@ -336,7 +361,8 @@ struct each_param_t
 	const v3tpos_t &player_pos;
 	const uint8_t cell_size_pow;
 	const uint8_t farmesh_quality_pow;
-	const std::function<bool(const child_t &)> &func;
+	const bool cell_size_each{1};
+	const std::function<bool(const child_t &, const block_step_t &)> &func;
 	const bool two_d{false};
 };
 
@@ -348,11 +374,19 @@ void each(const each_param_t &param, const child_t &child)
 					std::abs((tpos_t)param.player_pos.Y - child.pos.Y - childSize),
 					std::abs((tpos_t)param.player_pos.Z - child.pos.Z - childSize)});
 
-	const auto next_child_size = child.size << (1 + param.farmesh_quality_pow);
+	const auto next_child_size =
+			child.size << std::max(
+					0, 1 + std::max(param.farmesh_quality_pow, param.cell_size_pow) -
+							   (param.cell_size_each ? 0 : param.cell_size_pow));
 	if (distance >= next_child_size) {
-		param.func(child_t{.pos{child.pos},
-				.size{child.size >> param.cell_size_pow}
-				});
+		param.func(
+				child_t{
+						.pos{child.pos},
+						.size{child.size >>
+								(param.cell_size_each ? 0 : param.cell_size_pow)},
+						.step{rangeToStep(child.size)},
+				},
+				rangeToStep(child.size));
 		return;
 	}
 
@@ -391,8 +425,14 @@ void each(const each_param_t &param, const child_t &child)
 		}
 
 		if (child.size < (1 << (param.cell_size_pow))) {
-			if (param.func(child_t{.pos{child.pos},
-						.size{child.size >> param.cell_size_pow}}))
+			if (param.func(
+						child_t{
+								.pos{child.pos},
+								.size{child.size >>
+										(param.cell_size_each ? 0 : param.cell_size_pow)},
+								.step{rangeToStep(child.size)},
+						},
+						rangeToStep(child.size)))
 			{
 				return;
 			}
@@ -404,23 +444,28 @@ 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_pow, pos_t two_d,
-		const std::function<bool(const v3bpos_t &, const bpos_t &)> &func)
+		uint8_t farmesh_quality_pow, pos_t two_d, bool cell_each,
+		const std::function<bool(const v3bpos_t &, const bpos_t &, const block_step_t &)>
+				&func)
 {
-
 	tree_params_t tree_params{.tree_pow{farmesh_to_tree_pow(farmesh)}};
 	const auto start = tree_params_to_child(tree_params, ppos, two_d);
-	const auto func_convert = [&func](const child_t &child) {
-		return func(v3bpos_t(child.pos.X, child.pos.Y, child.pos.Z), child.size);
+	const auto func_convert = [&func](const child_t &child, const block_step_t &step) {
+		return func(v3bpos_t(child.pos.X, child.pos.Y, child.pos.Z), child.size, step);
 	};
 
 	// DUMP(start.pos, start.size, tree_align);
-
-	each({.player_pos{ppos.X, ppos.Y, ppos.Z},
-				 .cell_size_pow{cell_size_pow},
-				 .farmesh_quality_pow{farmesh_quality_pow},
-				 .func{func_convert},
-				 .two_d{static_cast<bool>(two_d)}},
+	each(
+			{
+					.player_pos{ppos.X, ppos.Y, ppos.Z},
+					.cell_size_pow{cell_size_pow},
+					.farmesh_quality_pow{farmesh_quality_pow},
+					.cell_size_each{cell_each},
+					.func{func_convert},
+					.two_d{
+							static_cast<bool>(two_d),
+					},
+			},
 			start);
 }
 

src/fm_far_calc.h

@@ -45,20 +45,21 @@ struct tree_params
 block_step_t getLodStep(const MapDrawControl &draw_control,
 		const v3bpos_t &playerblockpos, const v3bpos_t &block_pos, const pos_t speedf);
 block_step_t getFarStepCellSize(const MapDrawControl &draw_control, const v3bpos_t &ppos,
-		const v3bpos_t &blockpos, uint8_t cell_size_pow);
+		const v3bpos_t &blockpos, uint8_t cell_size_pow, bool cell_each = false);
 block_step_t getFarStep(const MapDrawControl &draw_control,
 		const v3bpos_t &playerblockpos, const v3bpos_t &block_pos,
-		const std::optional<uint8_t> &cell_size_pow = {});
+		const std::optional<uint8_t> &cell_size_pow = {}, bool cell_each = false);
 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,
-		const MapDrawControl &draw_control);
+		const MapDrawControl &draw_control, bool cell_each = false);
 v3bpos_t getFarActualBlockPos(const v3bpos_t &blockpos, const v3bpos_t &playerblockpos,
 		const MapDrawControl &draw_control,
-		const std::optional<uint8_t> &cell_size_pow = {});
+		const std::optional<uint8_t> &cell_size_pow = {}, bool cell_each = false);
 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_pow, pos_t two_d,
-		const std::function<bool(const v3bpos_t &, const bpos_t &)> &func);
+		uint8_t farmesh_quality_pow, pos_t two_d, bool cell_each,
+		const std::function<bool(const v3bpos_t &, const bpos_t &, const block_step_t &)>
+				&func);
 uint8_t rangeToStep(const int range);