diff --git a/application/editormode.cpp b/application/editormode.cpp index 653563a1..2b70bafa 100644 --- a/application/editormode.cpp +++ b/application/editormode.cpp @@ -1604,13 +1604,16 @@ void editor_mode::render_terrain_ui() }; // the tools are named like the headers below, which would give them the same IDs ImGui::PushID("terrain_tools"); + // the tools working on a click, then the brushes radio(STR_C("Select"), terrain_tool::none, STR_C("LMB picks the models, as in the surroundings")); ImGui::SameLine(); radio(STR_C("Chunks"), terrain_tool::chunks, STR_C("LMB adds a chunk shaped as the ground under it, next to the clicked one; Shift+LMB removes the clicked chunk")); ImGui::SameLine(); radio(STR_C("Spacing"), terrain_tool::spacing, STR_C("LMB selects the clicked chunk, Ctrl+LMB adds it to the selection or takes it away;\nthe point spacing of the selected chunks is converted in \"Chunk resolution\" below")); ImGui::SameLine(); - radio(STR_C("Restore"), terrain_tool::restore, STR_C("LMB takes back the touch-ups made over the tracks under the brush:\nthe terrain returns to the shape the modifiers (tracks) give it")); + 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")); + ImGui::SameLine(); + radio(STR_C("Fill"), terrain_tool::fill, STR_C("LMB adds a point of the outline of an area to fill with a material, Shift+LMB takes the last one back")); radio(STR_C("Sculpt"), terrain_tool::sculpt, STR_C("LMB raises the terrain under the brush, Shift+LMB lowers it")); ImGui::SameLine(); radio(STR_C("Smooth"), terrain_tool::smooth, STR_C("LMB evens the terrain out under the brush")); @@ -1619,7 +1622,7 @@ void editor_mode::render_terrain_ui() 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")); + radio(STR_C("Restore"), terrain_tool::restore, STR_C("LMB takes back the touch-ups made over the tracks under the brush:\nthe terrain returns to the shape the modifiers (tracks) give it")); ImGui::PopID(); m_terrain_tool = static_cast(tool); @@ -1747,7 +1750,9 @@ void editor_mode::render_terrain_ui() m_terrain_layer = std::clamp(m_terrain_layer, 0, static_cast(layers.size()) - 1); for (std::size_t i = 0; i < layers.size(); ++i) { - auto const label{layers[i].size > 0.f ? format("%zu: %s (%.1f m)", i, layers[i].material.c_str(), layers[i].size) : format("%zu: %s", i, layers[i].material.c_str())}; + auto label{layers[i].size > 0.f ? format("%zu: %s (%.1f m)", i, layers[i].material.c_str(), layers[i].size) : format("%zu: %s", i, layers[i].material.c_str())}; + if (layers[i].rotation != 0.f) + label += format(STR_C(", turned %.0f deg"), layers[i].rotation); if (ImGui::Selectable(label.c_str(), static_cast(i) == m_terrain_layer)) m_terrain_layer = static_cast(i); // a material dropped on an entry takes its place, on every chunk painted with it @@ -1764,6 +1769,14 @@ void editor_mode::render_terrain_ui() m_streamer.layer_size(static_cast(m_terrain_layer), size); if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", STR_C("Metres the textures of the chosen material repeat at; 0: as the material gives it, or 8 m")); + auto rotation{layers[m_terrain_layer].rotation}; + ImGui::SetNextItemWidth(120.0f); + ImGui::SliderFloat(STR_C("Turned by (deg)"), &rotation, -180.0f, 180.0f, "%.0f"); + if (ImGui::IsItemDeactivatedAfterEdit()) + m_streamer.layer_rotation(static_cast(m_terrain_layer), rotation); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("%s", STR_C("Angle the textures of the chosen material are turned by, on every chunk painted with it.\n" + "Ctrl+click to type it. To have the material turned in one place only, fill it there with an angle of its own.")); } ImGui::SetNextItemWidth(160.0f); ImGui::InputText(STR_C("Material"), m_terrain_material, IM_ARRAYSIZE(m_terrain_material)); @@ -1775,6 +1788,35 @@ void editor_mode::render_terrain_ui() "A texture dragged from the browser onto an entry of the palette takes its place.")); } + if (ImGui::CollapsingHeader(STR_C("Fill"), m_terrain_tool == terrain_tool::fill ? ImGuiTreeNodeFlags_DefaultOpen : 0)) + { + auto const &layers{m_streamer.manifest().layers}; + if (false == layers.empty()) + { + auto const &chosen{layers[std::clamp(m_terrain_layer, 0, static_cast(layers.size()) - 1)]}; + ImGui::Text(STR_C("Material: %s (chosen in the palette below)"), chosen.material.c_str()); + } + ImGui::Text(STR_C("Outline: %zu points"), m_paint_outline.size()); + ImGui::SetNextItemWidth(120.0f); + ImGui::DragFloat(STR_C("Edge blur (m)"), &m_paint_feather, 0.1f, 0.0f, 100.0f, m_paint_feather > 0.0f ? "%.1f" : STR_C("sharp")); + m_paint_feather = std::max(0.0f, m_paint_feather); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("%s", STR_C("Metres across the outline the material blends in over, half of them inside the area.\n" + "0: a sharp edge, as sharp as the paint samples go: every metre, or every 0.5 m in chunks converted to 0.5 m with fine paint")); + ImGui::SetNextItemWidth(120.0f); + ImGui::SliderFloat(STR_C("Texture turned by (deg)"), &m_paint_rotation, -180.0f, 180.0f, "%.0f"); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("%s", STR_C("The area gets the material turned by this angle: an entry of the palette with the material at that angle\n" + "is used, or added. Ctrl+click to type it")); + ImGui::BeginDisabled(m_paint_outline.size() < 3 || layers.empty()); + if (ImGui::Button(STR_C("Fill the area"))) + fill_terrain_area(); + ImGui::EndDisabled(); + ImGui::SameLine(); + if (ImGui::Button(STR_C("Clear the outline##fill"))) + m_paint_outline.clear(); + } + if (ImGui::CollapsingHeader(STR_C("Water"), m_terrain_tool == terrain_tool::water ? ImGuiTreeNodeFlags_DefaultOpen : 0)) { if (m_terrain_tool == terrain_tool::water) @@ -2072,6 +2114,32 @@ void editor_mode::draw_terrain_overlay() outline.emplace_back(point.x, water[i].level, point.y); polyline(outline, static_cast(i) == m_water_selected ? IM_COL32(120, 200, 255, 255) : IM_COL32(60, 120, 220, 160), true, static_cast(i) == m_water_selected ? 2.5f : 1.5f); } + if (m_terrain_tool == terrain_tool::fill && false == m_paint_outline.empty()) + { + // laid over the ground, the edges followed every few metres + std::vector outline; + auto const closed = m_paint_outline.size() >= 3; + for (std::size_t i = 0; i + (closed ? 0 : 1) < m_paint_outline.size(); ++i) + { + auto const &from = m_paint_outline[i]; + auto const &to = m_paint_outline[(i + 1) % m_paint_outline.size()]; + auto const steps = std::clamp(static_cast(glm::distance(glm::dvec2{from.x, from.z}, glm::dvec2{to.x, to.z}) / 4.0), 1, 200); + for (int k = 0; k < steps; ++k) + { + auto const point = from + (to - from) * (static_cast(k) / steps); + outline.emplace_back(point.x, ground(point.x, point.z, point.y) + 0.15, point.z); + } + } + if (false == closed) + outline.push_back(m_paint_outline.back() + glm::dvec3{0.0, 0.15, 0.0}); + polyline(outline, IM_COL32(250, 200, 90, 255), false, 2.0f); + for (auto const &point : m_paint_outline) + { + ImVec2 dot; + if (projection.project(point + glm::dvec3{0.0, 0.15, 0.0}, dot)) + drawlist->AddCircleFilled(dot, 4.0f, IM_COL32(250, 200, 90, 255)); + } + } if (m_terrain_tool == terrain_tool::water && false == m_water_points.empty()) { std::vector outline; @@ -2510,6 +2578,17 @@ void editor_mode::handle_terrain_click(bool const Shift) m_terrain_status = format(STR_C("Chunks selected: %zu"), m_terrain_selection.size()); break; } + case terrain_tool::fill: + { + if (Shift) + { + if (false == m_paint_outline.empty()) + m_paint_outline.pop_back(); + return; + } + m_paint_outline.push_back(placement_on_ground(world)); + break; + } case terrain_tool::water: { if (Shift) @@ -3120,6 +3199,25 @@ void editor_mode::handle_terrain_brush(double Deltatime) } } +void editor_mode::fill_terrain_area() +{ + auto const &layers = m_streamer.manifest().layers; + if (m_paint_outline.size() < 3 || layers.empty()) + return; + auto const chosen = layers[std::clamp(m_terrain_layer, 0, static_cast(layers.size()) - 1)]; + // the material turned by its own angle is another entry of the palette + auto const rotation = static_cast(std::remainder(static_cast(m_paint_rotation), 360.0)); + auto const layer = chosen.rotation == rotation ? static_cast(std::clamp(m_terrain_layer, 0, static_cast(layers.size()) - 1)) + : m_streamer.layer(chosen.material, chosen.size, rotation); + std::vector outline; + for (auto const &point : m_paint_outline) + outline.emplace_back(point.x, point.z); + auto const filled = m_streamer.fill(outline, m_paint_feather, layer); + m_terrain_status = filled ? format(STR_C("Area filled with %s"), chosen.material.c_str()) : std::string(STR_C("Nothing filled: no chunk under the outline, or no room for another material")); + if (filled) + m_paint_outline.clear(); +} + void editor_mode::convert_selected_chunks() { // with 0.5 m spacing the paint can be as fine, the other spacings keep a sample per metre diff --git a/application/editormode.h b/application/editormode.h index 6b21786c..03a53312 100644 --- a/application/editormode.h +++ b/application/editormode.h @@ -313,7 +313,8 @@ class editor_mode : public application_mode, private editor_track::observer paint, // paints the chosen material, Shift: the first material of the palette spacing, // selects chunks (Ctrl: adds or takes away one), whose point spacing is then converted water, // outlines a body of water - restore // takes the touch-ups over the modifiers back + restore, // takes the touch-ups over the modifiers back + fill // outlines an area filled with a material }; terrain_tool m_terrain_tool{terrain_tool::none}; bool terrain_brush() const @@ -325,7 +326,9 @@ class editor_mode : public application_mode, private editor_track::observer void convert_selected_chunks(); // 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; } + bool terrain_clicking() const { return m_terrain_tool == terrain_tool::chunks || m_terrain_tool == terrain_tool::spacing || m_terrain_tool == terrain_tool::water || m_terrain_tool == terrain_tool::fill; } + // fills the outlined area with the material of the chosen palette entry, turned by m_paint_rotation + void fill_terrain_area(); // the brush, the hovered chunk and the outlines of water drawn over the viewport void draw_terrain_overlay(); // forgets what's known about the ground, after the terrain changed @@ -442,6 +445,9 @@ class editor_mode : public application_mode, private editor_track::observer std::set m_terrain_selection; // chunks chosen with the spacing tool float m_terrain_convert_spacing{1.0f}; // point spacing the selected chunks are converted to bool m_terrain_convert_paint{true}; // chunks converted to 0.5 m get paint samples every 0.5 m too + std::vector m_paint_outline; // of the area filled with a material + float m_paint_feather{0.0f}; // metres the filled material blends in over across the outline, 0: sharp + float m_paint_rotation{0.0f}; // degrees the textures of the filled material are turned by float m_water_selected_level{0.0f}; // level of the chosen water, while it's edited bool m_water_level_dragged{false}; std::string m_terrain_status; diff --git a/application/editormodeselftest.cpp b/application/editormodeselftest.cpp index cd138fcc..98d4a1e2 100644 --- a/application/editormodeselftest.cpp +++ b/application/editormodeselftest.cpp @@ -84,6 +84,8 @@ http://mozilla.org/MPL/2.0/. // terrainbake the modifier baked into the ground // terrainselect [add] the chunk selected with the spacing tool (add: Ctrl) // terrainresolution [paint 0|1] the selected chunks converted, as the button of the resolution panel does it +// terrainfill ... the area outlined filled, as the fill tool does it +// terrainturn the textures of the palette entry turned // terrainwater [size] material and repeat of a body of water; terrainwaterdefault // orthophoto [in scene 0|1] the imagery layer on, placed and fitted as given // screenshot @@ -1188,6 +1190,29 @@ void editor_mode::selftest_step() forget_ground(); WriteLog(format("SELFTEST terrainmodifier: %zu modifiers", m_streamer.modifiers().size())); } + else if (command == "terrainfill") + { + int layer{0}; + words >> layer >> m_paint_feather >> m_paint_rotation; + m_terrain_layer = layer; + m_paint_outline.clear(); + double x, z; + while (words >> x >> z) + m_paint_outline.emplace_back(x, 0.0, z); + fill_terrain_area(); + std::string palette; + for (auto const &entry : m_streamer.manifest().layers) + palette += format(" [%s %.1f m %.0f deg]", entry.material.c_str(), entry.size, entry.rotation); + WriteLog("SELFTEST terrainfill: " + m_terrain_status + ", palette" + palette); + } + else if (command == "terrainturn") + { + int layer{0}; + float degrees{0.f}; + words >> layer >> degrees; + m_streamer.layer_rotation(static_cast(layer), degrees); + WriteLog(format("SELFTEST terrainturn %d: %.1f deg", layer, m_streamer.manifest().layers.at(layer).rotation)); + } else if (command == "terraintouchup") { int state{1}; @@ -1292,6 +1317,16 @@ void editor_mode::selftest_step() if (false == data.adjust.empty()) adjust = data.height_in(data.adjust, x, z); grid = format(", spacing %.1f, paint %d, base %s %.3f, touch-up %.3f", data.spacing(), data.paint, data.base.empty() ? "none" : "", base, adjust); + if (data.paint > 0) + { + // weights at the paint sample nearest the point + auto const corner{data.corner()}; + auto const ix{static_cast(std::lround((x - corner.x) / heightmap::chunk_size * data.paint))}; + auto const iz{static_cast(std::lround((z - corner.y) / heightmap::chunk_size * data.paint))}; + grid += ", weights"; + for (std::size_t slot = 0; slot < data.layer_count(); ++slot) + grid += format(" %d", data.weight(slot, std::clamp(ix, 0, data.paint), std::clamp(iz, 0, data.paint))); + } } WriteLog(format("SELFTEST terrainprobe %.1f %.1f: %s %.3f, %zu chunks, materials %s%s", x, z, found ? "height" : "no terrain", height, m_streamer.resident(), materials.c_str(), grid.c_str())); } diff --git a/application/editormodeviewport.cpp b/application/editormodeviewport.cpp index 8a9052d9..817658e3 100644 --- a/application/editormodeviewport.cpp +++ b/application/editormodeviewport.cpp @@ -216,6 +216,8 @@ void editor_mode::work_area_tools(std::vector &Buttons) Buttons.push_back({icon::count, STR_C("Point spacing"), nullptr, STR_C("LMB selects the clicked chunk, Ctrl+LMB adds one or takes it away; the tool options convert the point spacing of the selected"), chosen(terrain_tool::spacing), choose(terrain_tool::spacing)}); Buttons.push_back({icon::area_fill, STR_C("Water"), nullptr, STR_C("LMB adds a point of the outline of a body of water, Shift+LMB takes the last one back"), chosen(terrain_tool::water), choose(terrain_tool::water)}); + Buttons.push_back({icon::count, STR_C("Fill"), nullptr, STR_C("LMB adds a point of the outline of an area to fill with a material, Shift+LMB takes the last one back"), chosen(terrain_tool::fill), + choose(terrain_tool::fill)}); Buttons.push_back({icon::joints, STR_C("Restore"), nullptr, STR_C("LMB takes back the touch-ups made over the tracks: the terrain returns to the shape the tracks give it"), chosen(terrain_tool::restore), choose(terrain_tool::restore)}); auto const orthophoto{m_orthophoto.enabled()}; diff --git a/editor/editorTerrainStreamer.cpp b/editor/editorTerrainStreamer.cpp index 7a6dbab2..0c0a8161 100644 --- a/editor/editorTerrainStreamer.cpp +++ b/editor/editorTerrainStreamer.cpp @@ -358,7 +358,8 @@ void terrain_streamer::update_material(editor_terrain &Chunk) { auto const layer{data.layers[slot] == heightmap::no_layer ? std::uint16_t{0} : data.layers[slot]}; auto const size{layer < m_manifest.layers.size() ? m_manifest.layers[layer].size : 0.f}; - layers.push_back({palette_material(layer), size}); + auto const rotation{layer < m_manifest.layers.size() ? m_manifest.layers[layer].rotation : 0.f}; + layers.push_back({palette_material(layer), size, rotation}); } auto const corner{data.corner()}; auto const packcorner{heightmap::pack_corner(heightmap::pack_of(data.key))}; @@ -1166,15 +1167,62 @@ bool terrain_streamer::paint(double X, double Z, double Radius, double Strength, { if (Radius <= 0.0 || Strength <= 0.0) return false; + return paint_area(glm::dvec2{X - Radius, Z - Radius}, glm::dvec2{X + Radius, Z + Radius}, Layer, false, [&](double const Px, double const Pz) { + auto const distance{std::sqrt((Px - X) * (Px - X) + (Pz - Z) * (Pz - Z))}; + return distance > Radius ? 0.0 : Strength * falloff(distance, Radius); + }); +} + +bool terrain_streamer::fill(std::vector const &Outline, double Feather, std::uint16_t Layer, double Strength) +{ + if (Outline.size() < 3 || Strength <= 0.0) + return false; + Feather = std::max(0.0, Feather); + glm::dvec2 low{std::numeric_limits::max()}, high{-std::numeric_limits::max()}; + for (auto const &point : Outline) + { + low = glm::min(low, point); + high = glm::max(high, point); + } + // the blend runs across the outline, half of it inside + auto const margin{Feather * 0.5}; + return paint_area(low - glm::dvec2{margin}, high + glm::dvec2{margin}, Layer, true, [&](double const Px, double const Pz) { + glm::dvec2 const point{Px, Pz}; + bool inside{false}; + auto nearest{std::numeric_limits::max()}; + for (std::size_t i = 0, j = Outline.size() - 1; i < Outline.size(); j = i++) + { + auto const &a{Outline[i]}; + auto const &b{Outline[j]}; + if ((a.y > Pz) != (b.y > Pz) && Px < (b.x - a.x) * (Pz - a.y) / (b.y - a.y) + a.x) + inside = !inside; + if (Feather > 0.0) + { + auto const run{b - a}; + auto const length{glm::dot(run, run)}; + auto const t{length > 1e-12 ? std::clamp(glm::dot(point - a, run) / length, 0.0, 1.0) : 0.0}; + nearest = std::min(nearest, glm::length(point - (a + run * t))); + } + } + if (Feather <= 0.0) + return inside ? Strength : 0.0; + // signed distance from the outline, inside positive, led smoothly through the blend + auto const t{std::clamp(((inside ? nearest : -nearest) + margin) / Feather, 0.0, 1.0)}; + return Strength * t * t * (3.0 - 2.0 * t); + }); +} + +bool terrain_streamer::paint_area(glm::dvec2 const &Min, glm::dvec2 const &Max, std::uint16_t const Layer, bool const Load, std::function const &Amount) +{ bool changed{false}; - for (auto *chunk : chunks_in(glm::dvec2{X - Radius, Z - Radius}, glm::dvec2{X + Radius, Z + Radius}, false)) + for (auto *chunk : chunks_in(Min, Max, Load)) { auto const ¤t{chunk->data()}; auto const samples{current.paint > 0 ? current.paint : heightmap::default_paint_samples}; auto const step{heightmap::chunk_size / samples}; auto const low{current.corner()}; - auto const xs{index_range(low.x, step, samples + 1, X - Radius, X + Radius)}; - auto const zs{index_range(low.y, step, samples + 1, Z - Radius, Z + Radius)}; + auto const xs{index_range(low.x, step, samples + 1, Min.x, Max.x)}; + auto const zs{index_range(low.y, step, samples + 1, Min.y, Max.y)}; if (xs.first > xs.second || zs.first > zs.second) continue; if (current.paint <= 0 && current.layers[0] == Layer) @@ -1203,13 +1251,11 @@ bool terrain_streamer::paint(double X, double Z, double Radius, double Strength, for (int iz = zs.first; iz <= zs.second; ++iz) for (int ix = xs.first; ix <= xs.second; ++ix) { - auto const px{low.x + ix * step}, pz{low.y + iz * step}; - auto const distance{std::sqrt((px - X) * (px - X) + (pz - Z) * (pz - Z))}; - if (distance > Radius) + auto const amount{std::clamp(Amount(low.x + ix * step, low.y + iz * step), 0.0, 1.0)}; + if (amount <= 0.0) continue; auto const sample{static_cast(iz) * (samples + 1) + ix}; auto &own{data->weights[slot * plane + sample]}; - auto const amount{std::clamp(Strength * falloff(distance, Radius), 0.0, 1.0)}; auto const target{static_cast(std::lround(own + (255 - own) * amount))}; if (target == own) continue; @@ -1239,13 +1285,13 @@ bool terrain_streamer::paint(double X, double Z, double Radius, double Strength, return changed; } -std::uint16_t terrain_streamer::layer(std::string const &Material, float const Size) +std::uint16_t terrain_streamer::layer(std::string const &Material, float const Size, float const Rotation) { for (std::size_t i = 0; i < m_manifest.layers.size(); ++i) - if (m_manifest.layers[i].material == Material && (Size <= 0.f || m_manifest.layers[i].size == Size)) + if (m_manifest.layers[i].material == Material && (Size <= 0.f || m_manifest.layers[i].size == Size) && m_manifest.layers[i].rotation == Rotation) return static_cast(i); remember_manifest(); - m_manifest.layers.push_back({Material, std::max(0.f, Size)}); + m_manifest.layers.push_back({Material, std::max(0.f, Size), Rotation}); m_manifestchanged = true; return static_cast(m_manifest.layers.size() - 1); } @@ -1263,6 +1309,19 @@ void terrain_streamer::layer_size(std::uint16_t const Layer, float const Size) entry.second->m_paintedversion = 0; } +void terrain_streamer::layer_rotation(std::uint16_t const Layer, float Rotation) +{ + Rotation = static_cast(std::remainder(static_cast(Rotation), 360.0)); + if (Layer >= m_manifest.layers.size() || m_manifest.layers[Layer].rotation == Rotation) + return; + remember_manifest(); + m_manifest.layers[Layer].rotation = Rotation; + m_manifestchanged = true; + for (auto &entry : m_chunks) + if (entry.second->data().slot_of(Layer) >= 0 || (Layer == 0 && entry.second->data().layer_count() == 0)) + entry.second->m_paintedversion = 0; +} + void terrain_streamer::layer_material(std::uint16_t const Layer, std::string const &Material) { if (Layer >= m_manifest.layers.size() || Material.empty() || m_manifest.layers[Layer].material == Material) @@ -1529,7 +1588,7 @@ terrain_streamer::change terrain_streamer::restore(change const &Change) opposite.water_material = m_manifest.water_material; opposite.modifiers = m_manifest.modifiers; auto const samelayers{std::equal(Change.layers.begin(), Change.layers.end(), m_manifest.layers.begin(), m_manifest.layers.end(), - [](heightmap::layer_def const &A, heightmap::layer_def const &B) { return A.material == B.material && A.size == B.size; })}; + [](heightmap::layer_def const &A, heightmap::layer_def const &B) { return A.material == B.material && A.size == B.size && A.rotation == B.rotation; })}; m_manifest.layers = Change.layers; m_manifest.modifiers = Change.modifiers; m_manifest.water = Change.water; diff --git a/editor/editorTerrainStreamer.hpp b/editor/editorTerrainStreamer.hpp index 7fc44813..d29451e7 100644 --- a/editor/editorTerrainStreamer.hpp +++ b/editor/editorTerrainStreamer.hpp @@ -112,9 +112,15 @@ class terrain_streamer std::size_t touched_up() const; // paints the material of the palette entry Layer within Radius of (X,Z), Strength (0..1) of the way at the centre bool paint(double X, double Z, double Radius, double Strength, std::uint16_t Layer); - // palette entry of the material, added to the palette if needed - std::uint16_t layer(std::string const &Material, float Size = 0.f); + // fills the area within Outline (x, z) with the material of the palette entry Layer, Strength (0..1) of the way. + // Feather: metres across the outline the material blends in over, half of them inside; 0: a sharp edge, as sharp as + // the paint samples of the chunks go. the chunks are loaded where needed + bool fill(std::vector const &Outline, double Feather, std::uint16_t Layer, double Strength = 1.0); + // palette entry of the material (repeated at Size, 0: any, turned by Rotation degrees), added to the palette if needed + std::uint16_t layer(std::string const &Material, float Size = 0.f, float Rotation = 0.f); void layer_size(std::uint16_t Layer, float Size); + // turns the textures of the palette entry Layer by Rotation degrees, on every chunk painted with it + void layer_rotation(std::uint16_t Layer, float Rotation); // gives the palette entry Layer another material; the chunks painted with it change with it void layer_material(std::uint16_t Layer, std::string const &Material); void compress(bool State); @@ -234,6 +240,9 @@ class terrain_streamer heightmap::chunk_ptr neighbour(chunk_key const &Key) const; void touch_neighbours(chunk_key const &Key); material_handle palette_material(std::uint16_t const Layer); + // paints the material of the palette entry Layer over the paint samples within the rectangle, Amount (0..1) of the way + // at each, as Amount gives it for the place of the sample. Load: chunks not in memory are loaded + bool paint_area(glm::dvec2 const &Min, glm::dvec2 const &Max, std::uint16_t Layer, bool Load, std::function const &Amount); // chunk loaded right away from its pack file, for editing far from the camera editor_terrain *load_now(chunk_key const &Key); // chunks in memory or in the files overlapping the rectangle, loaded if needed diff --git a/rendering/opengl33terrain.cpp b/rendering/opengl33terrain.cpp index 35c3fd61..e8ab570b 100644 --- a/rendering/opengl33terrain.cpp +++ b/rendering/opengl33terrain.cpp @@ -289,6 +289,10 @@ material_handle opengl33_terrain_materials::make(material_handle const Reuse, st table[i * 4 + 2] = layer.normalmap ? 1.f : 0.f; table[i * 4 + 3] = layer.specgloss ? 1.f : 0.f; table[(max_layers + i) * 4 + 0] = layer.reflection; + // the textures turned by the layer of the chunk (the same material can be turned differently in another layer) + auto const angle{glm::radians(static_cast(Layers[i].rotation))}; + table[(max_layers + i) * 4 + 1] = static_cast(std::cos(angle)); + table[(max_layers + i) * 4 + 2] = static_cast(std::sin(angle)); } bind_for_upload(m_textures.texture(entry.table)); ::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, static_cast(max_layers), 2, 0, GL_RGBA, GL_FLOAT, table.data()); diff --git a/rendering/renderer.h b/rendering/renderer.h index 57d7365e..0b9eb60f 100644 --- a/rendering/renderer.h +++ b/rendering/renderer.h @@ -28,6 +28,7 @@ struct terrain_layer { material_handle material{null_handle}; float size{0.f}; + float rotation{0.f}; // degrees the textures are turned by }; } // namespace gfx diff --git a/scene/heightmapterrain.cpp b/scene/heightmapterrain.cpp index e2e508ac..a2bc6a2f 100644 --- a/scene/heightmapterrain.cpp +++ b/scene/heightmapterrain.cpp @@ -551,7 +551,7 @@ bool load_manifest(std::string const &Path, manifest &Manifest, std::string *Err if (auto const node{document["layers"]}; node && node.IsSequence()) for (auto const &layer : node) { - // a material name, or a map with the material and the size its textures repeat at + // a material name, or a map with the material, the size its textures repeat at and the angle they're turned by if (layer.IsMap()) { layer_def entry; @@ -559,6 +559,8 @@ bool load_manifest(std::string const &Path, manifest &Manifest, std::string *Err entry.material = material.as(); if (auto const size{layer["size"]}) entry.size = std::max(0.f, size.as()); + if (auto const rotation{layer["rotation"]}) + entry.rotation = rotation.as(); if (false == entry.material.empty()) result.layers.push_back(entry); } @@ -630,8 +632,13 @@ bool save_manifest(std::string const &Path, manifest const &Manifest, std::strin out << YAML::Key << "layers" << YAML::Value << YAML::BeginSeq; for (auto const &layer : Manifest.layers) { - if (layer.size > 0.f) - out << YAML::Flow << YAML::BeginMap << YAML::Key << "material" << YAML::Value << layer.material << YAML::Key << "size" << YAML::Value << layer.size << YAML::EndMap; + if (layer.size > 0.f || layer.rotation != 0.f) + { + out << YAML::Flow << YAML::BeginMap << YAML::Key << "material" << YAML::Value << layer.material << YAML::Key << "size" << YAML::Value << layer.size; + if (layer.rotation != 0.f) + out << YAML::Key << "rotation" << YAML::Value << layer.rotation; + out << YAML::EndMap; + } else out << layer.material; } diff --git a/scene/heightmapterrain.h b/scene/heightmapterrain.h index 8b2c17b9..c578e78f 100644 --- a/scene/heightmapterrain.h +++ b/scene/heightmapterrain.h @@ -153,11 +153,13 @@ class modifier_shape std::vector> m_grid; // (cell key, segment), sorted }; -// material of the palette, and the size (metres) its textures repeat at; 0: the size given by the material, or 8 m +// material of the palette, and the size (metres) its textures repeat at; 0: the size given by the material, or 8 m. +// the same material can be in the palette more than once, e.g. turned by another angle struct layer_def { std::string material; float size{0.f}; + float rotation{0.f}; // degrees the textures are turned by, counterclockwise seen from above }; // description of the terrain, terrain.yaml diff --git a/shaders/mat_terrain.frag b/shaders/mat_terrain.frag index 46e454fe..77519e1c 100644 --- a/shaders/mat_terrain.frag +++ b/shaders/mat_terrain.frag @@ -16,7 +16,7 @@ layout(location = 1) out vec4 out_motion; // heightmap terrain: up to 8 materials (layers) painted over a chunk, blended by their weights. // the textures of all layers of the terrain are kept in texture arrays; the table of the chunk tells which layers it has: // row 0, per layer: index in the arrays, 1 / metres the textures repeat at, has normal map, has specular/gloss map -// row 1, per layer: reflection +// row 1, per layer: reflection, cosine and sine of the angle the textures are turned by // f_coord holds metres from the corner of the pack of chunks, along x and -z #param (color, 0, 0, 4, diffuse) @@ -77,9 +77,12 @@ void main() continue; vec4 info = texelFetch(layertable, ivec2(i, 0), 0); vec4 extra = texelFetch(layertable, ivec2(i, 1), 0); - vec3 coord = vec3(f_coord * info.y, info.x); - vec2 dx = coorddx * info.y; - vec2 dy = coorddy * info.y; + // turned counterclockwise seen from above; f_coord runs along x and -z, so that's clockwise in it + vec2 turn = (extra.y == 0.0 && extra.z == 0.0) ? vec2(1.0, 0.0) : extra.yz; + mat2 rotation = mat2(turn.x, -turn.y, turn.y, turn.x); + vec3 coord = vec3(rotation * f_coord * info.y, info.x); + vec2 dx = rotation * coorddx * info.y; + vec2 dy = rotation * coorddy * info.y; albedo += textureGrad(layerdiffuse, coord, dx, dy).rgb * weight; vec3 layernormal_ts = vec3(0.0, 0.0, 1.0); float layerreflection = extra.x; @@ -88,6 +91,8 @@ void main() vec4 normalmap = textureGrad(layernormal, coord, dx, dy); layernormal_ts.xy = normalmap.rg * 2.0 - 1.0; layernormal_ts.z = sqrt(1.0 - clamp(dot(layernormal_ts.xy, layernormal_ts.xy), 0.0, 1.0)); + // the normal map leans along the turned texture; turned back to the axes of the terrain + layernormal_ts.xy = layernormal_ts.xy * rotation; layerreflection *= normalmap.a; } normal += layernormal_ts * weight;