diff --git a/application/editormode.cpp b/application/editormode.cpp index 73916325..5f92461b 100644 --- a/application/editormode.cpp +++ b/application/editormode.cpp @@ -391,7 +391,9 @@ namespace // ground triangles overlapping an XZ rectangle (Min/Max are x,z). shapes hold the (legacy) terrain, // model instances at least ModelRadius large (if ModelsAsGround) the terrain tiles - void gather_ground_triangles(glm::dvec2 const &Min, glm::dvec2 const &Max, bool const ModelsAsGround, float const ModelRadius, std::vector &Out, bool const Skiproads = false) + // Heightmap: the heightmap terrain is given as triangles too (for the ones which can ask the terrain for heights, it's a waste) + void gather_ground_triangles(glm::dvec2 const &Min, glm::dvec2 const &Max, bool const ModelsAsGround, float const ModelRadius, std::vector &Out, bool const Skiproads = false, + bool const Heightmap = true) { auto const started = std::chrono::steady_clock::now(); ++ground_question; @@ -444,7 +446,8 @@ namespace } } // the heightmap terrain answers for itself, with its full grid whatever is drawn of it - EditorTerrain.gather_triangles(Min, Max, Out); + if (Heightmap) + EditorTerrain.gather_triangles(Min, Max, Out); trim_ground_meshes(); // going through the scenery is the one thing here which can take long enough to be felt; when it does it's worth knowing auto const elapsed = std::chrono::duration(std::chrono::steady_clock::now() - started).count(); @@ -533,9 +536,10 @@ editor_mode::editor_mode() { road_select(nullptr); // the orthophoto is fitted onto the same ground as the area fill uses, terrain tile models included // the roads built in the editor aren't ground: the imagery goes under them - m_orthophoto.ground_source([](glm::dvec2 const &Min, glm::dvec2 const &Max, std::vector &Out) { - gather_ground_triangles(Min, Max, true, 50.0f, Out, true); + m_orthophoto.ground_source([](glm::dvec2 const &Min, glm::dvec2 const &Max, bool const Heightmap, std::vector &Out) { + gather_ground_triangles(Min, Max, true, 50.0f, Out, true, Heightmap); }); + m_orthophoto.height_source([](double const X, double const Z, double &Height) { return EditorTerrain.height_at(X, Z, Height); }); editor_track::observe(this); } @@ -1380,6 +1384,8 @@ bool editor_mode::update() // the brush of the terrain works while the left mouse button is held if (terrain_brush() && mouseHold) handle_terrain_brush(deltarealtime); + else + m_terrain_stroke = false; if (m_terrain_open) draw_terrain_overlay(); @@ -1606,6 +1612,8 @@ void editor_mode::render_terrain_ui() ImGui::SameLine(); radio(STR_C("Smooth"), terrain_tool::smooth, STR_C("LMB evens the terrain out under the brush")); ImGui::SameLine(); + radio(STR_C("Level"), terrain_tool::level, STR_C("LMB leads the terrain under the brush to the target height, Ctrl+LMB takes the target height from what's under the cursor")); + ImGui::SameLine(); radio(STR_C("Paint"), terrain_tool::paint, STR_C("LMB paints the material chosen in the palette, Shift+LMB the first material of the palette")); ImGui::SameLine(); radio(STR_C("Water"), terrain_tool::water, STR_C("LMB adds a point of the outline of a body of water, Shift+LMB takes the last one back")); @@ -1650,7 +1658,23 @@ void editor_mode::render_terrain_ui() ImGui::DragFloat(STR_C("Strength"), &m_terrain_brush_strength, 0.05f, 0.05f, 50.0f, "%.2f"); m_terrain_brush_strength = std::max(0.05f, m_terrain_brush_strength); if (ImGui::IsItemHovered()) - ImGui::SetTooltip("%s", STR_C("Sculpting: metres per second at the middle of the brush; smoothing and painting: how fast they work")); + ImGui::SetTooltip("%s", STR_C("Sculpting: metres per second at the middle of the brush; smoothing, levelling and painting: how fast they work")); + if (m_terrain_tool == terrain_tool::level) + { + ImGui::SetNextItemWidth(120.0f); + ImGui::DragFloat(STR_C("Target height (m)"), &m_terrain_target, 0.05f, -1000.0f, 5000.0f, "%.2f"); + ImGui::SameLine(); + if (ImGui::Button(m_terrain_picking ? STR_C("Click in the view...") : STR_C("Pick"))) + m_terrain_picking = false == m_terrain_picking; + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("%s", STR_C("The next click takes the height of whatever is under the cursor: terrain, a track, a model.\nCtrl+LMB does the same at any time")); + char const *modes[]{STR_C("Raise and lower"), STR_C("Only raise"), STR_C("Only lower")}; + ImGui::SetNextItemWidth(160.0f); + ImGui::Combo("##levelmode", &m_terrain_level_mode, modes, IM_ARRAYSIZE(modes)); + ImGui::Checkbox(STR_C("Target where the stroke starts"), &m_terrain_target_from_stroke); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("%s", STR_C("Each stroke takes the height of the terrain under the cursor where it starts as its target,\nand drags it along: the ground stroked over is levelled with that point")); + } } if (ImGui::CollapsingHeader(STR_C("Materials"), m_terrain_tool == terrain_tool::paint ? ImGuiTreeNodeFlags_DefaultOpen : 0)) @@ -1834,6 +1858,30 @@ void editor_mode::draw_terrain_overlay() } auto const color = m_terrain_tool == terrain_tool::paint ? IM_COL32(120, 230, 120, 220) : m_terrain_tool == terrain_tool::smooth ? IM_COL32(120, 200, 255, 220) : IM_COL32(255, 180, 80, 220); polyline(circle, color, true, 2.0f); + if (m_terrain_tool == terrain_tool::level) + { + // the target: the rim of the brush at its height, joined with the ground, and the height by the cursor + auto const target = static_cast(m_terrain_target); + std::vector level; + for (auto const &point : circle) + level.emplace_back(point.x, target, point.z); + ImU32 const levelcolor = IM_COL32(255, 230, 90, 230); + polyline(level, levelcolor, true, 1.5f); + for (std::size_t i = 0; i < circle.size(); i += circle.size() / 8) + { + ImVec2 from, to; + if (projection.project(circle[i], from) && projection.project(level[i], to)) + drawlist->AddLine(from, to, IM_COL32(255, 230, 90, 120), 1.0f); + } + ImVec2 label; + if (projection.project(glm::dvec3{cursor.x, target, cursor.z}, label)) + { + double ground{cursor.y}; + m_streamer.height_at(cursor.x, cursor.z, ground); + auto const text = format("%.2f m (%+.2f)", target, target - ground); + drawlist->AddText(ImVec2(label.x + 12.0f, label.y - 8.0f), levelcolor, text.c_str()); + } + } } if ((m_terrain_tool == terrain_tool::chunks || m_terrain_tool == terrain_tool::spacing) && hovering) { @@ -2888,6 +2936,18 @@ void editor_mode::handle_terrain_brush(double Deltatime) case terrain_tool::smooth: shaped = m_streamer.smooth(world.x, world.z, m_terrain_brush_radius, std::min(1.0, rate * 0.5)); break; + case terrain_tool::level: + { + if (false == m_terrain_stroke && m_terrain_target_from_stroke) + { + double height; + if (m_streamer.height_at(world.x, world.z, height)) + m_terrain_target = static_cast(height); + } + m_terrain_stroke = true; + shaped = m_streamer.level(world.x, world.z, m_terrain_brush_radius, m_terrain_target, std::min(1.0, rate * 0.5), m_terrain_level_mode); + break; + } case terrain_tool::paint: m_streamer.paint(world.x, world.z, m_terrain_brush_radius, std::min(1.0, rate * 0.25), Global.shiftState ? std::uint16_t{0} : static_cast(m_terrain_layer)); break; @@ -2902,6 +2962,16 @@ void editor_mode::handle_terrain_brush(double Deltatime) } } +bool editor_mode::pick_terrain_target() +{ + glm::dvec3 const offset = GfxRenderer->Mouse_Position(); + if (glm::length(offset) < 1e-3) + return false; // nothing under the cursor + m_terrain_target = static_cast(Camera.Pos.y + offset.y); + m_terrain_status = format(STR_C("Target height: %.2f m"), m_terrain_target); + return true; +} + void editor_mode::capture_terrain() { TAnimModel *model = dynamic_cast(m_node); @@ -5153,6 +5223,15 @@ void editor_mode::on_mouse_button(int const Button, int const Action, int const // with a brush of the terrain the left button works the brush instead of picking nodes if (terrain_brush() && Button == GLFW_MOUSE_BUTTON_LEFT) { + if (m_terrain_tool == terrain_tool::level && is_press(Action) && (Global.ctrlState || m_terrain_picking)) + { + // a click which picks the target height doesn't level anything + pick_terrain_target(); + m_terrain_picking = false; + mouseHold = false; + m_input.mouse.button(Button, Action); + return; + } mouseHold = is_press(Action); m_input.mouse.button(Button, Action); return; diff --git a/application/editormode.h b/application/editormode.h index 35a5645d..e6258fee 100644 --- a/application/editormode.h +++ b/application/editormode.h @@ -309,12 +309,15 @@ class editor_mode : public application_mode, private editor_track::observer chunks, // adds a chunk, Shift: removes it sculpt, // raises the ground, Shift: lowers it smooth, + level, // leads the ground to the target height, Ctrl: picks the target height under the cursor paint, // paints the chosen material, Shift: the first material of the palette spacing, // gives the clicked chunk the chosen point spacing water // outlines a body of water }; terrain_tool m_terrain_tool{terrain_tool::none}; - bool terrain_brush() const { return m_terrain_tool == terrain_tool::sculpt || m_terrain_tool == terrain_tool::smooth || m_terrain_tool == terrain_tool::paint; } + bool terrain_brush() const { return m_terrain_tool == terrain_tool::sculpt || m_terrain_tool == terrain_tool::smooth || m_terrain_tool == terrain_tool::level || m_terrain_tool == terrain_tool::paint; } + // takes the height of whatever is under the cursor (terrain, track, model) for the target of the level brush. returns: false if there's nothing + bool pick_terrain_target(); bool terrain_clicking() const { return m_terrain_tool == terrain_tool::chunks || m_terrain_tool == terrain_tool::spacing || m_terrain_tool == terrain_tool::water; } // the brush, the hovered chunk and the outlines of water drawn over the viewport void draw_terrain_overlay(); @@ -410,6 +413,12 @@ class editor_mode : public application_mode, private editor_track::observer int m_terrain_add_count{4}; // chunks along a side added around the camera float m_terrain_brush_radius{12.0f}; float m_terrain_brush_strength{4.0f}; // metres per second while held; for the paint, how fast it covers + // the level brush + float m_terrain_target{0.0f}; // height the ground is led to + int m_terrain_level_mode{0}; // 0: up and down, 1: only raises, 2: only lowers + bool m_terrain_target_from_stroke{false}; // the target is the height where a stroke starts + bool m_terrain_stroke{false}; // a stroke of the brush is under way + bool m_terrain_picking{false}; // the next click picks the target height int m_terrain_layer{0}; // entry of the palette painted char m_terrain_material[128]{"grass"}; // material added to the palette float m_terrain_material_size{0.0f}; // metres its textures repeat at, 0: given by the material diff --git a/application/editormodeselftest.cpp b/application/editormodeselftest.cpp index 3052df40..5cb2fe20 100644 --- a/application/editormodeselftest.cpp +++ b/application/editormodeselftest.cpp @@ -73,9 +73,12 @@ http://mozilla.org/MPL/2.0/. // newscenery the editor starts again with the wizard of a new scenery // vehicles logs each vehicle: its head, facing, and what its couplers hold // terrainmode the terrain field of work, with its texture browser -// terrainsculpt , terrainpaint as a stroke of the brush +// terrainsculpt , terrainpaint , +// terrainlevel [mode] as a stroke of the brush +// terrainadd chunks made around the camera, count x count, as the button of the chunks panel does it // terrainprobe logs the height of the heightmap terrain and the materials of the chunk // terrainconvert converts every material of the terrain files of the scenery +// orthophoto [in scene 0|1] the imagery layer on, placed and fitted as given // screenshot // save // log @@ -1138,19 +1141,42 @@ void editor_mode::selftest_step() } } } + else if (command == "orthophoto") + { + auto config{m_orthophoto.settings()}; + int fit{1}, inscene{0}; + words >> config.north >> config.east >> config.radius >> fit >> inscene; + config.drape = fit != 0; + config.in_scene = inscene != 0; + m_orthophoto.settings(config); + m_orthophoto.enabled(true); + WriteLog(format("SELFTEST orthophoto at %.0f %.0f, radius %d, %s%s", config.north, config.east, config.radius, config.drape ? "fitted" : "flat", config.in_scene ? ", in the scene" : "")); + } else if (command == "terrainmode") { m_terrain_open = true; WriteLog("SELFTEST terrainmode"); } - else if (command == "terrainsculpt" || command == "terrainpaint") + else if (command == "terrainsculpt" || command == "terrainpaint" || command == "terrainlevel") { double x{0.0}, z{0.0}, radius{10.0}, value{1.0}; - words >> x >> z >> radius >> value; - auto const changed{command == "terrainsculpt" ? m_streamer.sculpt(x, z, radius, value) : m_streamer.paint(x, z, radius, 1.0, static_cast(value))}; + int mode{0}; + words >> x >> z >> radius >> value >> mode; + auto const changed{command == "terrainsculpt" ? m_streamer.sculpt(x, z, radius, value) + : command == "terrainlevel" ? m_streamer.level(x, z, radius, value, 1.0, mode) + : m_streamer.paint(x, z, radius, 1.0, static_cast(value))}; forget_ground(); WriteLog(format("SELFTEST %s %.1f %.1f: %s", command.c_str(), x, z, changed ? "changed" : "nothing changed")); } + else if (command == "terrainadd") + { + int count{1}; + float spacing{m_terrain_spacing}; + words >> count >> spacing; + m_terrain_spacing = heightmap::valid_spacing(spacing); + add_chunks_around(std::clamp(count, 1, 8)); + WriteLog("SELFTEST terrainadd: " + m_terrain_status); + } else if (command == "terrainprobe") { double x{0.0}, z{0.0}, height{0.0}; diff --git a/application/editormodeviewport.cpp b/application/editormodeviewport.cpp index 46864156..847ba8e4 100644 --- a/application/editormodeviewport.cpp +++ b/application/editormodeviewport.cpp @@ -209,6 +209,8 @@ void editor_mode::work_area_tools(std::vector &Buttons) Buttons.push_back({icon::select, STR_C("Select"), nullptr, STR_C("LMB picks the models, as in the surroundings"), chosen(terrain_tool::none), choose(terrain_tool::none)}); Buttons.push_back({icon::sculpt, STR_C("Sculpt"), nullptr, STR_C("LMB raises the terrain under the brush, Shift+LMB lowers it"), chosen(terrain_tool::sculpt), choose(terrain_tool::sculpt)}); Buttons.push_back({icon::smooth, STR_C("Smooth"), nullptr, STR_C("LMB evens the terrain out under the brush"), chosen(terrain_tool::smooth), choose(terrain_tool::smooth)}); + Buttons.push_back({icon::profile, STR_C("Level"), nullptr, STR_C("LMB leads the terrain under the brush to the target height, Ctrl+LMB takes the target height from what's under the cursor"), + chosen(terrain_tool::level), choose(terrain_tool::level)}); Buttons.push_back({icon::brush, STR_C("Paint"), nullptr, STR_C("LMB paints the material chosen in the palette, Shift+LMB the first material of the palette"), chosen(terrain_tool::paint), choose(terrain_tool::paint)}); Buttons.push_back({icon::chunks, STR_C("Chunks"), nullptr, STR_C("LMB adds a chunk next to the clicked one, Shift+LMB removes it"), chosen(terrain_tool::chunks), choose(terrain_tool::chunks)}); Buttons.push_back({icon::count, STR_C("Point spacing"), nullptr, STR_C("LMB gives the clicked chunk the point spacing chosen in the tool options"), chosen(terrain_tool::spacing), choose(terrain_tool::spacing)}); diff --git a/editor/editorOrthophoto.cpp b/editor/editorOrthophoto.cpp index 6c194b90..4710f494 100644 --- a/editor/editorOrthophoto.cpp +++ b/editor/editorOrthophoto.cpp @@ -698,7 +698,11 @@ void editor_orthophoto::settings(config const &Config) { bool const sourcechanged = (Config.year != m_config.year || Config.hires != m_config.hires); bool const shapechanged = (Config.height != m_config.height || Config.drape != m_config.drape || Config.in_scene != m_config.in_scene || Config.lift != m_config.lift); + // the surface of the ground is gathered only for the geometry in the scene, the overlay makes do with the heights + bool const groundchanged = (Config.in_scene != m_config.in_scene); m_config = Config; + if (groundchanged) + refit(); m_config.lift = std::clamp(m_config.lift, 0.0f, 50.0f); m_config.radius = std::clamp(m_config.radius, 0, max_radius); m_config.opacity = std::clamp(m_config.opacity, 0.0f, 1.0f); @@ -914,12 +918,23 @@ void editor_orthophoto::sample_ground(tile_key const &Key, tile &Tile) glm::dvec2 const corner = tile_corner(Key); glm::dvec2 const min(corner.x - tile_size, corner.y - tile_size); glm::dvec2 const max(corner.x, corner.y); + // the clipped surface is drawn only by the geometry in the scene. the overlay needs just the heights, and the heightmap + // terrain gives these straight away: its triangles (hundreds of thousands in a tile) aren't gathered for it + bool const surface = m_config.in_scene || !m_height; std::vector triangles; - m_ground(min, max, triangles); + m_ground(min, max, surface, triangles); int constexpr samples{ground_grid + 1}; double constexpr step{tile_size / ground_grid}; std::vector heights(static_cast(samples) * samples, no_height); + if (!surface) + for (int j = 0; j < samples; ++j) + for (int i = 0; i < samples; ++i) + { + double y; + if (m_height(corner.x - i * step, corner.y - j * step, y)) + heights[static_cast(j) * samples + i] = static_cast(y); + } for (auto const &triangle : triangles) { @@ -935,17 +950,20 @@ void editor_orthophoto::sample_ground(tile_key const &Key, tile &Tile) if (length < 1e-9 || normal.y / length < steepest_ground) continue; // walls and the like don't receive the imagery - glm::dvec3 polygon[8] = {a, b, c}; - glm::dvec3 scratch[8]; - int count = clip_xz(polygon, 3, scratch, 0, max.x, true); - count = clip_xz(scratch, count, polygon, 0, min.x, false); - count = clip_xz(polygon, count, scratch, 2, max.y, true); - count = clip_xz(scratch, count, polygon, 2, min.y, false); - for (int k = 1; k + 1 < count; ++k) + if (surface) { - Tile.surface.push_back(polygon[0]); - Tile.surface.push_back(polygon[k]); - Tile.surface.push_back(polygon[k + 1]); + glm::dvec3 polygon[8] = {a, b, c}; + glm::dvec3 scratch[8]; + int count = clip_xz(polygon, 3, scratch, 0, max.x, true); + count = clip_xz(scratch, count, polygon, 0, min.x, false); + count = clip_xz(polygon, count, scratch, 2, max.y, true); + count = clip_xz(scratch, count, polygon, 2, min.y, false); + for (int k = 1; k + 1 < count; ++k) + { + Tile.surface.push_back(polygon[0]); + Tile.surface.push_back(polygon[k]); + Tile.surface.push_back(polygon[k + 1]); + } } // heightfield samples under the (whole) triangle, the highest surface wins @@ -1415,7 +1433,33 @@ void editor_orthophoto::draw(glm::mat4 const &ViewProjection, glm::dvec3 const & if (draped) segments = std::max(segments, distance < 300.0 ? ground_grid : distance < 800.0 ? ground_grid / 2 : ground_grid / 4); float const segmentsize = 1.0f / static_cast(segments); - auto const height_at = [&](float U, float V) { return draped ? sample_heights(t.heights, U, V) + lift : flat; }; + // the grid points of the heights are taken as they are where the segments fall on them + int const stride = (draped && ground_grid % segments == 0) ? ground_grid / segments : 0; + auto const height_at = [&](int I, int J) { + if (!draped) + return flat; + if (stride > 0) + return static_cast(t.heights[static_cast(J * stride) * (ground_grid + 1) + I * stride]) + lift; + return sample_heights(t.heights, I * segmentsize, J * segmentsize) + lift; + }; + + // each point of the grid is projected once, with the sides of the view it's beyond: a quad wholly inside goes + // straight to the draw list, one wholly beyond a side is skipped, only the ones across an edge are clipped + int const side = segments + 1; + static std::vector points; + static std::vector codes; + points.resize(static_cast(side) * side); + codes.resize(points.size()); + for (int j = 0; j < side; ++j) + for (int i = 0; i < side; ++i) + { + auto const index = static_cast(j) * side + i; + float const u = i * segmentsize, v = j * segmentsize; + glm::vec4 const position = clip(u, v, height_at(i, j)); + points[index] = {position, {u, v}}; + codes[index] = static_cast((position.w < near_w ? 1 : 0) | (position.x > position.w * guard ? 2 : 0) | (position.x < -position.w * guard ? 4 : 0) | + (position.y > position.w * guard ? 8 : 0) | (position.y < -position.w * guard ? 16 : 0)); + } drawlist->PushTextureID((ImTextureID)(intptr_t)(textureid)); for (int j = 0; j < segments; ++j) @@ -1426,19 +1470,29 @@ void editor_orthophoto::draw(glm::mat4 const &ViewProjection, glm::dvec3 const & drawlist->PopTextureID(); return; } - float const u0 = i * segmentsize, u1 = (i + 1) * segmentsize; - float const v0 = j * segmentsize, v1 = (j + 1) * segmentsize; - clip_vertex quad[4] = { - {clip(u0, v0, height_at(u0, v0)), {u0, v0}}, - {clip(u1, v0, height_at(u1, v0)), {u1, v0}}, - {clip(u1, v1, height_at(u1, v1)), {u1, v1}}, - {clip(u0, v1, height_at(u0, v1)), {u0, v1}}, - }; - glm::vec4 const positions[4] = {quad[0].position, quad[1].position, quad[2].position, quad[3].position}; - if (outside(positions, 4)) + std::size_t const corners[4] = {static_cast(j) * side + i, static_cast(j) * side + i + 1, static_cast(j + 1) * side + i + 1, + static_cast(j + 1) * side + i}; + auto const all = codes[corners[0]] & codes[corners[1]] & codes[corners[2]] & codes[corners[3]]; + if (all != 0) + continue; // beyond one side of the view + auto const any = codes[corners[0]] | codes[corners[1]] | codes[corners[2]] | codes[corners[3]]; + if (any == 0) + { + drawlist->PrimReserve(6, 4); + auto const base = static_cast(drawlist->_VtxCurrentIdx); + drawlist->PrimWriteIdx(base); + drawlist->PrimWriteIdx(static_cast(base + 1)); + drawlist->PrimWriteIdx(static_cast(base + 2)); + drawlist->PrimWriteIdx(base); + drawlist->PrimWriteIdx(static_cast(base + 2)); + drawlist->PrimWriteIdx(static_cast(base + 3)); + for (auto const corner : corners) + drawlist->PrimWriteVtx(toscreen(points[corner].position), ImVec2(points[corner].uv.x, points[corner].uv.y), color); continue; + } // clip against the near plane and the (slightly widened) sides of the view + clip_vertex quad[4] = {points[corners[0]], points[corners[1]], points[corners[2]], points[corners[3]]}; clip_vertex buffer0[12], buffer1[12]; int count = clip_polygon(quad, 4, buffer0, [](glm::vec4 const &v) { return v.w - near_w; }); count = clip_polygon(buffer0, count, buffer1, [&](glm::vec4 const &v) { return v.w * guard - v.x; }); diff --git a/editor/editorOrthophoto.hpp b/editor/editorOrthophoto.hpp index dd081021..8d7d942f 100644 --- a/editor/editorOrthophoto.hpp +++ b/editor/editorOrthophoto.hpp @@ -67,8 +67,11 @@ class editor_orthophoto }; using world_triangle = std::array; - // supplies the ground triangles overlapping an XZ rectangle (Min/Max are x,z); used to drape the imagery - using ground_query = std::function &Out)>; + // supplies the ground triangles overlapping an XZ rectangle (Min/Max are x,z); used to drape the imagery. + // Heightmap: the heightmap terrain as triangles too; without it the terrain is asked through the height query alone + using ground_query = std::function &Out)>; + // height of the heightmap terrain at a point, false where there's none + using height_query = std::function; struct statistics { @@ -93,6 +96,7 @@ class editor_orthophoto // changes of year / resolution invalidate resident tiles, the rest applies immediately void settings(config const &Config); void ground_source(ground_query Query) { m_ground = std::move(Query); } + void height_source(height_query Query) { m_height = std::move(Query); } // samples the ground again (after it was edited); tiles are refitted progressively void refit(); // takes the scene geometry out of the region (e.g. when the editor is left); it's re-created on the next update @@ -202,6 +206,7 @@ class editor_orthophoto std::vector m_free_slots; // pool of textures, reused between tiles int m_texture_count{0}; ground_query m_ground; + height_query m_height; scene::basic_region *m_region{nullptr}; // region the scene geometry was put into std::multimap m_free_chunks; // geometry chunks by capacity, reused between tiles // the scene opacity is baked into the textures, which means reading the tiles again; applied once the value settles diff --git a/editor/editorTerrainStreamer.cpp b/editor/editorTerrainStreamer.cpp index a6b8606d..27d75a95 100644 --- a/editor/editorTerrainStreamer.cpp +++ b/editor/editorTerrainStreamer.cpp @@ -1041,6 +1041,27 @@ bool terrain_streamer::smooth(double X, double Z, double Radius, double Amount) }); } +bool terrain_streamer::level(double X, double Z, double Radius, double Target, double Amount, int const Mode) +{ + if (Radius <= 0.0 || Amount <= 0.0) + return false; + return reshape(glm::dvec2{X - Radius, Z - Radius}, glm::dvec2{X + Radius, Z + Radius}, [&](double const Vx, double const Vz, float &Height) { + auto const distance{std::sqrt((Vx - X) * (Vx - X) + (Vz - Z) * (Vz - Z))}; + if (distance > Radius) + return false; + auto const own{static_cast(Height)}; + if ((Mode == 1 && own >= Target) || (Mode == 2 && own <= Target)) + return false; + // the middle of the brush gets there, the rim follows less; what's within the step of the stored heights is there already + auto const levelled{own + (Target - own) * std::min(1.0, Amount * falloff(distance, Radius))}; + auto const result{std::abs(Target - levelled) < heightmap::height_step ? Target : levelled}; + if (std::abs(result - own) < 1e-5) + return false; + Height = static_cast(result); + return true; + }); +} + bool terrain_streamer::paint(double X, double Z, double Radius, double Strength, std::uint16_t Layer) { if (Radius <= 0.0 || Strength <= 0.0) diff --git a/editor/editorTerrainStreamer.hpp b/editor/editorTerrainStreamer.hpp index 2e99e449..62e3cd9e 100644 --- a/editor/editorTerrainStreamer.hpp +++ b/editor/editorTerrainStreamer.hpp @@ -93,6 +93,9 @@ class terrain_streamer bool sculpt(double X, double Z, double Radius, double Strength); // evens out the ground within Radius of (X,Z), Amount (0..1) of the way at the centre bool smooth(double X, double Z, double Radius, double Amount); + // leads the ground within Radius of (X,Z) towards the height Target, Amount (0..1) of the way at the centre; + // Mode: 0 up and down, 1 only raises it, 2 only lowers it + bool level(double X, double Z, double Radius, double Target, double Amount, int Mode = 0); // gives every grid point within the rectangle to Shaper, with its world position and height (before the modifiers); // Shaper returns true if it changed the height bool reshape(glm::dvec2 const &Min, glm::dvec2 const &Max, std::function const &Shaper);