mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-22 05:34:58 +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:
@@ -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"
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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
220
editor/editorFillStore.cpp
Normal 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
|
||||
59
editor/editorFillStore.hpp
Normal file
59
editor/editorFillStore.hpp
Normal 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
|
||||
@@ -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"
|
||||
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user