Implement M9.3 camera navigation and bounded input intentions

This commit is contained in:
dingo
2026-10-01 17:26:35 -04:00
parent 04c7715646
commit bb0412cd0f
19 changed files with 899 additions and 27 deletions
+101
View File
@@ -0,0 +1,101 @@
#include "evo/client/camera.hpp"
#include "evo/world/coordinates.hpp"
#include <cmath>
namespace evo::client {
namespace {
constexpr double world_limit = static_cast<double>(world::voxel_limit * world::cell_pitch_mm);
bool valid(Viewport v) {
return v.width > 0 && v.height > 0 && v.pixel_width > 0 && v.pixel_height > 0 &&
v.width <= 32768 && v.height <= 32768 && v.pixel_width <= 32768 &&
v.pixel_height <= 32768;
}
bool valid(WorldPoint p) {
return std::isfinite(p.x_mm) && std::isfinite(p.y_mm) && p.x_mm >= -world_limit &&
p.y_mm >= -world_limit && p.x_mm < world_limit && p.y_mm < world_limit;
}
bool valid(ScreenPoint p) {
return std::isfinite(p.x) && std::isfinite(p.y) && std::abs(p.x) <= 1e15 &&
std::abs(p.y) <= 1e15;
}
bool valid_scale(double scale) {
return std::isfinite(scale) && scale >= 1e-4 && scale <= 1e4;
}
} // namespace
std::expected<Camera, CameraError> Camera::create(Viewport viewport, WorldPoint centre,
double scale) {
if (!valid(viewport))
return std::unexpected(CameraError::invalid_viewport);
if (!valid(centre) || !valid_scale(scale))
return std::unexpected(CameraError::invalid_value);
return Camera{viewport, centre, scale};
}
std::expected<void, CameraError> Camera::resize(Viewport viewport) {
if (!valid(viewport))
return std::unexpected(CameraError::invalid_viewport);
viewport_ = viewport;
return {};
}
std::expected<ScreenPoint, CameraError> Camera::world_to_screen(WorldPoint point) const {
if (!valid(point))
return std::unexpected(CameraError::invalid_value);
return ScreenPoint{(point.x_mm - centre_.x_mm) * scale_ + viewport_.width / 2.0,
(centre_.y_mm - point.y_mm) * scale_ + viewport_.height / 2.0};
}
std::expected<WorldPoint, CameraError> Camera::screen_to_world(ScreenPoint point) const {
if (!valid(point))
return std::unexpected(CameraError::invalid_value);
const WorldPoint result{centre_.x_mm + (point.x - viewport_.width / 2.0) / scale_,
centre_.y_mm - (point.y - viewport_.height / 2.0) / scale_};
if (!valid(result))
return std::unexpected(CameraError::out_of_range);
return result;
}
std::expected<PixelPoint, CameraError> Camera::to_pixels(ScreenPoint point) const {
if (!valid(point))
return std::unexpected(CameraError::invalid_value);
const PixelPoint result{point.x * viewport_.pixel_width / viewport_.width,
point.y * viewport_.pixel_height / viewport_.height};
if (!valid(ScreenPoint{result.x, result.y}))
return std::unexpected(CameraError::out_of_range);
return result;
}
std::expected<ScreenPoint, CameraError> Camera::from_pixels(PixelPoint point) const {
if (!valid(ScreenPoint{point.x, point.y}))
return std::unexpected(CameraError::invalid_value);
const ScreenPoint result{point.x * viewport_.width / viewport_.pixel_width,
point.y * viewport_.height / viewport_.pixel_height};
if (!valid(result))
return std::unexpected(CameraError::out_of_range);
return result;
}
std::expected<void, CameraError> Camera::pan(ScreenPoint delta) {
if (!valid(delta) || std::abs(delta.x) > 32768 || std::abs(delta.y) > 32768)
return std::unexpected(CameraError::invalid_value);
const WorldPoint next{centre_.x_mm + delta.x / scale_, centre_.y_mm - delta.y / scale_};
if (!valid(next))
return std::unexpected(CameraError::out_of_range);
centre_ = next;
return {};
}
std::expected<void, CameraError> Camera::zoom(double factor, ScreenPoint anchor) {
if (!std::isfinite(factor) || factor <= 0 || !valid(anchor) || anchor.x < 0 || anchor.y < 0 ||
anchor.x > viewport_.width || anchor.y > viewport_.height)
return std::unexpected(CameraError::invalid_value);
const double next_scale = scale_ * factor;
if (!valid_scale(next_scale))
return std::unexpected(CameraError::out_of_range);
if (factor == 1)
return {};
const auto world = screen_to_world(anchor);
if (!world)
return std::unexpected(world.error());
const WorldPoint next{world->x_mm - (anchor.x - viewport_.width / 2.0) / next_scale,
world->y_mm + (anchor.y - viewport_.height / 2.0) / next_scale};
if (!valid(next))
return std::unexpected(CameraError::out_of_range);
centre_ = next;
scale_ = next_scale;
return {};
}
} // namespace evo::client