18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-22 02:05:01 +01:00

feat(editor): area fill: Enter finishes an area, Esc drops the outline, a list of filled areas to change later (#241)

* feat(editor): fill_store, the filled areas kept in the scenery as //$f lines

* feat(editor): fill_store: reading and writing the filled areas

* build: editorFillStore.cpp

* feat(scene): //$f lines of the filled areas kept with the layer files

* feat(editor): area fill: the members of the list of filled areas

* lang(pl): area fill list

* feat(editor): area fill: Enter finishes an area, Esc drops the outline, filled areas listed to be changed later

* fix(editor): the filled areas kept as //$w lines, //$f being the fitted tracks of the profile tool

* fix(editor): a changed area keeps its own rotation and its layer; its models go to the layer of the area, on an undo as on a refill

Change + Enter took the rotation of the Functions panel instead of the area's own:
the area keeps it now, unless the rotation of the panel is changed while the area
is picked up.

The models of an area were made in the active layer, the area record stayed in its
own: on an undo of a change or a removal, with another layer active, they were
saved apart. create_model() takes the layer to put the model in (none: the active
one, as before), and the models of an area go to the layer of the area (the active
one if that's gone). The active layer isn't switched for it: Layers.active() also
shows and unlocks the layer it's given.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ

* chore(editor): the seeded generator of the area fill marked as not security (Sonar cpp:S2245)

The fill must repeat from its seed (the same area filled again gets the
same objects), so a cryptographic generator is not wanted there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ

* ci(windows): build lua51.dll for the unit tests

(cherry picked from commit b3e6e02779)

* fix(editor): the filled areas kept under //$u, as //$w is the mark of the shared grade lines on master

After the review of jerrrrycho: on master //$w is the mark of the shared grade lines (scenelayers.cpp,
editormodegradeline.cpp), and both stores save through Layers.mark(Layer, Mark, Lines), which replaces the
lines of the mark. Once master reached this branch, a layer with a grade line and a filled area would have
kept only the lines of whichever store saved last; before that, a master build reads the lines of the areas
as grade lines it doesn't know.

The area fill takes //$u, free on master, on feat/gl46-migration and in the letters of the starters
(n d f i l a), and the same letter the ficzery2 builds the testers have already save the areas under, so
their sceneries keep their areas. A scenery saved by a build of this PR before this commit has its areas
under //$w: they are no longer read as areas; saved again, the editor keeps those lines as lines it doesn't
know.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QRgQ1K1Qu7TCsa74zsNURd

---------

Co-authored-by: miloszunio <miloszunio@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Hirek193 <polomarket73@gmail.com>
This commit is contained in:
pol102
2026-11-20 03:56:13 +01:00
committed by GitHub
parent 793ff968de
commit c9c390017a
11 changed files with 779 additions and 105 deletions

View File

@@ -223,6 +223,7 @@ set(SOURCES
"editor/editorGroundFollow.cpp"
"editor/editorAlignmentStore.cpp"
"editor/editorSwitchStore.cpp"
"editor/editorFillStore.cpp"
"editor/editorSwitchCurve.cpp"
"editor/editorKilometrage.cpp"
"editor/editorStation.cpp"

View File

@@ -548,6 +548,7 @@ void editor_mode::editormode_input::poll()
editor_mode::editor_mode() {
alignment_store::reset();
switch_store::reset();
fill_store::reset();
kilometrage::reset();
m_userinterface = std::make_shared<editor_ui>();
// the area fill settings live in the node bank window, in the tab of the fill mode
@@ -962,9 +963,7 @@ void editor_mode::nullify_history_pointers(scene::basic_node *node)
s.infra.erase(std::remove_if(s.infra.begin(), s.infra.end(), followed), s.infra.end());
}
// deleted nodes also drop out of the "undo last fill" set
m_fill_last.erase(std::remove(m_fill_last.begin(), m_fill_last.end(), node), m_fill_last.end());
// and out of the selection and their group
// deleted nodes drop out of the selection and their group
m_selection.erase(std::remove(m_selection.begin(), m_selection.end(), node), m_selection.end());
scene::Groups.remove(node);
@@ -4801,16 +4800,44 @@ void editor_mode::add_area_fill_point()
m_fill_points.push_back(placement_on_ground(world));
}
void editor_mode::undo_last_area_fill()
fill_store::area editor_mode::fill_settings() const
{
// nullify_history_pointers() removes deleted nodes from m_fill_last, so work on a copy
auto const created = std::move(m_fill_last);
m_fill_last.clear();
fill_store::area area;
area.set_kind = static_cast<int>(m_fill_source.kind);
area.set_id = m_fill_source.id;
area.density = std::max(0.0f, m_fill_density);
area.spacing = std::max(0.0f, m_fill_min_spacing);
area.scale_min = std::max(0.01f, std::min(m_fill_scale_min, m_fill_scale_max));
area.scale_max = std::max(0.01f, std::max(m_fill_scale_min, m_fill_scale_max));
area.random_rotation = m_fill_random_rotation;
// without the random rotation the one of the Functions panel goes with the area, a fixed one or none
area.rotation = (false == m_fill_random_rotation && ui()->rot_mode() == functions_panel::FIXED) ? ui()->rot_val() : 0.0f;
area.models_as_ground = m_fill_models_as_ground;
if (m_fill_source.kind == model_set_ref::source::manual)
area.templates = m_fill_custom;
else
for (auto const *entry : ui()->nodebank().set_entries(m_fill_source))
area.templates.push_back(*entry);
area.templates.erase(std::remove_if(area.templates.begin(), area.templates.end(), [](std::string const &Template) { return Template.empty(); }), area.templates.end());
return area;
}
for (TAnimModel *model : created)
std::vector<TAnimModel *> editor_mode::fill_area_models(std::string const &Id) const
{
std::vector<TAnimModel *> models;
if (Id.empty())
return models;
for (auto *model : simulation::Instances.sequence())
if (model != nullptr && fill_store::owns(Id, model->name()))
models.push_back(model);
return models;
}
std::size_t editor_mode::erase_fill_area_models(std::string const &Id)
{
auto const models{fill_area_models(Id)};
for (auto *model : models)
{
if (model == nullptr)
continue;
if (m_node == model)
{
m_node = nullptr;
@@ -4818,66 +4845,58 @@ void editor_mode::undo_last_area_fill()
}
erase_model(model);
}
m_fill_status = format(STR_C("Removed %zu objects of the last fill"), created.size());
return models.size();
}
void editor_mode::run_area_fill()
std::size_t editor_mode::place_fill_area(fill_store::area const &Area, std::size_t &Target, std::size_t &Unsupported)
{
// limits keeping a single click from freezing the editor for too long
std::size_t constexpr max_objects = 20000;
// the models go to the layer of the area, whichever is active (on an undo, on a change): the area and its models are saved together;
// the active one if the area's is gone
auto layer{scene::Layers.resolve(Area.layer)};
if (false == scene::Layers.listed(layer))
layer = null_handle;
// large model instances (e.g. terrain tiles) are treated as ground, smaller ones (houses, trees) are not
float constexpr terrain_model_radius = 50.0f;
// ground is searched up to this far above the height interpolated from the outline points,
// so hills inside the outline are found but bridges or roofs high above it are not
double constexpr height_tolerance = 50.0;
if (m_fill_points.size() < 3)
{
m_fill_status = STR("Outline needs at least 3 points");
return;
}
Target = 0;
Unsupported = 0;
auto const &outline{Area.outline};
if (outline.size() < 3 || Area.templates.empty())
return 0;
// model package
std::vector<std::string> package;
if (m_fill_source.kind == model_set_ref::source::manual)
package = m_fill_custom;
else
for (auto const *entry : ui()->nodebank().set_entries(m_fill_source))
package.push_back(*entry);
package.erase(std::remove_if(package.begin(), package.end(), [](std::string const &Template) { return Template.empty(); }), package.end());
if (package.empty())
{
m_fill_status = STR("Selected model package is empty");
return;
}
// every random number of the fill comes from its seed, so the area filled again with the same settings gets the same objects
std::mt19937 random{Area.seed}; // NOSONAR(cpp:S2245) the placement of models, not security: it must repeat from the seed
auto const uniform = [&](double const Low, double const High) { return std::uniform_real_distribution<double>{Low, High}(random); };
// area bounds
glm::dvec2 bmin(std::numeric_limits<double>::max());
glm::dvec2 bmax(-std::numeric_limits<double>::max());
for (auto const &p : m_fill_points)
for (auto const &p : outline)
{
bmin = glm::min(bmin, glm::dvec2(p.x, p.z));
bmax = glm::max(bmax, glm::dvec2(p.x, p.z));
}
double const area = polygon_area_xz(m_fill_points);
auto const target = static_cast<std::size_t>(std::min<double>(std::round(area / 10000.0 * std::max(0.0f, m_fill_density)), max_objects));
if (target == 0)
{
m_fill_status = STR("Density too low for this area, nothing to place");
return;
}
double const area = polygon_area_xz(outline);
Target = static_cast<std::size_t>(std::min<double>(std::round(area / 10000.0 * std::max(0.0f, Area.density)), max_objects));
if (Target == 0)
return 0;
// scatter points: random samples inside the outline, rejecting the ones closer than the minimal spacing
// to an already accepted point (checked on a hashed grid with cell size == spacing)
double const spacing = std::max(0.0f, m_fill_min_spacing);
double const spacing = std::max(0.0f, Area.spacing);
std::unordered_map<std::int64_t, std::vector<std::size_t>> occupancy;
auto const cell_key = [](std::int64_t const X, std::int64_t const Z) { return (X << 32) ^ (Z & 0xffffffff); };
std::vector<glm::dvec2> points;
points.reserve(target);
for (std::size_t attempt = 0; attempt < target * 30 && points.size() < target; ++attempt)
points.reserve(Target);
for (std::size_t attempt = 0; attempt < Target * 30 && points.size() < Target; ++attempt)
{
glm::dvec2 const p(LocalRandom(bmin.x, bmax.x), LocalRandom(bmin.y, bmax.y));
if (false == point_in_polygon_xz(m_fill_points, p.x, p.y))
glm::dvec2 const p(uniform(bmin.x, bmax.x), uniform(bmin.y, bmax.y));
if (false == point_in_polygon_xz(outline, p.x, p.y))
continue;
if (spacing > 0.0)
{
@@ -4906,23 +4925,22 @@ void editor_mode::run_area_fill()
// ground geometry within the area
std::vector<world_triangle> triangles;
gather_ground_triangles(bmin, bmax, m_fill_models_as_ground, terrain_model_radius, triangles);
gather_ground_triangles(bmin, bmax, Area.models_as_ground, terrain_model_radius, triangles);
triangle_grid const ground(std::move(triangles), bmin, bmax);
auto const terrains = active_terrains();
auto const rotation_mode = m_fill_random_rotation ? functions_panel::RANDOM : ui()->rot_mode();
auto const fixed_rotation_value = ui()->rot_val();
float const scalemin = std::max(0.01f, std::min(m_fill_scale_min, m_fill_scale_max));
float const scalemax = std::max(0.01f, std::max(m_fill_scale_min, m_fill_scale_max));
std::vector<TAnimModel *> created;
created.reserve(points.size());
std::size_t unsupported = 0;
std::size_t placed{0};
std::size_t number{0};
for (auto const &p : points)
{
// the random numbers of the point are drawn before anything can skip it, so the points after it get the same ones
auto const pick{uniform(0.0, 1.0)};
auto const yaw{uniform(0.0, 360.0)};
auto const scale{uniform(0.0, 1.0)};
// reference height: the outline points, weighted by inverse squared distance
double weights = 0.0, reference = 0.0;
for (auto const &v : m_fill_points)
for (auto const &v : outline)
{
double const w = 1.0 / std::max(1e-6, glm::length2(glm::dvec2(v.x, v.z) - p));
weights += w;
@@ -4947,40 +4965,210 @@ void editor_mode::run_area_fill()
if (!found)
{
y = reference;
++unsupported;
++Unsupported;
}
glm::dvec3 const location(p.x, y, p.y);
if (!simulation::Region->point_inside(location))
continue;
auto const &src = package[package.size() > 1 ? std::min(package.size() - 1, static_cast<std::size_t>(LocalRandom(0.0, static_cast<double>(package.size())))) : 0];
// NOTE: no names here either, same as with the brush
TAnimModel *cloned = simulation::State.create_model(src, std::string{}, location);
auto const &src = Area.templates[std::min(Area.templates.size() - 1, static_cast<std::size_t>(pick * static_cast<double>(Area.templates.size())))];
// named after the area, so its models are found again in a scenery loaded later
TAnimModel *cloned = simulation::State.create_model(src, fill_store::model_name(Area.id, number++), location, layer);
if (!cloned)
continue;
apply_rotation_for_new_node(cloned, rotation_mode, fixed_rotation_value);
if (scalemin != 1.0f || scalemax != 1.0f)
cloned->Scale(static_cast<float>(LocalRandom(scalemin, scalemax)));
created.push_back(cloned);
if (Area.random_rotation)
m_editor.rotate(cloned, glm::vec3{0.0f, static_cast<float>(yaw), 0.0f}, 1);
else if (Area.rotation != 0.0f)
m_editor.rotate(cloned, glm::vec3{0.0f, Area.rotation, 0.0f}, 0);
if (Area.scale_min != 1.0f || Area.scale_max != 1.0f)
cloned->Scale(static_cast<float>(Area.scale_min + (Area.scale_max - Area.scale_min) * scale));
++placed;
}
return placed;
}
// a new fill replaces the "last fill" undo set; the previous objects stay in the scene
m_fill_last = std::move(created);
void editor_mode::finish_area_fill()
{
if (m_fill_points.size() < 3)
{
m_fill_status = STR("Outline needs at least 3 points");
return;
}
auto area{fill_settings()};
if (area.templates.empty())
{
m_fill_status = STR("Selected model package is empty");
return;
}
area.outline = m_fill_points;
if (std::round(polygon_area_xz(area.outline) / 10000.0 * area.density) < 1.0)
{
m_fill_status = STR("Density too low for this area, nothing to place");
return;
}
// a changed area keeps its name and the names of its models, a new one gets them
auto const *before{m_fill_editing.empty() ? nullptr : fill_store::find(m_fill_editing)};
fill_undo undo;
if (before != nullptr)
{
undo.what = fill_undo::kind::changed;
undo.before = *before;
area.id = before->id;
area.label = before->label;
// its own rotation, unless the rotation of the Functions panel was changed since it was picked up
if (false == area.random_rotation && false == before->random_rotation && static_cast<int>(ui()->rot_mode()) == m_fill_editing_panel_mode &&
ui()->rot_val() == m_fill_editing_panel_value)
area.rotation = m_fill_editing_rotation;
erase_fill_area_models(area.id);
}
else
{
undo.what = fill_undo::kind::added;
area.id = fill_store::next_id();
area.label = format(STR_C("Area %zu"), fill_store::areas().size() + 1);
}
undo.id = area.id;
area.seed = static_cast<std::uint32_t>(LocalRandom(0.0, 4294967295.0));
// a changed area stays in its layer, with its models; a new one goes to the active layer
area.layer = before != nullptr ? undo.before.layer : scene::Layers.active();
m_fill_status = format(STR_C("Placed %zu of %zu objects"), m_fill_last.size(), static_cast<std::size_t>(target));
if (points.size() < target)
std::size_t target{0};
std::size_t unsupported{0};
area.objects = place_fill_area(area, target, unsupported);
fill_store::put(area);
m_fill_undo = std::move(undo);
m_fill_points.clear();
m_fill_editing.clear();
m_fill_status = format(STR_C("%s: placed %zu of %zu objects"), area.label.c_str(), area.objects, target);
if (area.objects < target)
m_fill_status += STR_C(" (limited by min. spacing)");
if (unsupported > 0)
m_fill_status += format(STR_C(", without ground under them (height from the outline): %zu"), unsupported);
WriteLog("Editor: area fill - " + m_fill_status, logtype::generic);
}
void editor_mode::cancel_area_fill()
{
if (false == m_fill_editing.empty())
{
if (auto const *area{fill_store::find(m_fill_editing)})
m_fill_status = format(STR_C("%s left as it was"), area->label.c_str());
m_fill_editing.clear();
}
m_fill_points.clear();
}
void editor_mode::edit_fill_area(std::string const &Id)
{
auto const *area{fill_store::find(Id)};
if (area == nullptr)
return;
m_fill_editing = Id;
m_fill_points = area->outline;
m_fill_density = area->density;
m_fill_min_spacing = area->spacing;
m_fill_scale_min = area->scale_min;
m_fill_scale_max = area->scale_max;
m_fill_random_rotation = area->random_rotation;
m_fill_editing_rotation = area->rotation;
m_fill_editing_panel_mode = static_cast<int>(ui()->rot_mode());
m_fill_editing_panel_value = ui()->rot_val();
m_fill_models_as_ground = area->models_as_ground;
// the set the models came from, while it still holds the same templates; otherwise the templates of the area themselves
model_set_ref source;
source.kind = static_cast<model_set_ref::source>(std::clamp(area->set_kind, 0, 2));
source.id = area->set_id;
std::vector<std::string> entries;
if (source.kind != model_set_ref::source::manual)
for (auto const *entry : ui()->nodebank().set_entries(source))
if (false == entry->empty())
entries.push_back(*entry);
if (source.kind != model_set_ref::source::manual && entries == area->templates)
m_fill_source = source;
else
{
m_fill_source = model_set_ref{};
m_fill_custom = area->templates;
m_fill_custom_idx = -1;
}
m_fill_status = format(STR_C("%s picked up: change the outline or the settings, Enter fills it anew, Esc leaves it as it was"), area->label.c_str());
}
void editor_mode::remove_fill_area(std::string const &Id)
{
auto const *area{fill_store::find(Id)};
if (area == nullptr)
return;
if (m_fill_editing == Id)
{
m_fill_editing.clear();
m_fill_points.clear();
}
fill_undo undo;
undo.what = fill_undo::kind::removed;
undo.id = Id;
undo.before = *area;
auto const removed{erase_fill_area_models(Id)};
m_fill_status = format(STR_C("%s removed with its %zu objects"), undo.before.label.c_str(), removed);
fill_store::forget(Id);
m_fill_undo = std::move(undo);
}
void editor_mode::show_fill_area(std::string const &Id)
{
auto const *area{fill_store::find(Id)};
if (area == nullptr || area->outline.empty())
return;
glm::dvec3 low{std::numeric_limits<double>::max()};
glm::dvec3 high{-std::numeric_limits<double>::max()};
for (auto const &point : area->outline)
{
low = glm::min(low, point);
high = glm::max(high, point);
}
auto const centre{(low + high) * 0.5};
auto const extent{std::max(30.0, std::max(high.x - low.x, high.z - low.z))};
// from the south-east, high enough to see the whole outline
Camera.Pos = centre + glm::dvec3{-0.5 * extent, 0.8 * extent, 0.5 * extent};
auto const look{glm::normalize(centre - Camera.Pos)};
Camera.Angle = glm::vec3(static_cast<float>(std::asin(std::clamp(look.y, -1.0, 1.0))), static_cast<float>(std::atan2(-look.x, -look.z)), 0.0f);
Camera.Velocity = {};
Camera.m_owner = nullptr;
m_focus_active = false;
Global.pCamera = Camera;
}
void editor_mode::undo_last_area_fill()
{
if (false == m_fill_undo.has_value())
return;
auto const undo{std::move(*m_fill_undo)};
m_fill_undo.reset();
if (m_fill_editing == undo.id)
{
m_fill_editing.clear();
m_fill_points.clear();
}
auto const removed{erase_fill_area_models(undo.id)};
if (undo.what == fill_undo::kind::added)
{
fill_store::forget(undo.id);
m_fill_status = format(STR_C("Removed %zu objects of the last fill"), removed);
return;
}
// changed or removed: the area as it was, filled again from its seed, which gives the same objects
std::size_t target{0};
std::size_t unsupported{0};
auto before{undo.before};
before.objects = place_fill_area(before, target, unsupported);
fill_store::put(before);
m_fill_status = format(STR_C("%s back as it was, %zu objects"), before.label.c_str(), before.objects);
}
void editor_mode::draw_area_fill_outline() const
{
if (m_fill_points.empty())
return;
// same camera-relative view and clean perspective the transform gizmo uses
ImGuiIO const &io = ImGui::GetIO();
glm::mat4 const view = GfxRenderer->Camera_View_Matrix();
@@ -4995,27 +5183,42 @@ void editor_mode::draw_area_fill_outline() const
float constexpr nearw = 0.1f;
ImDrawList *drawlist = ImGui::GetBackgroundDrawList(ImGui::GetMainViewport());
auto const draw_edges = [&](std::vector<glm::dvec3> const &Points, bool const Open, ImU32 const Color, ImU32 const Closing, float const Thickness) {
std::size_t const count = Points.size();
for (std::size_t i = 0; i < count; ++i)
{
bool const closing = (i + 1 == count);
if (closing && (count < 3 || (Open && Closing == 0)))
break;
glm::vec4 a = to_clip(Points[i]);
glm::vec4 b = to_clip(Points[(i + 1) % count]);
// clip the edge against the near plane, so points behind the camera don't flip across the screen
if (a.w < nearw && b.w < nearw)
continue;
if (a.w < nearw)
a = glm::mix(a, b, (nearw - a.w) / (b.w - a.w));
else if (b.w < nearw)
b = glm::mix(b, a, (nearw - b.w) / (a.w - b.w));
drawlist->AddLine(to_screen(a), to_screen(b), closing && Open ? Closing : Color, Thickness);
}
};
// the areas on the list, the one under the cursor in the list brighter; the one being changed is drawn as the outline
for (auto const &area : fill_store::areas())
{
if (area.id == m_fill_editing)
continue;
auto const hovered{area.id == m_fill_hover};
draw_edges(area.outline, false, hovered ? IM_COL32(120, 230, 255, 255) : IM_COL32(120, 200, 255, 110), 0, hovered ? 3.0f : 1.5f);
}
if (m_fill_points.empty())
return;
ImU32 const edgecolor = IM_COL32(255, 200, 40, 230);
ImU32 const closingcolor = IM_COL32(255, 200, 40, 110);
draw_edges(m_fill_points, true, edgecolor, closingcolor, 2.0f);
std::size_t const count = m_fill_points.size();
for (std::size_t i = 0; i < count; ++i)
{
bool const closing = (i + 1 == count);
if (closing && count < 3)
break;
glm::vec4 a = to_clip(m_fill_points[i]);
glm::vec4 b = to_clip(m_fill_points[(i + 1) % count]);
// clip the edge against the near plane, so points behind the camera don't flip across the screen
if (a.w < nearw && b.w < nearw)
continue;
if (a.w < nearw)
a = glm::mix(a, b, (nearw - a.w) / (b.w - a.w));
else if (b.w < nearw)
b = glm::mix(b, a, (nearw - b.w) / (a.w - b.w));
drawlist->AddLine(to_screen(a), to_screen(b), closing ? closingcolor : edgecolor, 2.0f);
}
for (std::size_t i = 0; i < count; ++i)
{
glm::vec4 const c = to_clip(m_fill_points[i]);
if (c.w < nearw)
@@ -5026,7 +5229,10 @@ void editor_mode::draw_area_fill_outline() const
void editor_mode::render_area_fill()
{
ImGui::TextDisabled(STR_C("LMB: add outline point Backspace: remove last point"));
ImGui::TextDisabled(STR_C("LMB: add outline point Backspace: remove last point Enter: fill and finish Esc: drop the outline"));
if (false == m_fill_editing.empty())
if (auto const *editing{fill_store::find(m_fill_editing)})
ImGui::TextColored(ImVec4(0.47f, 0.9f, 1.0f, 1.0f), STR_C("Changing: %s"), editing->label.c_str());
double const area = polygon_area_xz(m_fill_points);
// the square sign written as its utf-8 bytes: the game is built without /utf-8 where it has the debug symbols
ImGui::Text(STR_C("Points: %zu Area: %.0f m\xC2\xB2 (%.2f ha)"), m_fill_points.size(), area, area / 10000.0);
@@ -5034,7 +5240,7 @@ void editor_mode::render_area_fill()
m_fill_points.pop_back();
ImGui::SameLine();
if (ImGui::Button(STR_C("Clear outline")))
m_fill_points.clear();
cancel_area_fill();
ImGui::Separator();
@@ -5069,15 +5275,102 @@ void editor_mode::render_area_fill()
ImGui::Text(STR_C("Estimated objects: %.0f"), std::round(area / 10000.0 * m_fill_density));
if (ImGui::Button(STR_C("Fill area")))
run_area_fill();
if (ImGui::Button(m_fill_editing.empty() ? STR_C("Fill area (Enter)") : STR_C("Fill again (Enter)")))
finish_area_fill();
ImGui::SameLine();
std::string const undolabel = format(STR_C("Undo last fill (%zu)"), m_fill_last.size());
if (ImGui::Button(undolabel.c_str()) && !m_fill_last.empty())
undo_last_area_fill();
if (m_fill_undo.has_value())
{
if (ImGui::Button(STR_C("Undo last fill")))
undo_last_area_fill();
}
else
ImGui::TextDisabled("%s", STR_C("Undo last fill"));
if (!m_fill_status.empty())
ImGui::TextUnformatted(m_fill_status.c_str());
ImGui::TextWrapped("%s", m_fill_status.c_str());
render_fill_area_list();
}
void editor_mode::render_fill_area_list()
{
ImGui::Separator();
auto const &areas{fill_store::areas()};
ImGui::Text(STR_C("Filled areas: %zu"), areas.size());
m_fill_hover.clear();
if (areas.empty())
{
ImGui::TextDisabled("%s", STR_C("None yet. Enter fills the outline and puts the area here, to be changed later"));
return;
}
// the buttons act after the list is drawn: they change the list
std::string edit, remove, show;
if (ImGui::BeginTable("fillareas", 4, ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_ScrollY, ImVec2(0.0f, std::min(10, static_cast<int>(areas.size()) + 1) * ImGui::GetFrameHeightWithSpacing())))
{
ImGui::TableSetupScrollFreeze(0, 1);
ImGui::TableSetupColumn(STR_C("Name"), ImGuiTableColumnFlags_WidthStretch, 3.0f);
ImGui::TableSetupColumn(STR_C("Objects"), ImGuiTableColumnFlags_WidthFixed);
ImGui::TableSetupColumn(STR_C("ha"), ImGuiTableColumnFlags_WidthFixed);
ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed);
ImGui::TableHeadersRow();
for (auto const &area : areas)
{
ImGui::PushID(area.id.c_str());
ImGui::TableNextRow();
if (area.id == m_fill_editing)
ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg1, IM_COL32(60, 120, 150, 120));
ImGui::TableNextColumn();
// the name, changed in place and kept with the area once the field is left
std::array<char, 96> name{};
std::snprintf(name.data(), name.size(), "%s", area.label.c_str());
ImGui::SetNextItemWidth(-1.0f);
ImGui::InputText("##name", name.data(), name.size());
if (ImGui::IsItemDeactivatedAfterEdit())
{
auto changed{area};
changed.label = name.data();
fill_store::put(std::move(changed));
ImGui::PopID();
break; // the list changed under the loop
}
auto hovered{ImGui::IsItemHovered()};
ImGui::TableNextColumn();
ImGui::Text("%zu", area.objects);
hovered = hovered || ImGui::IsItemHovered();
ImGui::TableNextColumn();
ImGui::Text("%.2f", polygon_area_xz(area.outline) / 10000.0);
hovered = hovered || ImGui::IsItemHovered();
ImGui::TableNextColumn();
if (ImGui::SmallButton(STR_C("Change")))
edit = area.id;
if (ImGui::IsItemHovered())
ImGui::SetTooltip("%s", STR_C("Its outline and settings back in the tool: move the points, change the models or the density, Enter fills it anew"));
hovered = hovered || ImGui::IsItemHovered();
ImGui::SameLine();
if (ImGui::SmallButton(STR_C("Show")))
show = area.id;
hovered = hovered || ImGui::IsItemHovered();
ImGui::SameLine();
if (ImGui::SmallButton(STR_C("Remove")))
remove = area.id;
if (ImGui::IsItemHovered())
ImGui::SetTooltip("%s", STR_C("The area and its models removed; Undo last fill brings them back"));
hovered = hovered || ImGui::IsItemHovered();
if (hovered)
m_fill_hover = area.id;
ImGui::PopID();
}
ImGui::EndTable();
}
if (false == show.empty())
show_fill_area(show);
if (false == edit.empty())
{
edit_fill_area(edit);
show_fill_area(edit);
}
if (false == remove.empty())
remove_fill_area(remove);
}
glm::vec3 editor_mode::array_size(TAnimModel const &Base)
@@ -7353,7 +7646,7 @@ void editor_mode::exit()
g_redo.clear();
m_history.clear();
m_orphans.clear();
m_fill_last.clear();
m_fill_undo.reset();
m_orthophoto.cancel_pending();
m_orthophoto.detach_scene(); // the layer is an editor aid, keep it out of the other modes
for (auto &layer : m_wms)
@@ -7691,6 +7984,12 @@ void editor_mode::on_key(int const Key, int const Scancode, int const Action, in
area_finish(false);
break;
}
// area fill: the outline dropped, an area picked up for a change left as it was
if (is_press(Action) && ui()->mode() == nodebank_panel::FILL && false == ImGui::GetIO().WantTextInput && (false == m_fill_points.empty() || false == m_fill_editing.empty()))
{
cancel_area_fill();
break;
}
if (is_press(Action))
{
road_cancel();
@@ -7781,6 +8080,12 @@ void editor_mode::on_key(int const Key, int const Scancode, int const Action, in
area_finish(true);
break;
}
// area fill: the outline filled and put on the list, the next one can be started
if (is_press(Action) && ui()->mode() == nodebank_panel::FILL && false == ImGui::GetIO().WantTextInput && false == m_fill_points.empty())
{
finish_area_fill();
break;
}
if (is_press(Action) && ui()->mode() == nodebank_panel::TRACK && m_lay.active)
lay_enter();
if (is_press(Action) && m_route.trace.active && route_active())

View File

@@ -38,6 +38,7 @@ http://mozilla.org/MPL/2.0/.
#include "editor/editorAlignment.hpp"
#include "editor/editorAlignmentStore.hpp"
#include "editor/editorSwitchStore.hpp"
#include "editor/editorFillStore.hpp"
#include "editor/editorSwitchCurve.hpp"
#include "editor/editorKilometrage.hpp"
#include "editor/editorSpeed.hpp"
@@ -1008,14 +1009,47 @@ class editor_mode : public application_mode, private editor_track::observer, pri
void render_change_history();
void render_settings();
// area fill: scatters models from a package over a polygon outlined in the viewport
// area fill: scatters models from a package over a polygon outlined in the viewport. a filled area goes on the list of the
// panel (fill_store, kept in the scenery), to be picked up again later: its outline and settings back in the tool, filled anew
void render_area_fill();
void render_fill_area_list();
void draw_area_fill_outline() const;
void add_area_fill_point();
void run_area_fill();
// Enter: the outline filled and put on the list, the tool ready for the next one
void finish_area_fill();
// Esc: the outline dropped; an area picked up for a change stays as it was
void cancel_area_fill();
void edit_fill_area(std::string const &Id);
void remove_fill_area(std::string const &Id);
void show_fill_area(std::string const &Id);
void undo_last_area_fill();
// the settings of the tool as an area, without its outline, id and label
fill_store::area fill_settings() const;
// the models the area is filled with, from its seed: the same each time for the same area. returns how many were placed
std::size_t place_fill_area(fill_store::area const &Area, std::size_t &Target, std::size_t &Unsupported);
std::vector<TAnimModel *> fill_area_models(std::string const &Id) const;
std::size_t erase_fill_area_models(std::string const &Id);
std::vector<glm::dvec3> m_fill_points; // outline vertices (world space) in click order
std::vector<TAnimModel *> m_fill_last; // instances created by the most recent fill, for "Undo last fill"
std::string m_fill_editing; // the listed area whose outline is in m_fill_points, empty for a new one
// the rotation of the area picked up and the one of the Functions panel then: the area keeps its own unless it's changed in the tool
float m_fill_editing_rotation{0.0f};
int m_fill_editing_panel_mode{-1};
float m_fill_editing_panel_value{0.0f};
std::string m_fill_hover; // the area under the cursor in the list, drawn brighter
// what "Undo last fill" takes back: the area filled, changed or removed last, and how it was before
struct fill_undo
{
enum class kind
{
added,
changed,
removed
};
kind what{kind::added};
std::string id;
fill_store::area before;
};
std::optional<fill_undo> m_fill_undo;
std::vector<std::string> m_fill_custom; // user-assembled package of node templates
int m_fill_custom_idx{-1};
model_set_ref m_fill_source; // manual = m_fill_custom, otherwise a user set or node bank group

220
editor/editorFillStore.cpp Normal file
View File

@@ -0,0 +1,220 @@
/*
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/.
*/
#include "stdafx.h"
#include "editor/editorFillStore.hpp"
#include "editor/editorFormat.hpp"
#include "model/AnimModel.h"
#include "simulation/simulation.h"
#include "utilities/Logs.h"
#include <algorithm>
#include <cstdlib>
#include <set>
#include <sstream>
namespace fill_store
{
namespace
{
std::string const kMark{"//$u"};
std::vector<area> g_areas;
bool g_loaded{false};
// format of the lines, coordinates in the space of the file:
// area <id> seed <seed> density <per ha> spacing <m> scale <min> <max> rotation <random|fixed> <deg> ground <0|1>
// set <kind> <id> objects <count> label <text to the end of the line>
// outline <count> <x y z>...
// template <node template to the end of the line>
// end
std::string trimmed(std::string Text)
{
auto const first{Text.find_first_not_of(" \t")};
if (first == std::string::npos)
return {};
auto const last{Text.find_last_not_of(" \t\r\n")};
return Text.substr(first, last - first + 1);
}
void mark(scene::layer_handle const Layer)
{
if (false == scene::Layers.valid(Layer))
return;
auto const &context{scene::Layers.layer(Layer).context_insert()};
std::vector<std::string> lines;
for (auto const &entry : g_areas)
{
if (entry.layer != Layer)
continue;
if (lines.empty())
lines.emplace_back("# areas filled with models in the editor, the simulation skips these lines");
auto header{format("area %s seed %u density %.3f spacing %.3f", entry.id.c_str(), static_cast<unsigned>(entry.seed), entry.density, entry.spacing)};
header += format(" scale %.3f %.3f rotation %s %.3f", entry.scale_min, entry.scale_max, entry.random_rotation ? "random" : "fixed", entry.rotation);
header += format(" ground %d set %d %d objects %zu label %s", entry.models_as_ground ? 1 : 0, entry.set_kind, entry.set_id, entry.objects, entry.label.c_str());
lines.push_back(std::move(header));
auto outline{format("outline %zu", entry.outline.size())};
for (auto const &point : entry.outline)
{
auto const local{context.to_local(point)};
outline += format(" %.4f %.4f %.4f", local.x, local.y, local.z);
}
lines.push_back(std::move(outline));
for (auto const &entry_template : entry.templates)
lines.push_back("template " + entry_template);
lines.emplace_back("end");
}
scene::Layers.mark(Layer, kMark, std::move(lines));
}
} // namespace
void reset()
{
g_areas.clear();
g_loaded = false;
}
void load()
{
if (g_loaded || scene::Layers.empty())
return;
g_loaded = true;
g_areas.clear();
for (auto const layer : scene::Layers.marked_layers(kMark))
{
auto const &context{scene::Layers.layer(layer).context_insert()};
area entry;
bool open{false};
for (auto const &text : scene::Layers.marked(layer, kMark))
{
std::istringstream line{text};
std::string keyword;
line >> keyword;
if (keyword == "area")
{
entry = area{};
entry.layer = layer;
std::string seed, density, spacing, scale, rotation, rotationkind, ground, set, objects, label;
int groundvalue{1};
unsigned seedvalue{0};
line >> entry.id >> seed >> seedvalue >> density >> entry.density >> spacing >> entry.spacing >> scale >> entry.scale_min >> entry.scale_max;
line >> rotation >> rotationkind >> entry.rotation >> ground >> groundvalue >> set >> entry.set_kind >> entry.set_id >> objects >> entry.objects >> label;
open = (false == line.fail()) && (false == entry.id.empty()) && label == "label";
if (false == open)
continue;
entry.seed = seedvalue;
entry.random_rotation = (rotationkind != "fixed");
entry.models_as_ground = (groundvalue != 0);
std::string rest;
std::getline(line, rest);
entry.label = trimmed(rest);
}
else if (keyword == "outline" && open)
{
std::size_t count{0};
line >> count;
for (std::size_t i = 0; i < count && i < 100000; ++i)
{
glm::dvec3 point{0.0};
line >> point.x >> point.y >> point.z;
if (line.fail())
break;
entry.outline.push_back(context.to_world(point));
}
}
else if (keyword == "template" && open)
{
std::string rest;
std::getline(line, rest);
rest = trimmed(rest);
if (false == rest.empty())
entry.templates.push_back(std::move(rest));
}
else if (keyword == "end" && open)
{
open = false;
if (entry.outline.size() >= 3)
g_areas.push_back(std::move(entry));
}
}
}
if (false == g_areas.empty())
WriteLog("Editor: " + std::to_string(g_areas.size()) + " filled area(s) read from the scenery", logtype::generic);
}
std::vector<area> const &areas()
{
load();
return g_areas;
}
area const *find(std::string const &Id)
{
load();
auto const lookup{std::find_if(g_areas.begin(), g_areas.end(), [&](area const &Entry) { return Entry.id == Id; })};
return lookup != g_areas.end() ? &(*lookup) : nullptr;
}
std::string next_id()
{
load();
for (std::size_t number = g_areas.size() + 1;; ++number)
{
auto const id{"fill" + std::to_string(number)};
if (find(id) == nullptr && simulation::Instances.find(model_name(id, 0)) == nullptr)
return id;
}
}
void put(area Entry)
{
load();
std::set<scene::layer_handle> layers{Entry.layer};
auto const existing{std::find_if(g_areas.begin(), g_areas.end(), [&](area const &Other) { return Other.id == Entry.id; })};
if (existing != g_areas.end())
{
layers.insert(existing->layer);
*existing = std::move(Entry);
}
else
g_areas.push_back(std::move(Entry));
for (auto const layer : layers)
mark(layer);
}
void forget(std::string const &Id)
{
load();
std::set<scene::layer_handle> layers;
for (auto const &entry : g_areas)
if (entry.id == Id)
layers.insert(entry.layer);
g_areas.erase(std::remove_if(g_areas.begin(), g_areas.end(), [&](area const &Entry) { return Entry.id == Id; }), g_areas.end());
for (auto const layer : layers)
mark(layer);
}
std::string model_name(std::string const &Id, std::size_t const Number)
{
return Id + "_" + std::to_string(Number);
}
bool owns(std::string const &Id, std::string const &Name)
{
if (Name.size() <= Id.size() + 1 || Name.compare(0, Id.size(), Id) != 0 || Name[Id.size()] != '_')
return false;
return std::all_of(Name.begin() + static_cast<std::ptrdiff_t>(Id.size()) + 1, Name.end(), [](char const Character) { return Character >= '0' && Character <= '9'; });
}
} // namespace fill_store

View File

@@ -0,0 +1,59 @@
/*
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 <cstdint>
#include <string>
#include <vector>
#include <glm/glm.hpp>
#include "scene/scenelayers.h"
// areas filled with models in the editor, kept in the scenery files as "//$u" comment lines: the outline, the models and the
// settings of the fill and the seed of its random numbers, so the area can be picked up again, changed and filled anew. the
// models of an area are named after it, <id>_<number>, which is how they're found again in a scenery loaded later
namespace fill_store
{
struct area
{
std::string id; // fill<number>, the prefix of the names of its models
std::string label; // given by the user, shown in the list
scene::layer_handle layer{null_handle};
std::vector<glm::dvec3> outline; // world space, in the order it was clicked
std::vector<std::string> templates; // the node templates the models were drawn from
int set_kind{0}; // the model set the templates came from (model_set_ref): 0 the list of the tool, 1 a user set, 2 a node bank group
int set_id{-1};
float density{200.0f}; // objects per hectare
float spacing{2.0f}; // minimal distance between the objects, m
float scale_min{1.0f};
float scale_max{1.0f};
bool random_rotation{true};
float rotation{0.0f}; // yaw of all objects without the random rotation, degrees
bool models_as_ground{true};
std::uint32_t seed{0}; // of the random numbers of the fill: the same seed and settings make the same objects
std::size_t objects{0}; // placed by the last fill
};
void reset();
void load();
std::vector<area> const &areas();
area const *find(std::string const &Id);
// an id no area has and no model is named after yet
std::string next_id();
// the area of the id is replaced, or added; it's kept in the file of its layer
void put(area Entry);
void forget(std::string const &Id);
// the name of the model of the area with the number
std::string model_name(std::string const &Id, std::size_t const Number);
// whether the model name is one of the models of the area
bool owns(std::string const &Id, std::string const &Name);
} // namespace fill_store

View File

@@ -3309,6 +3309,57 @@ msgstr "Szacowana liczba obiektów: %.0f"
msgid "Fill area"
msgstr "Wypełnij obszar"
msgid "LMB: add outline point Backspace: remove last point Enter: fill and finish Esc: drop the outline"
msgstr "LPM: dodaj punkt obrysu Backspace: usuń ostatni punkt Enter: wypełnij i zakończ Esc: porzuć obrys"
msgid "Changing: %s"
msgstr "Zmieniasz: %s"
msgid "Fill area (Enter)"
msgstr "Wypełnij obszar (Enter)"
msgid "Fill again (Enter)"
msgstr "Wypełnij od nowa (Enter)"
msgid "Undo last fill"
msgstr "Cofnij ostatnie wypełnienie"
msgid "Area %zu"
msgstr "Obszar %zu"
msgid "%s: placed %zu of %zu objects"
msgstr "%s: postawiono %zu z %zu obiektów"
msgid "%s left as it was"
msgstr "%s zostaje bez zmian"
msgid "%s picked up: change the outline or the settings, Enter fills it anew, Esc leaves it as it was"
msgstr "%s do zmiany: popraw obrys albo ustawienia, Enter wypełnia od nowa, Esc zostawia bez zmian"
msgid "%s removed with its %zu objects"
msgstr "Usunięto %s razem z obiektami (%zu)"
msgid "%s back as it was, %zu objects"
msgstr "%s przywrócony, obiektów: %zu"
msgid "Filled areas: %zu"
msgstr "Wypełnione obszary: %zu"
msgid "None yet. Enter fills the outline and puts the area here, to be changed later"
msgstr "Jeszcze żadnego. Enter wypełnia obrys i dopisuje obszar tutaj, do późniejszej zmiany"
msgid "ha"
msgstr "ha"
msgid "Change"
msgstr "Zmień"
msgid "Its outline and settings back in the tool: move the points, change the models or the density, Enter fills it anew"
msgstr "Obrys i ustawienia wracają do narzędzia: przesuń punkty, zmień modele albo gęstość, Enter wypełnia od nowa"
msgid "The area and its models removed; Undo last fill brings them back"
msgstr "Usuwa obszar i jego modele; Cofnij ostatnie wypełnienie przywraca je"
msgid "Copies of the selected model, set out in a row"
msgstr "Kopie zaznaczonego modelu, ustawione w rzędzie"

View File

@@ -858,7 +858,8 @@ namespace
{
// marks of the lines the editor keeps track of. The letters the starters read in a scenery file are left to them: the title //$n,
// the description //$d, the attachments //$f, the image //$i, the id //$l and the old scenery //$a, in the trainsets //$o and //$r
std::array<char const *, 11> const editormarks{"//$p", "//$h", "//$r", "//$b", "//$c", "//$o", "//$s", "//$k", "//$z", "//$w", "//$t"};
// the filled areas of the area fill //$u
std::array<char const *, 12> const editormarks{"//$p", "//$h", "//$r", "//$b", "//$c", "//$o", "//$s", "//$k", "//$z", "//$w", "//$t", "//$u"};
// the marks some of these had before, on the letters of the starters: the download area //$z was //$a, the shared grade lines //$w
// were //$n, the fitted tracks //$t were //$f. Their lines are read only by the word the editor wrote in them, or by the start of
@@ -894,7 +895,7 @@ bool editor_line(std::string_view const Mark, std::string const &Text)
std::string on, state, next;
return words >> on >> state && on == "on" && (state == "0" || state == "1") && (false == static_cast<bool>(words >> next) || next == "origin" || next == "year");
}
static std::array<std::pair<std::string_view, std::array<std::string_view, 11>>, 7> const words{{
static std::array<std::pair<std::string_view, std::array<std::string_view, 11>>, 8> const words{{
{"//$h", {"#", "alignment", "source", "ends", "norms", "pieces", "kept", "vertex", "click", "element", "end"}},
{"//$r", {"#", "switch", "slip", "crossing", "double", "connection"}},
{"//$s", {"#", "station"}},
@@ -902,6 +903,7 @@ bool editor_line(std::string_view const Mark, std::string const &Text)
{"//$z", {"#", "point"}},
{"//$w", {"#", "gradeline"}},
{"//$t", {"#", "fitted"}},
{"//$u", {"#", "area", "outline", "template", "end"}},
}};
auto const lookup{std::find_if(words.begin(), words.end(), [&](auto const &Entry) { return Entry.first == Mark; })};
if (lookup == words.end())

View File

@@ -545,8 +545,8 @@ void state_manager::process_commands() {
}
}
TAnimModel * state_manager::create_model(const std::string &src, const std::string &name, const glm::dvec3 &position) {
return m_serializer.create_model(src, name, position);
TAnimModel * state_manager::create_model(const std::string &src, const std::string &name, const glm::dvec3 &position, scene::layer_handle const Layer) {
return m_serializer.create_model(src, name, position, Layer);
}
std::vector<TDynamicObject *> state_manager::insert_trainset(std::string const &Name, TTrack *Path, double const Offset, std::string const &Vehicles, bool const Reversed) {

View File

@@ -39,7 +39,7 @@ public:
process_commands();
// create model from node string
TAnimModel *
create_model(const std::string &src, const std::string &name, const glm::dvec3 &position);
create_model(const std::string &src, const std::string &name, const glm::dvec3 &position, scene::layer_handle Layer = null_handle);
// places the vehicles, given as their node statements, as a trainset on the path. returns: the vehicles made
std::vector<TDynamicObject *>
insert_trainset(std::string const &Name, TTrack *Path, double const Offset, std::string const &Vehicles, bool const Reversed = false);

View File

@@ -1939,7 +1939,7 @@ state_serializer::export_nodes_to_stream(std::ostream &scmfile, bool Dirty) cons
}
}
TAnimModel *state_serializer::create_model(const std::string &src, const std::string &name, const glm::dvec3 &position) {
TAnimModel *state_serializer::create_model(const std::string &src, const std::string &name, const glm::dvec3 &position, scene::layer_handle const Layer) {
cParser parser(src);
parser.getTokens(); // "node"
parser.getTokens(2); // ranges
@@ -1950,7 +1950,8 @@ TAnimModel *state_serializer::create_model(const std::string &src, const std::st
parser.getTokens(2); // name, type
nodedata.name = name;
nodedata.type = "model";
nodedata.layer = scene::Layers.active(); // null_handle unless the scenery was opened for editing
// null_handle unless the scenery was opened for editing
nodedata.layer = Layer != null_handle ? Layer : scene::Layers.active();
scene::scratch_data scratch;

View File

@@ -43,7 +43,8 @@ public:
void
export_as_text( std::string const &Scenariofile ) const;
// create new model from node stirng
TAnimModel * create_model(std::string const &src, std::string const &name, const glm::dvec3 &position);
// the model goes to the layer given, or to the active one with none given
TAnimModel * create_model(std::string const &src, std::string const &name, const glm::dvec3 &position, scene::layer_handle Layer = null_handle);
// places the vehicles, given as their node statements, as a trainset on the path, while the simulation runs. returns: the vehicles made
std::vector<TDynamicObject *> insert_trainset(std::string const &Name, TTrack *Path, double const Offset, std::string const &Vehicles, bool const Reversed = false);
// create new eventlauncher from node stirng