wip

src/client/clientmap.h

@@ -37,7 +37,7 @@ struct MapDrawControl
 
 	// freeminer:
 	int32_t farmesh{30000};
-	uint16_t farmesh_quality{};
+	uint8_t farmesh_quality{};
 	bool farmesh_stable{};
 	int32_t lodmesh{4};
 	int cell_size{1};

src/client/fm_client.cpp

@@ -252,8 +252,9 @@ void Client::handleCommand_BlockDataFm(NetworkPacket *pkt)
 	} else {
 		static thread_local const auto farmesh_server =
 				g_settings->getU16("farmesh_server");
-		if (!farmesh_server)
+		if (!farmesh_server){
 			return;
+		}
 
 		auto &far_blocks_storage = getEnv().getClientMap().far_blocks_storage[step];
 		{
@@ -340,19 +341,19 @@ void Client::handleCommand_BlockDataFm(NetworkPacket *pkt)
 
 void Client::sendDrawControl()
 {
-	MSGPACK_PACKET_INIT((int)TOSERVER_DRAWCONTROL, 7);
+	MSGPACK_PACKET_INIT((int)TOSERVER_DRAWCONTROL, 3);
 	const auto &draw_control = m_env.getClientMap().getControl();
 	PACK(TOSERVER_DRAWCONTROL_WANTED_RANGE, (int32_t)draw_control.wanted_range);
-	PACK(TOSERVER_DRAWCONTROL_RANGE_ALL, draw_control.range_all);
+	//PACK(TOSERVER_DRAWCONTROL_RANGE_ALL, draw_control.range_all);
 	PACK(TOSERVER_DRAWCONTROL_FARMESH, draw_control.farmesh);
-	PACK(TOSERVER_DRAWCONTROL_LODMESH, draw_control.lodmesh);
-	PACK(TOSERVER_DRAWCONTROL_FOV, draw_control.fov);
+	//PACK(TOSERVER_DRAWCONTROL_LODMESH, draw_control.lodmesh);
+	//PACK(TOSERVER_DRAWCONTROL_FOV, draw_control.fov);
 	//PACK(TOSERVER_DRAWCONTROL_BLOCK_OVERFLOW, false /*draw_control.block_overflow*/);
-	PACK(TOSERVER_DRAWCONTROL_LODMESH, draw_control.lodmesh);
+	//PACK(TOSERVER_DRAWCONTROL_LODMESH, draw_control.lodmesh);
 	PACK(TOSERVER_DRAWCONTROL_FARMESH_QUALITY, draw_control.farmesh_quality);
 
 
-	NetworkPacket pkt(TOSERVER_DRAWCONTROL, 0);
+	NetworkPacket pkt(TOSERVER_DRAWCONTROL, buffer.size());
 	pkt.putLongString({buffer.data(), buffer.size()});
 	Send(&pkt);
 }

src/client/fm_farmesh.cpp

@@ -18,6 +18,7 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with Freeminer.  If not, see <http://www.gnu.org/licenses/>.
 */
+
 #include <array>
 #include <cstddef>
 #include <cstdint>
@@ -264,6 +265,29 @@ auto align_shift(auto pos, const auto amount)
 	(pos.Z >>= amount) <<= amount;
 	return pos;
 }
+
+int FarMesh::go_container()
+{
+	const auto &draw_control = m_client->getEnv().getClientMap().getControl();
+	const auto cbpos = getNodeBlockPos(m_camera_pos_aligned);
+
+	runFarAll(draw_control, cbpos, draw_control.cell_size_pow, false,
+			[this](const v3bpos_t &bpos, const bpos_t &size) -> bool {
+				const block_step_t step = log(size) / log(2);
+				const auto contains = m_client->getEnv()
+											  .getClientMap()
+											  .far_blocks_storage[step]
+											  .contains(bpos);
+
+				if (contains) {
+					makeFarBlock(bpos, step);
+				}
+
+				return false;
+			});
+	return 0;
+}
+
 int FarMesh::go_flat()
 {
 	const auto &draw_control = m_client->getEnv().getClientMap().getControl();
@@ -566,12 +590,16 @@ uint8_t FarMesh::update(v3opos_t camera_pos,
 				if (!plane_processed[i].processed) {
 					continue;
 				}
+
 				++planes_processed;
 				async[i].step([this, i = i]() {
 					plane_processed[i].processed = go_direction(i);
 				});
 			}
 		}
+
+		go_container();
+
 		planes_processed_last = planes_processed;
 
 		if (planes_processed) {

src/client/fm_farmesh.h

@@ -112,6 +112,7 @@ class FarMesh
 	std::atomic_uint last_distance_max{};
 	int go_direction(const size_t dir_n);
 	int go_flat();
+	int go_container();
 	uint32_t far_iteration_complete{};
 	bool complete_set{};
 	uint32_t collect_reset_timestamp{static_cast<uint32_t>(-1)};

src/clientiface.h

@@ -256,6 +256,7 @@ class RemoteClient
 	std::atomic_bool range_all{};
 	std::atomic_int farmesh{};
 	uint8_t farmesh_quality{};
+	bool have_farmesh_quality{};
 	float fov{72};
 	//bool block_overflow;
 	ServerEnvironment *m_env{};

src/defaultsettings.cpp

@@ -196,6 +196,10 @@ void fm_set_default_settings(Settings *settings) {
 	//settings->setDefault("client_mesh_chunk", std::to_string(std::max<int>(1, Thread::getNumberOfProcessors() / 4)));
 	settings->setDefault("client_mesh_chunk","1");
 
+	if (slow || android) {
+		settings->setDefault("translucent_liquids", "false");
+	}
+
 	// Liquid
 	settings->setDefault("liquid_real", "true");
     settings->setDefault("liquid_step", "100");

src/fm_clientiface.cpp

@@ -1,6 +1,7 @@
-#include <cstdint>
-#include "clientiface.h"
+#include "client/clientmap.h"
+#include "client/fm_far_calc.h"
 #include "constants.h"
+#include "server/clientiface.h"
 #include "irr_v3d.h"
 #include "irrlichttypes.h"
 #include "map.h"
@@ -605,6 +606,51 @@ uint32_t RemoteClient::SendFarBlocks()
 			}
 		}
 
+		// TODO: why not have?
+		if (have_farmesh_quality) {
+			auto *player = m_env->getPlayer(peer_id);
+			if (!player)
+				return 0;
+
+			auto *sao = player->getPlayerSAO();
+			if (!sao)
+				return 0;
+
+			MapDrawControl draw_control;
+			draw_control.farmesh_quality = farmesh_quality;
+			auto playerpos = sao->getBasePosition();
+
+			auto cbpos = floatToInt(playerpos, BS * MAP_BLOCKSIZE);
+			runFarAll(draw_control, cbpos, draw_control.cell_size_pow, false,
+					[this, &ordered](const v3bpos_t &bpos, const bpos_t &size) -> bool {
+						block_step_t step = log(size) / log(2);
+						auto &[stepp, sent_ts] = far_blocks_requested[step][bpos];
+						if (sent_ts < 0) { // <=
+							return false;
+						}
+						const auto dbase = GetFarDatabase(m_env->m_map->m_db.dbase,
+								m_env->m_server->far_dbases, m_env->m_map->m_savedir,
+								step);
+						if (!dbase) {
+							sent_ts = -1;
+							return false;
+						}
+						const auto block =
+								loadBlockNoStore(m_env->m_map.get(), dbase, bpos);
+						if (!block) {
+							sent_ts = -1;
+							return false;
+						}
+
+						block->far_step = step;
+						//sent_ts = 0;
+						sent_ts = -1; //TODO
+						ordered.emplace(sent_ts - step, block);
+
+						return false;
+					});
+		}
+
 		// First with larger iteration and smaller step
 
 		for (auto it = ordered.rbegin(); it != ordered.rend(); ++it) {
@@ -613,6 +659,7 @@ uint32_t RemoteClient::SendFarBlocks()
 					peer_id, it->second, serialization_version, net_proto_version);
 		}
 	}
