Implement M9.3 camera navigation and bounded input intentions
This commit is contained in:
@@ -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
|
||||
Reference in New Issue
Block a user