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 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>
330 lines
16 KiB
C++
330 lines
16 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <condition_variable>
|
|
#include <cstdint>
|
|
#include <deque>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <mutex>
|
|
#include <set>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <glm/glm.hpp>
|
|
|
|
#include "interfaces/ITexture.h" // texture_handle
|
|
#include "utilities/Classes.h" // material_handle
|
|
#include "rendering/geometrybank.h" // gfx::geometry_handle
|
|
|
|
bool editor_http_get(std::string const &Url, std::vector<std::uint8_t> &Out, std::string &Error);
|
|
|
|
namespace scene
|
|
{
|
|
class basic_region;
|
|
class basic_section;
|
|
class basic_cell;
|
|
} // namespace scene
|
|
|
|
// Editor aid: aerial orthophoto tiles from geoportal.gov.pl (GUGiK WMS), shown around the camera either
|
|
// on a horizontal plane or fitted onto the terrain.
|
|
//
|
|
// Tiles are aligned to an absolute 256 m grid in PUWG 1992 (EPSG:2180), so the disk cache is shared
|
|
// between sceneries. The scenery is placed on that grid through the PUWG coordinates of its (0,0,0)
|
|
// point; MaSzyna's +Z points north and +X points west, hence easting = E0 - x, northing = N0 + z.
|
|
//
|
|
// Downloading, cache I/O and image decoding run on worker threads; the main thread only uploads
|
|
// finished images (a bounded amount per frame) and emits the geometry. By default the layer goes into
|
|
// the ImGui background draw list, like the other editor viewport overlays: translucent and drawn over
|
|
// everything. Optionally it is put into the scene instead (shapes in the region sections, like the editor
|
|
// terrain, or translucent shapes in the cells when it isn't fully opaque), so tracks, models and terrain in
|
|
// front of it cover it.
|
|
class editor_orthophoto
|
|
{
|
|
public:
|
|
struct config
|
|
{
|
|
double north{0.0}; // PUWG 1992 X (northing) of the scenery origin
|
|
double east{0.0}; // PUWG 1992 Y (easting) of the scenery origin
|
|
int radius{2}; // tiles loaded around the camera tile (Chebyshev distance)
|
|
float height{0.0f}; // world Y of the layer (with drape: only where no ground was found)
|
|
float opacity{0.6f}; // 0..1
|
|
int year{0}; // 0 = newest available imagery, otherwise newest imagery taken up to the end of that year
|
|
bool hires{false}; // 4096 px tiles from the high-resolution product next to the camera, where it exists
|
|
bool drape{true}; // fit the imagery onto the ground geometry instead of a flat plane
|
|
float lift{0.05f}; // with drape: distance above the ground (in the scene it has to clear the ground to be seen)
|
|
bool in_scene{false}; // render as opaque scene geometry, covered by whatever is in front of it
|
|
// a WMS of the user's in place of the orthophoto of geoportal.gov.pl: its address and the layers asked of it in EPSG:2180, PNG
|
|
// clear where it draws nothing. Its tiles are kept in memory only and asked for only around the camera, none ahead
|
|
std::string service;
|
|
std::string layers;
|
|
};
|
|
|
|
using world_triangle = std::array<glm::dvec3, 3>;
|
|
// supplies the ground triangles overlapping an XZ rectangle (Min/Max are x,z); used to drape the imagery.
|
|
// Heightmap: the heightmap terrain as triangles too; without it the terrain is asked through the height query alone
|
|
using ground_query = std::function<void(glm::dvec2 const &Min, glm::dvec2 const &Max, bool Heightmap, std::vector<world_triangle> &Out)>;
|
|
// height of the heightmap terrain at a point, false where there's none
|
|
using height_query = std::function<bool(double X, double Z, double &Height)>;
|
|
|
|
struct statistics
|
|
{
|
|
int resident{0}; // tiles with imagery on screen
|
|
int loading{0}; // tiles waiting for or being processed by a worker
|
|
int failed{0}; // tiles whose last attempt failed
|
|
// the download area: its tiles, the ones in the disk cache in every product the settings ask for, the ones which failed
|
|
int area_tiles{0};
|
|
int area_cached{0};
|
|
int area_failed{0};
|
|
bool area_paused{false};
|
|
int requests{0}; // asked of the services since the start, the disk cache left out
|
|
int uploads{0}; // images of tiles sent to the graphics card
|
|
int stale{0}; // images which came when the tile no longer wanted them, dropped
|
|
};
|
|
|
|
static constexpr double tile_size{256.0}; // metres per tile side
|
|
static constexpr int max_radius{10};
|
|
static constexpr int oldest_year{1995}; // first year offered by the archival service
|
|
|
|
editor_orthophoto() = default;
|
|
~editor_orthophoto();
|
|
editor_orthophoto(editor_orthophoto const &) = delete;
|
|
editor_orthophoto &operator=(editor_orthophoto const &) = delete;
|
|
|
|
// the tiles over a rectangle of the world (x, z; what the camera sees), within the reach around the camera, asked for before anything
|
|
// else, the ones which failed tried again at once. returns: how many were put at the front of the queue
|
|
std::size_t hurry(glm::dvec2 const &Min, glm::dvec2 const &Max, glm::dvec3 const &Camera);
|
|
bool enabled() const { return m_enabled; }
|
|
// disabling drops the queue and returns the gpu memory of the resident tiles
|
|
void enabled(bool State);
|
|
config const &settings() const { return m_config; }
|
|
// the line of the scenery (//$o): whether the imagery is on and, with Origin, where the scenery lies; the rest of the settings
|
|
// are the user's
|
|
static std::string mark(config const &Config, bool Enabled, bool Origin);
|
|
static bool read_mark(std::string const &Text, config &Config, bool &Enabled);
|
|
// changes of year / resolution invalidate resident tiles, the rest applies immediately
|
|
void settings(config const &Config);
|
|
void ground_source(ground_query Query) { m_ground = std::move(Query); }
|
|
void height_source(height_query Query) { m_height = std::move(Query); }
|
|
// 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
|
|
void area(std::vector<glm::dvec2> Polygon);
|
|
std::vector<glm::dvec2> const &area() const { return m_area; }
|
|
// the download in the background held, or going on
|
|
void area_paused(bool const Paused);
|
|
// the squares of the tiles of the area in the world (x, z): 0 waiting, 1 in the disk cache, 2 failed
|
|
struct area_square
|
|
{
|
|
glm::dvec2 low{0.0};
|
|
glm::dvec2 high{0.0};
|
|
int state{0};
|
|
};
|
|
std::vector<area_square> area_squares() const;
|
|
// world (x, z) and PUWG 1992 (easting, northing), by the origin of the scenery
|
|
glm::dvec2 to_puwg(glm::dvec2 const &World) const { return {m_config.east - World.x, m_config.north + World.y}; }
|
|
glm::dvec2 to_world(glm::dvec2 const &Puwg) const { return {m_config.east - Puwg.x, Puwg.y - m_config.north}; }
|
|
// the area kept in the scenery, as the lines after its mark
|
|
static std::vector<std::string> area_lines(std::vector<glm::dvec2> const &Polygon);
|
|
static std::vector<glm::dvec2> read_area(std::vector<std::string> const &Lines);
|
|
// samples the ground again (after it was edited); tiles are refitted progressively
|
|
void refit();
|
|
// the tiles lying at guessed heights sampled again where the ground has come under them
|
|
void ground_arrived();
|
|
// the tiles with the ground sampled under them, and of these the ones at guessed heights
|
|
std::pair<std::size_t, std::size_t> grounded() const;
|
|
// the rectangles (x, z) of the tiles of the imagery asked for and not shown yet
|
|
std::vector<std::pair<glm::dvec2, glm::dvec2>> waiting() const;
|
|
// takes the scene geometry out of the region (e.g. when the editor is left); it's re-created on the next update
|
|
void detach_scene();
|
|
// true for geometry created by the layer, so ground queries can skip it
|
|
static bool owns(gfx::geometry_handle const &Geometry);
|
|
|
|
// main thread, once per frame: schedules tiles around the camera and uploads finished ones
|
|
void update(glm::dvec3 const &Camera);
|
|
// main thread, inside an ImGui frame: emits the overlay into the background draw list.
|
|
// ViewProjection must map camera-relative world positions (world - CameraPos) to clip space.
|
|
void draw(glm::mat4 const &ViewProjection, glm::dvec3 const &CameraPos, float ScreenWidth, float ScreenHeight) const;
|
|
// forgets pending (not yet started) downloads, e.g. when the editor is left
|
|
void cancel_pending();
|
|
// drops resident tiles and deletes the on-disk cache; enabled tiles are fetched again
|
|
void clear_cache();
|
|
// clears failure state so failed tiles are attempted again
|
|
void retry_failed();
|
|
|
|
statistics stats() const;
|
|
// false when the build has no http client; cached tiles are still shown
|
|
static bool can_download();
|
|
// what a WMS tells of itself in its capabilities: its title, its fees and access constraints, its layers with a name and whether it
|
|
// draws in EPSG:2180, the one the tiles are laid out in. Blocking, for a thread of its own
|
|
struct service_info
|
|
{
|
|
std::string title;
|
|
std::string terms;
|
|
std::vector<std::pair<std::string, std::string>> layers; // name, title
|
|
bool puwg{false};
|
|
std::string error;
|
|
};
|
|
static service_info describe(std::string const &Service);
|
|
static std::string cache_directory();
|
|
|
|
private:
|
|
using tile_key = std::pair<int, int>; // (easting index, northing index) on the PUWG tile grid
|
|
|
|
struct source
|
|
{
|
|
int year{0};
|
|
bool hires{false};
|
|
std::string service;
|
|
std::string layers;
|
|
};
|
|
|
|
struct job
|
|
{
|
|
tile_key key;
|
|
int level{0}; // requested texture size in pixels
|
|
std::uint8_t alpha{255}; // baked into the texture, for translucency in the scene
|
|
source src;
|
|
std::uint32_t generation{0};
|
|
};
|
|
|
|
struct result
|
|
{
|
|
tile_key key;
|
|
int level{0};
|
|
std::uint8_t alpha{255};
|
|
std::uint32_t generation{0};
|
|
bool ok{false};
|
|
bool empty{false}; // no imagery for this place/year: nothing to draw
|
|
int width{0};
|
|
int height{0};
|
|
std::vector<std::uint8_t> pixels; // RGBA8, first row = north edge
|
|
};
|
|
|
|
struct texture_slot
|
|
{
|
|
int index{-1}; // names the texture and its material
|
|
texture_handle texture{null_handle};
|
|
material_handle material{null_handle}; // created on first use by the scene geometry
|
|
};
|
|
|
|
struct tile
|
|
{
|
|
texture_slot slot;
|
|
int level{0}; // size of the imagery currently held (0 = nothing yet)
|
|
int requested{0}; // level of the job scheduled for this tile (0 = none)
|
|
std::uint8_t alpha{255}; // alpha of the imagery currently held
|
|
std::uint8_t requested_alpha{255}; // alpha of the scheduled job
|
|
bool empty{false};
|
|
int failures{0};
|
|
double retry_at{0.0}; // steady clock seconds
|
|
// ground fit
|
|
bool grounded{false}; // ground was sampled
|
|
std::vector<float> heights; // (ground_grid+1)^2 world Y, rows north->south, columns west->east; empty if no ground
|
|
float height_min{0.0f};
|
|
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
|
|
gfx::geometry_handle geometry{0, 0};
|
|
std::size_t capacity{0}; // vertex count of the geometry chunk
|
|
bool scene_dirty{true}; // the shape needs to be rebuilt
|
|
};
|
|
|
|
static int level_for(int Distance, bool Hires);
|
|
// the level a tile is asked for at first: a tile showing nothing yet takes the standard image before the 4K one
|
|
static int first_level(tile const &Tile, int Level);
|
|
// the tile is outside the download area set, which then has no imagery asked for it
|
|
bool outside_area(tile_key const &Key) const;
|
|
// a tile of the view hurried: put at the front of the queue unless it's shown as it should be. true: counted among the hurried
|
|
bool hurry_tile(tile_key const &Key, int Distance);
|
|
tile_key camera_tile(glm::dvec3 const &Camera) const;
|
|
glm::dvec2 tile_corner(tile_key const &Key) const; // world (x,z) of the north-west corner
|
|
void schedule(tile_key const &Key, tile &Tile, int Level, std::uint8_t Alpha);
|
|
std::uint8_t texture_alpha() const; // alpha the textures should carry with the current settings
|
|
std::size_t apply(result &Result, double Now); // returns bytes uploaded
|
|
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);
|
|
void remove_shape(tile &Tile);
|
|
void release_geometry(tile &Tile);
|
|
void update_scene();
|
|
void start_workers();
|
|
void worker();
|
|
// the tiles of the area queued for the download in the background again, nearest to the camera first
|
|
void restart_prefetch();
|
|
|
|
config m_config;
|
|
bool m_enabled{false};
|
|
std::map<tile_key, tile> m_tiles; // main thread only
|
|
tile_key m_camera_tile{0, 0};
|
|
std::vector<texture_slot> m_free_slots; // pool of textures, reused between tiles
|
|
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
|
|
std::uint8_t m_alpha{255}; // in effect
|
|
std::uint8_t m_alpha_pending{255}; // latest requested
|
|
double m_alpha_changed{0.0}; // when the requested value last changed
|
|
|
|
std::vector<glm::dvec2> m_area; // PUWG, empty: no area
|
|
std::set<tile_key> m_area_tiles; // the tiles it touches
|
|
int m_uploads{0};
|
|
int m_stale{0};
|
|
|
|
// shared with the workers, guarded by m_mutex
|
|
mutable std::mutex m_mutex;
|
|
std::condition_variable m_wakeup;
|
|
std::deque<job> m_queue;
|
|
std::deque<result> m_done;
|
|
tile_key m_focus{0, 0}; // workers pick the queued tile closest to it
|
|
std::set<tile_key> m_running; // tiles a worker is on: another job of one waits till that one is done
|
|
std::size_t m_running_hires{0}; // of them, the ones of a 4K image
|
|
// the download of the area in the background: the tiles nearest to the camera first, taken when no tile around the camera waits
|
|
std::vector<tile_key> m_prefetch;
|
|
std::size_t m_prefetch_next{0};
|
|
std::set<tile_key> m_prefetch_failed;
|
|
std::set<tile_key> m_prefetch_cached;
|
|
bool m_prefetch_paused{false};
|
|
source m_prefetch_source;
|
|
std::uint32_t m_prefetch_generation{0};
|
|
std::set<tile_key> m_urgent; // asked for by hurry(): workers take these first; guarded by m_mutex
|
|
|
|
std::atomic<bool> m_stop{false};
|
|
std::atomic<std::uint32_t> m_generation{1};
|
|
std::vector<std::thread> m_workers;
|
|
};
|