18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 21:24:58 +01:00

fix(editor): the orthophoto only on the chunks of the heightmap terrain in memory, and laid onto the ground again once it comes (#417)

* fix(editor): the orthophoto only on the chunks of the heightmap terrain in memory, and laid onto the ground again once it comes

Right after the editor started, the tiles of the orthophoto came from the disk cache at once and were fitted to the ground before
the chunks of the heightmap terrain had come (on IRT the orthophoto was on at 24.5 s, the first chunk came at 24.5 s, the last one
at 85 s). A tile with no ground under it, and none beside, stayed flat at the height of the layer (0 m, some 230 m under IRT);
one partly over the ground had its holes filled from the points beside. Neither was fitted again when the ground came: only the
guessed tiles were, by their middle and corners alone, and a tile with no chunk under it at all never got any. The overlay,
drawn over everything, then slid with the camera (WASD, turning) instead of lying on the ground. Turning the orthophoto off and on
hid it: by then the terrain was in and the tiles took their heights from it or from the edges of the tiles beside.

- With the heightmap terrain (the terrain streamer active), a tile of the orthophoto, of the WMS layers and of Ctrl+~ is asked
  for and shown only where its chunks are in memory (terrain_streamer::ground_under): it waits while one is still to come, and
  where no chunk is nor will be there's no imagery at all. A scenery without the heightmap terrain is as before.
- A tile remembers the points of its grid the ground didn't answer and is fitted again once the ground comes under any of them
  (every second point and the edges), not only the guessed tiles.

No asset changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(editor): the orthophoto waits only for the chunks that will come at this distance, and lies on the other ground or the guess elsewhere

After the reviews of maj00r and jerrrrycho on #417:

- A tile is no longer dropped where no chunk of the heightmap terrain is nor will be. There it lies on whatever ground there is (terrain models) or on the NMT guess, as on master; a scenery with a few chunks, or with chunks removed, keeps its imagery around them.

- A chunk counts as still to come only while it's being loaded or lies within the circle the streamer walks around the camera. The corners of the imagery in the 3D view, beyond that circle, no longer wait for chunks that won't load there: they lie on the guess and are sampled again when the camera comes near and the chunk loads.

- terrain_streamer::ground_under() (true / false / empty) became ground_coming() (bool), the cover source of the orthophoto the coming source, and on_ground() waits_for_ground(), which only holds back a new tile.

- In the scene (in_scene), the points a steep triangle leaves without a height but the heightmap terrain answers aren't kept as unanswered, so the tile isn't sampled again on every chunk that comes. The holes are counted from the heights again, as on master.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
pol102
2026-11-21 10:39:53 +01:00
committed by GitHub
parent c5d14e93ac
commit c556c4c8fd
5 changed files with 118 additions and 13 deletions

View File

@@ -937,23 +937,47 @@ void editor_orthophoto::ground_arrived()
{
if (!m_height)
return;
for (auto &entry : m_tiles)
for (auto &[key, t] : m_tiles)
{
auto &t{entry.second};
if (!t.grounded || !t.guessed)
continue;
// the middle and the corners: a chunk of the terrain is much larger than a tile, it covers some of these when it comes. A tile
// lying flat, with nothing to go by, also goes onto the model once it's in
glm::dvec2 const corner = tile_corner(entry.first);
for (auto const &[u, v] : {std::pair{0.5, 0.5}, std::pair{0.0, 0.0}, std::pair{1.0, 0.0}, std::pair{0.0, 1.0}, std::pair{1.0, 1.0}})
if (double y; m_height(corner.x - u * tile_size, corner.y - v * tile_size, y) || (t.heights.empty() && m_guess && m_guess(corner.x - u * tile_size, corner.y - v * tile_size, y)))
{
t.grounded = false;
break;
}
if (t.grounded && ground_came(key, t))
t.grounded = false;
}
}
bool editor_orthophoto::waits_for_ground(tile_key const &Key) const
{
// a tile laid out already stays, sampled again when its ground comes (ground_came)
if (!m_coming || m_tiles.contains(Key))
return false;
glm::dvec2 const corner = tile_corner(Key);
return m_coming(corner - glm::dvec2{tile_size}, corner);
}
bool editor_orthophoto::ground_came(tile_key const &Key, tile const &Tile) const
{
glm::dvec2 const corner = tile_corner(Key);
// a tile lying flat, with nothing to go by, also goes onto the model once it's in: the middle and the corners
if (Tile.guessed && Tile.heights.empty() && m_guess)
for (auto const &[u, v] : {std::pair{0.5, 0.5}, std::pair{0.0, 0.0}, std::pair{1.0, 0.0}, std::pair{0.0, 1.0}, std::pair{1.0, 1.0}})
if (double y; m_guess(corner.x - u * tile_size, corner.y - v * tile_size, y))
return true;
// the points the ground didn't answer, every second one of the grid (16 m) and the edges: a chunk of the terrain is about as
// large as a tile and comes over a part of it, often a band along a side; partly answered tiles count too, not only the guessed
static_assert(ground_grid % 2 == 0, "the edges of the grid are among its even points");
int constexpr samples{ground_grid + 1};
double constexpr step{tile_size / ground_grid};
for (auto const index : Tile.unanswered)
{
int const i{index % samples};
int const j{index / samples};
if (i % 2 != 0 || j % 2 != 0)
continue;
if (double y; m_height(corner.x - i * step, corner.y - j * step, y))
return true;
}
return false;
}
void editor_orthophoto::detach_scene()
{
for (auto &entry : m_tiles)
@@ -1247,6 +1271,7 @@ void editor_orthophoto::sample_ground(tile_key const &Key, tile &Tile)
Tile.scene_dirty = true;
Tile.heights.clear();
Tile.surface.clear();
Tile.unanswered.clear();
glm::dvec2 const corner = tile_corner(Key);
glm::dvec2 const min(corner.x - tile_size, corner.y - tile_size);
@@ -1318,6 +1343,21 @@ void editor_orthophoto::sample_ground(tile_key const &Key, tile &Tile)
}
}
// the points the ground didn't answer: the ground coming there later (the terrain loaded after the imagery, which comes from the
// disk cache at once) has the tile sampled again, rather than left at the heights filled in or guessed now
Tile.unanswered.clear();
auto const columns{static_cast<std::size_t>(samples)};
for (std::size_t index = 0; index < heights.size(); ++index)
{
if (heights[index] != no_height)
continue;
// in the scene the heights come from the triangles, and a steep spot (a wall, a quarry face) gives none: where the heightmap
// terrain answers the point, its ground is there already, and ground_came() would find it again on every chunk that comes
if (double y; surface && m_height && m_height(corner.x - static_cast<double>(index % columns) * step, corner.y - static_cast<double>(index / columns) * step, y))
continue;
Tile.unanswered.push_back(static_cast<std::uint16_t>(index));
}
// holes (places without ground) take the average of their neighbours, spreading inwards
std::size_t missing = std::count(heights.begin(), heights.end(), no_height);
if (missing == heights.size())
@@ -1653,6 +1693,8 @@ void editor_orthophoto::update(glm::dvec3 const &Camera)
}
continue;
}
if (waits_for_ground(key))
continue;
tile &t = m_tiles[key];
if (!in_service_area(key.first, key.second))
t.empty = true;

