126 lines
4.4 KiB
C++
126 lines
4.4 KiB
C++
#pragma once
|
|
|
|
#include <optional>
|
|
#include <sophia/aabb.hpp>
|
|
#include <sophia/entity.hpp>
|
|
#include <sophia/frame_info.hpp>
|
|
#include <sophia/handles.hpp>
|
|
#include <sophia/math.hpp>
|
|
#include <sophia/resource_registry_ref.hpp>
|
|
#include <sophia/scene_view_registry.hpp>
|
|
#include <sophia/ui/panel.hpp>
|
|
#include <sophia/ui/ui.hpp>
|
|
|
|
#include "../editor_camera.hpp"
|
|
#include "../editor_context.hpp"
|
|
|
|
/**
|
|
* Shows the active scene through the editor's own camera.
|
|
*
|
|
* 3D: right-drag orbits, middle-drag pans, the wheel zooms, right-drag with
|
|
* WASD/QE flies. 2D: right- or middle-drag pans, the wheel zooms. F frames
|
|
* the selection in both.
|
|
*
|
|
* The selection gets a transform gizmo: W moves, E rotates, R scales, and
|
|
* holding Ctrl snaps. Clicking selects the mesh or sprite under the mouse;
|
|
* in 2D, dragging it also moves it.
|
|
*/
|
|
class ScenePanel : public sophia::Panel {
|
|
public:
|
|
// Renders into `target` through `view`, a SceneView this panel keeps
|
|
// pointed at the active scene. `camera` is the entity the view looks
|
|
// through; it belongs to a scene of the editor's own, and this panel
|
|
// drives it from its EditorCamera.
|
|
ScenePanel(sophia::UI& ui, sophia::ResourceRegistryRef resources,
|
|
EditorContext& context, sophia::SceneViewRegistry& sceneViews,
|
|
sophia::SceneViewHandle view, sophia::RenderTargetHandle target,
|
|
sophia::Entity camera)
|
|
: Panel{{.name = "Scene", .windowFlags = WINDOW_FLAGS}},
|
|
ui{ui},
|
|
resources{resources},
|
|
context{context},
|
|
sceneViews{sceneViews},
|
|
view{view},
|
|
target{target},
|
|
camera{camera} {}
|
|
|
|
void onUpdate(const sophia::FrameInfo& frameInfo) override;
|
|
|
|
private:
|
|
static constexpr ImGuiWindowFlags WINDOW_FLAGS =
|
|
ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
|
|
|
|
enum class GizmoOperation { Translate, Rotate, Scale };
|
|
|
|
// A half-line in world space. `direction` is normalized, so distances
|
|
// along it are in world units.
|
|
struct Ray {
|
|
glm::vec3 origin;
|
|
glm::vec3 direction;
|
|
};
|
|
|
|
// Where the scene image is on screen this frame, and the camera looking
|
|
// through it.
|
|
struct ViewportTransform {
|
|
ImVec2 origin;
|
|
ImVec2 size;
|
|
glm::mat4 viewProjection;
|
|
glm::mat4 inverseViewProjection;
|
|
|
|
// Null for points behind the camera.
|
|
std::optional<ImVec2> worldToScreen(const glm::vec3& world) const;
|
|
// Where `screen` is on the camera's near plane. Only the x and y, which
|
|
// is all that's needed in 2D.
|
|
glm::vec2 screenToWorld(const ImVec2& screen) const;
|
|
// From the near plane through `screen`, into the scene.
|
|
Ray screenToRay(const ImVec2& screen) const;
|
|
|
|
// Draws a world-space line, cut off where it passes behind the camera.
|
|
void drawLine(ImDrawList* drawList, const glm::vec3& a, const glm::vec3& b,
|
|
ImU32 color, float thickness) const;
|
|
|
|
private:
|
|
ImVec2 clipToScreen(const glm::vec4& clip) const;
|
|
};
|
|
|
|
void drawToolbar();
|
|
void drawGrid(ImVec2 origin, ImVec2 size);
|
|
void handleCameraInput(const sophia::FrameInfo& frameInfo, ImVec2 size);
|
|
void handleSelectionInput(const ViewportTransform& viewport);
|
|
void handleGizmoHotkeys();
|
|
// Draws the transform gizmo on the selection, and applies any change made
|
|
// with it. `view` is the editor camera's, and `aspect` the viewport's
|
|
// width over its height.
|
|
void drawGizmo(const glm::mat4& view, float aspect);
|
|
void drawSelection(const ViewportTransform& viewport);
|
|
void frameSelection();
|
|
|
|
// The bounds of the entity's mesh in the mesh's own space, if it has one.
|
|
std::optional<sophia::AABB> getMeshBounds(sophia::Entity entity);
|
|
|
|
// The entity drawn in front along `ray`, or a null Entity. Only meshes and
|
|
// sprites can be hit.
|
|
sophia::Entity pick(const Ray& ray);
|
|
|
|
sophia::UI& ui;
|
|
sophia::ResourceRegistryRef resources;
|
|
EditorContext& context;
|
|
sophia::SceneViewRegistry& sceneViews;
|
|
sophia::SceneViewHandle view;
|
|
sophia::RenderTargetHandle target;
|
|
sophia::Entity camera;
|
|
|
|
EditorCamera editorCamera;
|
|
|
|
GizmoOperation gizmoOperation = GizmoOperation::Translate;
|
|
// Whether the gizmo works along the entity's own axes or the world's.
|
|
bool gizmoLocal = true;
|
|
// Whether the viewport button was active last frame, i.e. a camera drag or
|
|
// click is under way, which the gizmo mustn't interrupt.
|
|
bool viewportActive = false;
|
|
|
|
bool showGrid = true;
|
|
// Set while a drag that started on the selected entity is moving it.
|
|
bool dragging = false;
|
|
};
|