bdnugget/freeminer
1
0 Fork 0
mirror of https://github.com/bdnugget/freeminer.git synced 2026-11-07 06:57:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

far fixes

Browse Source
This commit is contained in:
proller committed 2026-02-09 23:43:52 +01:00
1 parent 9157db4401
commit 3134cf57ee
8 files changed
+122 -126
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/client/camera.cpp
+1 -1
View File
@@ -607,7 +607,7 @@ void Camera::updateViewingRange()
viewing_range = farmesh;
}
m_cameranode->setFarValue(std::fmax(2000, viewing_range * 2) * BS);
m_cameranode->setFarValue(std::fmax(2000, viewing_range * 3) * BS);
}
void Camera::setDigging(s32 button)
src/client/clientmap.cpp
+1 -1
View File
@@ -1139,7 +1139,7 @@ void ClientMap::updateDrawListFm(float dtime, unsigned int max_cycle_ms)
{
blocks_skip_farmesh.emplace(getFarActualBlockPos(
bp, getNodeBlockPos(far_blocks_last_cam_pos), m_control));
m_control, getNodeBlockPos(far_blocks_last_cam_pos), bp ));
}
if (mesh) {
src/client/fm_client.cpp
+2 -2
View File
@@ -299,8 +299,8 @@ void Client::handleCommand_BlockDataFm(NetworkPacket *pkt)
auto &client_map = getEnv().getClientMap();
const auto &control = client_map.getControl();
const auto bpos = block->getPos();
if (!inFarGrid(bpos, getNodeBlockPos(client_map.far_blocks_last_cam_pos),
control)) {
if (!inFarGrid(control, getNodeBlockPos(client_map.far_blocks_last_cam_pos),
bpos, step)) {
return;
}
createFarMesh(block);
src/client/fm_far_container.cpp
+12 -11
View File
@@ -21,17 +21,18 @@ 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 block_pos = getNodeBlockPos(pos);
auto &client_map = m_client->getEnv().getClientMap();
const auto player_bpos = getNodeBlockPos(client_map.far_blocks_last_cam_pos);
const auto player_block_pos = getNodeBlockPos(client_map.far_blocks_last_cam_pos);
const auto &control = client_map.getControl();
const auto step = getFarStep(control, player_bpos, bpos, {}, true
// , 0
);
const v3bpos_t bpos_aligned =
getFarActualBlockPos(bpos, player_bpos, control, {}, true
// , 0
);
const auto tree_result = getFarParams(control, player_block_pos, block_pos);
if (!tree_result) {
return m_mg->visible_transparent;
}
const auto &step = tree_result->step;
const v3bpos_t &bpos_aligned = tree_result->pos;
MapBlockPtr block;
const auto step_block_pos = std::make_pair(step, bpos_aligned);
if (block_cache && step_block_pos == block_cache_p) {
@@ -93,8 +94,8 @@ const MapNode &FarContainer::getNodeRefUnsafe(const v3pos_t &pos)
const v3pos_t relpos = pos - bpos_aligned * MAP_BLOCKSIZE;
const auto &relpos_shift = step;
const auto relpos_shifted = v3pos_t(relpos.X >> relpos_shift,
relpos.Y >> relpos_shift, relpos.Z >> relpos_shift);
const auto relpos_shifted = v3pos_t{relpos.X >> relpos_shift,
relpos.Y >> relpos_shift, relpos.Z >> relpos_shift};
const auto &n = block->getNodeNoLock(relpos_shifted);
if (n.getContent() != CONTENT_IGNORE) {
return n;
src/client/fm_farmesh.cpp
+3 -3
View File
@@ -65,8 +65,8 @@ void FarMesh::makeFarBlock(const v3bpos_t &blockpos, block_step_t step, bool bne
const auto blockpos_actual =
blockpos_actual_optional.has_value() ? blockpos_actual_optional.value()
: bnear ? blockpos
: getFarActualBlockPos(blockpos,
getNodeBlockPos(m_camera_pos_aligned), draw_control);
: getFarActualBlockPos(draw_control,
getNodeBlockPos(m_camera_pos_aligned), blockpos);
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);
@@ -154,7 +154,7 @@ void FarMesh::makeFarBlocks(const v3bpos_t &blockpos, block_step_t step)
for (const auto &dir : use_dirs) {
const auto bpos_dir = blockpos + dir * step_width;
const auto bpos = getFarActualBlockPos(
bpos_dir, getNodeBlockPos(m_camera_pos_aligned), control);
control, getNodeBlockPos(m_camera_pos_aligned), bpos_dir);
const auto block_step_correct =
getFarStep(control, getNodeBlockPos(m_camera_pos_aligned), bpos);
makeFarBlock(bpos, block_step_correct, {}, bpos);
src/client/hud.cpp
+11 -7
View File
@@ -936,14 +936,15 @@ void Hud::drawBlockBounds()
// 3s16 pos = player->getStandingNodePos();
if (m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN || m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN_EACH) {
const auto is_each_mode= m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN_EACH;
if (m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN || is_each_mode) {
const auto offset = intToFloat(client->getCamera()->getOffset(), BS);
//s8 radius = m_block_bounds_mode == BLOCK_BOUNDS_NEAR ? 2 : 0;
const auto halfNode = v3opos_t(BS, BS, BS) / 2.0f;
const auto &client_map = client->getEnv().getClientMap();
const auto & far_blocks = client_map.m_far_blocks;
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) {
@@ -963,12 +964,12 @@ void Hud::drawBlockBounds()
const auto &mesh_step = block->far_step;
int g = 0;
if (!inFarGrid(blockPos,
getNodeBlockPos(client_map.far_blocks_last_cam_pos),
client_map.getControl(),
m_block_bounds_mode == BLOCK_BOUNDS_FAR_DRAWN_EACH)) {
if (!inFarGrid(client_map.getControl(),
getNodeBlockPos(client_map.far_blocks_last_cam_pos), blockPos,
mesh_step, is_each_mode)) {
// DUMP("Not in grid", blockPos, block->far_step, mesh_step, block->getTimestamp(), client->getEnv() .getClientMap() .m_far_blocks_last_cam_pos);
// continue;
if (is_each_mode)
continue;
g += 50;
}
@@ -985,6 +986,9 @@ void Hud::drawBlockBounds()
lod_step = mesh->lod_step;
far_step = mesh->far_step;
}
if (is_each_mode) {
fscale = 1 << block->far_step;
}
const aabb3f box(oposToV3f(intToFloat((blockPos)*MAP_BLOCKSIZE, BS) -
offset - halfNode + 1),
oposToV3f(intToFloat(((blockPos)*MAP_BLOCKSIZE) +
src/fm_far_calc.cpp
+63 -88
View File
@@ -130,12 +130,14 @@ using v3tpos_t = v3bpos_t;
using tpos_t = int32_t;
using v3tpos_t = v3s32;
#endif
bool inFarGrid(const v3bpos_t &blockpos, const v3bpos_t &playerblockpos,
const MapDrawControl &draw_control, bool cell_each)
bool inFarGrid(const MapDrawControl &draw_control, const v3bpos_t &player_block_pos,
const v3bpos_t &blockpos, const block_step_t step, bool cell_each)
{
const auto act =
getFarActualBlockPos(blockpos, playerblockpos, draw_control, {}, cell_each);
return act == blockpos;
const auto res = getFarParams(draw_control, player_block_pos, blockpos, cell_each);
if (!res) {
return false;
}
return res->pos == blockpos && res->step == step;
}
struct find_param_t
@@ -151,15 +153,14 @@ struct child_t
{
v3tpos_t pos;
tpos_t size;
block_step_t step;
};
std::optional<child_t> find(const find_param_t &param,
std::optional<tree_result_t> find(const find_param_t &param,
const child_t &child,
uint16_t depth = 0)
{
const auto make_result = [&param](const auto &child) {
return child_t{
return tree_result_t{
.pos{child.pos},
.size{child.size >> (param.cell_size_each ? 0 : param.cell_size_pow)},
.step{rangeToStep(child.size)},
@@ -185,10 +186,12 @@ std::optional<child_t> find(const find_param_t &param,
}
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))});
const 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))}) >>
param.cell_size_pow)
<< param.cell_size_pow;
const auto next_child_size =
child.size << (1 + std::max(param.farmesh_quality_pow, param.cell_size_pow));
if (distance >= next_child_size) {
@@ -274,64 +277,39 @@ child_t tree_params_to_child(
.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, 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({.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
if (res->pos.X > MAX_MAP_GENERATION_LIMIT ||
res->pos.X < -MAX_MAP_GENERATION_LIMIT ||
res->pos.Y > MAX_MAP_GENERATION_LIMIT ||
res->pos.Y < -MAX_MAP_GENERATION_LIMIT ||
res->pos.Z > MAX_MAP_GENERATION_LIMIT ||
res->pos.Z < -MAX_MAP_GENERATION_LIMIT)
return {};
#endif
*/
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,
bool cell_each)
{
return getFarStepCellSize(draw_control, ppos, blockpos,
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,
bool cell_each)
std::optional<tree_result_t> getFarParams(const MapDrawControl &draw_control,
const v3bpos_t &player_block_pos, const v3bpos_t &blockpos, 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 start = tree_params_to_child(tree_params, player_block_pos);
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.value_or(draw_control.cell_size_pow)},
.player_pos{
player_block_pos.X, player_block_pos.Y, player_block_pos.Z},
.cell_size_pow{draw_control.cell_size_pow},
.farmesh_quality_pow{draw_control.farmesh_quality_pow},
.cell_size_each{cell_each}},
start);
return res;
}
block_step_t getFarStep(const MapDrawControl &draw_control,
const v3bpos_t &player_block_pos, const v3bpos_t &blockpos, bool cell_each)
{
const auto res = getFarParams(draw_control, player_block_pos, blockpos, cell_each);
if (res) {
return res->step;
}
return 0;
}
v3bpos_t getFarActualBlockPos(const MapDrawControl &draw_control,
const v3bpos_t &player_block_pos, const v3bpos_t &blockpos, const bool cell_each)
{
const auto res = getFarParams(draw_control, player_block_pos, blockpos, cell_each);
if (res) {
#if USE_POS32
return res->pos;
@@ -349,10 +327,11 @@ v3bpos_t getFarActualBlockPos(const v3bpos_t &blockpos,
return v3bpos_t(res->pos.X, res->pos.Y, res->pos.Z);
#endif
}
const tree_params_t tree_params{.tree_pow{farmesh_to_tree_pow(draw_control.farmesh)}};
const auto &ext_align = tree_params.external_pow; // + cell_size_pow;
const v3bpos_t ret((blockpos.X >> ext_align) << ext_align,
const v3bpos_t ret{(blockpos.X >> ext_align) << ext_align,
(blockpos.Y >> ext_align) << ext_align,
(blockpos.Z >> ext_align) << ext_align);
(blockpos.Z >> ext_align) << ext_align};
return ret;
}
@@ -362,31 +341,28 @@ struct each_param_t
const uint8_t cell_size_pow;
const uint8_t farmesh_quality_pow;
const bool cell_size_each{1};
const std::function<bool(const child_t &, const block_step_t &)> &func;
const std::function<bool(const tree_result_t &)> &func;
const bool two_d{false};
};
void each(const each_param_t &param, const child_t &child)
{
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)});
const 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))}) >>
param.cell_size_pow)
<< param.cell_size_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));
child.size << (1 + std::max(param.farmesh_quality_pow, param.cell_size_pow));
if (distance >= next_child_size) {
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));
param.func(tree_result_t{
.pos{child.pos},
.size{child.size >> (param.cell_size_each ? 0 : param.cell_size_pow)},
.step{rangeToStep(child.size)},
});
return;
}
@@ -425,14 +401,12 @@ 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_each ? 0 : param.cell_size_pow)},
.step{rangeToStep(child.size)},
},
rangeToStep(child.size)))
if (param.func(tree_result_t{
.pos{child.pos},
.size{child.size >>
(param.cell_size_each ? 0 : param.cell_size_pow)},
.step{rangeToStep(child.size)},
}))
{
return;
}
@@ -450,8 +424,9 @@ void runFarAll(const v3bpos_t &ppos, uint8_t cell_size_pow, int farmesh,
{
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, const block_step_t &step) {
return func(v3bpos_t(child.pos.X, child.pos.Y, child.pos.Z), child.size, step);
const auto func_convert = [&func](const tree_result_t &child) {
return func(
v3bpos_t{child.pos.X, child.pos.Y, child.pos.Z}, child.size, child.step);
};
// DUMP(start.pos, start.size, tree_align);
src/fm_far_calc.h
+29 -13
View File
@@ -42,24 +42,40 @@ struct tree_params
const uint16_t external_pow = tree_pow - 2;
};
struct tree_result_t
{
v3bpos_t pos;
bpos_t size;
block_step_t step;
};
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, bool cell_each = false);
const v3bpos_t &player_block_pos, const v3bpos_t &block_pos, const pos_t speedf);
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 = {}, bool cell_each = false);
const v3bpos_t &player_block_pos, const v3bpos_t &block_pos,
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, 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 = {}, bool cell_each = false);
const v3bpos_t &player_block_pos, const v3bpos_t &block_pos);
bool inFarGrid(const MapDrawControl &draw_control, const v3bpos_t &player_block_pos,
const v3bpos_t &blockpos, const block_step_t step, const bool cell_each = false);
std::optional<tree_result_t> getFarParams(const MapDrawControl &draw_control,
const v3bpos_t &player_block_pos, const v3bpos_t &blockpos,
bool cell_each = false);
v3bpos_t getFarActualBlockPos(const MapDrawControl &draw_control,
const v3bpos_t &player_block_pos, const v3bpos_t &blockpos,
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,
const MapDrawControl &draw_control, const v3bpos_t &player_block_pos);
void runFarAll(const v3bpos_t &player_block_pos, uint8_t cell_size_pow, int farmesh,
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);