View File

@@ -120,6 +120,10 @@ class editor_orthophoto
// the heights the ground will have where there's none yet, as of the terrain model on its way: a tile laid out before its
// ground comes lies there, or level with the tiles beside, rather than at the height of the layer far below or above
void guess_source(height_query Query) { m_guess = std::move(Query); }
// true while the ground under an XZ rectangle (Min/Max are x,z) is still to come. A new tile there waits for it, rather than
// being laid out at the height of the layer; elsewhere it lies on whatever ground there is, or on the guess, as without it
using coming_query = std::function<bool(glm::dvec2 const &Min, glm::dvec2 const &Max)>;
void coming_source(coming_query Query) { m_coming = std::move(Query); }
// the area the imagery is downloaded in, a polygon of PUWG 1992 (easting, northing): its tiles go to the disk cache in the
// background, the products the settings ask for, and no tile outside it is asked for around the camera. Empty: no area, the
// tiles around the camera as before
@@ -239,6 +243,9 @@ class editor_orthophoto
float height_max{0.0f};
std::vector<glm::dvec3> surface; // upward facing ground triangles clipped to the tile (3 vertices each)
bool guessed{false}; // no ground under it when sampled: the heights guessed, from the terrain model or the tiles beside
// the points of the grid of the heights the ground didn't answer when sampled (rows north->south, as heights): filled from
// the points beside or guessed, and sampled again once the ground comes under one of them
std::vector<std::uint16_t> unanswered;
// scene geometry
scene::basic_section *section{nullptr}; // section holding the shape (nullptr = not in the scene)
scene::basic_cell *cell{nullptr}; // set instead of the section's shape list when the shape is translucent
@@ -262,6 +269,10 @@ class editor_orthophoto
void release_tile(tile &Tile);
texture_slot acquire_slot();
void sample_ground(tile_key const &Key, tile &Tile);
// the ground has come under a point of the tile which had none when it was sampled
bool ground_came(tile_key const &Key, tile const &Tile) const;
// a new tile isn't asked for yet: the ground under it is still to come
bool waits_for_ground(tile_key const &Key) const;
// the height of the ground sampled under a tile beside Own at the point, the tiles with guessed heights left out
bool sampled_height(tile_key const &Own, double const X, double const Z, float &Height) const;
void build_shape(tile_key const &Key, tile &Tile);
@@ -281,6 +292,7 @@ class editor_orthophoto
ground_query m_ground;
height_query m_height;
height_query m_guess;
coming_query m_coming;
scene::basic_region *m_region{nullptr}; // region the scene geometry was put into
std::multimap<std::size_t, gfx::geometry_handle> m_free_chunks; // geometry chunks by capacity, reused between tiles
// the scene opacity is baked into the textures, which means reading the tiles again; applied once the value settles