+
 	return sent_cnt;
 }
 

src/fm_server.cpp

@@ -545,12 +545,19 @@ void Server::handleCommand_Drawcontrol(NetworkPacket *pkt)
 	}
 	{
 		const auto lock = client->lock_unique_rec();
-		client->wanted_range = packet[TOSERVER_DRAWCONTROL_WANTED_RANGE].as<uint32_t>();
-		client->range_all = packet[TOSERVER_DRAWCONTROL_RANGE_ALL].as<bool>();
-		client->farmesh = packet[TOSERVER_DRAWCONTROL_FARMESH].as<uint32_t>();
+		if (packet.contains(TOSERVER_DRAWCONTROL_WANTED_RANGE))
+			client->wanted_range =
+					packet[TOSERVER_DRAWCONTROL_WANTED_RANGE].as<uint32_t>();
+		if (packet.contains(TOSERVER_DRAWCONTROL_RANGE_ALL))
+			client->range_all = packet[TOSERVER_DRAWCONTROL_RANGE_ALL].as<bool>();
+		if (packet.contains(TOSERVER_DRAWCONTROL_FARMESH))
+			client->farmesh = packet[TOSERVER_DRAWCONTROL_FARMESH].as<uint32_t>();
 		//client->lodmesh = packet[TOSERVER_DRAWCONTROL_LODMESH].as<u32>();
-		client->fov = packet[TOSERVER_DRAWCONTROL_FOV].as<float>();
-		client->farmesh_quality = packet[TOSERVER_DRAWCONTROL_FARMESH_QUALITY].as<uint8_t>();
+		if (packet.contains(TOSERVER_DRAWCONTROL_FARMESH_QUALITY)) {
+			client->farmesh_quality =
+					packet[TOSERVER_DRAWCONTROL_FARMESH_QUALITY].as<uint8_t>();
+			client->have_farmesh_quality = true;
+		}
 	}
 	//client->block_overflow = packet[TOSERVER_DRAWCONTROL_BLOCK_OVERFLOW].as<bool>();
 

src/network/serveropcodes.cpp

@@ -32,7 +32,7 @@ const ToServerCommandHandler toServerCommandTable[TOSERVER_NUM_MSG_TYPES] =
 // fm:
 	{ "TOSERVER_INIT_FM",                  TOSERVER_STATE_NOT_CONNECTED, &Server::handleCommand_InitFm }, // 0x03
 	{ "TOSERVER_GET_BLOCKS",               TOSERVER_STATE_INGAME,  &Server::handleCommand_GetBlocks}, // 0x04
-	{ "TOSERVER_DRAWCONTROL",              TOSERVER_STATE_STARTUP, &Server::handleCommand_Drawcontrol }, // 0x05
+	{ "TOSERVER_DRAWCONTROL",              TOSERVER_STATE_NOT_CONNECTED, &Server::handleCommand_Drawcontrol }, // 0x05
 // ==
 
 	null_command_handler, // 0x06