18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 00:24:57 +01:00

Merge pull request #314 from miloszunio/pr/ground-ray

fix(editor): the points of the terrain tools put on the ground along the ray through the cursor in this frame
This commit is contained in:
maj00r
2026-11-11 23:13:08 +01:00
committed by GitHub
4 changed files with 115 additions and 22 deletions

View File

@@ -2203,9 +2203,9 @@ void editor_mode::draw_terrain_overlay()
return; return;
screen_projection const projection; screen_projection const projection;
auto *drawlist = ImGui::GetBackgroundDrawList(); auto *drawlist = ImGui::GetBackgroundDrawList();
glm::dvec3 const offset = GfxRenderer->Mouse_Position(); // the cursor where a click would put the point: the ground along the ray through the cursor in this frame
bool const hovering = glm::length(offset) > 1e-3 && false == ImGui::GetIO().WantCaptureMouse; glm::dvec3 cursor{Camera.Pos};
glm::dvec3 const cursor = Camera.Pos + offset; bool const hovering = false == ImGui::GetIO().WantCaptureMouse && cursor_on_ground(cursor);
auto const ground = [&](double const X, double const Z, double const Fallback) { auto const ground = [&](double const X, double const Z, double const Fallback) {
double height; double height;
return m_streamer.height_at(X, Z, height) ? height : Fallback; return m_streamer.height_at(X, Z, height) ? height : Fallback;
@@ -2220,8 +2220,12 @@ void editor_mode::draw_terrain_overlay()
} }
}; };
if (terrain_brush() && hovering) // the brush aimed at the ground itself along the ray through the cursor
glm::dvec3 brushcentre = cursor;
bool const onground = false == ImGui::GetIO().WantCaptureMouse && terrain_cursor(brushcentre);
if (terrain_brush() && onground)
{ {
auto const cursor = brushcentre;
std::vector<glm::dvec3> circle; std::vector<glm::dvec3> circle;
for (int i = 0; i < 64; ++i) for (int i = 0; i < 64; ++i)
{ {
@@ -2827,10 +2831,9 @@ void editor_mode::add_chunks_around(int const Count)
void editor_mode::handle_terrain_click(bool const Shift) void editor_mode::handle_terrain_click(bool const Shift)
{ {
glm::dvec3 const offset = GfxRenderer->Mouse_Position(); glm::dvec3 world;
if (glm::length(offset) < 1e-3) if (false == cursor_on_ground(world))
return; // nothing under the cursor (yet) return; // nothing under the cursor
glm::dvec3 const world = Camera.Pos + offset;
switch (m_terrain_tool) switch (m_terrain_tool)
{ {
case terrain_tool::chunks: case terrain_tool::chunks:
@@ -3537,12 +3540,11 @@ void editor_mode::export_scenery()
void editor_mode::handle_terrain_brush(double Deltatime) void editor_mode::handle_terrain_brush(double Deltatime)
{ {
// world point under the cursor (Mouse_Position is camera-relative, like the brush placement uses) // the ground itself along the ray through the cursor in this frame
glm::dvec3 const offset = GfxRenderer->Mouse_Position(); glm::dvec3 world;
if (glm::length(offset) < 1e-3) if (false == terrain_cursor(world))
return; return;
glm::dvec3 const world = Camera.Pos + offset; // only when the cursor is over the terrain
// only when the cursor is over the terrain (avoids editing on a stale depth read)
if (terrain_at(world.x, world.z) == nullptr) if (terrain_at(world.x, world.z) == nullptr)
return; return;
@@ -3585,6 +3587,40 @@ void editor_mode::handle_terrain_brush(double Deltatime)
} }
} }
bool editor_mode::cursor_on_ground(glm::dvec3 &World)
{
if (m_streamer.active() && terrain_cursor(World))
return true;
// no terrain under the ray: the depth read back under the cursor, as before, where it hit anything
if (false == GfxRenderer->Mouse_Hit())
return false;
World = Camera.Pos + GfxRenderer->Mouse_Position();
return true;
}
bool editor_mode::terrain_cursor(glm::dvec3 &World) const
{
// along the ray through the cursor as it is in this frame: the depth read back lags a frame behind
ImGuiIO const &io = ImGui::GetIO();
if (io.DisplaySize.x <= 0.0f || io.DisplaySize.y <= 0.0f)
return false;
auto const inverse = glm::inverse(editor_mode::projection_matrix(io.DisplaySize.x / io.DisplaySize.y) * GfxRenderer->Camera_View_Matrix());
glm::vec2 const ndc{io.MousePos.x / io.DisplaySize.x * 2.0f - 1.0f, 1.0f - io.MousePos.y / io.DisplaySize.y * 2.0f};
// two points of the ray, whatever the depth range of the projection
auto const point = [&](float const Depth) {
auto const clip = inverse * glm::vec4(ndc, Depth, 1.0f);
return glm::dvec3{glm::vec3{clip} / clip.w};
};
auto const direction = point(0.5f) - point(0.0f);
if (glm::length(direction) < 1e-9)
return false;
// the top view sees from 10 km behind the plane of the camera (the near plane of its projection): the ray starts there,
// so the ground higher than the camera is met too
auto const back{Global.EditorOrtho ? 10000.0 : 0.0};
auto const along{glm::normalize(direction)};
return m_streamer.raycast(GfxRenderer->Camera_Position() + point(0.0f) - along * back, along, 5000.0 + back, World);
}
void editor_mode::fill_terrain_area() void editor_mode::fill_terrain_area()
{ {
auto const &layers = m_streamer.manifest().layers; auto const &layers = m_streamer.manifest().layers;
@@ -3641,10 +3677,10 @@ void editor_mode::convert_selected_chunks()
bool editor_mode::pick_terrain_target() bool editor_mode::pick_terrain_target()
{ {
glm::dvec3 const offset = GfxRenderer->Mouse_Position(); glm::dvec3 world;
if (glm::length(offset) < 1e-3) if (false == cursor_on_ground(world))
return false; // nothing under the cursor return false; // nothing under the cursor
m_terrain_target = static_cast<float>(Camera.Pos.y + offset.y); m_terrain_target = static_cast<float>(world.y);
m_terrain_status = format(STR_C("Target height: %.2f m"), m_terrain_target); m_terrain_status = format(STR_C("Target height: %.2f m"), m_terrain_target);
return true; return true;
} }
@@ -4476,14 +4512,13 @@ void editor_mode::render_object_menu()
void editor_mode::add_area_fill_point() void editor_mode::add_area_fill_point()
{ {
// like the other placement tools, the point comes from the depth buffer under the cursor // the ground along the ray through the cursor in this frame
// (ground geometry only), relative to the camera glm::dvec3 world;
glm::dvec3 const offset = GfxRenderer->Mouse_Position(); if (false == cursor_on_ground(world))
if (glm::length(offset) < 1e-3) return; // no ground under the cursor
return; // no ground under the cursor (yet)
// the outline gives the fill the height to look for the ground at, and the height of what it finds no ground for // the outline gives the fill the height to look for the ground at, and the height of what it finds no ground for
m_fill_points.push_back(placement_on_ground(Camera.Pos + offset)); m_fill_points.push_back(placement_on_ground(world));
} }
void editor_mode::undo_last_area_fill() void editor_mode::undo_last_area_fill()

View File

@@ -677,6 +677,13 @@ class editor_mode : public application_mode, private editor_track::observer, pri
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 || 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 ||
m_terrain_tool == terrain_tool::restore; m_terrain_tool == terrain_tool::restore;
} }
// the point of the ground of the terrain under the cursor, found along the ray through the cursor, so it's found also over
// a hole and behind the grass. returns: false if the ray meets no terrain
bool terrain_cursor(glm::dvec3 &World) const;
// the point of the ground under the cursor in this frame, for the points put on the ground (outlines, areas, brushes): along the ray
// through the cursor to the terrain; the depth read back (a frame late, and stopped by the models over the ground) only where
// there's none. false: nothing under the cursor
bool cursor_on_ground(glm::dvec3 &World);
// converts the point spacing of the selected chunks to m_terrain_convert_spacing // converts the point spacing of the selected chunks to m_terrain_convert_spacing
void convert_selected_chunks(); void convert_selected_chunks();
// the chunks selected with the spacing tool taken out of the terrain, in one step of the history // the chunks selected with the spacing tool taken out of the terrain, in one step of the history

View File

@@ -810,6 +810,55 @@ editor_terrain *terrain_streamer::terrain_at(double X, double Z) const
return nullptr; return nullptr;
} }
bool terrain_streamer::raycast(glm::dvec3 const &Origin, glm::dvec3 const &Direction, double const Reach, glm::dvec3 &Hit) const
{
if (glm::length(Direction) < 1e-9)
return false;
auto const direction{glm::normalize(Direction)};
// 1 above the ground, -1 under it, 0 where there's no terrain
auto const side = [&](double const T) {
auto const point{Origin + direction * T};
double height;
if (false == height_at(point.x, point.z, height))
return 0;
return point.y > height ? 1 : -1;
};
auto const above = [&](double const T) { return side(T) >= 0; };
auto last{side(0.0)};
if (last < 0)
return false; // starts under the ground
double previous{0.0};
double t{0.0};
while (t < Reach)
{
// finer near the camera, where the brush is aimed most
t = std::min(Reach, t + std::max(0.25, t * 0.004));
auto const now{side(t)};
if (now >= 0)
{
previous = t;
last = now;
continue;
}
// under the ground coming from where there's no terrain: the side of a chunk seen through a gap, not the ground
// seen on the screen; the depth read back says where that is
if (last == 0)
return false;
auto low{previous}, high{t};
for (int i = 0; i < 24; ++i)
{
auto const middle{(low + high) * 0.5};
if (above(middle))
low = middle;
else
high = middle;
}
Hit = Origin + direction * high;
return true;
}
return false;
}
bool terrain_streamer::height_at(double X, double Z, double &Height) const bool terrain_streamer::height_at(double X, double Z, double &Height) const
{ {
auto const *chunk{terrain_at(X, Z)}; auto const *chunk{terrain_at(X, Z)};

View File

@@ -69,6 +69,8 @@ class terrain_streamer
editor_terrain *terrain_at(double X, double Z) const; editor_terrain *terrain_at(double X, double Z) const;
// height of the terrain at (X,Z); false where there's no chunk in memory // height of the terrain at (X,Z); false where there's no chunk in memory
bool height_at(double X, double Z, double &Height) const; bool height_at(double X, double Z, double &Height) const;
// the first point of the ground along the ray from the origin, within the reach; false if it meets none
bool raycast(glm::dvec3 const &Origin, glm::dvec3 const &Direction, double Reach, glm::dvec3 &Hit) const;
// triangles of the full grid of the chunks in memory overlapping the rectangle (x, z) // triangles of the full grid of the chunks in memory overlapping the rectangle (x, z)
void gather_triangles(glm::dvec2 const &Min, glm::dvec2 const &Max, std::vector<std::array<glm::dvec3, 3>> &Out) const; void gather_triangles(glm::dvec2 const &Min, glm::dvec2 const &Max, std::vector<std::array<glm::dvec3, 3>> &Out) const;
// true if the geometry belongs to the terrain (or its water) // true if the geometry belongs to the terrain (or its water)