View File

@@ -20,6 +20,7 @@ http://mozilla.org/MPL/2.0/.
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <filesystem>
terrain_streamer EditorTerrain;
@@ -907,6 +908,44 @@ bool terrain_streamer::owns(gfx::geometry_handle const &Geometry) const
return false;
}
bool terrain_streamer::in_walk(chunk_key const &Key) const
{
// the circle update() walks around the camera and around where it's heading
auto const within = [this, &Key](chunk_key const &Centre) {
auto const dx{Key.first - Centre.first};
auto const dz{Key.second - Centre.second};
return std::abs(dx) <= m_walkradius && std::abs(dz) <= m_walkradius && dx * dx + dz * dz <= (m_walkradius + 1) * (m_walkradius + 1);
};
return within(m_walkhere) || within(m_walkthere);
}
bool terrain_streamer::chunk_coming(chunk_key const &Key) const
{
if (m_chunks.contains(Key) || m_removed.contains(Key))
return false;
if (m_loading.contains(Key))
return true;
// a chunk the walk doesn't reach at this distance isn't loaded, so it isn't waited for: it's taken in when the camera comes near
if (false == in_walk(Key))
return false;
// still to come while its pack isn't read yet, or it's in its pack; not there where the pack is read without it
auto const pack{m_packs.find(heightmap::pack_of(Key))};
if (pack == m_packs.end() || pack->second.status == pack_state::state::unknown || pack->second.status == pack_state::state::loading)
return true;
return pack->second.status == pack_state::state::ready && pack->second.file->has(Key);
}
bool terrain_streamer::ground_coming(glm::dvec2 const &Low, glm::dvec2 const &High) const
{
auto const first{heightmap::chunk_at(Low.x, Low.y)};
auto const last{heightmap::chunk_at(High.x, High.y)};
for (auto z{std::min(first.second, last.second)}; z <= std::max(first.second, last.second); ++z)
for (auto x{std::min(first.first, last.first)}; x <= std::max(first.first, last.first); ++x)
if (chunk_coming(chunk_key{x, z}))
return true;
return false;
}
bool terrain_streamer::exists(chunk_key const &Key) const
{
if (m_chunks.count(Key) > 0)

View File

@@ -81,6 +81,10 @@ class terrain_streamer
std::string stats() const;
// chunks in the pack files and in memory, less the removed ones; the files known so far
bool exists(chunk_key const &Key) const;
// true while a chunk over an XZ rectangle (Low/High are x,z) is still to come at this distance of the camera: being loaded, or
// within the walk around the camera and in its pack or with its pack not read yet. False where all of them are in memory, where
// none is nor will be, and where the walk doesn't reach
bool ground_coming(glm::dvec2 const &Low, glm::dvec2 const &High) const;
// editing; the chunks changed are written to the files by save()
heightmap::manifest const &manifest() const { return m_manifest; }
@@ -235,6 +239,11 @@ class terrain_streamer
scene::basic_cell *cell{nullptr};
};
// within the circle of chunks the last walk of update() asked for
bool in_walk(chunk_key const &Key) const;
// the chunk is still to come at this distance of the camera (see ground_coming)
bool chunk_coming(chunk_key const &Key) const;
void start_workers();
void stop_workers();
void worker();